moonbit-community/flate/zip

README
E
InflateError
- ::CompressorCompressor::Compressor
- ::compressCompressor::compress
- ::compress_intoCompressor::compress_into
- ::DecompressorDecompressor::Decompressor
- ::decompress_intoDecompressor::decompress_into
- ::equalDeflateAction::equal
- ::not_equalDeflateAction::not_equal
- ::to_reprDeflateAction::to_repr
- ::DeflaterDeflater::Deflater
- ::is_finishedDeflater::is_finished
- ::last_consumedDeflater::last_consumed
- ::last_producedDeflater::last_produced
- ::resetDeflater::reset
- ::stepDeflater::step
- ::equalInflateErrorKind::equal
- ::not_equalInflateErrorKind::not_equal
- ::to_reprInflateErrorKind::to_repr
- ::InflaterInflater::Inflater
- ::is_finishedInflater::is_finished
- ::last_consumedInflater::last_consumed
- ::last_producedInflater::last_produced
- ::resetInflater::reset
- ::stepInflater::step
- ::step_intoInflater::step_into
- ::equalStatus::equal
- ::not_equalStatus::not_equal
- ::to_reprStatus::to_repr
V
DEFLATE_BLOCK_SIZE
V
HASH_BITS
V
HUFFMAN_CHUNK_BITS
V
HUFFMAN_VALUE_SHIFT
V
MAX_NUM_DIST
V
MAX_NUM_LIT
V
MIN_LOOKAHEAD
V
NUM_CODES
V
OPTIMAL_MASTER_BLOCK
V
WINDOW_SIZE
V
deflate_all
V
deflate_all_optimal
V
deflate_all_split
V
deflate_bound
V
deflate_into
V
inflate_all
V
inflate_all_limited
V
inflate_exact
V
inflate_into

moonbit-community/flate/zip does not have a README file

ZipError

pub suberror ZipError {
  ZipError(ZipErrorKind, String)
}

Structured ZIP failure: a stable category plus a human-readable diagnostic.

Archive::Archive

source

fn Archive::Archive() -> Archive

Create an empty archive.

Archive::add

source

fn Archive::add(self : Archive, name : String, data : BytesView, compression? : Compression, data_descriptor? : Bool) -> Unit

Append a new entry whose payload is data. data is owned by the archive, so later Bytes mutation cannot corrupt it. The default method is Deflate; pass Store to keep the payload verbatim. Setting data_descriptor=true emits the entry in streaming form (zeroed local sizes + a trailing data descriptor).

Archive::clone

source

fn Archive::clone(self : Archive) -> Archive

Returns an independently mutable snapshot of this archive. The clone shares entry payloads and preserved source records (immutable Bytes) but owns a fresh entries array, so add/replace/remove on either side never affects the other. add and replace defensively own their inputs.

Archive::comment

source

fn Archive::comment(self : Archive) -> BytesView

The archive-level comment bytes (empty when none).

Archive::entries

source

fn Archive::entries(self : Archive) -> ArrayView[Entry]

The archive's entry list in order.

Archive::fork

source

#deprecated("use `Archive::clone` instead")
fn Archive::fork(self : Archive) -> Archive

Deprecated alias of Archive::clone.

Archive::get

source

fn Archive::get(self : Archive, name : StringView) -> BytesView?

A read-only view of an entry payload, or None when absent.

Archive::remove

source

fn Archive::remove(self : Archive, name : StringView) -> Bool

Remove the entry named name. Returns false when no such entry exists.

Archive::replace

source

fn Archive::replace(self : Archive, name : StringView, data : BytesView) -> Bool

Replace the payload of the entry named name. The entry keeps its method policy but drops its raw source records (the next write re-encodes it). Its original position in the archive is retained, so a byte-preserving write keeps the entry where it was. Returns false when no such entry exists.

Archive::retained_size_estimate

source

fn Archive::retained_size_estimate(self : Archive) -> Int64

Conservatively estimates bytes retained by this materialized archive: the archive comment, captured trailer records, and per-entry payloads, names, and preserved source records (each with a bookkeeping reserve). Payloads and records are counted exactly; only allocator/container overhead uses a fixed per-entry reserve. The source package buffer an archive was read from is not included.

Archive::set_comment

source

fn Archive::set_comment(self : Archive, comment : BytesView) -> Unit

Replace the archive-level comment. Long comments (over 65535 bytes) are rejected at write time. Changing the comment invalidates a retained end-record template, so a later byte-preserving write regenerates the trailer with the new comment.

Compression

source

