@patrickdk77/archive-defuse 0.1.2 → 0.1.3

package/dist/lzma1/lzma-decoder.js

@@ -1,484 +1,206 @@
 "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.
 /**
  * LZMA decoder: turns range-coded symbols back into literals and matches.
  *
- * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov. The main
- * loop is structured like `LzmaDec_DecodeReal` of the LZMA SDK.
+ * Ported from XZ for Java (0BSD), `src/org/tukaani/xz/lzma/LZMADecoder.java`,
+ * by Lasse Collin and Igor Pavlov.
+ *
+ * Contract adaptations, pinned by the recorded malformed-stream
+ * expectations in `fixtures/malformed.json` and
+ * `fixtures/raw-malformed.json`:
+ * - `decode(outLimit, inLimit)` drives the loop by the number of bytes
+ *   produced (`outPos`) and the input position, instead of the Java code's
+ *   `LZDecoder` window limit, because the input arrives in chunks and the
+ *   output goes to a sink. `outPos` also provides the position bits
+ *   (`posState` and the literal subcoder index). The Java code reads them
+ *   from `LZDecoder.getPos()`, its position in a circular dictionary
+ *   buffer that `LZMAInputStream.getDictSize` and
+ *   `LZMA2InputStream.getDictSize` round up to a multiple of 16 for exactly
+ *   this purpose, so that position equals `outPos` modulo 16. LZMA2 sets
+ *   `outPos` to the bytes since the last dictionary reset, where
+ *   `LZDecoder.reset` puts the Java position back to 0. The position masks
+ *   keep at most the low 4 bits (`pb`, `lp` <= 4), so the two agree for
+ *   every dictionary size.
+ * - The end marker returns `true` instead of surfacing as the error the
+ *   Java code's `lz.repeat` raises for it; a match that would cross the
+ *   output limit, the declared size or the end of an LZMA2 chunk, is an
+ *   error.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LzmaDecoder = void 0;
 const lzma_coder_1 = require("./lzma-coder");
-const range_coder_1 = require("./range-coder");
-/** Distance value that marks the end of the stream. */
+/** Distance value that marks the end of the stream (0xFFFFFFFF as int32). */
 const END_MARKER_DIST = -1;
 class LzmaDecoder extends lzma_coder_1.LzmaCoder {
+    // Package-private in Java: the literal subdecoders read these.
     lz;
     rc;
-    /** Number of bytes decoded so far. */
+    literalDecoder;
+    matchLenDecoder = new LengthDecoder(this.probs, lzma_coder_1.MATCH_LEN);
+    repLenDecoder = new LengthDecoder(this.probs, lzma_coder_1.REP_LEN);
+    /** Bytes decoded so far; for LZMA2, since the last dictionary reset. */
     outPos = 0;
+    /**
+     * @param probs Probability array of an earlier decoder to reuse, of
+     *        `probsSize(lc, lp)` entries; a new one is allocated without it.
+     */
     constructor(lz, rc, lc, lp, pb, probs) {
         super(lc, lp, pb, probs);
         this.lz = lz;
         this.rc = rc;
+        this.literalDecoder = new LiteralDecoder(this, lc, lp);
         this.reset();
     }
     /**
-     * Decodes symbols until `outLimit` bytes have been produced or the input
+     * Returns true if LZMA end marker was detected. It is encoded as
+     * the maximum match distance which with int32 values becomes -1.
+     */
+    endMarkerDetected() {
+        return this.reps[0] === END_MARKER_DIST;
+    }
+    /**
+     * Decodes symbols until `outPos` reaches `outLimit` or the input
      * position passes `inLimit`.
      *
-     * Performance: this is the hot loop of decompression. The range decoder
-     * state, the coder state and the reps live in local variables, and the
-     * bit decoding step (`decodeBit` in `range-coder_test.ts`) is repeated inline:
-     *
-     *     prob = probs[i];
-     *     bound = (range >>> 11) * prob;
-     *     if (code < bound) { range = bound; probs[i] = prob + ((2048 - prob) >>> 5); bit 0 }
-     *     else { range -= bound; code -= bound; probs[i] = prob - (prob >>> 5); bit 1 }
-     *     if (range < 2^24) { shift in the next input byte }
-     *
-     * With the state in object fields, engines store and reload it around
-     * every probability update, which costs 10-15% on V8.
-     *
      * @returns `true` if the end marker was decoded
      */
     decode(outLimit, inLimit) {
-        const probs = this.probs;
-        const lz = this.lz;
-        const reps = this.reps;
-        const posMask = this.posMask;
         const rc = this.rc;
-        const input = rc.input;
-        const inputEnd = input.length;
-        let range = rc.range;
-        let code = rc.code;
-        let inPos = rc.pos;
-        let state = this.state;
-        let outPos = this.outPos;
-        let rep0 = reps[0];
-        let rep1 = reps[1];
-        let rep2 = reps[2];
-        let rep3 = reps[3];
+        const lz = this.lz;
         let endMarker = false;
-        let i = 0;
-        let prob = 0;
-        let bound = 0;
-        while (outPos < outLimit && inPos <= inLimit) {
-            const posState = outPos & posMask;
-            // -- Literal or match? --
-            i = lzma_coder_1.IS_MATCH + (state << 4) + posState;
-            prob = probs[i];
-            bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
-            if (code < bound) {
-                range = bound;
-                probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
-                if (range < range_coder_1.TOP_VALUE) {
-                    if (inPos >= inputEnd)
-                        throw truncated();
-                    range = (range << 8) >>> 0;
-                    code = ((code << 8) | input[inPos++]) >>> 0;
-                }
-                // -- Literal: 8 bits, MSB first --
-                const offset = this.literalOffset(lz.getByte(0), outPos);
-                let symbol = 1;
-                if ((0, lzma_coder_1.isLiteralState)(state)) {
-                    do {
-                        i = offset + symbol;
-                        prob = probs[i];
-                        bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
-                        if (code < bound) {
-                            range = bound;
-                            probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
-                            symbol <<= 1;
-                        }
-                        else {
-                            range -= bound;
-                            code -= bound;
-                            probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
-                            symbol = (symbol << 1) | 1;
-                        }
-                        if (range < range_coder_1.TOP_VALUE) {
-                            if (inPos >= inputEnd)
-                                throw truncated();
-                            range = (range << 8) >>> 0;
-                            code = ((code << 8) | input[inPos++]) >>> 0;
-                        }
-                    } while (symbol < 0x100);
-                }
-                else {
-                    // After a match, the bits of the byte at rep0 select the
-                    // probabilities until the first bit that differs.
-                    let matchByte = lz.getByte(rep0);
-                    let matchOffset = 0x100;
-                    do {
-                        matchByte <<= 1;
-                        const matchBit = matchByte & matchOffset;
-                        i = offset + matchOffset + matchBit + symbol;
-                        prob = probs[i];
-                        bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
-                        if (code < bound) {
-                            range = bound;
-                            probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
-                            symbol <<= 1;
-                            matchOffset &= ~matchBit;
-                        }
-                        else {
-                            range -= bound;
-                            code -= bound;
-                            probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
-                            symbol = (symbol << 1) | 1;
-                            matchOffset &= matchBit;
-                        }
-                        if (range < range_coder_1.TOP_VALUE) {
-                            if (inPos >= inputEnd)
-                                throw truncated();
-                            range = (range << 8) >>> 0;
-                            code = ((code << 8) | input[inPos++]) >>> 0;
-                        }
-                    } while (symbol < 0x100);
-                }
-                lz.putByte(symbol & 0xff);
-                state = (0, lzma_coder_1.stateAfterLiteral)(state);
-                ++outPos;
-                continue;
-            }
-            range -= bound;
-            code -= bound;
-            probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
-            if (range < range_coder_1.TOP_VALUE) {
-                if (inPos >= inputEnd)
-                    throw truncated();
-                range = (range << 8) >>> 0;
-                code = ((code << 8) | input[inPos++]) >>> 0;
-            }
-            // -- Match or rep match? --
-            let lenCoder;
-            i = lzma_coder_1.IS_REP + state;
-            prob = probs[i];
-            bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
-            if (code < bound) {
-                range = bound;
-                probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
-                if (range < range_coder_1.TOP_VALUE) {
-                    if (inPos >= inputEnd)
-                        throw truncated();
-                    range = (range << 8) >>> 0;
-                    code = ((code << 8) | input[inPos++]) >>> 0;
-                }
-                // Match: the distance follows the length.
-                state = (0, lzma_coder_1.stateAfterMatch)(state);
-                rep3 = rep2;
-                rep2 = rep1;
-                rep1 = rep0;
-                lenCoder = lzma_coder_1.MATCH_LEN;
+        while (this.outPos < outLimit && rc.pos <= inLimit) {
+            const posState = this.outPos & this.posMask;
+            if (rc.decodeBit(this.probs, lzma_coder_1.IS_MATCH + (this.state.get() << 4) + posState) === 0) {
+                this.literalDecoder.decode();
+                ++this.outPos;
             }
             else {
-                range -= bound;
-                code -= bound;
-                probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
-                if (range < range_coder_1.TOP_VALUE) {
-                    if (inPos >= inputEnd)
-                        throw truncated();
-                    range = (range << 8) >>> 0;
-                    code = ((code << 8) | input[inPos++]) >>> 0;
-                }
-                // Rep match: one of the four recent distances.
-                i = lzma_coder_1.IS_REP0 + state;
-                prob = probs[i];
-                bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
-                if (code < bound) {
-                    range = bound;
-                    probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
-                    if (range < range_coder_1.TOP_VALUE) {
-                        if (inPos >= inputEnd)
-                            throw truncated();
-                        range = (range << 8) >>> 0;
-                        code = ((code << 8) | input[inPos++]) >>> 0;
-                    }
-                    // rep0: a single byte ("short rep") or a longer match?
-                    i = lzma_coder_1.IS_REP0_LONG + (state << 4) + posState;
-                    prob = probs[i];
-                    bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
-                    if (code < bound) {
-                        range = bound;
-                        probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
-                        if (range < range_coder_1.TOP_VALUE) {
-                            if (inPos >= inputEnd)
-                                throw truncated();
-                            range = (range << 8) >>> 0;
-                            code = ((code << 8) | input[inPos++]) >>> 0;
-                        }
-                        state = (0, lzma_coder_1.stateAfterShortRep)(state);
-                        if (outPos >= outLimit)
-                            throw exceedsSize();
-                        lz.repeat(rep0, 1);
-                        ++outPos;
-                        continue;
-                    }
-                    range -= bound;
-                    code -= bound;
-                    probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
-                    if (range < range_coder_1.TOP_VALUE) {
-                        if (inPos >= inputEnd)
-                            throw truncated();
-                        range = (range << 8) >>> 0;
-                        code = ((code << 8) | input[inPos++]) >>> 0;
-                    }
+                const len = rc.decodeBit(this.probs, lzma_coder_1.IS_REP + this.state.get()) === 0 ? this.decodeMatch(posState) : this.decodeRepMatch(posState);
+                if (this.endMarkerDetected()) {
+                    endMarker = true;
+                    break;
                 }
-                else {
-                    range -= bound;
-                    code -= bound;
-                    probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
-                    if (range < range_coder_1.TOP_VALUE) {
-                        if (inPos >= inputEnd)
-                            throw truncated();
-                        range = (range << 8) >>> 0;
-                        code = ((code << 8) | input[inPos++]) >>> 0;
-                    }
-                    let dist;
-                    // rep1, or rep2/rep3?
-                    i = lzma_coder_1.IS_REP1 + state;
-                    prob = probs[i];
-                    bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
-                    if (code < bound) {
-                        range = bound;
-                        probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
-                        dist = rep1;
-                    }
-                    else {
-                        range -= bound;
-                        code -= bound;
-                        probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
-                        if (range < range_coder_1.TOP_VALUE) {
-                            if (inPos >= inputEnd)
-                                throw truncated();
-                            range = (range << 8) >>> 0;
-                            code = ((code << 8) | input[inPos++]) >>> 0;
-                        }
-                        // rep2 or rep3?
-                        i = lzma_coder_1.IS_REP2 + state;
-                        prob = probs[i];
-                        bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
-                        if (code < bound) {
-                            range = bound;
-                            probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
-                            dist = rep2;
-                        }
-                        else {
-                            range -= bound;
-                            code -= bound;
-                            probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
-                            dist = rep3;
-                            rep3 = rep2;
-                        }
-                        rep2 = rep1;
-                    }
-                    if (range < range_coder_1.TOP_VALUE) {
-                        if (inPos >= inputEnd)
-                            throw truncated();
-                        range = (range << 8) >>> 0;
-                        code = ((code << 8) | input[inPos++]) >>> 0;
-                    }
-                    rep1 = rep0;
-                    rep0 = dist;
+                if (len > outLimit - this.outPos) {
+                    throw new Error('Corrupted input: data exceeds the declared size');
                 }
-                state = (0, lzma_coder_1.stateAfterLongRep)(state);
-                lenCoder = lzma_coder_1.REP_LEN;
+                lz.repeat(this.reps[0], len);
+                this.outPos += len;
             }
-            // -- Length: choice bits select the low, mid or high tree --
-            let treeOffset;
-            let treeBits;
-            let len;
-            i = lenCoder + lzma_coder_1.LEN_CHOICE;
-            prob = probs[i];
-            bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
-            if (code < bound) {
-                range = bound;
-                probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
-                treeOffset = lenCoder + lzma_coder_1.LEN_LOW + posState * lzma_coder_1.LOW_SYMBOLS;
-                treeBits = 3;
-                len = lzma_coder_1.MATCH_LEN_MIN;
+        }
+        rc.normalize();
+        return endMarker;
+    }
+    decodeMatch(posState) {
+        this.state.updateMatch();
+        this.reps[3] = this.reps[2];
+        this.reps[2] = this.reps[1];
+        this.reps[1] = this.reps[0];
+        const len = this.matchLenDecoder.decode(this.rc, posState);
+        const distSlot = this.rc.decodeBitTree(this.probs, lzma_coder_1.DIST_SLOT_OFFSET + ((0, lzma_coder_1.getDistState)(len) << lzma_coder_1.DIST_SLOT_BITS), lzma_coder_1.DIST_SLOT_BITS);
+        if (distSlot < lzma_coder_1.DIST_MODEL_START) {
+            this.reps[0] = distSlot;
+        }
+        else {
+            const limit = (distSlot >> 1) - 1;
+            this.reps[0] = (2 | (distSlot & 1)) << limit;
+            if (distSlot < lzma_coder_1.DIST_MODEL_END) {
+                this.reps[0] |= this.rc.decodeReverseBitTree(this.probs, (0, lzma_coder_1.distSpecialOffset)(distSlot, this.reps[0]), limit);
             }
             else {
-                range -= bound;
-                code -= bound;
-                probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
-                if (range < range_coder_1.TOP_VALUE) {
-                    if (inPos >= inputEnd)
-                        throw truncated();
-                    range = (range << 8) >>> 0;
-                    code = ((code << 8) | input[inPos++]) >>> 0;
-                }
-                i = lenCoder + lzma_coder_1.LEN_CHOICE2;
-                prob = probs[i];
-                bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
-                if (code < bound) {
-                    range = bound;
-                    probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
-                    treeOffset = lenCoder + lzma_coder_1.LEN_MID + posState * lzma_coder_1.MID_SYMBOLS;
-                    treeBits = 3;
-                    len = lzma_coder_1.MATCH_LEN_MIN + lzma_coder_1.LOW_SYMBOLS;
-                }
-                else {
-                    range -= bound;
-                    code -= bound;
-                    probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
-                    treeOffset = lenCoder + lzma_coder_1.LEN_HIGH;
-                    treeBits = 8;
-                    len = lzma_coder_1.MATCH_LEN_MIN + lzma_coder_1.LOW_SYMBOLS + lzma_coder_1.MID_SYMBOLS;
-                }
+                this.reps[0] |= this.rc.decodeDirectBits(limit - lzma_coder_1.ALIGN_BITS) << lzma_coder_1.ALIGN_BITS;
+                this.reps[0] |= this.rc.decodeReverseBitTree(this.probs, lzma_coder_1.DIST_ALIGN, lzma_coder_1.ALIGN_BITS);
             }
-            if (range < range_coder_1.TOP_VALUE) {
-                if (inPos >= inputEnd)
-                    throw truncated();
-                range = (range << 8) >>> 0;
-                code = ((code << 8) | input[inPos++]) >>> 0;
+        }
+        return len;
+    }
+    decodeRepMatch(posState) {
+        if (this.rc.decodeBit(this.probs, lzma_coder_1.IS_REP0 + this.state.get()) === 0) {
+            if (this.rc.decodeBit(this.probs, lzma_coder_1.IS_REP0_LONG + (this.state.get() << 4) + posState) === 0) {
+                this.state.updateShortRep();
+                return 1;
             }
-            {
-                const end = 1 << treeBits;
-                let symbol = 1;
-                do {
-                    i = treeOffset + symbol;
-                    prob = probs[i];
-                    bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
-                    if (code < bound) {
-                        range = bound;
-                        probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
-                        symbol <<= 1;
-                    }
-                    else {
-                        range -= bound;
-                        code -= bound;
-                        probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
-                        symbol = (symbol << 1) | 1;
-                    }
-                    if (range < range_coder_1.TOP_VALUE) {
-                        if (inPos >= inputEnd)
-                            throw truncated();
-                        range = (range << 8) >>> 0;
-                        code = ((code << 8) | input[inPos++]) >>> 0;
-                    }
-                } while (symbol < end);
-                len += symbol - end;
+        }
+        else {
+            let tmp;
+            if (this.rc.decodeBit(this.probs, lzma_coder_1.IS_REP1 + this.state.get()) === 0) {
+                tmp = this.reps[1];
             }
-            // -- Distance (normal matches only) --
-            if (lenCoder === lzma_coder_1.MATCH_LEN) {
-                // Distance slot: 6 bits, MSB first
-                const slotTree = lzma_coder_1.DIST_SLOTS + ((0, lzma_coder_1.getDistState)(len) << lzma_coder_1.DIST_SLOT_BITS);
-                let distSlot = 1;
-                do {
-                    i = slotTree + distSlot;
-                    prob = probs[i];
-                    bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
-                    if (code < bound) {
-                        range = bound;
-                        probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
-                        distSlot <<= 1;
-                    }
-                    else {
-                        range -= bound;
-                        code -= bound;
-                        probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
-                        distSlot = (distSlot << 1) | 1;
-                    }
-                    if (range < range_coder_1.TOP_VALUE) {
-                        if (inPos >= inputEnd)
-                            throw truncated();
-                        range = (range << 8) >>> 0;
-                        code = ((code << 8) | input[inPos++]) >>> 0;
-                    }
-                } while (distSlot < 1 << lzma_coder_1.DIST_SLOT_BITS);
-                distSlot -= 1 << lzma_coder_1.DIST_SLOT_BITS;
-                if (distSlot < lzma_coder_1.DIST_MODEL_START) {
-                    rep0 = distSlot;
+            else {
+                if (this.rc.decodeBit(this.probs, lzma_coder_1.IS_REP2 + this.state.get()) === 0) {
+                    tmp = this.reps[2];
                 }
                 else {
-                    // The slot gives the top two bits; the footer bits follow.
-                    const footerBits = (distSlot >>> 1) - 1;
-                    let dist = (2 | (distSlot & 1)) << footerBits;
-                    let reverseTree;
-                    let reverseBits;
-                    if (distSlot < lzma_coder_1.DIST_MODEL_END) {
-                        reverseTree = (0, lzma_coder_1.distSpecialOffset)(distSlot, dist);
-                        reverseBits = footerBits;
-                    }
-                    else {
-                        // Direct bits with a fixed 50% probability, then 4
-                        // align bits with probabilities.
-                        let direct = 0;
-                        for (let k = footerBits - lzma_coder_1.ALIGN_BITS; k > 0; --k) {
-                            range >>>= 1;
-                            let bit = 0;
-                            if (code >= range) {
-                                code -= range;
-                                bit = 1;
-                            }
-                            direct = ((direct << 1) | bit) >>> 0;
-                            if (range < range_coder_1.TOP_VALUE) {
-                                if (inPos >= inputEnd)
-                                    throw truncated();
-                                range = (range << 8) >>> 0;
-                                code = ((code << 8) | input[inPos++]) >>> 0;
-                            }
-                        }
-                        dist |= direct << lzma_coder_1.ALIGN_BITS;
-                        reverseTree = lzma_coder_1.DIST_ALIGN;
-                        reverseBits = lzma_coder_1.ALIGN_BITS;
-                    }
-                    // Footer or align bits, LSB first
-                    let symbol = 1;
-                    for (let k = 0; k < reverseBits; ++k) {
-                        i = reverseTree + symbol;
-                        prob = probs[i];
-                        bound = (range >>> range_coder_1.BIT_MODEL_TOTAL_BITS) * prob;
-                        if (code < bound) {
-                            range = bound;
-                            probs[i] = prob + ((range_coder_1.BIT_MODEL_TOTAL - prob) >>> range_coder_1.MOVE_BITS);
-                            symbol <<= 1;
-                        }
-                        else {
-                            range -= bound;
-                            code -= bound;
-                            probs[i] = prob - (prob >>> range_coder_1.MOVE_BITS);
-                            symbol = (symbol << 1) | 1;
-                            dist |= 1 << k;
-                        }
-                        if (range < range_coder_1.TOP_VALUE) {
-                            if (inPos >= inputEnd)
-                                throw truncated();
-                            range = (range << 8) >>> 0;
-                            code = ((code << 8) | input[inPos++]) >>> 0;
-                        }
-                    }
-                    // As int32, the end marker distance 0xFFFFFFFF is -1.
-                    rep0 = dist | 0;
-                    if (rep0 === END_MARKER_DIST) {
-                        endMarker = true;
-                        break;
-                    }
+                    tmp = this.reps[3];
+                    this.reps[3] = this.reps[2];
                 }
+                this.reps[2] = this.reps[1];
             }
-            if (len > outLimit - outPos)
-                throw exceedsSize();
-            lz.repeat(rep0, len);
-            outPos += len;
+            this.reps[1] = this.reps[0];
+            this.reps[0] = tmp;
         }
-        rc.range = range;
-        rc.code = code;
-        rc.pos = inPos;
-        this.state = state;
-        this.outPos = outPos;
-        reps[0] = rep0;
-        reps[1] = rep1;
-        reps[2] = rep2;
-        reps[3] = rep3;
-        return endMarker;
+        this.state.updateLongRep();
+        return this.repLenDecoder.decode(this.rc, posState);
     }
 }
 exports.LzmaDecoder = LzmaDecoder;
-function truncated() {
-    return new Error('Truncated input');
+class LiteralDecoder extends lzma_coder_1.LiteralCoder {
+    decoder;
+    subdecoders;
+    constructor(decoder, lc, lp) {
+        super(lc, lp);
+        this.decoder = decoder;
+        this.subdecoders = Array.from({ length: 1 << (lc + lp) }, (_, i) => new LiteralSubdecoder(decoder, lzma_coder_1.LITERAL + 0x300 * i));
+    }
+    decode() {
+        const decoder = this.decoder;
+        // The Java code reads the position bits from the dictionary
+        // position; `outPos` is equivalent (see the module comment).
+        const i = this.getSubcoderIndex(decoder.lz.getByte(0), decoder.outPos);
+        this.subdecoders[i].decode();
+    }
 }
-function exceedsSize() {
-    return new Error('Corrupted input: data exceeds the declared size');
+class LiteralSubdecoder extends lzma_coder_1.LiteralSubcoder {
+    decoder;
+    constructor(decoder, literalOffset) {
+        super(decoder.probs, literalOffset);
+        this.decoder = decoder;
+    }
+    decode() {
+        const decoder = this.decoder;
+        const rc = decoder.rc;
+        const probs = this.probs;
+        let symbol = 1;
+        if (decoder.state.isLiteral()) {
+            do {
+                symbol = (symbol << 1) | rc.decodeBit(probs, this.literalOffset + symbol);
+            } while (symbol < 0x100);
+        }
+        else {
+            let matchByte = decoder.lz.getByte(decoder.reps[0]);
+            let offset = 0x100;
+            let matchBit;
+            let bit;
+            do {
+                matchByte <<= 1;
+                matchBit = matchByte & offset;
+                bit = rc.decodeBit(probs, this.literalOffset + offset + matchBit + symbol);
+                symbol = (symbol << 1) | bit;
+                offset &= -bit ^ ~matchBit;
+            } while (symbol < 0x100);
+        }
+        decoder.lz.putByte(symbol & 0xff);
+        decoder.state.updateLiteral();
+    }
+}
+class LengthDecoder extends lzma_coder_1.LengthCoder {
+    decode(rc, posState) {
+        if (rc.decodeBit(this.probs, this.coder + lzma_coder_1.LEN_CHOICE) === 0) {
+            return rc.decodeBitTree(this.probs, this.coder + lzma_coder_1.LEN_LOW + posState * lzma_coder_1.LOW_SYMBOLS, 3) + lzma_coder_1.MATCH_LEN_MIN;
+        }
+        if (rc.decodeBit(this.probs, this.coder + lzma_coder_1.LEN_CHOICE2) === 0) {
+            return rc.decodeBitTree(this.probs, this.coder + lzma_coder_1.LEN_MID + posState * lzma_coder_1.MID_SYMBOLS, 3) + lzma_coder_1.MATCH_LEN_MIN + lzma_coder_1.LOW_SYMBOLS;
+        }
+        return rc.decodeBitTree(this.probs, this.coder + lzma_coder_1.LEN_HIGH, 8) + lzma_coder_1.MATCH_LEN_MIN + lzma_coder_1.LOW_SYMBOLS + lzma_coder_1.MID_SYMBOLS;
+    }
 }

package/dist/lzma1/lzma-encoder-fast.d.ts

@@ -2,7 +2,8 @@
  * Fast LZMA encoder: picks symbols with simple heuristics, similar to a
  * lazy-matching LZ77 encoder.
  *
- * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+ * Ported from XZ for Java (0BSD), `src/org/tukaani/xz/lzma/LZMAEncoderFast.java`,
+ * by Lasse Collin and Igor Pavlov.
  */
 import { LzmaEncoder } from './lzma-encoder';
 export declare const FAST_EXTRA_SIZE_BEFORE = 1;

package/dist/lzma1/lzma-encoder-fast.js

@@ -1,10 +1,11 @@
 "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.
 /**
  * Fast LZMA encoder: picks symbols with simple heuristics, similar to a
  * lazy-matching LZ77 encoder.
  *
- * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+ * Ported from XZ for Java (0BSD), `src/org/tukaani/xz/lzma/LZMAEncoderFast.java`,
+ * by Lasse Collin and Igor Pavlov.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LzmaEncoderFast = exports.FAST_EXTRA_SIZE_AFTER = exports.FAST_EXTRA_SIZE_BEFORE = void 0;