@patrickdk77/archive-defuse 0.1.2 → 0.1.3

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

@@ -32,8 +32,11 @@
  * 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.
+ * Ported from XZ for Java (0BSD), `src/org/tukaani/xz/LZMA2InputStream.java`,
+ * with `rangecoder/RangeDecoderFromBuffer.java` and the LZMA2-only methods of
+ * `lz/LZDecoder.java` as functions, by Lasse Collin and Igor Pavlov.
  */
+import { LzDecoder } from './lz-decoder';
 export declare class Lzma2Decoder {
     private readonly lz;
     private readonly rc;
@@ -70,7 +73,7 @@ export declare class Lzma2Decoder {
      * Approximate memory needed to decode, in KiB, as XZ for Java's
      * `LZMA2InputStream.getMemoryUsage` computes it.
      */
-    static getMemoryUsage(dictSize: number): number;
+    static getMemoryUsageKb(dictSize: number): number;
     /** Decodes as much of `input` as possible. */
     write(input: Uint8Array): void;
     /** Throws if the data ended before its end marker. */
@@ -83,3 +86,15 @@ export declare class Lzma2Decoder {
     private currentLzma;
     private decodeLzmaChunk;
 }
+/**
+ * Copies `len` bytes of uncompressed data from `input` at `inPos` into the
+ * dictionary: `LZDecoder.copyUncompressed`. XZ for Java copies up to the end
+ * of the buffer and leaves the rest to its caller; this copy continues past
+ * the end like `repeat`.
+ */
+export declare function copyUncompressed(lz: LzDecoder, input: Uint8Array, inPosIn: number, lenIn: number): void;
+/**
+ * Empties the dictionary, so matches can't reach back before this point:
+ * `LZDecoder.reset`.
+ */
+export declare function resetDictionary(lz: LzDecoder): void;

package/dist/lzma1/lzma2-decoder.js

@@ -1,5 +1,5 @@
 "use strict";
-// Copied from lzma1 (Apache-2.0, Copyright Filip Seman) and changed for lzma-defuse. NOTICE in this folder lists the changes.
+// Copied from lzma1 0.6.1 (Apache-2.0, Copyright Filip Seman) and changed for archive-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
@@ -34,24 +34,28 @@
  * 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.
+ * Ported from XZ for Java (0BSD), `src/org/tukaani/xz/LZMA2InputStream.java`,
+ * with `rangecoder/RangeDecoderFromBuffer.java` and the LZMA2-only methods of
+ * `lz/LZDecoder.java` as functions, by Lasse Collin and Igor Pavlov.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Lzma2Decoder = void 0;
+exports.copyUncompressed = copyUncompressed;
+exports.resetDictionary = resetDictionary;
 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.
+ * Input kept back while a chunk is decoded, as `INPUT_MARGIN` in lzma1's alone-decoder.ts, which archive-defuse does
+ * not carry. The value is lzma1's.
  */
 const INPUT_MARGIN = 64;
+const COMPRESSED_SIZE_MAX = 1 << 16;
 /** 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();
+    rc = new range_decoder_1.RangeDecoder();
     lzma = null;
     uncompressedSize = 0;
     compressedSize = 0;
@@ -87,7 +91,7 @@ class Lzma2Decoder {
      * Approximate memory needed to decode, in KiB, as XZ for Java's
      * `LZMA2InputStream.getMemoryUsage` computes it.
      */
-    static getMemoryUsage(dictSize) {
+    static getMemoryUsageKb(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.
@@ -103,7 +107,7 @@ class Lzma2Decoder {
             }
             if (!this.isLzmaChunk) {
                 const copySize = Math.min(this.uncompressedSize, input.length - pos);
-                this.lz.copyUncompressed(input, pos, copySize);
+                copyUncompressed(this.lz, input, pos, copySize);
                 pos += copySize;
                 this.outPos += copySize;
                 this.uncompressedSize -= copySize;
@@ -127,9 +131,9 @@ class Lzma2Decoder {
         }
     }
     /** Collects the chunk header and decodes it once it is complete. */
-    readChunkHeader(input, start) {
+    readChunkHeader(input, posIn) {
+        let pos = posIn;
         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);
@@ -151,7 +155,7 @@ class Lzma2Decoder {
         if (control >= 0xe0 || control === 0x01) {
             this.needProps = true;
             this.needDictReset = false;
-            this.lz.reset();
+            resetDictionary(this.lz);
             this.outPos = 0;
         }
         else if (this.needDictReset) {
@@ -184,8 +188,8 @@ class Lzma2Decoder {
             this.uncompressedSize = readUnsignedShort(header, 1) + 1;
         }
     }
-    decodeProps(byte) {
-        let props = byte;
+    decodeProps(propsIn) {
+        let props = propsIn;
         if (props > (4 * 5 + 4) * 9 + 8) {
             throw new Error('Corrupted input: invalid LZMA2 properties');
         }
@@ -207,14 +211,14 @@ class Lzma2Decoder {
     decodeLzmaChunk() {
         const lzma = this.currentLzma();
         const outLimit = this.outPos + this.uncompressedSize;
-        this.rc.prepareInputBuffer(this.inBuf, this.compressedSize);
+        prepareInputBuffer(this.rc, 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()) {
+        if (lzma.outPos !== outLimit || !isChunkFinished(this.rc, this.compressedSize)) {
             throw new Error("Corrupted input: LZMA2 chunk doesn't match its sizes");
         }
         this.outPos = outLimit;
@@ -222,6 +226,58 @@ class Lzma2Decoder {
     }
 }
 exports.Lzma2Decoder = Lzma2Decoder;
+/**
+ * Copies `len` bytes of uncompressed data from `input` at `inPos` into the
+ * dictionary: `LZDecoder.copyUncompressed`. XZ for Java copies up to the end
+ * of the buffer and leaves the rest to its caller; this copy continues past
+ * the end like `repeat`.
+ */
+function copyUncompressed(lz, input, inPosIn, lenIn) {
+    let inPos = inPosIn;
+    let len = lenIn;
+    while (len > 0) {
+        const copySize = Math.min(lz.buf.length - lz.pos, len);
+        lz.buf.set(input.subarray(inPos, inPos + copySize), lz.pos);
+        lz.pos += copySize;
+        inPos += copySize;
+        len -= copySize;
+        if (lz.pos === lz.buf.length) {
+            lz.onBufferEnd();
+        }
+    }
+}
+/**
+ * Empties the dictionary, so matches can't reach back before this point:
+ * `LZDecoder.reset`.
+ */
+function resetDictionary(lz) {
+    // In XZ for Java the caller flushes first. Here the sink has to get the
+    // pending bytes before the positions restart, or they are lost.
+    lz.flush();
+    lz.start = 0;
+    lz.pos = 0;
+    lz.wrapped = false;
+    // getByte(0) has to return 0x00 when nothing has been decoded.
+    lz.buf[lz.buf.length - 1] = 0x00;
+}
+/**
+ * Starts decoding the `len` bytes of chunk data at the start of `input`:
+ * `RangeDecoderFromBuffer.prepareInputBuffer`. Every LZMA chunk starts a new
+ * range coder.
+ */
+function prepareInputBuffer(rc, input, len) {
+    if (len < range_decoder_1.RANGE_DECODER_INIT_SIZE) {
+        throw new Error('Corrupted input: LZMA2 chunk is too short');
+    }
+    rc.init(input, 0);
+}
+/**
+ * True when the chunk's `len` bytes have been consumed exactly and the range
+ * coder is finished: `RangeDecoderFromBuffer.isFinished`.
+ */
+function isChunkFinished(rc, len) {
+    return rc.pos === len && rc.code === 0;
+}
 /** Size of the chunk header that starts with `control`. */
 function chunkHeaderSize(control) {
     if (control >= 0xc0) {

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

@@ -1,6 +1,10 @@
 /**
  * Constants shared by the range encoder and decoder.
  *
+ * Ported from XZ for Java (0BSD), `src/org/tukaani/xz/rangecoder/RangeCoder.java`,
+ * by Lasse Collin and Igor Pavlov. The Java code's `(range & TOP_MASK) == 0`
+ * test appears here as the unsigned comparison `range < TOP_VALUE`.
+ *
  * 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.

package/dist/lzma1/range-coder.js

@@ -1,8 +1,12 @@
 "use strict";
-// Copied from lzma1 (Apache-2.0, Copyright Filip Seman) and changed for lzma-defuse. NOTICE in this folder lists the changes.
+// Copied from lzma1 0.6.1 (Apache-2.0, Copyright Filip Seman) and changed for archive-defuse. NOTICE in this folder lists the changes.
 /**
  * Constants shared by the range encoder and decoder.
  *
+ * Ported from XZ for Java (0BSD), `src/org/tukaani/xz/rangecoder/RangeCoder.java`,
+ * by Lasse Collin and Igor Pavlov. The Java code's `(range & TOP_MASK) == 0`
+ * test appears here as the unsigned comparison `range < TOP_VALUE`.
+ *
  * 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.

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

@@ -1,15 +1,25 @@
-/** 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.
+ * Ported from XZ for Java (0BSD), `src/org/tukaani/xz/rangecoder/RangeDecoder.java`
+ * and `RangeDecoderFromStream.java`, by Lasse Collin and Igor Pavlov.
+ *
+ * Integer adaptations: `range` and `code` are unsigned 32-bit values in
+ * regular numbers (`<<` followed by `>>> 0`), so `Integer.compareUnsigned`
+ * becomes a plain `<`, and `(range & TOP_MASK) == 0` becomes `range <
+ * TOP_VALUE`. In `decodeDirectBits`, `(code - range) >>> 31` wraps to the
+ * same 32-bit pattern as Java's int subtraction.
  *
- * 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.
+ * Contract adaptations: instead of an input stream, the input arrives in
+ * chunks (`setInput`) and running out of it throws, so a truncated stream
+ * is detected like the Java code's read past the end of the stream. An
+ * LZMA2 chunk is a buffer with spare bytes after its data, and a read into
+ * them makes the chunk fail, at the latest at its end check in
+ * `lzma2-decoder.ts`.
  */
+import { type Probs } from './range-coder';
+/** Number of bytes the range decoder reads on initialization. */
+export declare const RANGE_DECODER_INIT_SIZE = 5;
 export declare class RangeDecoder {
     range: number;
     code: number;
@@ -23,19 +33,9 @@ export declare class RangeDecoder {
     /** 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;
+    normalize(): void;
+    decodeBit(probs: Probs, index: number): number;
+    decodeBitTree(probs: Probs, offset: number, bits: number): number;
+    decodeReverseBitTree(probs: Probs, offset: number, bits: number): number;
+    decodeDirectBits(countIn: number): number;
 }

package/dist/lzma1/range-decoder.js

@@ -1,19 +1,29 @@
 "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;
+// Copied from lzma1 0.6.1 (Apache-2.0, Copyright Filip Seman) and changed for archive-defuse. NOTICE in this folder lists the changes.
 /**
  * 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.
+ * Ported from XZ for Java (0BSD), `src/org/tukaani/xz/rangecoder/RangeDecoder.java`
+ * and `RangeDecoderFromStream.java`, by Lasse Collin and Igor Pavlov.
  *
- * 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.
+ * Integer adaptations: `range` and `code` are unsigned 32-bit values in
+ * regular numbers (`<<` followed by `>>> 0`), so `Integer.compareUnsigned`
+ * becomes a plain `<`, and `(range & TOP_MASK) == 0` becomes `range <
+ * TOP_VALUE`. In `decodeDirectBits`, `(code - range) >>> 31` wraps to the
+ * same 32-bit pattern as Java's int subtraction.
+ *
+ * Contract adaptations: instead of an input stream, the input arrives in
+ * chunks (`setInput`) and running out of it throws, so a truncated stream
+ * is detected like the Java code's read past the end of the stream. An
+ * LZMA2 chunk is a buffer with spare bytes after its data, and a read into
+ * them makes the chunk fail, at the latest at its end check in
+ * `lzma2-decoder.ts`.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RangeDecoder = exports.RANGE_DECODER_INIT_SIZE = void 0;
+const range_coder_1 = require("./range-coder");
+/** Number of bytes the range decoder reads on initialization. */
+exports.RANGE_DECODER_INIT_SIZE = 5;
 class RangeDecoder {
     range = 0;
     code = 0;
@@ -50,29 +60,61 @@ class RangeDecoder {
         }
         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');
+    normalize() {
+        if (this.range < range_coder_1.TOP_VALUE) {
+            this.code = ((this.code << 8) | this.readByte()) >>> 0;
+            this.range = (this.range << 8) >>> 0;
         }
-        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;
+    decodeBit(probs, index) {
+        this.normalize();
+        const prob = probs[index];
+        const bound = (this.range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
+        let bit;
+        if (this.code < bound) {
+            this.range = bound;
+            probs[index] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
+            bit = 0;
+        }
+        else {
+            this.range -= bound;
+            this.code -= bound;
+            probs[index] = prob - (prob >>> range_coder_1.MOVE_BITS);
+            bit = 1;
+        }
+        return bit;
+    }
+    decodeBitTree(probs, offset, bits) {
+        let symbol = 1;
+        do {
+            symbol = (symbol << 1) | this.decodeBit(probs, offset + symbol);
+        } while (symbol < 1 << bits);
+        return symbol - (1 << bits);
+    }
+    decodeReverseBitTree(probs, offset, bits) {
+        let symbol = 1;
+        let i = 0;
+        let result = 0;
+        do {
+            const bit = this.decodeBit(probs, offset + symbol);
+            symbol = (symbol << 1) | bit;
+            result |= bit << i++;
+        } while (symbol < 1 << bits);
+        return result;
+    }
+    decodeDirectBits(countIn) {
+        let count = countIn;
+        let result = 0;
+        do {
+            this.normalize();
+            this.range >>>= 1;
+            // 1 when code < range as 32-bit values (the subtraction wraps
+            // to the same bit pattern as Java's int arithmetic).
+            const t = (this.code - this.range) >>> 31;
+            this.code = (this.code - (this.range & (t - 1))) >>> 0;
+            result = (result << 1) | (1 - t);
+        } while (--count !== 0);
+        return result;
     }
 }
-exports.RangeDecoderFromBuffer = RangeDecoderFromBuffer;
+exports.RangeDecoder = RangeDecoder;

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

@@ -1,53 +1,51 @@
-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.
+ * Ported from XZ for Java (0BSD), `src/org/tukaani/xz/rangecoder/RangeEncoder.java`
+ * and `RangeEncoderToBuffer.java`, by Lasse Collin and Igor Pavlov.
  *
- * Performance: like `RangeDecoder`, the methods that encode several bits
- * keep `range` and `low` in local variables for the whole symbol.
+ * Integer adaptations (see the hazard checklist in `docs/verification.md`):
+ * - `low` needs 33 bits (32 bits plus a carry), so it is a regular number;
+ *   doubles represent integers up to 2^53 exactly. The carry test uses
+ *   division instead of `low >>> 32`.
+ * - `range` is an unsigned 32-bit value in a regular number: `<<` is
+ *   followed by `>>> 0`, and `(range & TOP_MASK) == 0` becomes an
+ *   unsigned `range < TOP_VALUE`.
+ * - Bitwise ops on values that may exceed 2^31 are kept off the signed
+ *   int32 path (`low`'s 24-bit wrap multiplies by 256 instead of
+ *   shifting).
  */
+import { type Probs } from './range-coder';
+export declare function createPriceTable(): Uint32Array;
+export declare function getBitPrice(prob: number, bit: number): number;
+export declare function getBitTreePrice(probs: Probs, offset: number, bits: number, symbolIn: number): number;
+export declare function getReverseBitTreePrice(probs: Probs, offset: number, bits: number, symbolIn: number): number;
+export declare function getDirectBitsPrice(count: number): number;
 export declare class RangeEncoder {
     private low;
     private range;
     private cache;
+    /**
+     * NOTE: int is OK for LZMA2 because a compressed chunk is not more
+     * than 64 KiB, but with LZMA1 there is no chunking so in theory
+     * cacheSize can grow very big. A JS number counts well past 2^32.
+     */
     private cacheSize;
     private buf;
     private size;
     constructor(initialCapacity: number);
+    reset(): void;
     /** 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;
+    private writeByte;
+    private shiftLow;
     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;
 }