@patrickdk77/archive-defuse 0.1.2 → 0.2.0

package/dist/lzma1/lzma-coder.js

@@ -1,20 +1,26 @@
 "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.
 /**
  * Probability models and state machine shared by the LZMA encoder and decoder.
  *
- * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+ * Ported from XZ for Java (0BSD), `src/org/tukaani/xz/lzma/LZMACoder.java`
+ * and `State.java`, by Lasse Collin and Igor Pavlov.
+ *
+ * The nested coder classes of the Java code (`LiteralCoder.LiteralSubcoder`,
+ * `LengthCoder`) are top-level classes here, because TypeScript has no inner
+ * classes; subclasses in the encoder and decoder files pass their outer
+ * coder explicitly where Java captures it implicitly.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LzmaCoder = exports.LITERAL = exports.REP_LEN = exports.MATCH_LEN = exports.DIST_ALIGN = exports.DIST_SPECIAL = exports.DIST_SLOTS = exports.IS_REP0_LONG = exports.IS_REP2 = exports.IS_REP1 = exports.IS_REP0 = exports.IS_REP = exports.IS_MATCH = exports.INITIAL_STATE = exports.STATES = exports.REPS = exports.ALIGN_MASK = exports.ALIGN_SIZE = exports.ALIGN_BITS = exports.FULL_DISTANCES = exports.DIST_MODEL_END = exports.DIST_MODEL_START = exports.DIST_SLOT_COUNT = exports.DIST_SLOT_BITS = exports.DIST_STATES = exports.LEN_SIZE = exports.LEN_HIGH = exports.LEN_MID = exports.LEN_LOW = exports.LEN_CHOICE2 = exports.LEN_CHOICE = exports.MATCH_LEN_MAX = exports.HIGH_SYMBOLS = exports.MID_SYMBOLS = exports.LOW_SYMBOLS = exports.MATCH_LEN_MIN = exports.POS_STATES_MAX = void 0;
-exports.isLiteralState = isLiteralState;
+exports.LengthCoder = exports.LiteralSubcoder = exports.LiteralCoder = exports.LzmaCoder = exports.LITERAL = exports.REP_LEN = exports.MATCH_LEN = exports.DIST_ALIGN = exports.DIST_SPECIAL = exports.DIST_SLOT_OFFSET = exports.IS_REP0_LONG = exports.IS_REP2 = exports.IS_REP1 = exports.IS_REP0 = exports.IS_REP = exports.IS_MATCH = exports.STATES = exports.State = exports.REPS = exports.ALIGN_MASK = exports.ALIGN_SIZE = exports.ALIGN_BITS = exports.FULL_DISTANCES = exports.DIST_MODEL_END = exports.DIST_MODEL_START = exports.DIST_SLOT_BITS = exports.DIST_SLOTS = exports.DIST_STATES = exports.LEN_SIZE = exports.LEN_HIGH = exports.LEN_MID = exports.LEN_LOW = exports.LEN_CHOICE2 = exports.LEN_CHOICE = exports.MATCH_LEN_MAX = exports.HIGH_SYMBOLS = exports.MID_SYMBOLS = exports.LOW_SYMBOLS = exports.MATCH_LEN_MIN = exports.POS_STATES_MAX = void 0;
+exports.getDistState = getDistState;
+exports.probsSize = probsSize;
 exports.stateAfterLiteral = stateAfterLiteral;
 exports.stateAfterMatch = stateAfterMatch;
 exports.stateAfterLongRep = stateAfterLongRep;
 exports.stateAfterShortRep = stateAfterShortRep;
-exports.getDistState = getDistState;
+exports.isLiteralState = isLiteralState;
 exports.distSpecialOffset = distSpecialOffset;
-exports.probsSize = probsSize;
 const range_coder_1 = require("./range-coder");
 exports.POS_STATES_MAX = 1 << 4;
 exports.MATCH_LEN_MIN = 2;
@@ -34,8 +40,9 @@ exports.LEN_MID = exports.LEN_LOW + exports.POS_STATES_MAX * exports.LOW_SYMBOLS
 exports.LEN_HIGH = exports.LEN_MID + exports.POS_STATES_MAX * exports.MID_SYMBOLS;
 exports.LEN_SIZE = exports.LEN_HIGH + exports.HIGH_SYMBOLS;
 exports.DIST_STATES = 4;
+exports.DIST_SLOTS = 1 << 6;
+/** Bits of a distance slot: the depth of the slot bit trees. */
 exports.DIST_SLOT_BITS = 6;
-exports.DIST_SLOT_COUNT = 1 << exports.DIST_SLOT_BITS;
 exports.DIST_MODEL_START = 4;
 exports.DIST_MODEL_END = 14;
 exports.FULL_DISTANCES = 1 << (exports.DIST_MODEL_END / 2);
