import {
"moonbitlang/core/compress/flate",
"moonbitlang/core/compress/gzip",
"moonbitlang/core/compress/zlib",
"moonbitlang/core/archive/zip",
}///|
test "README raw DEFLATE round-trip" {
let source = b"runtime-agnostic streaming compression"
let compressed = @flate.deflate_all(source)
@test.assert_eq(@flate.inflate_prefix(compressed).data, source)
}///|
test "README caller-buffer DEFLATE" {
let source = b"direct input and caller-owned output"
let compressor = @flate.Compressor(strategy=Standard(level=6))
let compressed_buffer = FixedArray::make(
@flate.deflate_bound(source.length()),
b'\x00',
)
guard compressor.compress_into(source, compressed_buffer.mut_view())
is Some(compressed_len) else {
@test.fail("deflate_bound was too small")
}
let compressed = Bytes::from_array(compressed_buffer[:compressed_len])
let decompressor = @flate.Decompressor()
let output = FixedArray::make(source.length(), b'\x00')
let decoded = decompressor.decompress_into(compressed, output.mut_view())
@test.assert_eq(decoded.consumed, compressed.length())
@test.assert_eq(Bytes::from_array(output[:decoded.produced]), source)
}///|
test "README prefix decode" {
// A record: a raw DEFLATE stream, then whatever follows it.
let payload = b"the stream ends with its final block"
let record = @flate.deflate_all(payload) + b"what follows"
let decompressor = @flate.Decompressor()
let result = decompressor.decompress(record, mode=Prefix)
@test.assert_eq(result.data, payload)
let rest = record[result.consumed:]
@test.assert_eq(rest.to_owned(), b"what follows")
}///|
test "README streaming IncrementalEncoder" {
let source = b"small buffers exercise suspension and resume"
let encoder = @flate.IncrementalEncoder()
let chunk = FixedArray::make(3, b'\x00')
let compressed = @buffer.Buffer()
let mut first = true
for ;; {
let input = if first { source[:] } else { b"" }
let result = encoder.step(
input,
chunk.mut_view(),
action=if first { Finish } else { Continue },
)
let consumed = result.consumed
let produced = result.produced
@test.assert_eq(consumed, if first { source.length() } else { 0 })
first = false
for i in 0..<produced {
compressed.write_byte(chunk[i])
}
if result.status is Done {
break
}
}
@test.assert_eq(@flate.inflate_prefix(compressed.to_bytes()).data, source)
}inflate_exact(input, dictionary?, max_output?, cancelled?, two_pass?=false) -> Bytes
inflate_prefix(input, dictionary?, max_output?, cancelled?, two_pass?=false) -> Decompressed
Decompressor::decompress(self, input, mode?=Exact, max_output?, cancelled?) -> Decompressed
Decompressor::decompress_into(self, input, output, mode?=Exact, cancelled?) -> DecompressResult///|
test "README exact and limited inflate" {
let source = b"bounded convenience API"
let compressed = @flate.deflate_all(source)
@test.assert_eq(
@flate.inflate_exact(compressed, max_output=source.length()),
source,
)
}///|
fn browse_zip(
size : UInt64,
read_range : (UInt64, Int32) -> Bytes raise,
) -> @zip.Directory raise {
let reader = @zip.DirectoryReader(
size,
limits=DirectoryLimits(max_directory_bytes=16777216UL, max_entries=100000UL),
)
let mut input : Bytes = b""
for ;; {
match reader.advance(input) {
NeedRead(range) => input = read_range(range.offset(), range.length())
Done(directory) => return directory
}
}
}///|
fn extract_entry(
directory : @zip.Directory,
index : Int32,
read_range : (UInt64, Int32) -> Bytes raise,
emit : (BytesView) -> Unit raise,
) -> Unit raise {
let reader = directory.open_entry(index)
let output = FixedArray::make(65536, b'\x00')
let mut input : Bytes = b""
for ;; {
let status = reader.step(input, output.mut_view())
let produced = reader.last_produced()
if produced > 0 {
emit(Bytes::from_array(output[:produced]))
}
match status {
NeedRead(range) => input = read_range(range.offset(), range.length())
NeedMoreOutput => input = b""
Done => return
}
}
}///|
test "README zip round-trip" {
let archive = @zip.Archive()
archive.add("hello.txt", b"hello, zip")
let bytes = @zip.write(archive)
let parsed = @zip.read_all(bytes)
@test.assert_eq(parsed.get("hello.txt"), Some(b"hello, zip"))
}///|
test "README incremental ZIP writer" {
// A real folder adapter passes a buffered file-write callback here.
let output = @buffer.Buffer()
let writer = @zip.Writer(chunk => output.write_bytes(chunk))
writer.add("small.txt", b"small file")
writer.begin_entry("chunked.txt", size=6UL)
writer.write(b"abc")
writer.write(b"def")
writer.end_entry()
writer.finish()
let archive = @zip.read_all(output.to_bytes())
@test.assert_eq(archive.get("chunked.txt"), Some(b"abcdef"))
}| Path | Implementation |
|---|---|
| Whole-buffer compression | deflate_all.mbt, lz77.mbt |
| Streaming compression | deflate.mbt, block_planner.mbt, lz77.mbt |
| Content-driven block splitting | split_plan.mbt |
| Iterated optimal parsing and splitting | optimal_parse.mbt, optimal_plan.mbt |
| Block encoding and bit output | block_writer.mbt, huffman_build.mbt, bitwriter.mbt |
| Whole-buffer decompression | inflate_all.mbt |
| Streaming decompression | inflate.mbt |
| Shared decoding tables and validation | huffman_table.mbt, tables.mbt, decode_rules.mbt |
///|
let codec = @flate.Compressor(strategy=Standard(level=6), fast_store=true)
///|
let raw = @flate.deflate_all(input, fast_store=true)
///|
let stream = @flate.IncrementalEncoder(level=6, fast_store=true)
///|
let archive_bytes = @zip.write(archive, fast_store=true)type Compressorfn Compressor::Compressor(strategy? : Strategy, dictionary? : BytesView, fast_store? : Bool) -> Compressorfn Compressor::compress_into(self : Compressor, input : BytesView, output : MutArrayView[Byte]) -> Int?type Decompressorfn Decompressor::decompress(self : Decompressor, input : BytesView, mode? : InputMode, max_output? : Int, cancelled? : () -> Bool) -> Decompressed raise InflateErrorfn Decompressor::decompress_into(self : Decompressor, input : BytesView, output : MutArrayView[Byte], mode? : InputMode, cancelled? : () -> Bool) -> DecompressResult raise InflateErrortype IncrementalDecoderfn IncrementalDecoder::step(self : IncrementalDecoder, input : BytesView, output : MutArrayView[Byte]) -> StepResult raise InflateErrortype IncrementalEncoderfn IncrementalEncoder::IncrementalEncoder(level? : Int, dictionary? : BytesView, fast_store? : Bool) -> IncrementalEncoderfn IncrementalEncoder::step(self : IncrementalEncoder, input : BytesView, output : MutArrayView[Byte], action? : DeflateAction) -> StepResultfn deflate_all(input : BytesView, strategy? : Strategy, dictionary? : BytesView, fast_store? : Bool) -> Bytesfn inflate_exact(input : BytesView, dictionary? : BytesView, max_output? : Int, cancelled? : () -> Bool, two_pass? : Bool) -> Bytes raise InflateErrorfn inflate_prefix(input : BytesView, dictionary? : BytesView, max_output? : Int, cancelled? : () -> Bool, two_pass? : Bool) -> Decompressed raise InflateErrorInstall
Installed by default