@patrickdk77/archive-defuse 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,105 @@
+/**
+ * LZMA encoder base: codes the symbols chosen by a subclass and keeps the
+ * price tables the subclasses use to choose between symbols.
+ *
+ * Subclasses implement `getNextSymbol()`:
+ * - `LzmaEncoderFast` uses simple heuristics (levels 1-3).
+ * - `LzmaEncoderNormal` searches for the cheapest symbol sequence (levels 4-9).
+ *
+ * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+ */
+import type { LzEncoder, Matches } from './lz-encoder';
+import { LzmaCoder } from './lzma-coder';
+import { type Probs } from './range-coder';
+import { type RangeEncoder } from './range-encoder';
+/** Returns the distance slot: roughly 2 * log2(dist), plus the next bit. */
+export declare function getDistSlot(dist: number): number;
+export interface LzmaEncoderConfig {
+    lc: number;
+    lp: number;
+    pb: number;
+    dictSize: number;
+    niceLen: number;
+}
+export declare abstract class LzmaEncoder extends LzmaCoder {
+    private rc;
+    readonly lz: LzEncoder;
+    readonly niceLen: number;
+    readonly matchLenEncoder: LengthEncoder;
+    readonly repLenEncoder: LengthEncoder;
+    private distPriceCount;
+    private alignPriceCount;
+    /** Whether a distance or align bits were encoded since the last reset. */
+    private distModelsUsed;
+    private alignModelUsed;
+    private readonly distSlotPricesSize;
+    /** Price of each distance slot per distance state, `[distState << 6 | slot]`. */
+    private readonly distSlotPrices;
+    /** Price of each distance below `FULL_DISTANCES` per distance state, `[distState << 7 | dist]`. */
+    private readonly fullDistPrices;
+    private readonly alignPrices;
+    /**
+     * Symbol chosen by `getNextSymbol()`:
+     * -1 = literal, 0-3 = rep match, 4+ = match with distance `back - REPS`.
+     */
+    protected back: number;
+    /** Bytes the match finder is ahead of the encoder. */
+    protected readAhead: number;
+    constructor(rc: RangeEncoder, lz: LzEncoder, config: LzmaEncoderConfig);
+    /** Prepares for a new, independent input written to `rc`. */
+    restart(rc: RangeEncoder): void;
+    /**
+     * Chooses the next symbol: sets `back` and returns its length.
+     */
+    protected abstract getNextSymbol(): number;
+    reset(): void;
+    /** Encodes as much of the buffered input as the lookahead allows. */
+    encode(): void;
+    /** Encodes the end marker: a match with distance 0xFFFFFFFF. */
+    encodeEndMarker(): void;
+    /** The first symbol is always a literal with no previous byte. */
+    private encodeInit;
+    private encodeSymbol;
+    private encodeLiteral;
+    private encodeMatch;
+    private encodeRepMatch;
+    protected getMatches(): Matches;
+    protected skip(len: number): void;
+    protected getLiteralPrice(curByte: number, matchByte: number, prevByte: number, pos: number, state: number): number;
+    protected getAnyMatchPrice(state: number, posState: number): number;
+    protected getNormalMatchPrice(anyMatchPrice: number, state: number): number;
+    protected getAnyRepPrice(anyMatchPrice: number, state: number): number;
+    protected getShortRepPrice(anyRepPrice: number, state: number, posState: number): number;
+    protected getLongRepPrice(anyRepPrice: number, rep: number, state: number, posState: number): number;
+    protected getLongRepAndLenPrice(rep: number, len: number, state: number, posState: number): number;
+    protected getMatchAndLenPrice(normalMatchPrice: number, dist: number, len: number, posState: number): number;
+    /** Price of coding `dist` in distance state `distState`. */
+    protected getDistPrice(distState: number, dist: number): number;
+    /** Refreshes the price tables that are due for an update. */
+    protected updatePrices(): void;
+    private updateDistPrices;
+    private updateAlignPrices;
+}
+/**
+ * Length encoder with cached prices. Prices of each position state are
+ * recalculated after every `LEN_PRICE_UPDATE_INTERVAL` encoded lengths.
+ */
+export declare class LengthEncoder {
+    private readonly probs;
+    /** Offset of this length coder in `probs`. */
+    private readonly coder;
+    private readonly counters;
+    /** Whether a length was encoded since the last reset. */
+    private used;
+    /** Prices per position state, `[posState * lenSymbols + len - MATCH_LEN_MIN]`. */
+    readonly prices: Uint32Array;
+    readonly lenSymbols: number;
+    constructor(probs: Probs, coder: number, pb: number, niceLen: number);
+    reset(): void;
+    encode(rc: RangeEncoder, lenIn: number, posState: number): void;
+    getPrice(len: number, posState: number): number;
+    /** Offset in `prices` such that `prices[offset + len]` is the price of `len`. */
+    priceOffset(posState: number): number;
+    updatePrices(): void;
+    private updatePosStatePrices;
+}