@@ -44,13 +51,54 @@ exports.ALIGN_SIZE = 1 << exports.ALIGN_BITS;
 exports.ALIGN_MASK = exports.ALIGN_SIZE - 1;
 /** Number of recent match distances ("reps") that can be reused cheaply. */
 exports.REPS = 4;
+/** Distances are coded with different probabilities for lengths 2, 3, 4 and 5+. */
+function getDistState(len) {
+    return len < exports.DIST_STATES + exports.MATCH_LEN_MIN ? len - exports.MATCH_LEN_MIN : exports.DIST_STATES - 1;
+}
+/** Number of probabilities of a coder with `lc` and `lp` literal bits. */
+function probsSize(lc, lp) {
+    return exports.LITERAL + (0x300 << (lc + lp));
+}
 /**
  * The coder state remembers the kinds of the most recent symbols
  * (literal, match, long rep, short rep). It selects which probabilities
  * are used for the next symbol.
  */
-exports.STATES = 12;
-/** States below this value mean the previous symbol was a literal. */
+class State {
+    static STATES = 12;
+    state = 0;
+    constructor(other) {
+        if (other !== undefined) {
+            this.state = other.state;
+        }
+    }
+    reset() {
+        this.state = LIT_LIT;
+    }
+    get() {
+        return this.state;
+    }
+    set(other) {
+        this.state = other.state;
+    }
+    updateLiteral() {
+        this.state = stateAfterLiteral(this.state);
+    }
+    updateMatch() {
+        this.state = stateAfterMatch(this.state);
+    }
+    updateLongRep() {
+        this.state = stateAfterLongRep(this.state);
+    }
+    updateShortRep() {
+        this.state = stateAfterShortRep(this.state);
+    }
+    isLiteral() {
+        return isLiteralState(this.state);
+    }
+}
+exports.State = State;
+exports.STATES = State.STATES;
 const LIT_STATES = 7;
 const LIT_LIT = 0;
 const SHORTREP_LIT_LIT = 3;
@@ -59,16 +107,21 @@ const LIT_LONGREP = 8;
 const LIT_SHORTREP = 9;
 const NONLIT_MATCH = 10;
 const NONLIT_REP = 11;
