@patrickdk77/archive-defuse 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,107 @@
+/**
+ * Probability models and state machine shared by the LZMA encoder and decoder.
+ *
+ * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+ */
+import { type Probs } from './range-coder';
+export declare const POS_STATES_MAX: number;
+export declare const MATCH_LEN_MIN = 2;
+export declare const LOW_SYMBOLS: number;
+export declare const MID_SYMBOLS: number;
+export declare const HIGH_SYMBOLS: number;
+export declare const MATCH_LEN_MAX: number;
+/**
+ * Layout of a length coder, relative to its offset. Lengths 2-9 use a
+ * `low` tree, 10-17 a `mid` tree (both per position state), and 18-273 the
+ * `high` tree.
+ */
+export declare const LEN_CHOICE = 0;
+export declare const LEN_CHOICE2 = 1;
+export declare const LEN_LOW = 2;
+export declare const LEN_MID: number;
+export declare const LEN_HIGH: number;
+export declare const LEN_SIZE: number;
+export declare const DIST_STATES = 4;
+export declare const DIST_SLOT_BITS = 6;
+export declare const DIST_SLOT_COUNT: number;
+export declare const DIST_MODEL_START = 4;
+export declare const DIST_MODEL_END = 14;
+export declare const FULL_DISTANCES: number;
+export declare const ALIGN_BITS = 4;
+export declare const ALIGN_SIZE: number;
+export declare const ALIGN_MASK: number;
+/** Number of recent match distances ("reps") that can be reused cheaply. */
+export declare const REPS = 4;
+/**
+ * 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.
+ */
+export declare const STATES = 12;
+export declare const INITIAL_STATE = 0;
+export declare function isLiteralState(state: number): boolean;
+export declare function stateAfterLiteral(state: number): number;
+export declare function stateAfterMatch(state: number): number;
+export declare function stateAfterLongRep(state: number): number;
+export declare function stateAfterShortRep(state: number): number;
+/** Distances are coded with different probabilities for lengths 2, 3, 4 and 5+. */
+export declare function getDistState(len: number): number;
+/**
+ * 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.
+ *
+ * Bit trees of `2^n` leaves occupy `2^n` entries starting at their offset;
+ * index 0 of a tree is unused.
+ */
+export declare const IS_MATCH = 0;
+export declare const IS_REP: number;
+export declare const IS_REP0: number;
+export declare const IS_REP1: number;
+export declare const IS_REP2: number;
+export declare const IS_REP0_LONG: number;
+/** Bit trees of 6 bits per distance state. */
+export declare const DIST_SLOTS: number;
+/** Reverse bit trees for the low bits of distances in slots 4-13. */
+export declare const DIST_SPECIAL: number;
+/** Reverse bit tree for the lowest 4 bits of distances in slots 14+. */
+export declare const DIST_ALIGN: number;
+export declare const MATCH_LEN: number;
+export declare const REP_LEN: number;
+/** `2^(lc + lp)` literal coders of 0x300 probabilities each. */
+export declare const LITERAL: number;
+/**
+ * Offset of the reverse bit tree for the footer bits of `distSlot` (4-13).
+ * The trees are packed like in the LZMA SDK: the tree of a slot starts at
+ * `base - distSlot - 1` where `base` is the slot's lowest distance, so the
+ * trees of all slots fill `FULL_DISTANCES - DIST_MODEL_END` entries.
+ */
+export declare function distSpecialOffset(distSlot: number, base: number): number;
+/** Number of probabilities of a coder with `lc` and `lp` literal bits. */
+export declare function probsSize(lc: number, lp: number): number;
+/**
+ * Probability models and coder state shared by the encoder and decoder.
+ */
+export declare class LzmaCoder {
+    readonly posMask: number;
+    private readonly lc;
+    private readonly literalPosMask;
+    readonly reps: Int32Array<ArrayBuffer>;
+    state: number;
+    readonly probs: Probs;
+    /**
+     * @param probs Probability array to reuse, of `probsSize(lc, lp)` entries.
+     *        Its contents are overwritten by `reset()`.
+     */
+    constructor(lc: number, lp: number, pb: number, probs?: Probs);
+    reset(): void;
+    /**
+     * 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: number, pos: number): number;
+}

package/dist/lzma1/lzma-coder.js

@@ -0,0 +1,162 @@
+"use strict";
+// Copied from lzma1 (Apache-2.0, Copyright Filip Seman) and changed for lzma-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.
+ */
+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.stateAfterLiteral = stateAfterLiteral;
+exports.stateAfterMatch = stateAfterMatch;
+exports.stateAfterLongRep = stateAfterLongRep;
+exports.stateAfterShortRep = stateAfterShortRep;
+exports.getDistState = getDistState;
+exports.distSpecialOffset = distSpecialOffset;
+exports.probsSize = probsSize;
+const range_coder_1 = require("./range-coder");
+exports.POS_STATES_MAX = 1 << 4;
+exports.MATCH_LEN_MIN = 2;
+exports.LOW_SYMBOLS = 1 << 3;
+exports.MID_SYMBOLS = 1 << 3;
+exports.HIGH_SYMBOLS = 1 << 8;
+exports.MATCH_LEN_MAX = exports.MATCH_LEN_MIN + exports.LOW_SYMBOLS + exports.MID_SYMBOLS + exports.HIGH_SYMBOLS - 1; // 273
+/**
+ * Layout of a length coder, relative to its offset. Lengths 2-9 use a
+ * `low` tree, 10-17 a `mid` tree (both per position state), and 18-273 the
+ * `high` tree.
+ */
+exports.LEN_CHOICE = 0;
+exports.LEN_CHOICE2 = 1;
+exports.LEN_LOW = 2; // [posState][LOW_SYMBOLS]
+exports.LEN_MID = exports.LEN_LOW + exports.POS_STATES_MAX * exports.LOW_SYMBOLS; // [posState][MID_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_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);
+exports.ALIGN_BITS = 4;
+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;
+/**
+ * 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. */
+const LIT_STATES = 7;
+const LIT_LIT = 0;
+const SHORTREP_LIT_LIT = 3;
+const LIT_MATCH = 7;
+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;
+}
+function stateAfterLiteral(state) {
+    if (state <= SHORTREP_LIT_LIT)
+        return LIT_LIT;
+    if (state <= LIT_SHORTREP)
+        return state - 3;
+    return state - 6;
+}
+function stateAfterMatch(state) {
+    return state < LIT_STATES ? LIT_MATCH : NONLIT_MATCH;
+}
+function stateAfterLongRep(state) {
+    return state < LIT_STATES ? LIT_LONGREP : NONLIT_REP;
+}
+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;
+}
+/**
+ * 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.
+ *
+ * Bit trees of `2^n` leaves occupy `2^n` entries starting at their offset;
+ * index 0 of a tree is unused.
+ */
+exports.IS_MATCH = 0; // [state][posState]
+exports.IS_REP = exports.IS_MATCH + exports.STATES * exports.POS_STATES_MAX; // [state]
+exports.IS_REP0 = exports.IS_REP + exports.STATES; // [state]
+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;
+/** 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;
+/** 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;
+exports.REP_LEN = exports.MATCH_LEN + exports.LEN_SIZE;
+/** `2^(lc + lp)` literal coders of 0x300 probabilities each. */
+exports.LITERAL = exports.REP_LEN + exports.LEN_SIZE;
+/**
+ * Offset of the reverse bit tree for the footer bits of `distSlot` (4-13).
+ * The trees are packed like in the LZMA SDK: the tree of a slot starts at
+ * `base - distSlot - 1` where `base` is the slot's lowest distance, so the
+ * trees of all slots fill `FULL_DISTANCES - DIST_MODEL_END` entries.
+ */
+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;
+    probs;
+    /**
+     * @param probs Probability array to reuse, of `probsSize(lc, lp)` entries.
+     *        Its contents are overwritten by `reset()`.
+     */
+    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;
+        (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) {
+        const low = prevByte >> (8 - this.lc);
+        const high = (pos & this.literalPosMask) << this.lc;
+        return exports.LITERAL + 0x300 * (low + high);
+    }
+}
+exports.LzmaCoder = LzmaCoder;

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

@@ -0,0 +1,36 @@
+/**
+ * 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.
+ */
+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. */
+    outPos: number;
+    constructor(lz: LzDecoder, rc: RangeDecoder, lc: number, lp: number, pb: number, probs?: Uint16Array);
+    /**
+     * Decodes symbols until `outLimit` bytes have been produced 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;
+}