package/dist/lzma1/lzma-encoder.js

@@ -0,0 +1,497 @@
+"use strict";
+// Copied from lzma1 (Apache-2.0, Copyright Filip Seman) and changed for lzma-defuse. NOTICE in this folder lists the changes.
+/**
+ * LZMA encoder base: codes the symbols chosen by a subclass and keeps the
+ * price tables the subclasses use to choose between symbols.
+ *
+ * Subclasses implement `getNextSymbol()`:
+ * - `LzmaEncoderFast` uses simple heuristics (levels 1-3).
+ * - `LzmaEncoderNormal` searches for the cheapest symbol sequence (levels 4-9).
+ *
+ * Ported from XZ for Java (0BSD) by Lasse Collin and Igor Pavlov.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LengthEncoder = exports.LzmaEncoder = void 0;
+exports.getDistSlot = getDistSlot;
+const lzma_coder_1 = require("./lzma-coder");
+const range_coder_1 = require("./range-coder");
+const range_encoder_1 = require("./range-encoder");
+const DIST_PRICE_UPDATE_INTERVAL = lzma_coder_1.FULL_DISTANCES;
+const ALIGN_PRICE_UPDATE_INTERVAL = lzma_coder_1.ALIGN_SIZE;
+const LEN_PRICE_UPDATE_INTERVAL = 32;
+/** Returns the distance slot: roughly 2 * log2(dist), plus the next bit. */
+function getDistSlot(dist) {
+    if (dist <= lzma_coder_1.DIST_MODEL_START && dist >= 0) {
+        return dist;
+    }
+    const i = 31 - Math.clz32(dist);
+    return (i << 1) + ((dist >>> (i - 1)) & 1);
+}
+class LzmaEncoder extends lzma_coder_1.LzmaCoder {
+    rc;
+    lz;
+    niceLen;
+    matchLenEncoder;
+    repLenEncoder;
+    distPriceCount = 0;
+    alignPriceCount = 0;
+    /** Whether a distance or align bits were encoded since the last reset. */
+    distModelsUsed = false;
+    alignModelUsed = false;
+    distSlotPricesSize;
+    /** Price of each distance slot per distance state, `[distState << 6 | slot]`. */
+    distSlotPrices = new Uint32Array(lzma_coder_1.DIST_STATES << lzma_coder_1.DIST_SLOT_BITS);
+    /** Price of each distance below `FULL_DISTANCES` per distance state, `[distState << 7 | dist]`. */
+    fullDistPrices = new Uint32Array(lzma_coder_1.DIST_STATES * lzma_coder_1.FULL_DISTANCES);
+    alignPrices = new Uint32Array(lzma_coder_1.ALIGN_SIZE);
+    /**
+     * Symbol chosen by `getNextSymbol()`:
+     * -1 = literal, 0-3 = rep match, 4+ = match with distance `back - REPS`.
+     */
+    back = 0;
+    /** Bytes the match finder is ahead of the encoder. */
+    readAhead = -1;
+    constructor(rc, lz, config) {
+        super(config.lc, config.lp, config.pb);
+        this.rc = rc;
+        this.lz = lz;
+        this.niceLen = config.niceLen;
+        this.matchLenEncoder = new LengthEncoder(this.probs, lzma_coder_1.MATCH_LEN, config.pb, config.niceLen);
+        this.repLenEncoder = new LengthEncoder(this.probs, lzma_coder_1.REP_LEN, config.pb, config.niceLen);
+        this.distSlotPricesSize = getDistSlot(config.dictSize - 1) + 1;
+        this.reset();
+    }
+    /** Prepares for a new, independent input written to `rc`. */
+    restart(rc) {
+        this.rc = rc;
+        this.lz.reset();
+        this.reset();
+    }
+    reset() {
+        super.reset();
+        this.matchLenEncoder.reset();
+        this.repLenEncoder.reset();
+        this.distPriceCount = 0;
+        this.alignPriceCount = 0;
+        this.distModelsUsed = false;
+        this.alignModelUsed = false;
+        this.readAhead = -1;
+    }
+    /** Encodes as much of the buffered input as the lookahead allows. */
+    encode() {
+        if (!this.lz.isStarted() && !this.encodeInit()) {
+            return;
+        }
+        while (this.encodeSymbol()) {
+            // Each call encodes one symbol.
+        }
+    }
+    /** Encodes the end marker: a match with distance 0xFFFFFFFF. */
+    encodeEndMarker() {
+        const posState = (this.lz.getPos() - this.readAhead) & this.posMask;
+        this.rc.encodeBit(this.probs, lzma_coder_1.IS_MATCH + (this.state << 4) + posState, 1);
+        this.rc.encodeBit(this.probs, lzma_coder_1.IS_REP + this.state, 0);
+        this.encodeMatch(-1, lzma_coder_1.MATCH_LEN_MIN, posState);
+    }
+    /** The first symbol is always a literal with no previous byte. */
+    encodeInit() {
+        if (!this.lz.hasEnoughData(0)) {
+            return false;
+        }
+        this.skip(1);
+        this.rc.encodeBit(this.probs, lzma_coder_1.IS_MATCH + (this.state << 4), 0);
+        this.encodeLiteral(this.literalOffset(0, 0));
+        --this.readAhead;
+        return true;
+    }
+    encodeSymbol() {
+        if (!this.lz.hasEnoughData(this.readAhead + 1)) {
+            return false;
+        }
+        const len = this.getNextSymbol();
+        const lz = this.lz;
+        const rc = this.rc;
+        const probs = this.probs;
+        const pos = lz.getPos() - this.readAhead;
+        const posState = pos & this.posMask;
+        const back = this.back;
+        if (back === -1) {
+            rc.encodeBit(probs, lzma_coder_1.IS_MATCH + (this.state << 4) + posState, 0);
+            this.encodeLiteral(this.literalOffset(lz.getByte(1 + this.readAhead), pos));
+        }
+        else {
+            rc.encodeBit(probs, lzma_coder_1.IS_MATCH + (this.state << 4) + posState, 1);
+            if (back < lzma_coder_1.REPS) {
+                rc.encodeBit(probs, lzma_coder_1.IS_REP + this.state, 1);
+                this.encodeRepMatch(back, len, posState);
+            }
+            else {
+                rc.encodeBit(probs, lzma_coder_1.IS_REP + this.state, 0);
+                this.encodeMatch(back - lzma_coder_1.REPS, len, posState);
+            }
+        }
+        this.readAhead -= len;
+        return true;
+    }
+    encodeLiteral(offset) {
+        const symbol = this.lz.getByte(this.readAhead);
+        if ((0, lzma_coder_1.isLiteralState)(this.state)) {
+            this.rc.encodeLiteral(this.probs, offset, symbol);
+        }
+        else {
+            const matchByte = this.lz.getByte(this.reps[0] + 1 + this.readAhead);
+            this.rc.encodeMatchedLiteral(this.probs, offset, symbol, matchByte);
+        }
+        this.state = (0, lzma_coder_1.stateAfterLiteral)(this.state);
+    }
+    encodeMatch(dist, len, posState) {
+        const rc = this.rc;
+        const probs = this.probs;
+        const reps = this.reps;
+        this.state = (0, lzma_coder_1.stateAfterMatch)(this.state);
+        this.matchLenEncoder.encode(rc, len, posState);
+        const distSlot = getDistSlot(dist);
+        rc.encodeBitTree(probs, lzma_coder_1.DIST_SLOTS + ((0, lzma_coder_1.getDistState)(len) << lzma_coder_1.DIST_SLOT_BITS), lzma_coder_1.DIST_SLOT_BITS, distSlot);
+        this.distModelsUsed = true;
+        if (distSlot >= lzma_coder_1.DIST_MODEL_START) {
+            const footerBits = (distSlot >>> 1) - 1;
+            const base = (2 | (distSlot & 1)) << footerBits;
+            const distReduced = dist - base;
+            if (distSlot < lzma_coder_1.DIST_MODEL_END) {
+                rc.encodeReverseBitTree(probs, (0, lzma_coder_1.distSpecialOffset)(distSlot, base), footerBits, distReduced);
+            }
+            else {
+                rc.encodeDirectBits(distReduced >>> lzma_coder_1.ALIGN_BITS, footerBits - lzma_coder_1.ALIGN_BITS);
+                rc.encodeReverseBitTree(probs, lzma_coder_1.DIST_ALIGN, lzma_coder_1.ALIGN_BITS, distReduced & lzma_coder_1.ALIGN_MASK);
+                this.alignModelUsed = true;
+                --this.alignPriceCount;
+            }
+        }
+        reps[3] = reps[2];
+        reps[2] = reps[1];
+        reps[1] = reps[0];
+        reps[0] = dist;
+        --this.distPriceCount;
+    }
+    encodeRepMatch(rep, len, posState) {
+        const rc = this.rc;
+        const probs = this.probs;
+        const reps = this.reps;
+        const state = this.state;
+        if (rep === 0) {
+            rc.encodeBit(probs, lzma_coder_1.IS_REP0 + state, 0);
+            rc.encodeBit(probs, lzma_coder_1.IS_REP0_LONG + (state << 4) + posState, len === 1 ? 0 : 1);
+        }
+        else {
+            const dist = reps[rep];
+            rc.encodeBit(probs, lzma_coder_1.IS_REP0 + state, 1);
+            if (rep === 1) {
+                rc.encodeBit(probs, lzma_coder_1.IS_REP1 + state, 0);
+            }
+            else {
+                rc.encodeBit(probs, lzma_coder_1.IS_REP1 + state, 1);
+                rc.encodeBit(probs, lzma_coder_1.IS_REP2 + state, rep - 2);
+                if (rep === 3) {
+                    reps[3] = reps[2];
+                }
+                reps[2] = reps[1];
+            }
+            reps[1] = reps[0];
+            reps[0] = dist;
+        }
+        if (len === 1) {
+            this.state = (0, lzma_coder_1.stateAfterShortRep)(state);
+        }
+        else {
+            this.repLenEncoder.encode(rc, len, posState);
+            this.state = (0, lzma_coder_1.stateAfterLongRep)(state);
+        }
+    }
+    // -- Match finder access --
+    getMatches() {
+        ++this.readAhead;
+        return this.lz.getMatches();
+    }
+    skip(len) {
+        this.readAhead += len;
+        this.lz.skip(len);
+    }
+    // -- Prices --
+    getLiteralPrice(curByte, matchByte, prevByte, pos, state) {
+        const probs = this.probs;
+        const offset = this.literalOffset(prevByte, pos);
+        const price = (0, range_encoder_1.getBitPrice)(probs[lzma_coder_1.IS_MATCH + (state << 4) + (pos & this.posMask)], 0);
+        return price + ((0, lzma_coder_1.isLiteralState)(state) ? getLiteralNormalPrice(probs, offset, curByte) : getLiteralMatchedPrice(probs, offset, curByte, matchByte));
+    }
+    getAnyMatchPrice(state, posState) {
+        return (0, range_encoder_1.getBitPrice)(this.probs[lzma_coder_1.IS_MATCH + (state << 4) + posState], 1);
+    }
+    getNormalMatchPrice(anyMatchPrice, state) {
+        return anyMatchPrice + (0, range_encoder_1.getBitPrice)(this.probs[lzma_coder_1.IS_REP + state], 0);
+    }
+    getAnyRepPrice(anyMatchPrice, state) {
+        return anyMatchPrice + (0, range_encoder_1.getBitPrice)(this.probs[lzma_coder_1.IS_REP + state], 1);
+    }
+    getShortRepPrice(anyRepPrice, state, posState) {
+        const probs = this.probs;
+        return anyRepPrice + (0, range_encoder_1.getBitPrice)(probs[lzma_coder_1.IS_REP0 + state], 0) + (0, range_encoder_1.getBitPrice)(probs[lzma_coder_1.IS_REP0_LONG + (state << 4) + posState], 0);
+    }
+    getLongRepPrice(anyRepPrice, rep, state, posState) {
+        const probs = this.probs;
+        let price = anyRepPrice;
+        if (rep === 0) {
+            price += (0, range_encoder_1.getBitPrice)(probs[lzma_coder_1.IS_REP0 + state], 0) + (0, range_encoder_1.getBitPrice)(probs[lzma_coder_1.IS_REP0_LONG + (state << 4) + posState], 1);
+        }
+        else {
+            price += (0, range_encoder_1.getBitPrice)(probs[lzma_coder_1.IS_REP0 + state], 1);
+            if (rep === 1) {
+                price += (0, range_encoder_1.getBitPrice)(probs[lzma_coder_1.IS_REP1 + state], 0);
+            }
+            else {
+                price += (0, range_encoder_1.getBitPrice)(probs[lzma_coder_1.IS_REP1 + state], 1) + (0, range_encoder_1.getBitPrice)(probs[lzma_coder_1.IS_REP2 + state], rep - 2);
+            }
+        }
+        return price;
+    }
+    getLongRepAndLenPrice(rep, len, state, posState) {
+        const anyMatchPrice = this.getAnyMatchPrice(state, posState);
+        const anyRepPrice = this.getAnyRepPrice(anyMatchPrice, state);
+        const longRepPrice = this.getLongRepPrice(anyRepPrice, rep, state, posState);
+        return longRepPrice + this.repLenEncoder.getPrice(len, posState);
+    }
+    getMatchAndLenPrice(normalMatchPrice, dist, len, posState) {
+        return normalMatchPrice + this.matchLenEncoder.getPrice(len, posState) + this.getDistPrice((0, lzma_coder_1.getDistState)(len), dist);
+    }
+    /** Price of coding `dist` in distance state `distState`. */
+    getDistPrice(distState, dist) {
+        if (dist < lzma_coder_1.FULL_DISTANCES) {
+            return this.fullDistPrices[distState * lzma_coder_1.FULL_DISTANCES + dist];
+        }
+        // distSlotPrices includes the price of the direct bits.
+        return this.distSlotPrices[(distState << lzma_coder_1.DIST_SLOT_BITS) + getDistSlot(dist)] + this.alignPrices[dist & lzma_coder_1.ALIGN_MASK];
+    }
+    /** Refreshes the price tables that are due for an update. */
+    updatePrices() {
+        if (this.distPriceCount <= 0) {
+            this.updateDistPrices();
+        }
+        if (this.alignPriceCount <= 0) {
+            this.updateAlignPrices();
+        }
+        this.matchLenEncoder.updatePrices();
+        this.repLenEncoder.updatePrices();
+    }
+    updateDistPrices() {
+        this.distPriceCount = DIST_PRICE_UPDATE_INTERVAL;
+        if (this.distModelsUsed) {
+            computeDistPrices(this.probs, this.distSlotPricesSize, this.distSlotPrices, this.fullDistPrices);
+        }
+        else {
+            // The models still have their initial probabilities.
+            const initial = getInitialPrices();
+            this.distSlotPrices.set(initial.distSlots);
+            this.fullDistPrices.set(initial.fullDists);
+        }
+    }
+    updateAlignPrices() {
+        this.alignPriceCount = ALIGN_PRICE_UPDATE_INTERVAL;
+        if (this.alignModelUsed) {
+            computeAlignPrices(this.probs, this.alignPrices);
+        }
+        else {
+            this.alignPrices.set(getInitialPrices().align);
+        }
+    }
+}
+exports.LzmaEncoder = LzmaEncoder;
+/**
+ * Prices of the distance slots `[distState << 6 | slot]` (including the
+ * direct bits) and of the distances below `FULL_DISTANCES`
+ * `[distState * FULL_DISTANCES + dist]`.
+ */
+function computeDistPrices(probs, slotCount, slotPrices, fullPrices) {
+    for (let distState = 0; distState < lzma_coder_1.DIST_STATES; ++distState) {
+        const slots = distState << lzma_coder_1.DIST_SLOT_BITS;
+        const tree = lzma_coder_1.DIST_SLOTS + slots;
+        for (let distSlot = 0; distSlot < slotCount; ++distSlot) {
+            slotPrices[slots + distSlot] = (0, range_encoder_1.getBitTreePrice)(probs, tree, lzma_coder_1.DIST_SLOT_BITS, distSlot);
+        }
+        for (let distSlot = lzma_coder_1.DIST_MODEL_END; distSlot < slotCount; ++distSlot) {
+            const count = (distSlot >>> 1) - 1 - lzma_coder_1.ALIGN_BITS;
+            slotPrices[slots + distSlot] += (0, range_encoder_1.getDirectBitsPrice)(count);
+        }
+        for (let dist = 0; dist < lzma_coder_1.DIST_MODEL_START; ++dist) {
+            fullPrices[distState * lzma_coder_1.FULL_DISTANCES + dist] = slotPrices[slots + dist];
+        }
+    }
+    let dist = lzma_coder_1.DIST_MODEL_START;
+    for (let distSlot = lzma_coder_1.DIST_MODEL_START; distSlot < lzma_coder_1.DIST_MODEL_END; ++distSlot) {
+        const footerBits = (distSlot >>> 1) - 1;
+        const base = (2 | (distSlot & 1)) << footerBits;
+        const tree = (0, lzma_coder_1.distSpecialOffset)(distSlot, base);
+        for (let i = 0; i < 1 << footerBits; ++i) {
+            const price = (0, range_encoder_1.getReverseBitTreePrice)(probs, tree, footerBits, dist - base);
+            for (let distState = 0; distState < lzma_coder_1.DIST_STATES; ++distState) {
+                fullPrices[distState * lzma_coder_1.FULL_DISTANCES + dist] = slotPrices[(distState << lzma_coder_1.DIST_SLOT_BITS) + distSlot] + price;
+            }
+            ++dist;
+        }
+    }
+}
+function computeAlignPrices(probs, alignPrices) {
+    for (let i = 0; i < lzma_coder_1.ALIGN_SIZE; ++i) {
+        alignPrices[i] = (0, range_encoder_1.getReverseBitTreePrice)(probs, lzma_coder_1.DIST_ALIGN, lzma_coder_1.ALIGN_BITS, i);
+    }
+}
+/**
+ * Prices of `count` lengths for `posState` with the length coder at
+ * `coder`, written to `prices` from `start`.
+ */
+function computeLengthPrices(probs, coder, posState, prices, start, count) {
+    const end = start + count;
+    let i = 0;
+    let choice0Price = (0, range_encoder_1.getBitPrice)(probs[coder + lzma_coder_1.LEN_CHOICE], 0);
+    const low = coder + lzma_coder_1.LEN_LOW + posState * lzma_coder_1.LOW_SYMBOLS;
+    for (; i < lzma_coder_1.LOW_SYMBOLS; ++i) {
+        prices[start + i] = choice0Price + (0, range_encoder_1.getBitTreePrice)(probs, low, 3, i);
+    }
+    choice0Price = (0, range_encoder_1.getBitPrice)(probs[coder + lzma_coder_1.LEN_CHOICE], 1);
+    let choice1Price = (0, range_encoder_1.getBitPrice)(probs[coder + lzma_coder_1.LEN_CHOICE2], 0);
+    const mid = coder + lzma_coder_1.LEN_MID + posState * lzma_coder_1.MID_SYMBOLS;
+    for (; i < lzma_coder_1.LOW_SYMBOLS + lzma_coder_1.MID_SYMBOLS; ++i) {
+        prices[start + i] = choice0Price + choice1Price + (0, range_encoder_1.getBitTreePrice)(probs, mid, 3, i - lzma_coder_1.LOW_SYMBOLS);
+    }
+    choice1Price = (0, range_encoder_1.getBitPrice)(probs[coder + lzma_coder_1.LEN_CHOICE2], 1);
+    for (; start + i < end; ++i) {
+        prices[start + i] = choice0Price + choice1Price + (0, range_encoder_1.getBitTreePrice)(probs, coder + lzma_coder_1.LEN_HIGH, 8, i - lzma_coder_1.LOW_SYMBOLS - lzma_coder_1.MID_SYMBOLS);
+    }
+}
+let initialPrices;
+/**
+ * Price tables for models that still have their initial probabilities.
+ * They are the same for every encoder, so they are computed once. Copying
+ * them saves about a quarter of the time of compressing a small input.
+ */
+function getInitialPrices() {
+    if (initialPrices === undefined) {
+        const probs = new Uint16Array(lzma_coder_1.LITERAL);
+        (0, range_coder_1.initProbs)(probs);
+        const distSlots = new Uint32Array(lzma_coder_1.DIST_STATES << lzma_coder_1.DIST_SLOT_BITS);
+        const fullDists = new Uint32Array(lzma_coder_1.DIST_STATES * lzma_coder_1.FULL_DISTANCES);
+        computeDistPrices(probs, lzma_coder_1.DIST_SLOT_COUNT, distSlots, fullDists);
+        const align = new Uint32Array(lzma_coder_1.ALIGN_SIZE);
+        computeAlignPrices(probs, align);
+        const lengths = new Uint32Array(lzma_coder_1.MATCH_LEN_MAX - lzma_coder_1.MATCH_LEN_MIN + 1);
+        computeLengthPrices(probs, lzma_coder_1.MATCH_LEN, 0, lengths, 0, lengths.length);
+        initialPrices = { distSlots, fullDists, align, lengths };
+    }
+    return initialPrices;
+}
+function getLiteralNormalPrice(probs, offset, symbolIn) {
+    let symbol = symbolIn;
+    let price = 0;
+    symbol |= 0x100;
+    do {
+        price += (0, range_encoder_1.getBitPrice)(probs[offset + (symbol >>> 8)], (symbol >>> 7) & 1);
+        symbol <<= 1;
+    } while (symbol < 0x10000);
+    return price;
+}
+function getLiteralMatchedPrice(probs, offset, symbolIn, matchByteIn) {
+    let symbol = symbolIn;
+    let matchByte = matchByteIn;
+    let price = 0;
+    let matchOffset = 0x100;
+    symbol |= 0x100;
+    do {
+        matchByte <<= 1;
+        const matchBit = matchByte & matchOffset;
+        price += (0, range_encoder_1.getBitPrice)(probs[offset + matchOffset + matchBit + (symbol >>> 8)], (symbol >>> 7) & 1);
+        symbol <<= 1;
+        matchOffset &= ~(matchByte ^ symbol);
+    } while (symbol < 0x10000);
+    return price;
+}
+/**
+ * Length encoder with cached prices. Prices of each position state are
+ * recalculated after every `LEN_PRICE_UPDATE_INTERVAL` encoded lengths.
+ */
+class LengthEncoder {
+    probs;
+    /** Offset of this length coder in `probs`. */
+    coder;
+    counters;
+    /** Whether a length was encoded since the last reset. */
+    used = false;
+    /** Prices per position state, `[posState * lenSymbols + len - MATCH_LEN_MIN]`. */
+    prices;
+    lenSymbols;
+    constructor(probs, coder, pb, niceLen) {
+        this.probs = probs;
+        this.coder = coder;
+        const posStates = 1 << pb;
+        this.counters = new Int32Array(posStates);
+        // Always allocate at least LOW_SYMBOLS + MID_SYMBOLS entries to keep
+        // updatePrices() simple.
+        this.lenSymbols = Math.max(niceLen - lzma_coder_1.MATCH_LEN_MIN + 1, lzma_coder_1.LOW_SYMBOLS + lzma_coder_1.MID_SYMBOLS);
+        this.prices = new Uint32Array(posStates * this.lenSymbols);
+    }
+    reset() {
+        // Zero counters force a price update before the prices are needed.
+        this.counters.fill(0);
+        this.used = false;
+    }
+    encode(rc, lenIn, posState) {
+        let len = lenIn;
+        const probs = this.probs;
+        const coder = this.coder;
+        len -= lzma_coder_1.MATCH_LEN_MIN;
+        if (len < lzma_coder_1.LOW_SYMBOLS) {
+            rc.encodeBit(probs, coder + lzma_coder_1.LEN_CHOICE, 0);
+            rc.encodeBitTree(probs, coder + lzma_coder_1.LEN_LOW + posState * lzma_coder_1.LOW_SYMBOLS, 3, len);
+        }
+        else {
+            rc.encodeBit(probs, coder + lzma_coder_1.LEN_CHOICE, 1);
+            len -= lzma_coder_1.LOW_SYMBOLS;
+            if (len < lzma_coder_1.MID_SYMBOLS) {
+                rc.encodeBit(probs, coder + lzma_coder_1.LEN_CHOICE2, 0);
+                rc.encodeBitTree(probs, coder + lzma_coder_1.LEN_MID + posState * lzma_coder_1.MID_SYMBOLS, 3, len);
+            }
+            else {
+                rc.encodeBit(probs, coder + lzma_coder_1.LEN_CHOICE2, 1);
+                rc.encodeBitTree(probs, coder + lzma_coder_1.LEN_HIGH, 8, len - lzma_coder_1.MID_SYMBOLS);
+            }
+        }
+        --this.counters[posState];
+        this.used = true;
+    }
+    getPrice(len, posState) {
+        return this.prices[posState * this.lenSymbols + len - lzma_coder_1.MATCH_LEN_MIN];
+    }
+    /** Offset in `prices` such that `prices[offset + len]` is the price of `len`. */
+    priceOffset(posState) {
+        return posState * this.lenSymbols - lzma_coder_1.MATCH_LEN_MIN;
+    }
+    updatePrices() {
+        for (let posState = 0; posState < this.counters.length; ++posState) {
+            if (this.counters[posState] <= 0) {
+                this.counters[posState] = LEN_PRICE_UPDATE_INTERVAL;
+                this.updatePosStatePrices(posState);
+            }
+        }
+    }
+    updatePosStatePrices(posState) {
+        const start = posState * this.lenSymbols;
+        if (this.used) {
+            computeLengthPrices(this.probs, this.coder, posState, this.prices, start, this.lenSymbols);
+        }
+        else {
+            // The model still has its initial probabilities.
+            const initial = getInitialPrices().lengths;
+            for (let i = 0; i < this.lenSymbols; ++i) {
+                this.prices[start + i] = initial[i];
+            }
+        }
+    }
+}
+exports.LengthEncoder = LengthEncoder;

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

