@patrickdk77/archive-defuse 0.0.0-stage → 0.1.0

package/dist/lzma1/range-encoder.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RangeEncoder = void 0;
+exports.getBitPrice = getBitPrice;
+exports.getBitTreePrice = getBitTreePrice;
+exports.getReverseBitTreePrice = getReverseBitTreePrice;
+exports.getDirectBitsPrice = getDirectBitsPrice;
+// Copied from lzma1 (Apache-2.0, Copyright Filip Seman) and changed for lzma-defuse. NOTICE in this folder lists the changes.
+const range_coder_1 = require("./range-coder");
+const MOVE_REDUCING_BITS = 4;
+const BIT_PRICE_SHIFT_BITS = 4;
+/**
+ * Price (approximate cost in 1/16 bits) of encoding a bit with a given
+ * probability, indexed by `probability >>> MOVE_REDUCING_BITS`.
+ */
+const PRICES = createPriceTable();
+function createPriceTable() {
+    const prices = new Uint32Array(range_coder_1.BIT_MODEL_TOTAL >>> MOVE_REDUCING_BITS);
+    for (let i = (1 << MOVE_REDUCING_BITS) / 2; i < range_coder_1.BIT_MODEL_TOTAL; i += 1 << MOVE_REDUCING_BITS) {
+        // Approximate -log2(i / BIT_MODEL_TOTAL) using repeated squaring.
+        let w = i;
+        let bitCount = 0;
+        for (let j = 0; j < BIT_PRICE_SHIFT_BITS; ++j) {
+            w *= w;
+            bitCount <<= 1;
+            while (w >= 0x10000) {
+                w >>>= 1;
+                ++bitCount;
+            }
+        }
+        prices[i >> MOVE_REDUCING_BITS] = (range_coder_1.BIT_MODEL_TOTAL_BITS << BIT_PRICE_SHIFT_BITS) - 15 - bitCount;
+    }
+    return prices;
+}
+function getBitPrice(prob, bit) {
+    return PRICES[(prob ^ (-bit & (range_coder_1.BIT_MODEL_TOTAL - 1))) >>> MOVE_REDUCING_BITS];
+}
+/** Price of a `bits`-bit symbol coded MSB-first with the bit tree at `offset`. */
+function getBitTreePrice(probs, offset, bits, symbolIn) {
+    let symbol = symbolIn;
+    let price = 0;
+    symbol |= 1 << bits;
+    do {
+        const bit = symbol & 1;
+        symbol >>>= 1;
+        price += getBitPrice(probs[offset + symbol], bit);
+    } while (symbol !== 1);
+    return price;
+}
+/** Price of a `bits`-bit symbol coded LSB-first with the bit tree at `offset`. */
+function getReverseBitTreePrice(probs, offset, bits, symbolIn) {
+    let symbol = symbolIn;
+    let price = 0;
+    let index = 1;
+    for (let i = 0; i < bits; ++i) {
+        const bit = symbol & 1;
+        symbol >>>= 1;
+        price += getBitPrice(probs[offset + index], bit);
+        index = (index << 1) | bit;
+    }
+    return price;
+}
+/** Price of bits coded with a fixed 50% probability. */
+function getDirectBitsPrice(count) {
+    return count << BIT_PRICE_SHIFT_BITS;
+}
+/**
+ * Range encoder writing to its own growable buffer.
+ *
+ * `low` needs 33 bits (32 bits plus a carry), so it is kept as a regular
+ * number instead of an int32. Doubles represent integers up to 2^53 exactly.
+ *
+ * Performance: like `RangeDecoder`, the methods that encode several bits
+ * keep `range` and `low` in local variables for the whole symbol.
+ */
+class RangeEncoder {
+    low = 0;
+    range = 0xffffffff;
+    cache = 0;
+    cacheSize = 1;
+    buf;
+    size = 0;
+    constructor(initialCapacity) {
+        this.buf = new Uint8Array(Math.max(64, initialCapacity));
+    }
+    /** Appends bytes that are not range coded, e.g. a header. */
+    writeBytes(bytes) {
+        this.ensureCapacity(bytes.length);
+        this.buf.set(bytes, this.size);
+        this.size += bytes.length;
+    }
+    /** Returns a copy of the output written so far and empties the buffer. */
+    take() {
+        const bytes = this.buf.slice(0, this.size);
+        this.size = 0;
+        return bytes;
+    }
+    /** Flushes all pending bytes and returns the rest of the output. */
+    finish() {
+        let low = this.low;
+        for (let i = 0; i < 5; ++i) {
+            low = this.shiftLow(low);
+        }
+        this.low = low;
+        return this.size === this.buf.length ? this.buf : this.buf.slice(0, this.size);
+    }
+    encodeBit(probs, index, bit) {
+        const prob = probs[index];
+        const bound = (this.range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+        if (bit === 0) {
+            this.range = bound;
+            probs[index] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
+        }
+        else {
+            this.low += bound;
+            this.range -= bound;
+            probs[index] = prob - (prob >>> range_coder_1.MOVE_BITS);
+        }
+        if (this.range < range_coder_1.TOP_VALUE) {
+            this.range = (this.range << 8) >>> 0;
+            this.low = this.shiftLow(this.low);
+        }
+    }
+    /** Encodes a `bits`-bit symbol MSB-first with the bit tree at `offset`. */
+    encodeBitTree(probs, offset, bits, symbol) {
+        let range = this.range;
+        let low = this.low;
+        let index = 1;
+        for (let i = bits - 1; i >= 0; --i) {
+            const bit = (symbol >>> i) & 1;
+            const prob = probs[offset + index];
+            const bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+            if (bit === 0) {
+                range = bound;
+                probs[offset + index] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
+            }
+            else {
+                low += bound;
+                range -= bound;
+                probs[offset + index] = prob - (prob >>> range_coder_1.MOVE_BITS);
+            }
+            if (range < range_coder_1.TOP_VALUE) {
+                range = (range << 8) >>> 0;
+                low = this.shiftLow(low);
+            }
+            index = (index << 1) | bit;
+        }
+        this.range = range;
+        this.low = low;
+    }
+    /** Encodes a `bits`-bit symbol LSB-first with the bit tree at `offset`. */
+    encodeReverseBitTree(probs, offset, bits, symbolIn) {
+        let symbol = symbolIn;
+        let range = this.range;
+        let low = this.low;
+        let index = 1;
+        for (let i = 0; i < bits; ++i) {
+            const bit = symbol & 1;
+            symbol >>>= 1;
+            const prob = probs[offset + index];
+            const bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+            if (bit === 0) {
+                range = bound;
+                probs[offset + index] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
+            }
+            else {
+                low += bound;
+                range -= bound;
+                probs[offset + index] = prob - (prob >>> range_coder_1.MOVE_BITS);
+            }
+            if (range < range_coder_1.TOP_VALUE) {
+                range = (range << 8) >>> 0;
+                low = this.shiftLow(low);
+            }
+            index = (index << 1) | bit;
+        }
+        this.range = range;
+        this.low = low;
+    }
+    /** Encodes a literal byte with the 0x100-leaf bit tree at `offset`. */
+    encodeLiteral(probs, offset, symbol) {
+        this.encodeBitTree(probs, offset, 8, symbol);
+    }
+    /**
+     * Encodes a literal after a match. The bits of `matchByte` (the byte at
+     * rep0) select separate probabilities until the first bit that differs.
+     */
+    encodeMatchedLiteral(probs, offset, symbolIn, matchByteIn) {
+        let symbol = symbolIn;
+        let matchByte = matchByteIn;
+        let range = this.range;
+        let low = this.low;
+        let matchOffset = 0x100;
+        symbol |= 0x100;
+        do {
+            matchByte <<= 1;
+            const matchBit = matchByte & matchOffset;
+            const index = offset + matchOffset + matchBit + (symbol >>> 8);
+            const bit = (symbol >>> 7) & 1;
+            const prob = probs[index];
+            const bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+            if (bit === 0) {
+                range = bound;
+                probs[index] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
+            }
+            else {
+                low += bound;
+                range -= bound;
+                probs[index] = prob - (prob >>> range_coder_1.MOVE_BITS);
+            }
+            if (range < range_coder_1.TOP_VALUE) {
+                range = (range << 8) >>> 0;
+                low = this.shiftLow(low);
+            }
+            symbol <<= 1;
+            matchOffset &= ~(matchByte ^ symbol);
+        } while (symbol < 0x10000);
+        this.range = range;
+        this.low = low;
+    }
+    /** Encodes the `count` low bits of `value` with a fixed 50% probability. */
+    encodeDirectBits(value, countIn) {
+        let count = countIn;
+        let range = this.range;
+        let low = this.low;
+        do {
+            range >>>= 1;
+            if (((value >>> --count) & 1) !== 0) {
+                low += range;
+            }
+            if (range < range_coder_1.TOP_VALUE) {
+                range = (range << 8) >>> 0;
+                low = this.shiftLow(low);
+            }
+        } while (count !== 0);
+        this.range = range;
+        this.low = low;
+    }
+    /**
+     * Moves the top byte of `low` to the output and returns the new `low`.
+     * A run of 0xFF bytes is held back (`cache` + `cacheSize`) until it is
+     * known whether a carry will propagate into it.
+     */
+    shiftLow(low) {
+        if (low < 0xff000000 || low >= 0x100000000) {
+            const carry = low >= 0x100000000 ? 1 : 0;
+            this.ensureCapacity(this.cacheSize);
+            const buf = this.buf;
+            let size = this.size;
+            buf[size++] = (this.cache + carry) & 0xff;
+            for (let i = 1; i < this.cacheSize; ++i) {
+                buf[size++] = (0xff + carry) & 0xff;
+            }
+            this.size = size;
+            this.cacheSize = 0;
+            this.cache = (low >>> 24) & 0xff;
+        }
+        ++this.cacheSize;
+        return (low & 0x00ffffff) * 256;
+    }
+    ensureCapacity(extra) {
+        if (this.size + extra > this.buf.length) {
+            const grown = new Uint8Array(Math.max(this.size + extra, this.buf.length * 2));
+            grown.set(this.buf.subarray(0, this.size));
+            this.buf = grown;
+        }
+    }
+}
+exports.RangeEncoder = RangeEncoder;

package/dist/lzma1-stream.d.ts

@@ -0,0 +1,60 @@
+export interface Lzma1Props {
+    lc: number;
+    lp: number;
+    pb: number;
+    dictSize: number;
+}
+/** Splits the properties byte of an LZMA header or 7z coder: (pb * 5 + lp) * 9 + lc. */
+export declare function decodeProps(byte: number, dictSize: number): Lzma1Props;
+/** The dictionary a stream allocates at most: what the properties say, but no more than the data when its size is known. */
+export declare function effectiveDictSize(dictSize: number, size: number | undefined): number;
+/**
+ * Decodes raw LZMA1 data that arrives in pieces, built from lzma1's decoder like its AloneDecoder, with what this
+ * package needs to judge the end of the data: where it ended, whether an end marker ended it, and what follows.
+ *
+ * With a known size, decoding stops after that many bytes. `probe` then checks what the range coder holds next: a
+ * finished coder ends the data, an end marker may follow, and anything else means the data goes on past the size.
+ * Without a known size the data must end with an end marker.
+ */
+export declare class Lzma1Stream {
+    private readonly lz;
+    private readonly lzma;
+    private readonly rc;
+    private readonly size;
+    private readonly probe;
+    private pending;
+    /** Input offset of pending[0]. */
+    private base;
+    private rcStarted;
+    /** Bytes decoded after the end are no longer passed on, which the end-marker probe relies on. */
+    private sealed;
+    /** Bytes after the end, the first PROBE_KEEP of them. */
+    private after;
+    /** Set once the data has ended. */
+    done: boolean;
+    /** An end marker ended the data. */
+    endMarker: boolean;
+    /** Input bytes the data took, once done. */
+    consumed: number;
+    /** Input bytes after the end of the data. */
+    trailing: number;
+    /**
+     * @param size Decoded size, or undefined when an end marker ends the data
+     * @param sink Receives decoded bytes. The chunk is only valid during the call.
+     * @param probe Look past a known size for an end marker or more data, as for an .lzma file
+     */
+    constructor(props: Lzma1Props, size: number | undefined, sink: (chunk: Uint8Array) => void, probe: boolean);
+    /** Bytes decoded so far. */
+    get decoded(): number;
+    /** Decodes as much of `chunk` as possible. */
+    write(chunk: Uint8Array): void;
+    /** Decodes the rest. Throws when the data is incomplete or goes on past its declared size. */
+    end(): void;
+    private needsProbe;
+    private keepAfter;
+    private decode;
+    private finish;
+    /** Decodes one more symbol, which must be the end marker. */
+    private runProbe;
+}
+export declare function concat(a: Uint8Array, b: Uint8Array): Uint8Array;

package/dist/lzma1-stream.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lzma1Stream = void 0;
+exports.decodeProps = decodeProps;
+exports.effectiveDictSize = effectiveDictSize;
+exports.concat = concat;
+const errors_1 = require("./errors");
+const lz_decoder_1 = require("./lzma1/lz-decoder");
+const lzma_decoder_1 = require("./lzma1/lzma-decoder");
+const range_decoder_1 = require("./lzma1/range-decoder");
+/**
+ * Upper bound of input bytes a single LZMA symbol can consume, as lzma1's alone-decoder.ts defines it. Decoding pauses
+ * while fewer are left, so a symbol never runs out of input halfway.
+ */
+const INPUT_MARGIN = 64;
+const DICT_SIZE_MIN = 1 << 12;
+/** Bytes after the end of the data kept for the end-marker probe. The marker and the range coder flush fit in 16. */
+const PROBE_KEEP = 256;
+/** Splits the properties byte of an LZMA header or 7z coder: (pb * 5 + lp) * 9 + lc. */
+function decodeProps(byte, dictSize) {
+    if (byte >= 9 * 5 * 5)
+        throw new errors_1.DataError('invalid LZMA properties');
+    return { lc: byte % 9, lp: Math.floor(byte / 9) % 5, pb: Math.floor(byte / 45), dictSize };
+}
+/** The dictionary a stream allocates at most: what the properties say, but no more than the data when its size is known. */
+function effectiveDictSize(dictSize, size) {
+    const d = Math.max(dictSize, DICT_SIZE_MIN);
+    return size === undefined ? d : Math.max(Math.min(d, size), 1);
+}
+/**
+ * Decodes raw LZMA1 data that arrives in pieces, built from lzma1's decoder like its AloneDecoder, with what this
+ * package needs to judge the end of the data: where it ended, whether an end marker ended it, and what follows.
+ *
+ * With a known size, decoding stops after that many bytes. `probe` then checks what the range coder holds next: a
+ * finished coder ends the data, an end marker may follow, and anything else means the data goes on past the size.
+ * Without a known size the data must end with an end marker.
+ */
+class Lzma1Stream {
+    lz;
+    lzma;
+    rc = new range_decoder_1.RangeDecoder();
+    size;
+    probe;
+    pending = new Uint8Array(0);
+    /** Input offset of pending[0]. */
+    base = 0;
+    rcStarted = false;
+    /** Bytes decoded after the end are no longer passed on, which the end-marker probe relies on. */
+    sealed = false;
+    /** Bytes after the end, the first PROBE_KEEP of them. */
+    after = new Uint8Array(0);
+    /** Set once the data has ended. */
+    done = false;
+    /** An end marker ended the data. */
+    endMarker = false;
+    /** Input bytes the data took, once done. */
+    consumed = 0;
+    /** Input bytes after the end of the data. */
+    trailing = 0;
+    /**
+     * @param size Decoded size, or undefined when an end marker ends the data
+     * @param sink Receives decoded bytes. The chunk is only valid during the call.
+     * @param probe Look past a known size for an end marker or more data, as for an .lzma file
+     */
+    constructor(props, size, sink, probe) {
+        this.size = size;
+        this.probe = probe;
+        this.lz = new lz_decoder_1.LzDecoder(effectiveDictSize(props.dictSize, size), chunk => {
+            if (!this.sealed)
+                sink(chunk);
+        });
+        this.lzma = new lzma_decoder_1.LzmaDecoder(this.lz, this.rc, props.lc, props.lp, props.pb);
+    }
+    /** Bytes decoded so far. */
+    get decoded() {
+        return this.lzma.outPos;
+    }
+    /** Decodes as much of `chunk` as possible. */
+    write(chunk) {
+        if (this.done) {
+            this.keepAfter(chunk);
+            return;
+        }
+        this.decode(concat(this.pending, chunk), false);
+    }
+    /** Decodes the rest. Throws when the data is incomplete or goes on past its declared size. */
+    end() {
+        if (!this.done)
+            this.decode(this.pending, true);
+        if (!this.done)
+            throw new errors_1.DataError('the data ends before its end', true);
+        if (this.needsProbe)
+            this.runProbe();
+    }
+    needsProbe = false;
+    keepAfter(chunk) {
+        this.trailing += chunk.length;
+        if (this.after.length < PROBE_KEEP)
+            this.after = concat(this.after, chunk.subarray(0, PROBE_KEEP - this.after.length));
+    }
+    decode(input, isLast) {
+        const rc = this.rc;
+        if (!this.rcStarted) {
+            if (input.length < range_decoder_1.RANGE_DECODER_INIT_SIZE) {
+                // An empty stream of known size 0 may hold nothing at all.
+                if (isLast && this.size === 0 && input.length === 0) {
+                    this.finish(input, 0, false);
+                    return;
+                }
+                if (isLast)
+                    throw new errors_1.DataError('the data ends before its end', true);
+                this.pending = input.slice();
+                return;
+            }
+            try {
+                rc.init(input, 0);
+            }
+            catch (e) {
+                throw new errors_1.DataError(String(e.message).replace(/^Corrupted input: /, ''));
+            }
+            this.rcStarted = true;
+        }
+        else
+            rc.setInput(input, 0);
+        const outLimit = this.size ?? Number.POSITIVE_INFINITY;
+        const inLimit = isLast ? Number.POSITIVE_INFINITY : input.length - INPUT_MARGIN;
+        let endMarker;
+        try {
+            endMarker = this.size === 0 ? false : this.lzma.decode(outLimit, inLimit);
+        }
+        catch (e) {
+            throw asDataError(e);
+        }
+        this.lz.flush();
+        if (endMarker) {
+            if (!rc.isFinished())
+                throw new errors_1.DataError('invalid end marker');
+            this.finish(input, rc.pos, true);
+        }
+        else if (this.lzma.outPos === this.size) {
+            this.finish(input, rc.pos, false);
+        }
+        else {
+            this.base += rc.pos;
+            this.pending = input.slice(rc.pos);
+        }
+    }
+    finish(input, pos, endMarker) {
+        this.done = true;
+        this.sealed = true;
+        this.endMarker = endMarker;
+        this.consumed = this.base + pos;
+        this.pending = new Uint8Array(0);
+        this.keepAfter(input.subarray(pos));
+        // The data ended at its size. A finished range coder ends it cleanly; otherwise an end marker or more data follows.
+        this.needsProbe = !endMarker && this.probe && this.rcStarted && !this.rc.isFinished();
+    }
+    /** Decodes one more symbol, which must be the end marker. */
+    runProbe() {
+        this.needsProbe = false;
+        const rc = this.rc;
+        const after = this.after;
+        rc.setInput(after, 0);
+        let marker = false;
+        try {
+            marker = this.lzma.decode((this.size ?? 0) + 1, Number.POSITIVE_INFINITY);
+        }
+        catch {
+            marker = false;
+        }
+        if (!marker || !rc.isFinished())
+            throw new errors_1.DataError('the data goes on past its declared size');
+        this.endMarker = true;
+        this.consumed += rc.pos;
+        this.trailing -= rc.pos;
+    }
+}
+exports.Lzma1Stream = Lzma1Stream;
+/** The decoder's errors as data errors, with lzma1's prefix taken off. */
+function asDataError(e) {
+    if (e instanceof errors_1.DataError)
+        return e;
+    const message = String(e?.message ?? e);
+    if (message === 'Truncated input')
+        return new errors_1.DataError('the data ends before its end', true);
+    if (/declared size/.test(message))
+        return new errors_1.DataError('the data goes on past its declared size');
+    // An error from the sink, such as a limit, is not about the data.
+    if (!/^Corrupted input/.test(message))
+        throw e;
+    return new errors_1.DataError(message.replace(/^Corrupted input: /, ''));
+}
+function concat(a, b) {
+    if (a.length === 0)
+        return b;
+    if (b.length === 0)
+        return a;
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a);
+    out.set(b, a.length);
+    return out;
+}

