#moonzip

let small = @gzip.gzip(body[:])
let back = @gzip.gunzip(small[:])     // raises if the checksum disagrees

let archive = @zip.zip([@zip.Entry::new("readme.txt", body)][:])
let members = @zip.unzip(archive[:])

• minimal — the smallest program: compress and read back one buffer.
• tour — the surface in one go: deflate, gzip, zlib and brotli, the two checksums, and a tampered stream refused.
• formats — every codec, one-shot, with the size it reached and a round-trip check.
• throughput — megabytes per second for the one-shot codecs, best of several runs.
• stream — the streaming pair, both ways, on a body taken a piece at a time.
• checksums — CRC-32, Adler-32 and CRC-32C, one-shot and streamed a piece at a time.
• archive — zip (Zip64, descriptors, a password) and tar, tar.gz and 7z.
• bundle — a small release packer: stream-compress, wrap in four containers, read back.
• vectors — the byte streams handed to an external checker for conformance.

#Configuration

@deflate.deflate(body[:])                    // level 6, a 32 KiB window
@deflate.deflate(body[:], level=9)           // search hardest
@deflate.deflate(body[:], level=0)           // store, do not compress
@deflate.deflate(body[:], blocks=Fixed)      // pin the block type
@deflate.deflate(body[:], chain=2048)        // set the search depth directly

@deflate.inflate(stream[:], limit=1 << 20)   // refuse to expand past a megabyte

@gzip.gzip(body[:], name="report.csv", mtime=written_at)
@gzip.gunzip(stream[:], checksum=false)      // read what a damaged stream holds

#Streaming

// out
let writer = @gzip.Writer::new(level=9)
for part in parts {
  for b in writer.push(part) { out.push(b) }   // maybe nothing, at first
}
for b in writer.finish() { out.push(b) }       // the rest, plus the trailer

// back
let reader = @gzip.Reader::new()
for part in chunks {
  for b in reader.push(part) { out.push(b) }   // may cross a symbol
}
for b in reader.finish() { out.push(b) }       // and the trailer is checked here

#Archives

let archive = @zip.zip([
  @zip.Entry::new("hello.txt", b"hello"),
  @zip.Entry::new("dir/nested.txt", body, mtime=written_at),
][:])

@zip.names(archive[:])              // list it, without expanding anything
@zip.entry(archive[:], "hello.txt") // one member, expanding only that one
@zip.unzip(archive[:], limit=limit) // all of them, bounded

@zip.zip(entries[:], zip64=true)          // sixty-four-bit sizes and offsets
@zip.zip(entries[:], descriptor=true)     // sizes after each member, not before
@zip.zip(entries[:], password="hunter2")  // ZipCrypto
@zip.zip(entries[:], password="hunter2", aes=256)         // WinZip AES-256, AE-1
@zip.zip(entries[:], password="hunter2", aes=256, ae=2)   // AE-2, CRC zeroed
@zip.unzip(archive[:], password="hunter2")

@tar.tar([@tar.Entry::new("a.txt", body), @tar.Entry::directory("empty")][:])
@tar.targz(files[:])        // and untargz

let parts = @zip.zip_split(entries[:], 65536)  // volumes of at most 64 KiB
@zip.volume_names("archive", parts.length())   // ["archive.z01", ..., "archive.zip"]
let back = @zip.unzip_split(parts)             // if it arrives as several files

let disks = @zip.zip_spanned(entries[:], 65536)  // true spanned disks
@zip.unzip_spanned(disks)                        // disk numbers translated back

@zip.unzip(archive[:], codecs=mine[:])

#LZMA

@lzma.lzma(body[:])            // the .lzma alone container
@lzma.unlzma(packed[:])        // both a stated length and an end marker

@xz.xz(body[:])                // the container, one block, CRC-64
@xz.unxz(packed[:])            // header, block header, index and footer checked

#bzip2

@bzip2.bzip2(body[:], level=9)      // 900k blocks
@bzip2.bunzip2(packed[:])           // block CRCs and the combined one checked

• The selector count is a fifteen-bit field, not a unary run. A reader that assumes unary decodes the first table perfectly and then reads the data as code lengths.
• Blocks are not padded. bsFinishWrite is called once, after the trailer, so a block boundary can fall in the middle of a byte — which means a streaming reader has to carry a bit position, not a byte offset.

#7z

@sevenz.sevenz(members[:], how=@sevenz.Method::Lzma2, solid=true)
@sevenz.un7z(archive[:])       // folder, substream and signature checksums verified
@sevenz.names(archive[:])      // the directory only, without touching the data

