@patrickdk77/archive-defuse 0.0.0-stage → 0.1.0

package/dist/lzma1/lzma2-decoder.js

@@ -0,0 +1,249 @@
+"use strict";
+// Copied from lzma1 (Apache-2.0, Copyright Filip Seman) and changed for lzma-defuse. NOTICE in this folder lists the changes.
+/**
+ * Decoder for raw LZMA2 data, the chunked format inside `.xz` blocks and
+ * 7z LZMA2 entries. LZMA2 has no header of its own. The container stores
+ * the dictionary size.
+ *
+ * Each chunk starts with a control byte:
+ *
+ * | control   | chunk                                                  |
+ * | --------- | ------------------------------------------------------ |
+ * | 0x00      | end of the data                                        |
+ * | 0x01      | uncompressed, dictionary reset                         |
+ * | 0x02      | uncompressed, no reset                                 |
+ * | 0x80-0x9F | LZMA, no reset                                         |
+ * | 0xA0-0xBF | LZMA, state reset                                      |
+ * | 0xC0-0xDF | LZMA, state reset and new properties                   |
+ * | 0xE0-0xFF | LZMA, dictionary reset, state reset and new properties |
+ *
+ * The sizes follow as big-endian values minus one, then the data:
+ *
+ * | bytes | uncompressed chunk | LZMA chunk                                 |
+ * | ----- | ------------------ | ------------------------------------------ |
+ * | 1-2   | size               | uncompressed size, bits 0-15; bits 16-20   |
+ * |       |                    | are the low 5 bits of the control byte     |
+ * | 3-4   |                    | compressed size                            |
+ * | 5     |                    | `(pb * 5 + lp) * 9 + lc`, 0xC0 and up      |
+ *
+ * The first chunk has to reset the dictionary, and after a dictionary reset
+ * the next LZMA chunk has to set properties. Every LZMA chunk starts a new
+ * range coder, and LZMA2 doesn't use the end marker of the LZMA layer.
+ *
+ * Input may arrive in pieces. The decoder copies uncompressed chunks as
+ * they arrive and decodes an LZMA chunk once its compressed data, at most
+ * 64 KiB, is complete.
+ *
+ * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lzma2Decoder = void 0;
+const lz_decoder_1 = require("./lz-decoder");
+const lzma_decoder_1 = require("./lzma-decoder");
+const range_decoder_1 = require("./range-decoder");
+const COMPRESSED_SIZE_MAX = 1 << 16;
+/**
+ * Upper bound of input bytes a single symbol can consume. The value of
+ * `INPUT_MARGIN` in lzma1's alone-decoder.ts, which lzma-defuse does not carry.
+ */
+const INPUT_MARGIN = 64;
+/** Largest chunk header: control byte, two sizes and the properties. */
+const CHUNK_HEADER_SIZE_MAX = 6;
+class Lzma2Decoder {
+    lz;
+    rc = new range_decoder_1.RangeDecoderFromBuffer();
+    lzma = null;
+    uncompressedSize = 0;
+    compressedSize = 0;
+    isLzmaChunk = false;
+    needDictReset = true;
+    needProps = true;
+    endReached = false;
+    /**
+     * Bytes decoded since the last dictionary reset. LZMA's position bits
+     * come from it. XZ for Java reads it from the dictionary
+     * (`lz.getPos()`); `LzmaDecoder` counts it in `outPos`.
+     */
+    outPos = 0;
+    /** Header of the next chunk, collected until it is complete. */
+    header = new Uint8Array(CHUNK_HEADER_SIZE_MAX);
+    headerPos = 0;
+    /**
+     * Compressed data of the current LZMA chunk, collected until it is
+     * complete. `INPUT_MARGIN` bytes after the data leave room for corrupt
+     * input, which can make the decoder read past it.
+     */
+    inBuf = new Uint8Array(COMPRESSED_SIZE_MAX + INPUT_MARGIN);
+    inPos = 0;
+    /**
+     * @param dictSize Dictionary size in bytes
+     * @param sink Receives decompressed data. The chunk is only valid during
+     *        the call.
+     */
+    constructor(dictSize, sink) {
+        this.lz = new lz_decoder_1.LzDecoder(dictSize, sink);
+    }
+    /**
+     * Approximate memory needed to decode, in KiB, as XZ for Java's
+     * `LZMA2InputStream.getMemoryUsage` computes it.
+     */
+    static getMemoryUsage(dictSize) {
+        // The base state is around 30-40 KiB (probabilities etc.), the range
+        // decoder needs COMPRESSED_SIZE_MAX bytes for buffering, and the LZ
+        // decoder needs a dictionary buffer.
+        return 40 + COMPRESSED_SIZE_MAX / 1024 + Math.floor(getDictSize(dictSize) / 1024);
+    }
+    /** Decodes as much of `input` as possible. */
+    write(input) {
+        let pos = 0;
+        while (pos < input.length && !this.endReached) {
+            if (this.uncompressedSize === 0) {
+                pos = this.readChunkHeader(input, pos);
+                continue;
+            }
+            if (!this.isLzmaChunk) {
+                const copySize = Math.min(this.uncompressedSize, input.length - pos);
+                this.lz.copyUncompressed(input, pos, copySize);
+                pos += copySize;
+                this.outPos += copySize;
+                this.uncompressedSize -= copySize;
+            }
+            else {
+                const copySize = Math.min(this.compressedSize - this.inPos, input.length - pos);
+                this.inBuf.set(input.subarray(pos, pos + copySize), this.inPos);
+                pos += copySize;
+                this.inPos += copySize;
+                if (this.inPos === this.compressedSize) {
+                    this.decodeLzmaChunk();
+                }
+            }
+            this.lz.flush();
+        }
+    }
+    /** Throws if the data ended before its end marker. */
+    end() {
+        if (!this.endReached) {
+            throw new Error('Truncated input');
+        }
+    }
+    /** Collects the chunk header and decodes it once it is complete. */
+    readChunkHeader(input, start) {
+        const header = this.header;
+        let pos = start;
+        header[this.headerPos++] = input[pos++];
+        const size = chunkHeaderSize(header[0]);
+        const copySize = Math.min(size - this.headerPos, input.length - pos);
+        header.set(input.subarray(pos, pos + copySize), this.headerPos);
+        this.headerPos += copySize;
+        if (this.headerPos === size) {
+            this.headerPos = 0;
+            this.decodeChunkHeader();
+        }
+        return pos + copySize;
+    }
+    decodeChunkHeader() {
+        const header = this.header;
+        const control = header[0];
+        if (control === 0x00) {
+            this.endReached = true;
+            return;
+        }
+        if (control >= 0xe0 || control === 0x01) {
+            this.needProps = true;
+            this.needDictReset = false;
+            this.lz.reset();
+            this.outPos = 0;
+        }
+        else if (this.needDictReset) {
+            throw new Error("Corrupted input: the first LZMA2 chunk doesn't reset the dictionary");
+        }
+        if (control >= 0x80) {
+            this.isLzmaChunk = true;
+            this.uncompressedSize = (control & 0x1f) << 16;
+            this.uncompressedSize += readUnsignedShort(header, 1) + 1;
+            // XZ for Java reads the compressed data here; `write` collects
+            // it instead.
+            this.compressedSize = readUnsignedShort(header, 3) + 1;
+            this.inPos = 0;
+            if (control >= 0xc0) {
+                this.needProps = false;
+                this.decodeProps(header[5]);
+            }
+            else if (this.needProps) {
+                throw new Error('Corrupted input: LZMA2 chunk without properties');
+            }
+            else if (control >= 0xa0) {
+                this.currentLzma().reset();
+            }
+        }
+        else if (control > 0x02) {
+            throw new Error('Corrupted input: invalid LZMA2 control byte');
+        }
+        else {
+            this.isLzmaChunk = false;
+            this.uncompressedSize = readUnsignedShort(header, 1) + 1;
+        }
+    }
+    decodeProps(byte) {
+        let props = byte;
+        if (props > (4 * 5 + 4) * 9 + 8) {
+            throw new Error('Corrupted input: invalid LZMA2 properties');
+        }
+        const pb = (props / (9 * 5)) | 0;
+        props -= pb * 9 * 5;
+        const lp = (props / 9) | 0;
+        const lc = props - lp * 9;
+        if (lc + lp > 4) {
+            throw new Error('Corrupted input: invalid LZMA2 properties');
+        }
+        this.lzma = new lzma_decoder_1.LzmaDecoder(this.lz, this.rc, lc, lp, pb);
+    }
+    /** The LZMA decoder of the last properties, which a chunk without properties continues. */
+    currentLzma() {
+        if (this.lzma === null)
+            throw new Error('Corrupted input: LZMA2 chunk without properties');
+        return this.lzma;
+    }
+    decodeLzmaChunk() {
+        const lzma = this.currentLzma();
+        const outLimit = this.outPos + this.uncompressedSize;
+        this.rc.prepareInputBuffer(this.inBuf, this.compressedSize);
+        lzma.outPos = this.outPos;
+        lzma.decode(outLimit, this.compressedSize);
+        // Decoding stops before the chunk's size when it reads past the
+        // chunk's data or decodes an end marker. XZ for Java throws in both
+        // cases. A match that would cross the chunk's end throws in
+        // `decode`, which XZ for Java detects with `lz.hasPending()`.
+        if (lzma.outPos !== outLimit || !this.rc.isFinished()) {
+            throw new Error("Corrupted input: LZMA2 chunk doesn't match its sizes");
+        }
+        this.outPos = outLimit;
+        this.uncompressedSize = 0;
+    }
+}
+exports.Lzma2Decoder = Lzma2Decoder;
+/** Size of the chunk header that starts with `control`. */
+function chunkHeaderSize(control) {
+    if (control >= 0xc0) {
+        return 6;
+    }
+    if (control >= 0x80) {
+        return 5;
+    }
+    if (control === 0x01 || control === 0x02) {
+        return 3;
+    }
+    // The end marker, or an invalid control byte, which throws
+    return 1;
+}
+function readUnsignedShort(bytes, pos) {
+    return (bytes[pos] << 8) | bytes[pos + 1];
+}
+/**
+ * Dictionary size rounded up to a multiple of 16, as XZ for Java allocates
+ * it, so the memory needed matches its numbers.
+ */
+function getDictSize(dictSize) {
+    // Not `(dictSize + 15) & ~15`, which turns sizes of 2 GiB and up negative.
+    return Math.ceil(dictSize / 16) * 16;
+}

