#bikallem/compress

#Features

• Pure MoonBit — no FFI required (optional native acceleration for blit/checksum)
• Multi-target: native, js, and wasm-gc backends
• Dynamic Huffman coding with optimal fixed/dynamic block selection
• Level-differentiated compression: fast greedy (1-3), lazy matching (4-9)
• SA-IS suffix array construction for O(n) bzip2 BWT
• Hardware-accelerated CRC-32 (PCLMULQDQ) and Adler-32 (SSSE3) on native, software fallback elsewhere
• Two-level Huffman table decompression with zero-copy direct output
• BytesView-based streaming API — zero-copy input slicing
• Signal protocol streaming — no callbacks, no trait objects, explicit control flow
• Async streaming for DEFLATE via MoonBit's async/io
• Cross-validated against Go's compress/* stdlib where applicable, plus external golden vectors for additional formats

#Table of Contents

• Packages
• Installation
• Quick Start
• Streaming API
  • Compression
  • Decompression
  • Format Wrappers
  • Async Streaming
• Compression Levels
• Checksums
• Performance
• License

#Packages

#Installation

moon add bikallem/compress

#Quick Start

// DEFLATE (level defaults to DefaultCompression)
let compressed = @flate.compress(data)
let compressed = @flate.compress(data, level=BestSpeed)
let decompressed = @flate.decompress(compressed)

// gzip
let compressed = @gzip.compress(data)
let compressed = @gzip.compress(data, level=BestCompression, header={ name: "data.txt", ..Header::default() })
let (decompressed, header) = @gzip.decompress(compressed)

// zlib (supports preset dictionaries)
let compressed = @zlib.compress(data)
let compressed = @zlib.compress(data, dict=my_dict, level=BestSpeed)
let decompressed = @zlib.decompress(compressed)

// LZW
let compressed = @lzw.compress(data, LSB, 8)
let decompressed = @lzw.decompress(compressed, LSB, 8)

// Brotli (level 0-11)
let compressed = @brotli.compress(data)
let compressed = @brotli.compress(data, level=Level(1))
let decompressed = @brotli.decompress(compressed)

// bzip2 (level 1-9, controls block size)
let compressed = @bzip2.compress(data)
let compressed = @bzip2.compress(data, level=9)
let decompressed = @bzip2.decompress(compressed)

// Zstandard
let compressed = @zstd.compress(data)
let compressed = @zstd.compress(data, level=Fast)
let compressed = @zstd.compress(data, dict=my_zstd_dict)
let decompressed = @zstd.decompress(compressed)
let decompressed = @zstd.decompress(compressed, dict=my_zstd_dict)

// LZ4 (independent-block frames)
let compressed = @lz4.compress(data)
let decompressed = @lz4.decompress(compressed)

// Checksums
let crc = @checksum.crc32(data[:])
let adler = @checksum.adler32(data[:])

#Streaming API

#Compression

let d = @flate.Deflater::new(level=BestSpeed)
match d.encode(Some(data[:])) {
  Ok => ()         // input buffered, no output yet
  Data(out) => ... // compressed output ready
  End => ...       // shouldn't happen mid-stream
  Error(e) => ...  // compression error
}
loop d.encode(None) {
  Data(out) => { write(out); continue d.encode(None) }
  End => break
  Ok | Error(_) => break
}

#Decompression

let d = @flate.Inflater::new()
d.src(compressed_chunk[:])
loop d.decode() {
  Await => { d.src(next_chunk[:]); continue d.decode() }
  Data(out) => { write(out); continue d.decode() }
  End => break
  Error(e) => ...
}

#Format Wrappers

// gzip with custom header
let d = @gzip.Deflater::new(header={ name: "data.txt", ..Header::default() })
// Access the header after decompression
let header = inflater.header()

// zlib with preset dictionary
let d = @zlib.Deflater::new(dict=my_dict)
let i = @zlib.Inflater::new(dict=my_dict)

// LZW with bit order and literal width
let d = @lzw.Deflater::new(MSB, 8)
let i = @lzw.Inflater::new(MSB, 8)

// Brotli
let d = @brotli.Deflater::new(level=Level(6))
let i = @brotli.Inflater::new()

// bzip2
let d = @bzip2.Deflater::new(level=9)
let i = @bzip2.Inflater::new()

// Zstandard
let d = @zstd.Deflater::new(level=Fast, dict=my_zstd_dict)
let i = @zstd.Inflater::new(dict=my_zstd_dict)

// LZ4 (buffered wrapper, independent-block frames only)
let d = @lz4.Deflater::new()
let i = @lz4.Inflater::new()

// Get remaining unprocessed input after decompression
let leftover = inflater.remaining()

#Async Streaming

// Async DEFLATE compression
async fn compress_stream(reader : &@io.Reader, writer : &@io.Writer) -> Unit {
  @flate.async.compress(reader, writer, level=BestSpeed)
}

// Async DEFLATE decompression
async fn decompress_stream(reader : &@io.Reader, writer : &@io.Writer) -> Unit {
  @flate.async.decompress(reader, writer)
}

#Compression Levels

#Checksums

let h = @checksum.CRC32::new()
h.update(chunk1[:])
h.update(chunk2[:])
let result = h.checksum()

#Performance

#DEFLATE

#bzip2

#LZW

#License