From one buffer
to an archive.

fn main raise {
  let out : Array[Byte] = []
  for _ in 0..<200 {
    for b in "the quick brown fox jumps over the lazy dog. " {
      out.push((b.to_int() % 256).to_byte())
    }
  }
  let body = Bytes::from_array(out)
  println("original  -> \{body.length()} bytes")

  let raw = @deflate.deflate(body[:])
  println("deflate   -> \{raw.length()} bytes, back to \{@deflate.inflate(raw[:]).length()}")

  let gz = @gzip.gzip(body[:])
  println("gzip      -> \{gz.length()} bytes, back to \{@gzip.gunzip(gz[:]).length()}")

  let zl = @zlib.zlib(body[:])
  println("zlib      -> \{zl.length()} bytes, back to \{@zlib.unzlib(zl[:]).length()}")
}

original  -> 9000 bytes
deflate   -> 87 bytes, back to 9000
gzip      -> 105 bytes, back to 9000
zlib      -> 93 bytes, back to 9000

A container that carries a checksum checks it. Flip one byte of the trailing CRC and gunzip refuses, rather than hand back bytes that look right and are not.

fn main raise {
  let out : Array[Byte] = []
  for _ in 0..<200 {
    for b in "the quick brown fox jumps over the lazy dog. " {
      out.push((b.to_int() % 256).to_byte())
    }
  }
  let body = Bytes::from_array(out)

  let gz = @gzip.gzip(body[:])
  let bent = gz.to_array()
  bent[gz.length() - 8] = (bent[gz.length() - 8].to_int() ^ 0xFF).to_byte()
  try @gzip.gunzip(Bytes::from_array(bent)[:]) |> ignore catch {
    Checksum(..) => println("tampered  -> refused: the checksum does not match")
    _ => println("tampered  -> refused")
  } noraise {
    _ => println("tampered  -> accepted, which would be the bug")
  }
}

tampered  -> refused: the checksum does not match

The same input gives the same bytes every time: gzip writes a zero modification time by default, so a build stays reproducible.

fn main raise {
  let entries = [
    @zip.Entry::new("readme.txt", b"a member of an archive\n", mtime=1700000000L),
    @zip.Entry::new("data/table.csv", b"name,size\nreadme,24\n"),
  ]
  let archive = @zip.zip(entries[:])
  println("zip       -> \{archive.length()} bytes, \{@zip.names(archive[:]).length()} members")
  println("zip names -> \{@zip.names(archive[:]).join(", ")}")
  let back = @zip.unzip(archive[:])
  println("unzip     -> \{back.length()} members, first is \{back[0].name}")

  let files = [
    @tar.Entry::new("readme.txt", b"a member of an archive\n", mtime=1700000000L),
    @tar.Entry::new("data/table.csv", b"name,size\nreadme,24\n"),
  ]
  let tarball = @tar.tar(files[:])
  let gzipped = @tar.targz(files[:])
  println("tar       -> \{tarball.length()} bytes")
  println("tar.gz    -> \{gzipped.length()} bytes")
}

zip       -> 265 bytes, 2 members
zip names -> readme.txt, data/table.csv
unzip     -> 2 members, first is readme.txt
tar       -> 3072 bytes
tar.gz    -> 170 bytes

Listing reads only the directory; unzip expands on demand, so a caller can pull one member without touching the rest.

fn main raise {
  let entries = [@zip.Entry::new("secret.txt", b"attack at dawn")]

  let sealed = @zip.zip(entries[:], password="hunter2", aes=256)
  let opened = @zip.unzip(sealed[:], password="hunter2")
  println("aes-256  -> \{opened[0].name}, \{opened[0].data.length()} bytes")

  let parts = @zip.zip_split(entries[:], 64)
  println("volumes  -> \{parts.length()} pieces: \{@zip.volume_names("archive", parts.length()).join(", ")}")
  let joined = @zip.unzip_split(parts)
  println("rejoined -> \{joined[0].name}, \{joined[0].data.length()} bytes")
}

aes-256  -> secret.txt, 14 bytes
volumes  -> 3 pieces: archive.z01, archive.z02, archive.zip
rejoined -> secret.txt, 14 bytes

A wrong password is caught by the two-byte verification value, and a tampered payload by the tag, both before any byte is returned.

fn main raise {
  let out : Array[Byte] = []
  for i in 0..<4000 {
    for b in "the quick brown fox jumps over the lazy dog. " {
      out.push((b.to_int() % 256).to_byte())
    }
    out.push((i % 251).to_byte())
  }
  let source = Bytes::from_array(out)
  println("body      -> \{source.length()} bytes")

  let writer = @gzip.Writer::new(level=9)
  let packed : Array[Byte] = []
  let mut at = 0
  while at < source.length() {
    let stop = if source.length() - at < 4096 { source.length() } else { at + 4096 }
    for b in writer.push(source[at:stop]) { packed.push(b) }
    at = stop
  }
  for b in writer.finish() { packed.push(b) }
  let gzipped = Bytes::from_array(packed)
  println("gzip      -> \{gzipped.length()} bytes (\{100 - gzipped.length() * 100 / source.length()}% smaller)")

  let reader = @gzip.Reader::new()
  let got : Array[Byte] = []
  let mut at2 = 0
  while at2 < gzipped.length() {
    let stop = if gzipped.length() - at2 < 777 { gzipped.length() } else { at2 + 777 }
    for b in reader.push(gzipped[at2:stop]) { got.push(b) }
    at2 = stop
  }
  for b in reader.finish() { got.push(b) }
  println("gunzip    -> \{Bytes::from_array(got).length()} bytes, matches: \{Bytes::from_array(got) == source}")
}

body      -> 184000 bytes
gzip      -> 1983 bytes (99% smaller)
gunzip    -> 184000 bytes, matches: true

The home page runs the same algorithm in the browser; here it is in MoonBit, on a body fed back in pieces that fall inside headers and codes.