package/dist/lzma1/range-coder.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Constants shared by the range encoder and decoder.
+ *
+ * LZMA's entropy coder is a binary range coder: every coded bit has an
+ * adaptive probability (an 11-bit integer, the chance that the bit is 0)
+ * that is updated after each use.
+ */
+/** When the range drops below this value, one byte is shifted in or out. */
+export declare const TOP_VALUE: number;
+export declare const BIT_MODEL_TOTAL_BITS = 11;
+export declare const BIT_MODEL_TOTAL: number;
+/** Initial probability: 0 and 1 are equally likely. */
+export declare const PROB_INIT: number;
+/** Adaptation speed of the probabilities. */
+export declare const MOVE_BITS = 5;
+/** Probability array. Each entry is an 11-bit probability of a 0 bit. */
+export type Probs = Uint16Array;
+export declare function initProbs(probs: Probs): void;

package/dist/lzma1/range-coder.js

@@ -0,0 +1,23 @@
+"use strict";
+// Copied from lzma1 (Apache-2.0, Copyright Filip Seman) and changed for lzma-defuse. NOTICE in this folder lists the changes.
+/**
+ * Constants shared by the range encoder and decoder.
+ *
+ * LZMA's entropy coder is a binary range coder: every coded bit has an
+ * adaptive probability (an 11-bit integer, the chance that the bit is 0)
+ * that is updated after each use.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOVE_BITS = exports.PROB_INIT = exports.BIT_MODEL_TOTAL = exports.BIT_MODEL_TOTAL_BITS = exports.TOP_VALUE = void 0;
+exports.initProbs = initProbs;
+/** When the range drops below this value, one byte is shifted in or out. */
+exports.TOP_VALUE = 1 << 24;
+exports.BIT_MODEL_TOTAL_BITS = 11;
+exports.BIT_MODEL_TOTAL = 1 << exports.BIT_MODEL_TOTAL_BITS;
+/** Initial probability: 0 and 1 are equally likely. */
+exports.PROB_INIT = exports.BIT_MODEL_TOTAL / 2;
+/** Adaptation speed of the probabilities. */
+exports.MOVE_BITS = 5;
+function initProbs(probs) {
+    probs.fill(exports.PROB_INIT);
+}