@@ -0,0 +1,85 @@
+/**
+ * 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.
+ */
+export declare class Lzma2Decoder {
+    private readonly lz;
+    private readonly rc;
+    private lzma;
+    private uncompressedSize;
+    private compressedSize;
+    private isLzmaChunk;
+    private needDictReset;
+    private needProps;
+    private endReached;
+    /**
+     * 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`.
+     */
+    private outPos;
+    /** Header of the next chunk, collected until it is complete. */
+    private readonly header;
+    private headerPos;
+    /**
+     * 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.
+     */
+    private readonly inBuf;
+    private inPos;
+    /**
+     * @param dictSize Dictionary size in bytes
+     * @param sink Receives decompressed data. The chunk is only valid during
+     *        the call.
+     */
+    constructor(dictSize: number, sink: (chunk: Uint8Array) => void);
+    /**
+     * Approximate memory needed to decode, in KiB, as XZ for Java's
+     * `LZMA2InputStream.getMemoryUsage` computes it.
+     */
+    static getMemoryUsage(dictSize: number): number;
+    /** Decodes as much of `input` as possible. */
+    write(input: Uint8Array): void;
+    /** Throws if the data ended before its end marker. */
+    end(): void;
+    /** Collects the chunk header and decodes it once it is complete. */
+    private readChunkHeader;
+    private decodeChunkHeader;
+    private decodeProps;
+    /** The LZMA decoder of the last properties, which a chunk without properties continues. */
+    private currentLzma;
+    private decodeLzmaChunk;
+}