pub(all) enum Compression {
  Store
  Deflate
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The ZIP compression methods this package can read and write.

Compression::equal

source

fn Compression::equal(Compression, Compression) -> Bool

Compression::not_equal

source

fn Compression::not_equal(x : Compression, y : Compression) -> Bool

Compression::to_repr

source

fn Compression::to_repr(Compression) -> @moonbitlang/core/debug.Repr
Repr

Entry

source

pub struct Entry {
  // private fields
}

A single archive entry: its decoded payload plus the metadata the central directory carried for it. Entries produced by read also retain their raw source records (raw_local_record / raw_central_record) for byte-preserving rewrites; entries built with Archive::add do not.

Entry::compression

source

fn Entry::compression(self : Entry) -> Compression

Entry::crc32

source

fn Entry::crc32(self : Entry) -> UInt

The entry's stored CRC-32: the central-directory value for entries read from an archive, or computed at add time for entries created in memory.

Entry::data

source

fn Entry::data(self : Entry) -> BytesView

Entry::data_descriptor

source

fn Entry::data_descriptor(self : Entry) -> Bool

Entry::name

source

fn Entry::name(self : Entry) -> String

Entry::raw_central_record

source

fn Entry::raw_central_record(self : Entry) -> BytesView?

The original central directory record bytes of a pristine entry read from an archive, or None for entries created in memory or replaced after a read.

Entry::raw_local_record

source

fn Entry::raw_local_record(self : Entry) -> BytesView?

The original local header + payload (+ data descriptor) bytes of a pristine entry read from an archive, or None for entries created in memory or replaced after a read.

LimitKind

source

pub(all) enum LimitKind {
  PackageBytes
  Entries
  EntryUncompressedBytes
  TotalUncompressedBytes
  PreservedSourceBytes
  OutputBytes
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Which bounded resource was exceeded during a bounded read or write. The payload-related kinds guard against decompression bombs; PreservedSource bounds the raw local/central records retained for byte-preserving rewrites; OutputBytes bounds a serialization's total size.

LimitKind::equal

source

fn LimitKind::equal(LimitKind, LimitKind) -> Bool

LimitKind::not_equal

source

fn LimitKind::not_equal(x : LimitKind, y : LimitKind) -> Bool

LimitKind::to_repr

source

fn LimitKind::to_repr(LimitKind) -> @moonbitlang/core/debug.Repr
Repr

ReadLimits

source

pub struct ReadLimits {
  max_package_bytes : Int
  max_entries : Int
  max_entry_uncompressed_bytes : Int
  max_total_uncompressed_bytes : Int
  max_preserved_source_bytes : Int
}

Resource bounds applied to a bounded read. Every field is a ceiling in bytes (or, for max_entries, a count); ReadLimits::default() imposes no limits. max_preserved_source_bytes bounds the raw local/central records retained in memory so a byte-preserving rewrite cannot be weaponized as an unbounded retention bomb.

ReadLimits::default

source

fn ReadLimits::default() -> ReadLimits

The default, unlimited resource bounds.

ReadLimits::with_entries_limit

source

fn ReadLimits::with_entries_limit(self : ReadLimits, limit : Int) -> ReadLimits

A copy of self with a new entry-count ceiling.

ReadLimits::with_entry_limit

source

fn ReadLimits::with_entry_limit(self : ReadLimits, limit : Int) -> ReadLimits

A copy of self with a new per-entry uncompressed ceiling.

ReadLimits::with_package_limit

source

fn ReadLimits::with_package_limit(self : ReadLimits, limit : Int) -> ReadLimits

A copy of self with a new package-size ceiling.

ReadLimits::with_preserved_source_limit

source

fn ReadLimits::with_preserved_source_limit(self : ReadLimits, limit : Int) -> ReadLimits

A copy of self with a new preserved-source-record ceiling.

ReadLimits::with_total_limit

source

fn ReadLimits::with_total_limit(self : ReadLimits, limit : Int) -> ReadLimits

A copy of self with a new total uncompressed ceiling.

Writer

source

pub struct Writer {
  // private fields
}

An incremental ZIP writer over a synchronous byte sink. add handles an already loaded file; begin_entry/write/end_entry handle bounded chunks. Only central-directory records and reusable codec buffers are retained. The sink must consume each view before returning. A sink exception poisons the writer and is propagated unchanged; no further output can be emitted.

Writer::Writer

source

fn Writer::Writer(sink : (BytesView) -> Unit raise, level? : Int, fast_store? : Bool) -> Writer

Create a ZIP writer. The sink supplies file/socket I/O or collects chunks; this package itself performs no I/O. Calling finish writes the directory. Optional fast_store applies to Deflate entries: whole-file detection for add, per-block detection for chunked writes. It is off by default and may increase output size. ZIP entry methods are unchanged.

Writer::add

source

fn Writer::add(self : Writer, name : String, data : Bytes, compression? : Compression) -> Unit raise

Compress and emit one complete file immediately. Reuses a whole-buffer compressor, avoiding the staging overhead of chunked DEFLATE for small files. Stored files are sent directly to the sink without an intermediate copy.

Writer::begin_entry

source

fn Writer::begin_entry(self : Writer, name : String, compression? : Compression, size? : UInt64) -> Unit raise

Open a chunked entry. Supply the known uncompressed size to use classic headers when it fits safely; unknown sizes reserve ZIP64 fields up front. The declared size is checked before accepting input and before closing.

Writer::end_entry

source

fn Writer::end_entry(self : Writer) -> Unit raise

Finish the current entry and emit its data descriptor. The next file may then be started; the writer retains only the completed directory record.

Writer::finish

source

fn Writer::finish(self : Writer, comment? : BytesView) -> Unit raise

Write the central directory and close the ZIP. Further writes are rejected. The optional archive comment must fit the ZIP 16-bit comment length.

Writer::is_failed

source

fn Writer::is_failed(self : Writer) -> Bool

Whether a sink failure has made this writer unusable.

Writer::is_finished

source

fn Writer::is_finished(self : Writer) -> Bool

Whether the directory and archive trailer have been successfully emitted.

Writer::position

source

fn Writer::position(self : Writer) -> UInt64

Number of successfully emitted bytes, including headers and descriptors.

Writer::write

source

fn Writer::write(self : Writer, bytes : BytesView) -> Unit raise

Consume a chunk of the current entry, updating CRC while its bytes are hot. Produced compressed blocks are sent to the sink before this call returns.

ZipErrorKind

source

pub(all) enum ZipErrorKind {
  Truncated
  InvalidSignature
  MissingEndOfCentral
  UnsupportedCompression(Int)
  InvalidUtf8
  UnsupportedFeature
  LimitExceeded(LimitKind, Int, Int)
  Cancelled
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Machine-readable category for a ZIP container failure. The accompanying ZipError message is intended for diagnostics rather than branching.

ZipErrorKind::equal

source

fn ZipErrorKind::equal(ZipErrorKind, ZipErrorKind) -> Bool

ZipErrorKind::not_equal

source

fn ZipErrorKind::not_equal(x : ZipErrorKind, y : ZipErrorKind) -> Bool

ZipErrorKind::to_repr

source

fn ZipErrorKind::to_repr(ZipErrorKind) -> @moonbitlang/core/debug.Repr
Repr

CENTRAL_HEADER_SIG

source

let CENTRAL_HEADER_SIG : UInt

DATA_DESCRIPTOR_SIG

source

let DATA_DESCRIPTOR_SIG : UInt

END_OF_CENTRAL_SIG

source

let END_OF_CENTRAL_SIG : UInt

FLAG_DATA_DESCRIPTOR

source

let FLAG_DATA_DESCRIPTOR : Int

FLAG_DEFLATE_STRENGTH

source

let FLAG_DEFLATE_STRENGTH : Int

FLAG_ENCRYPTED

source

let FLAG_ENCRYPTED : Int

FLAG_UTF8

source

let FLAG_UTF8 : Int

LOCAL_HEADER_SIG

source

let LOCAL_HEADER_SIG : UInt

MAX_U32

source

let MAX_U32 : UInt

ZIP64_EOCD_SIG

source

let ZIP64_EOCD_SIG : UInt

ZIP64_EXTRA_ID

source

let ZIP64_EXTRA_ID : Int

ZIP64_LOCATOR_SIG

source

let ZIP64_LOCATOR_SIG : UInt

read

source

fn read(bytes : BytesView, limits? : ReadLimits, cancelled? : () -> Bool) -> Archive raise ZipError

Read a ZIP archive from bytes, decoding every entry. limits bounds the package size, entry count, per-entry and total decompressed bytes, and the source records retained for byte-preserving rewrites; cancelled is polled across parsing and decoding. Each entry exposes the central directory's stored CRC-32 via Entry::crc32; it is not verified during this read — callers that need integrity checking compare it against @checksum.crc32(entry.data()). Failures carry a stable ZipErrorKind plus a diagnostic.

write

source

fn write(archive : Archive, level? : Int, fast_store? : Bool) -> Bytes raise ZipError

Serialize archive into a ZIP byte stream, encoding every entry fresh (DEFLATE by default, STORED when the entry says so). level 0-9 trades speed for ratio on the DEFLATE payloads. fast_store defaults to false. Fresh DEFLATE payloads may use heuristic stored blocks when enabled; ZIP methods and preserved records stay intact.

write_limited

source

fn write_limited(archive : Archive, max_output_bytes~ : Int, level? : Int, fast_store? : Bool) -> Bytes raise ZipError

Serialize archive like write while enforcing a hard output ceiling. The output is sized first, so an over-limit archive raises LimitExceeded(OutputBytes, ...) without materializing a candidate buffer. fast_store defaults to false. Fresh DEFLATE payloads may use heuristic stored blocks when enabled; ZIP methods and preserved records stay intact.

write_preserving

source

fn write_preserving(archive : Archive, level? : Int, fast_store? : Bool) -> Bytes raise ZipError

Serialize archive, re-emitting pristine entries (those read from a previous archive and never replaced) byte-for-byte from their retained source records, so unchanged packages round-trip without loss. Entries created or replaced in memory are encoded fresh. fast_store defaults to false. Fresh DEFLATE payloads may use heuristic stored blocks when enabled; ZIP methods and preserved records stay intact.

write_preserving_limited

source

fn write_preserving_limited(archive : Archive, max_output_bytes~ : Int, level? : Int, fast_store? : Bool) -> Bytes raise ZipError

Serialize archive like write_preserving while enforcing a hard output ceiling (sized first, so an over-limit archive raises without materializing a candidate buffer). fast_store defaults to false. Fresh DEFLATE payloads may use heuristic stored blocks when enabled; ZIP methods and preserved records stay intact.

Source Files

Site source Report issue Packages Build queue Skills Statistics

#ZipError

#Archive

#Archive::Archive

#Archive::add

#Archive::clone

#Archive::comment

#Archive::entries

#Archive::fork

#Archive::get

#Archive::remove

#Archive::replace

#Archive::retained_size_estimate

#Archive::set_comment

#Compression

#Compression::equal

#Compression::not_equal

#Compression::to_repr

#Entry

#Entry::compression

#Entry::crc32

#Entry::data

#Entry::data_descriptor

#Entry::name

#Entry::raw_central_record

#Entry::raw_local_record

#LimitKind

#LimitKind::equal

#LimitKind::not_equal

#LimitKind::to_repr

#ReadLimits

#ReadLimits::default

#ReadLimits::with_entries_limit

#ReadLimits::with_entry_limit

#ReadLimits::with_package_limit

#ReadLimits::with_preserved_source_limit

#ReadLimits::with_total_limit

#Writer

#Writer::Writer

#Writer::add

#Writer::begin_entry

#Writer::end_entry

#Writer::finish

#Writer::is_failed

#Writer::is_finished

#Writer::position

#Writer::write

#ZipErrorKind

#ZipErrorKind::equal

#ZipErrorKind::not_equal

#ZipErrorKind::to_repr

#CENTRAL_HEADER_SIG

#DATA_DESCRIPTOR_SIG

#END_OF_CENTRAL_SIG

#FLAG_DATA_DESCRIPTOR

#FLAG_DEFLATE_STRENGTH

#FLAG_ENCRYPTED

#FLAG_UTF8

#LOCAL_HEADER_SIG

#MAX_U32

#ZIP64_EOCD_SIG

#ZIP64_EXTRA_ID

#ZIP64_LOCATOR_SIG

#read

#write

#write_limited

#write_preserving

#write_preserving_limited

Source Files

ZipError

Archive

Archive::Archive

Archive::add

Archive::clone

Archive::comment

Archive::entries

Archive::fork

Archive::get

Archive::remove

Archive::replace

Archive::retained_size_estimate

Archive::set_comment

Compression

Compression::equal

Compression::not_equal

Compression::to_repr

Entry

Entry::compression

Entry::crc32

Entry::data

Entry::data_descriptor

Entry::name

Entry::raw_central_record

Entry::raw_local_record

LimitKind

LimitKind::equal

LimitKind::not_equal

LimitKind::to_repr

ReadLimits

ReadLimits::default

ReadLimits::with_entries_limit

ReadLimits::with_entry_limit

ReadLimits::with_package_limit

ReadLimits::with_preserved_source_limit

ReadLimits::with_total_limit

Writer

Writer::Writer

Writer::add

Writer::begin_entry

Writer::end_entry

Writer::finish

Writer::is_failed

Writer::is_finished

Writer::position

Writer::write

ZipErrorKind

ZipErrorKind::equal

ZipErrorKind::not_equal

ZipErrorKind::to_repr

CENTRAL_HEADER_SIG

DATA_DESCRIPTOR_SIG

END_OF_CENTRAL_SIG

FLAG_DATA_DESCRIPTOR

FLAG_DEFLATE_STRENGTH

FLAG_ENCRYPTED

FLAG_UTF8

LOCAL_HEADER_SIG

MAX_U32

ZIP64_EOCD_SIG

ZIP64_EXTRA_ID

ZIP64_LOCATOR_SIG

read

write

write_limited

write_preserving

write_preserving_limited