package/dist/lzma1/range-decoder.d.ts

@@ -0,0 +1,41 @@
+/** Number of bytes the range decoder reads on initialization. */
+export declare const RANGE_DECODER_INIT_SIZE = 5;
+/**
+ * Range decoder reading from an in-memory byte array.
+ *
+ * `range` and `code` are unsigned 32-bit values stored in regular numbers,
+ * so plain `<` comparisons are unsigned.
+ *
+ * The LZMA decoder loop (`LzmaDecoder.decode`) does the decoding steps
+ * inline with the state in local variables, which is why the state fields
+ * are public. `range-coder_test.ts` has the reference implementations.
+ */
+export declare class RangeDecoder {
+    range: number;
+    code: number;
+    input: Uint8Array;
+    /** Position of the next unread input byte. */
+    pos: number;
+    /** Reads the initial bytes from `input` starting at `pos`. */
+    init(input: Uint8Array, pos: number): void;
+    /** Continues decoding from a different buffer (used when streaming). */
+    setInput(input: Uint8Array, pos: number): void;
+    /** True when the encoder's flush bytes have been consumed exactly. */
+    isFinished(): boolean;
+    private readByte;
+}
+/**
+ * Range decoder for one LZMA2 chunk. Every LZMA chunk starts a new range
+ * coder, and its compressed data is complete in the buffer before decoding
+ * starts, so the data ends at a known position.
+ *
+ * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+ */
+export declare class RangeDecoderFromBuffer extends RangeDecoder {
+    /** Position after the chunk's compressed data. */
+    private end;
+    /** Starts decoding the `len` bytes of chunk data at the start of `input`. */
+    prepareInputBuffer(input: Uint8Array, len: number): void;
+    /** True when the chunk's data has been consumed exactly. */
+    isFinished(): boolean;
+}

