#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[:])

#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.unzip(archive[:], password="hunter2")

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

@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

• 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 is a parameter, 10 to 24
@brotli.unbrotli(packed[:], limit=1 << 24)

• 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

#What it reads and what it writes

#Where the checksums live

#Why one package per format

#Install

moon add moonbitstack/moonzip

#Licence