-exports.INITIAL_STATE = LIT_LIT;
-function isLiteralState(state) {
-    return state < LIT_STATES;
-}
+/*
+ * The transitions of `State` on a plain state value, so that the optimum
+ * search can keep its per-position states as numbers. `State`'s methods
+ * call these, so the state machine is written once.
+ */
 function stateAfterLiteral(state) {
-    if (state <= SHORTREP_LIT_LIT)
+    if (state <= SHORTREP_LIT_LIT) {
         return LIT_LIT;
-    if (state <= LIT_SHORTREP)
+    }
+    else if (state <= LIT_SHORTREP) {
         return state - 3;
-    return state - 6;
+    }
+    else {
+        return state - 6;
+    }
 }
 function stateAfterMatch(state) {
     return state < LIT_STATES ? LIT_MATCH : NONLIT_MATCH;
@@ -79,14 +132,14 @@ function stateAfterLongRep(state) {
 function stateAfterShortRep(state) {
     return state < LIT_STATES ? LIT_SHORTREP : NONLIT_REP;
 }
-/** Distances are coded with different probabilities for lengths 2, 3, 4 and 5+. */
-function getDistState(len) {
-    return len < exports.DIST_STATES + exports.MATCH_LEN_MIN ? len - exports.MATCH_LEN_MIN : exports.DIST_STATES - 1;
+function isLiteralState(state) {
+    return state < LIT_STATES;
 }
 /**
  * Layout of the probability array. All probabilities of a coder live in one
- * `Uint16Array`, like in the LZMA SDK and liblzma: one allocation, one reset,
- * and the hot loops index a single array.
+ * `Uint16Array`, like in the LZMA SDK and liblzma, instead of the
+ * Java code's per-model arrays: one allocation, and the hot loops index a
+ * single array.
  *
  * Bit trees of `2^n` leaves occupy `2^n` entries starting at their offset;
  * index 0 of a tree is unused.
@@ -98,9 +151,9 @@ exports.IS_REP1 = exports.IS_REP0 + exports.STATES; // [state]
 exports.IS_REP2 = exports.IS_REP1 + exports.STATES; // [state]
 exports.IS_REP0_LONG = exports.IS_REP2 + exports.STATES; // [state][posState]
 /** Bit trees of 6 bits per distance state. */
-exports.DIST_SLOTS = exports.IS_REP0_LONG + exports.STATES * exports.POS_STATES_MAX;
+exports.DIST_SLOT_OFFSET = exports.IS_REP0_LONG + exports.STATES * exports.POS_STATES_MAX;
 /** Reverse bit trees for the low bits of distances in slots 4-13. */
-exports.DIST_SPECIAL = exports.DIST_SLOTS + exports.DIST_STATES * exports.DIST_SLOT_COUNT;
+exports.DIST_SPECIAL = exports.DIST_SLOT_OFFSET + exports.DIST_STATES * exports.DIST_SLOTS;
 /** Reverse bit tree for the lowest 4 bits of distances in slots 14+. */
 exports.DIST_ALIGN = exports.DIST_SPECIAL + exports.FULL_DISTANCES - exports.DIST_MODEL_END;
 exports.MATCH_LEN = exports.DIST_ALIGN + exports.ALIGN_SIZE;
@@ -116,19 +169,10 @@ exports.LITERAL = exports.REP_LEN + exports.LEN_SIZE;
 function distSpecialOffset(distSlot, base) {
     return exports.DIST_SPECIAL + base - distSlot - 1;
 }
-/** Number of probabilities of a coder with `lc` and `lp` literal bits. */
-function probsSize(lc, lp) {
-    return exports.LITERAL + (0x300 << (lc + lp));
-}
-/**
- * Probability models and coder state shared by the encoder and decoder.
- */
 class LzmaCoder {
     posMask;
-    lc;
-    literalPosMask;
     reps = new Int32Array(exports.REPS);
-    state = exports.INITIAL_STATE;
+    state = new State();
     probs;
     /**
      * @param probs Probability array to reuse, of `probsSize(lc, lp)` entries.
@@ -136,27 +180,49 @@ class LzmaCoder {
      */
     constructor(lc, lp, pb, probs) {
         this.posMask = (1 << pb) - 1;
-        this.lc = lc;
-        this.literalPosMask = (1 << lp) - 1;
         this.probs = probs ?? new Uint16Array(probsSize(lc, lp));
     }
     reset() {
-        this.reps.fill(0);
-        this.state = exports.INITIAL_STATE;
+        this.reps[0] = 0;
+        this.reps[1] = 0;
+        this.reps[2] = 0;
+        this.reps[3] = 0;
+        this.state.reset();
         (0, range_coder_1.initProbs)(this.probs);
     }
-    /**
-     * Offset of the literal coder for a literal at `pos` after `prevByte`:
-     * selected by the high `lc` bits of the previous byte and the low `lp`
-     * bits of the position.
-     *
-     * Each literal coder has 0x300 probabilities: 0x100 for a plain bit
-     * tree, and 2 * 0x100 used while the bits still agree with the "match byte".
-     */
-    literalOffset(prevByte, pos) {
+}
+exports.LzmaCoder = LzmaCoder;
+class LiteralCoder {
+    lc;
+    literalPosMask;
+    constructor(lc, lp) {
+        this.lc = lc;
+        this.literalPosMask = (1 << lp) - 1;
+    }
+    getSubcoderIndex(prevByte, pos) {
         const low = prevByte >> (8 - this.lc);
         const high = (pos & this.literalPosMask) << this.lc;
-        return exports.LITERAL + 0x300 * (low + high);
+        return low + high;
     }
 }
-exports.LzmaCoder = LzmaCoder;
+exports.LiteralCoder = LiteralCoder;
+class LiteralSubcoder {
+    probs;
+    /** Offset of this subcoder's 0x300 probabilities in `probs`. */
+    literalOffset;
+    constructor(probs, literalOffset) {
+        this.probs = probs;
+        this.literalOffset = literalOffset;
+    }
+}
+exports.LiteralSubcoder = LiteralSubcoder;
+class LengthCoder {
+    probs;
+    /** Offset of this length coder in `probs`. */
+    coder;
+    constructor(probs, coder) {
+        this.probs = probs;
+        this.coder = coder;
+    }
+}
+exports.LengthCoder = LengthCoder;

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

@@ -1,36 +1,58 @@
 /**
  * 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.
  */
 import type { LzDecoder } from './lz-decoder';
 import { LzmaCoder } from './lzma-coder';
 import type { RangeDecoder } from './range-decoder';
 export declare class LzmaDecoder extends LzmaCoder {
-    private readonly lz;
-    private readonly rc;
-    /** Number of bytes decoded so far. */
+    readonly lz: LzDecoder;
+    readonly rc: RangeDecoder;
+    private readonly literalDecoder;
+    private readonly matchLenDecoder;
+    private readonly repLenDecoder;
+    /** Bytes decoded so far; for LZMA2, since the last dictionary reset. */
     outPos: number;
+    /**
+     * @param probs Probability array of an earlier decoder to reuse, of
+     *        `probsSize(lc, lp)` entries; a new one is allocated without it.
+     */
     constructor(lz: LzDecoder, rc: RangeDecoder, lc: number, lp: number, pb: number, probs?: Uint16Array);
     /**
-     * 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.
+     */
+    private endMarkerDetected;
+    /**
+     * 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: number, inLimit: number): boolean;
+    private decodeMatch;
+    private decodeRepMatch;
 }