package/dist/lzma1/range-decoder.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RangeDecoderFromBuffer = exports.RangeDecoder = exports.RANGE_DECODER_INIT_SIZE = void 0;
+// Copied from lzma1 (Apache-2.0, Copyright Filip Seman) and changed for lzma-defuse. NOTICE in this folder lists the changes.
+/** Number of bytes the range decoder reads on initialization. */
+exports.RANGE_DECODER_INIT_SIZE = 5;
+/**
+ * Range decoder reading from an in-memory byte array.
+ *
+ * `range` and `code` are unsigned 32-bit values stored in regular numbers,
+ * so plain `<` comparisons are unsigned.
+ *
+ * The LZMA decoder loop (`LzmaDecoder.decode`) does the decoding steps
+ * inline with the state in local variables, which is why the state fields
+ * are public. `range-coder_test.ts` has the reference implementations.
+ */
+class RangeDecoder {
+    range = 0;
+    code = 0;
+    input = new Uint8Array(0);
+    /** Position of the next unread input byte. */
+    pos = 0;
+    /** Reads the initial bytes from `input` starting at `pos`. */
+    init(input, pos) {
+        this.setInput(input, pos);
+        if (this.readByte() !== 0x00) {
+            throw new Error('Corrupted input: invalid range coder header');
+        }
+        this.range = 0xffffffff;
+        this.code = 0;
+        for (let i = 1; i < exports.RANGE_DECODER_INIT_SIZE; ++i) {
+            this.code = ((this.code << 8) | this.readByte()) >>> 0;
+        }
+        if (this.code === this.range) {
+            throw new Error('Corrupted input: invalid range coder header');
+        }
+    }
+    /** Continues decoding from a different buffer (used when streaming). */
+    setInput(input, pos) {
+        this.input = input;
+        this.pos = pos;
+    }
+    /** True when the encoder's flush bytes have been consumed exactly. */
+    isFinished() {
+        return this.code === 0;
+    }
+    readByte() {
+        if (this.pos >= this.input.length) {
+            throw new Error('Truncated input');
+        }
+        return this.input[this.pos++];
+    }
+}
+exports.RangeDecoder = RangeDecoder;
+/**
+ * Range decoder for one LZMA2 chunk. Every LZMA chunk starts a new range
+ * coder, and its compressed data is complete in the buffer before decoding
+ * starts, so the data ends at a known position.
+ *
+ * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+ */
+class RangeDecoderFromBuffer extends RangeDecoder {
+    /** Position after the chunk's compressed data. */
+    end = 0;
+    /** Starts decoding the `len` bytes of chunk data at the start of `input`. */
+    prepareInputBuffer(input, len) {
+        if (len < exports.RANGE_DECODER_INIT_SIZE) {
+            throw new Error('Corrupted input: LZMA2 chunk is too short');
+        }
+        this.init(input, 0);
+        this.end = len;
+    }
+    /** True when the chunk's data has been consumed exactly. */
+    isFinished() {
+        return this.pos === this.end && this.code === 0;
+    }
+}
+exports.RangeDecoderFromBuffer = RangeDecoderFromBuffer;