package/dist/model.d.ts

@@ -0,0 +1,141 @@
+import type { SpillSink, TempDir } from './io';
+import type { ArchiveCategory, ArchiveDetail, ArchiveFormat, ByteSink } from './types';
+/** Something a reader saw, which the engine turns into a finding. */
+export interface Note {
+    category: ArchiveCategory;
+    detail: ArchiveDetail;
+    data?: Record<string, string | number>;
+    location?: string;
+    /** The rewrite keeps what the note reports when its rule is info, so an info override removes nothing. */
+    keptOnInfo?: boolean;
+}
+export type EntryKind = 'file' | 'directory' | 'symlink' | 'hardlink' | 'device' | 'fifo' | 'socket' | 'other';
+export type Encryption = {
+    kind: 'zipcrypto';
+} | {
+    kind: 'aes';
+    bits: 128 | 192 | 256;
+} | {
+    kind: 'unsupported';
+    reason: string;
+};
+/** How an entry's bytes are compressed, as far as the engine needs to know. */
+export interface Method {
+    /** The format's own name or number for it, for findings. */
+    name: string;
+    /** False when this package has no decoder for it. */
+    readable: boolean;
+    /** Readable, but few readers handle it. */
+    unusual: boolean;
+    /** Readable by this package, but not on the running Node. */
+    unavailable?: boolean;
+}
+/** One entry of an archive, as every format reader describes it. */
+export interface Entry {
+    /** Position in the archive's own order. */
+    index: number;
+    /** The name as the format gives it, decoded, before any rule fixes it. Folders end in "/". */
+    name: string;
+    kind: EntryKind;
+    /** Permission bits, including setuid and setgid, when the format records them. */
+    mode?: number;
+    /** A link's target. A ZIP stores a symbolic link's target as its content, which the engine reads before the rules run. */
+    linkTarget?: string;
+    /** For an entry of a type no rule names, the format's code for it. */
+    typeCode?: string;
+    /** Decompressed size the headers declare. */
+    size: number;
+    /** Bytes the entry's data takes in the archive. */
+    compressedSize: number;
+    encryption?: Encryption;
+    method?: Method;
+    /** Why the entry's data cannot be read, when the headers already show it. The entry is removed. */
+    broken?: string;
+    /** Findings about this entry's headers. */
+    notes: Note[];
+    /** Extended attributes that grant capabilities, by name. */
+    capabilities?: string[];
+    /** The entry's comment, when the format has one. */
+    comment?: string;
+    /** A 7z anti-item, which tells an updater to delete the file of that name. */
+    anti?: boolean;
+}
+/** What the engine decided about one entry, for the writer. */
+export interface Kept<E extends Entry> {
+    entry: E;
+    /** The name to write, after the rules fixed it. */
+    name: string;
+    /** Permission bits to write. */
+    mode?: number;
+    /** A hard link's target as written, after the rules fixed the target's name. */
+    linkTarget?: string;
+    /** Bytes a plugin wrote in place of the entry's own. */
+    replacement?: SpillSink;
+    /** Compress the entry again with the format's common method instead of copying its compressed bytes. */
+    recompress: boolean;
+    /** The password that opened the entry. */
+    password?: string;
+    /** CRC-32 of the entry's decoded content, known once the engine has read it. */
+    crc?: number;
+    /** Drop the extended attributes that grant capabilities. */
+    dropCapabilities: boolean;
+}
+export interface WritePlan<E extends Entry> {
+    kept: Kept<E>[];
+    stripMetadata: boolean;
+    /** Write data found before the archive ahead of the rewritten one. */
+    keepLeading: boolean;
+    /** Write data found after the archive after the rewritten one. */
+    keepTrailing: boolean;
+    /** Keep header fields the rewrite would otherwise drop, such as unknown ZIP extra fields. */
+    keepExtraFields: boolean;
+    /** The ratio limit of the run. A writer stores data that compresses past it, so its output reads under the same limit. */
+    ratioLimit: number;
+}
+/** Counts the bytes one entry decodes to against the limits, and checks the deadline. */
+export interface Meter {
+    /** Adds decoded bytes, with the compressed bytes read so far when the reader knows them. */
+    add(decoded: number, compressedSoFar?: number): void;
+    /** Throws once the deadline has passed. */
+    time(): void;
+}
+/** What a writer needs from the run. */
+export interface WriteContext {
+    /** A meter that checks the deadline while the writer decodes entries again. */
+    meter(): Meter;
+    /** The run's temporary directory, for data a writer compresses before it knows the size. */
+    temp: TempDir;
+    /** Bytes a writer keeps in memory before it spills to a temporary file. */
+    threshold: number;
+}
+/** An archive opened for reading, with what the engine needs to inspect it and write it again. */
+export interface Archive<E extends Entry = Entry> {
+    format: ArchiveFormat;
+    entries: E[];
+    /** True for gzip, bzip2, zstd and brotli, which hold one file. */
+    single: boolean;
+    /** True when the format stores no names for the entries, as a 7z archive without a names property can. */
+    nameless?: boolean;
+    /** Findings about the archive as a whole, known once it is open. */
+    notes: Note[];
+    /** Findings about the archive found while its single entry was read, such as the members of a gzip file. */
+    lateNotes: Note[];
+    /** The archive's own comment. */
+    comment?: string;
+    /** True when the archive holds metadata that stripMetadata removes: comments, owners, times or attributes. */
+    hasMetadata(): boolean;
+    /** True when `password` opens the encrypted entry. Only readers with encrypted entries are asked. */
+    unlock(e: E, password: string): Promise<boolean>;
+    /** A symbolic link's target, for a format that keeps it as the link's content. */
+    linkTarget?(e: E, meter: Meter): Promise<string | undefined>;
+    /** The entry's content, decrypted and decompressed, checked against its size and checksum as it goes. */
+    read(e: E, meter: Meter, password?: string): AsyncGenerator<Uint8Array>;
+    /** Writes the archive again with the entries in `plan`. The caller closes the sink. */
+    write(plan: WritePlan<E>, sink: ByteSink, context: WriteContext): Promise<void>;
+}
+/** The content a writer puts in an entry: what a plugin wrote, or the entry's own bytes decoded again. */
+export declare function contentOf<E extends Entry>(archive: Archive<E>, k: Kept<E>, context: WriteContext): AsyncIterable<Uint8Array>;
+/** No chunks, for an entry with no content. */
+export declare function nothing(): AsyncGenerator<Uint8Array>;
+/** The decoded size of what a writer puts in an entry. */
+export declare const sizeOf: <E extends Entry>(k: Kept<E>) => number;

package/dist/model.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sizeOf = void 0;
+exports.contentOf = contentOf;
+exports.nothing = nothing;
+/** The content a writer puts in an entry: what a plugin wrote, or the entry's own bytes decoded again. */
+function contentOf(archive, k, context) {
+    return k.replacement ? k.replacement.read() : archive.read(k.entry, context.meter(), k.password);
+}
+/** No chunks, for an entry with no content. */
+async function* nothing() {
+    // An empty stream yields nothing.
+}
+/** The decoded size of what a writer puts in an entry. */
+const sizeOf = (k) => (k.replacement ? k.replacement.length : k.entry.size);
+exports.sizeOf = sizeOf;