let w = @sevenz.Writer::new(level=6)
let mut body : Array[Byte] = []
for entry in members {
  for b in w.add(entry) {
    body.push(b)          // compressed as it arrives; write it out here
  }
}
let directory = w.finish()
let start = w.signature()  // the thirty-two bytes that go in front

let r = @sevenz.Reader::new(limit=1 << 26)
for piece in pieces {
  r.push(piece[:])        // the signature is checked on the first six bytes
}
let members = r.finish()

• The length encoding is n bytes for 7n bits, with the first byte holding the high bits: 80 97 is 151, not 38656. A writer that gets this wrong is correct for every value below 16384.
• A coder id of length zero is not "no coder" — it is how COPY is spelled.
• A file table entry is a boxed record with mutable fields; filling an array with one gives every slot the same box, and every entry becomes the last one written.

#zstd

@zstd.zstd(body[:], level=3)
@zstd.unzstd(packed[:])

• The bitstreams are read backwards. The last byte holds a stop bit: 0-7 zeros and then a one, with the data below it.
• An FSE decoding table seeds each symbol's next-state counter at that symbol's count, not at where its block of states begins. Getting that wrong decodes every symbol correctly and every next state wrongly — which reads as "the first sequence is right and everything after it drifts".
• The encoder must not spend bits on the last sequence's state update, because the decoder does not read one; it seeds the three states from those symbols instead.

#brotli

• Block types. Literals, commands and distances are three separate symbol streams, and each may switch between up to 256 sets of prefix codes, with the two most recent types addressable in three bits. A file with prose and a table of numbers gets one model for each.
• Literal contexts. Every literal is coded with one of 64 sub-alphabets, chosen by the two bytes before it — a hand-written model of where in a UTF-8 character the reader is. This is where most of brotli's edge over DEFLATE comes from on text, and it is the reason utf8 and signed are context modes rather than a detail.
• A static dictionary. 13,504 common words in several languages, plus 121 transforms over them, reachable by a distance larger than the window. A word the encoder recognises costs a distance code instead of its letters.

@brotli.brotli(body[:], window=22)   // window is 10 to 24
@brotli.brotli(body[:], quality=11)  // search hardest; quality is 0 to 11
@brotli.unbrotli(packed[:], limit=1 << 24)

• Literal contexts. The writer picks a context mode — UTF8 for text, LSB6 for binary — counts every literal in one of 64 sub-alphabets keyed by the two bytes before it, and then groups those sub-alphabets into at most six codes. The grouping is a recursive bisection: each round splits the group whose split pays best, and stops when no split pays or the cap is reached. The routing table that says which context uses which code is sent with the stream, so a body whose contexts look alike comes out with one code and one bit of map.
• Split streams. The command stream may be cut in two, and so may the literal stream, each half carrying its own prefix code and — for literals — its own context map. Where each cut falls is searched; both are declined when the extra code does not pay.
• The static dictionary. Words the format already knows are coded as a dictionary reference — a distance past the window that names (transform, word) — instead of their letters. The writer indexes the 13,504 words by their first four bytes and probes each position twice: once as spelled, once with the first letter lowercased, so a sentence-initial Time costs the same code as time. It then reaches 103 of the 121 transforms. With no prefix the word starts at the position being searched, so that index finds it and the work is comparing the suffix after it; with a prefix the text starts with those bytes and the word starts just past them, so the same index works one probe further in. That covers word + " ", word + ".", " " + word, " the " + word + " of " and the capitalised and shouted spellings of each. Eight are out of reach because they drop the word's opening bytes, which are exactly what the text does not contain. Ten more — the ones that drop the word's tail — are reachable and declined: a truncated word covers less text for the same far distance, and on this file they cost 260 bytes at every minimum length tried. An affix is not part of the copy length either: the command carries the word's length, which selects the bucket, and the transform decides how much comes out, so time with the space-suffix transform is a copy of four bytes that produces five.

• The code-length code is written as a prefix code, not as four raw bits per value. It looks like a fixed-width field and is not, and a writer that assumes otherwise produces a stream whose trees are almost right.
• A code-length code with one symbol costs zero bits. The reference zeroes that symbol's width after writing the header. A reader that charges one bit per run length desynchronises on the very next symbol, and the streams that hit it are the ones where every literal has the same width — the alphabet, not the prose.
• The dictionary transform table holds fragment ids. The 49-prefix table is reached through a second indirection; indexing it with the transform's own position reads past its fifty entries.
• The simple prefix-code form does not transmit widths. The reader derives them from the number of symbols and always gives the shortest one to the symbol it read first, so a writer has to assign widths the same way — with three symbols the frequency-based choice and the positional one disagree.

#The formats chosen for speed

#Throughput

#What it reads and what it writes

#Where the checksums live

#Why one package per format

#Install

moon add moonbitstack/moonzip

#Licence