package/dist/lzma1/range-encoder.d.ts

@@ -0,0 +1,53 @@
+import { type Probs } from './range-coder';
+export declare function getBitPrice(prob: number, bit: number): number;
+/** Price of a `bits`-bit symbol coded MSB-first with the bit tree at `offset`. */
+export declare function getBitTreePrice(probs: Probs, offset: number, bits: number, symbolIn: number): number;
+/** Price of a `bits`-bit symbol coded LSB-first with the bit tree at `offset`. */
+export declare function getReverseBitTreePrice(probs: Probs, offset: number, bits: number, symbolIn: number): number;
+/** Price of bits coded with a fixed 50% probability. */
+export declare function getDirectBitsPrice(count: number): number;
+/**
+ * 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.
+ */
+export declare class RangeEncoder {
+    private low;
+    private range;
+    private cache;
+    private cacheSize;
+    private buf;
+    private size;
+    constructor(initialCapacity: number);
+    /** Appends bytes that are not range coded, e.g. a header. */
+    writeBytes(bytes: Uint8Array): void;
+    /** Returns a copy of the output written so far and empties the buffer. */
+    take(): Uint8Array;
+    /** Flushes all pending bytes and returns the rest of the output. */
+    finish(): Uint8Array;
+    encodeBit(probs: Probs, index: number, bit: number): void;
+    /** Encodes a `bits`-bit symbol MSB-first with the bit tree at `offset`. */
+    encodeBitTree(probs: Probs, offset: number, bits: number, symbol: number): void;
+    /** Encodes a `bits`-bit symbol LSB-first with the bit tree at `offset`. */
+    encodeReverseBitTree(probs: Probs, offset: number, bits: number, symbolIn: number): void;
+    /** Encodes a literal byte with the 0x100-leaf bit tree at `offset`. */
+    encodeLiteral(probs: Probs, offset: number, symbol: number): void;
+    /**
+     * 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: Probs, offset: number, symbolIn: number, matchByteIn: number): void;
+    /** Encodes the `count` low bits of `value` with a fixed 50% probability. */
+    encodeDirectBits(value: number, countIn: number): void;
+    /**
+     * 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.
+     */
+    private shiftLow;
+    private ensureCapacity;
+}