@patrickdk77/archive-defuse 0.1.1 → 0.1.3

package/dist/lzma1/lzma-encoder.js

@@ -1,5 +1,5 @@
 "use strict";
-// Copied from lzma1 (Apache-2.0, Copyright Filip Seman) and changed for lzma-defuse. NOTICE in this folder lists the changes.
+// Copied from lzma1 0.6.1 (Apache-2.0, Copyright Filip Seman) and changed for archive-defuse. NOTICE in this folder lists the changes.
 /**
  * LZMA encoder base: codes the symbols chosen by a subclass and keeps the
  * price tables the subclasses use to choose between symbols.
@@ -8,60 +8,73 @@
  * - `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.
+ * Ported from XZ for Java (0BSD), `src/org/tukaani/xz/lzma/LZMAEncoder.java`,
+ * by Lasse Collin and Igor Pavlov. The LZMA2 entry points and chunk limits
+ * are not ported; this library produces only LZMA1 (".lzma") streams. The
+ * inner coder classes take their outer encoder (or the range encoder) as
+ * an explicit parameter where Java captures it implicitly.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LengthEncoder = exports.LzmaEncoder = void 0;
+exports.LengthEncoder = exports.LiteralEncoder = 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. */
+/**
+ * Gets an integer [0, 63] matching the highest two bits of an integer.
+ * This is like bit scan reverse (BSR) on x86 except that this also
+ * cares about the second highest bit.
+ */
 function getDistSlot(dist) {
     if (dist <= lzma_coder_1.DIST_MODEL_START && dist >= 0) {
         return dist;
     }
+    // 31 - Integer.numberOfLeadingZeros(dist)
     const i = 31 - Math.clz32(dist);
     return (i << 1) + ((dist >>> (i - 1)) & 1);
 }
 class LzmaEncoder extends lzma_coder_1.LzmaCoder {
     rc;
     lz;
-    niceLen;
+    literalEncoder;
     matchLenEncoder;
     repLenEncoder;
+    niceLen;
     distPriceCount = 0;
     alignPriceCount = 0;
-    /** Whether a distance or align bits were encoded since the last reset. */
+    /** Whether a distance was encoded since the last reset. */
     distModelsUsed = false;
+    /** Whether align bits were encoded since the last reset. */
     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);
+    distSlotPrices;
+    fullDistPrices = newPriceArray(lzma_coder_1.DIST_STATES, lzma_coder_1.FULL_DISTANCES);
+    alignPrices = new Int32Array(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. */
+    /** Bytes the match finder is ahead of the encoder. Package-private in Java. */
     readAhead = -1;
     constructor(rc, lz, config) {
         super(config.lc, config.lp, config.pb);
         this.rc = rc;
         this.lz = lz;
         this.niceLen = config.niceLen;
+        this.literalEncoder = new LiteralEncoder(this, config.lc, config.lp);
         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.distSlotPrices = newPriceArray(lzma_coder_1.DIST_STATES, this.distSlotPricesSize);
         this.reset();
     }
-    /** Prepares for a new, independent input written to `rc`. */
+    /**
+     * Prepares for a new, independent input written to `rc` (contract
+     * adaptation: lets a pooled encoder be reused by a later call).
+     */
     restart(rc) {
         this.rc = rc;
         this.lz.reset();
@@ -77,7 +90,7 @@ class LzmaEncoder extends lzma_coder_1.LzmaCoder {
         this.alignModelUsed = false;
         this.readAhead = -1;
     }
-    /** Encodes as much of the buffered input as the lookahead allows. */
+    /** Compress for LZMA1. */
     encode() {
         if (!this.lz.isStarted() && !this.encodeInit()) {
             return;
@@ -86,21 +99,26 @@ class LzmaEncoder extends lzma_coder_1.LzmaCoder {
             // Each call encodes one symbol.
         }
     }
-    /** Encodes the end marker: a match with distance 0xFFFFFFFF. */
     encodeEndMarker() {
+        // End of stream marker is encoded as a match with the maximum
+        // possible distance. The length is ignored by the decoder,
+        // but the minimum length has been used by the LZMA SDK.
+        //
+        // Distance is a 32-bit unsigned integer in LZMA.
+        // As an int32, UINT32_MAX becomes -1.
         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.rc.encodeBit(this.probs, lzma_coder_1.IS_MATCH + (this.state.get() << 4) + posState, 1);
+        this.rc.encodeBit(this.probs, lzma_coder_1.IS_REP + this.state.get(), 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;
         }
+        // The first symbol must be a literal.
         this.skip(1);
-        this.rc.encodeBit(this.probs, lzma_coder_1.IS_MATCH + (this.state << 4), 0);
-        this.encodeLiteral(this.literalOffset(0, 0));
+        this.rc.encodeBit(this.probs, lzma_coder_1.IS_MATCH + (this.state.get() << 4), 0);
+        this.literalEncoder.encodeInit(this.rc);
         --this.readAhead;
         return true;
     }
@@ -109,105 +127,86 @@ class LzmaEncoder extends lzma_coder_1.LzmaCoder {
             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));
+        const posState = (this.lz.getPos() - this.readAhead) & this.posMask;
+        if (this.back === -1) {
+            // Literal i.e. eight-bit byte
+            this.rc.encodeBit(this.probs, lzma_coder_1.IS_MATCH + (this.state.get() << 4) + posState, 0);
+            this.literalEncoder.encode(this.rc);
         }
         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);
+            // Some type of match
+            this.rc.encodeBit(this.probs, lzma_coder_1.IS_MATCH + (this.state.get() << 4) + posState, 1);
+            if (this.back < lzma_coder_1.REPS) {
+                // Repeated match i.e. the same distance
+                // has been used earlier.
+                this.rc.encodeBit(this.probs, lzma_coder_1.IS_REP + this.state.get(), 1);
+                this.encodeRepMatch(this.back, len, posState);
             }
             else {
-                rc.encodeBit(probs, lzma_coder_1.IS_REP + this.state, 0);
-                this.encodeMatch(back - lzma_coder_1.REPS, len, posState);
+                // Normal match
+                this.rc.encodeBit(this.probs, lzma_coder_1.IS_REP + this.state.get(), 0);
+                this.encodeMatch(this.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);
+        this.state.updateMatch();
+        this.matchLenEncoder.encode(this.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.rc.encodeBitTree(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, 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);
+                this.rc.encodeReverseBitTree(this.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.rc.encodeDirectBits(distReduced >>> lzma_coder_1.ALIGN_BITS, footerBits - lzma_coder_1.ALIGN_BITS);
+                this.rc.encodeReverseBitTree(this.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.reps[3] = this.reps[2];
+        this.reps[2] = this.reps[1];
+        this.reps[1] = this.reps[0];
+        this.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);
+            this.rc.encodeBit(this.probs, lzma_coder_1.IS_REP0 + this.state.get(), 0);
+            this.rc.encodeBit(this.probs, lzma_coder_1.IS_REP0_LONG + (this.state.get() << 4) + posState, len === 1 ? 0 : 1);
         }
         else {
-            const dist = reps[rep];
-            rc.encodeBit(probs, lzma_coder_1.IS_REP0 + state, 1);
+            const dist = this.reps[rep];
+            this.rc.encodeBit(this.probs, lzma_coder_1.IS_REP0 + this.state.get(), 1);
             if (rep === 1) {
-                rc.encodeBit(probs, lzma_coder_1.IS_REP1 + state, 0);
+                this.rc.encodeBit(this.probs, lzma_coder_1.IS_REP1 + this.state.get(), 0);
             }
             else {
-                rc.encodeBit(probs, lzma_coder_1.IS_REP1 + state, 1);
-                rc.encodeBit(probs, lzma_coder_1.IS_REP2 + state, rep - 2);
+                this.rc.encodeBit(this.probs, lzma_coder_1.IS_REP1 + this.state.get(), 1);
+                this.rc.encodeBit(this.probs, lzma_coder_1.IS_REP2 + this.state.get(), rep - 2);
                 if (rep === 3) {
-                    reps[3] = reps[2];
+                    this.reps[3] = this.reps[2];
                 }
-                reps[2] = reps[1];
+                this.reps[2] = this.reps[1];
             }
-            reps[1] = reps[0];
-            reps[0] = dist;
+            this.reps[1] = this.reps[0];
+            this.reps[0] = dist;
         }
         if (len === 1) {
-            this.state = (0, lzma_coder_1.stateAfterShortRep)(state);
+            this.state.updateShortRep();
         }
         else {
-            this.repLenEncoder.encode(rc, len, posState);
-            this.state = (0, lzma_coder_1.stateAfterLongRep)(state);
+            this.repLenEncoder.encode(this.rc, len, posState);
+            this.state.updateLongRep();
         }
     }
-    // -- Match finder access --
     getMatches() {
         ++this.readAhead;
         return this.lz.getMatches();
@@ -216,13 +215,6 @@ class LzmaEncoder extends lzma_coder_1.LzmaCoder {
         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);
     }
@@ -233,22 +225,20 @@ class LzmaEncoder extends lzma_coder_1.LzmaCoder {
         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);
+        return anyRepPrice + (0, range_encoder_1.getBitPrice)(this.probs[lzma_coder_1.IS_REP0 + state], 0) + (0, range_encoder_1.getBitPrice)(this.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);
+            price += (0, range_encoder_1.getBitPrice)(this.probs[lzma_coder_1.IS_REP0 + state], 0) + (0, range_encoder_1.getBitPrice)(this.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);
+            price += (0, range_encoder_1.getBitPrice)(this.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);
+                price += (0, range_encoder_1.getBitPrice)(this.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);
+                price += (0, range_encoder_1.getBitPrice)(this.probs[lzma_coder_1.IS_REP1 + state], 1) + (0, range_encoder_1.getBitPrice)(this.probs[lzma_coder_1.IS_REP2 + state], rep - 2);
             }
         }
         return price;
@@ -259,27 +249,17 @@ class LzmaEncoder extends lzma_coder_1.LzmaCoder {
         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];
+            return this.fullDistPrices[distState][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];
+        // Note that distSlotPrices includes also
+        // the price of direct bits.
+        const distSlot = getDistSlot(dist);
+        return this.distSlotPrices[distState][distSlot] + 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();
+    getMatchAndLenPrice(normalMatchPrice, dist, len, posState) {
+        return normalMatchPrice + this.matchLenEncoder.getPrice(len, posState) + this.getDistPrice((0, lzma_coder_1.getDistState)(len), dist);
     }
     updateDistPrices() {
         this.distPriceCount = DIST_PRICE_UPDATE_INTERVAL;
@@ -289,8 +269,10 @@ class LzmaEncoder extends lzma_coder_1.LzmaCoder {
         else {
             // The models still have their initial probabilities.
             const initial = getInitialPrices();
-            this.distSlotPrices.set(initial.distSlots);
-            this.fullDistPrices.set(initial.fullDists);
+            for (let distState = 0; distState < lzma_coder_1.DIST_STATES; ++distState) {
+                this.distSlotPrices[distState].set(initial.distSlotPrices[distState].subarray(0, this.distSlotPricesSize));
+                this.fullDistPrices[distState].set(initial.fullDistPrices[distState]);
+            }
         }
     }
     updateAlignPrices() {
@@ -299,40 +281,49 @@ class LzmaEncoder extends lzma_coder_1.LzmaCoder {
             computeAlignPrices(this.probs, this.alignPrices);
         }
         else {
-            this.alignPrices.set(getInitialPrices().align);
+            this.alignPrices.set(getInitialPrices().alignPrices);
+        }
+    }
+    /**
+     * Updates the lookup tables used for calculating match distance
+     * and length prices. The updating is skipped for performance reasons
+     * if the tables haven't changed much since the previous update.
+     */
+    updatePrices() {
+        if (this.distPriceCount <= 0) {
+            this.updateDistPrices();
         }
+        if (this.alignPriceCount <= 0) {
+            this.updateAlignPrices();
+        }
+        this.matchLenEncoder.updatePrices();
+        this.repLenEncoder.updatePrices();
     }
 }
 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) {
+function computeDistPrices(probs, distSlotPricesSize, distSlotPrices, fullDistPrices) {
     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 = 0; distSlot < distSlotPricesSize; ++distSlot) {
+            distSlotPrices[distState][distSlot] = (0, range_encoder_1.getBitTreePrice)(probs, lzma_coder_1.DIST_SLOT_OFFSET + (distState << lzma_coder_1.DIST_SLOT_BITS), lzma_coder_1.DIST_SLOT_BITS, distSlot);
         }
-        for (let distSlot = lzma_coder_1.DIST_MODEL_END; distSlot < slotCount; ++distSlot) {
+        for (let distSlot = lzma_coder_1.DIST_MODEL_END; distSlot < distSlotPricesSize; ++distSlot) {
             const count = (distSlot >>> 1) - 1 - lzma_coder_1.ALIGN_BITS;
-            slotPrices[slots + distSlot] += (0, range_encoder_1.getDirectBitsPrice)(count);
+            distSlotPrices[distState][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];
+            fullDistPrices[distState][dist] = distSlotPrices[distState][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);
+        const limit = 1 << footerBits;
+        for (let i = 0; i < limit; ++i) {
+            const distReduced = dist - base;
+            const price = (0, range_encoder_1.getReverseBitTreePrice)(probs, (0, lzma_coder_1.distSpecialOffset)(distSlot, base), footerBits, distReduced);
             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;
+                fullDistPrices[distState][dist] = distSlotPrices[distState][distSlot] + price;
             }
             ++dist;
         }
@@ -343,155 +334,221 @@ function computeAlignPrices(probs, alignPrices) {
         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);
+function newPriceArray(count, size) {
+    return Array.from({ length: count }, () => new Int32Array(size));
+}
+class LiteralEncoder extends lzma_coder_1.LiteralCoder {
+    encoder;
+    subencoders;
+    constructor(encoder, lc, lp) {
+        super(lc, lp);
+        this.encoder = encoder;
+        this.subencoders = Array.from({ length: 1 << (lc + lp) }, (_, i) => new LiteralSubencoder(encoder, lzma_coder_1.LITERAL + 0x300 * i));
+    }
+    encodeInit(rc) {
+        // When encoding the first byte of the stream, there is
+        // no previous byte in the dictionary so the encode function
+        // wouldn't work.
+        this.subencoders[0].encode(rc);
+    }
+    encode(rc) {
+        const encoder = this.encoder;
+        const i = this.getSubcoderIndex(encoder.lz.getByte(1 + encoder.readAhead), encoder.lz.getPos() - encoder.readAhead);
+        this.subencoders[i].encode(rc);
+    }
+    getPrice(curByte, matchByte, prevByte, pos, state) {
+        const encoder = this.encoder;
+        let price = (0, range_encoder_1.getBitPrice)(encoder.probs[lzma_coder_1.IS_MATCH + (state << 4) + (pos & encoder.posMask)], 0);
+        const i = this.getSubcoderIndex(prevByte, pos);
+        price += (0, lzma_coder_1.isLiteralState)(state) ? this.subencoders[i].getNormalPrice(curByte) : this.subencoders[i].getMatchedPrice(curByte, matchByte);
+        return price;
     }
-    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);
+}
+exports.LiteralEncoder = LiteralEncoder;
+class LiteralSubencoder extends lzma_coder_1.LiteralSubcoder {
+    encoder;
+    constructor(encoder, literalOffset) {
+        super(encoder.probs, literalOffset);
+        this.encoder = encoder;
+    }
+    encode(rc) {
+        const encoder = this.encoder;
+        const probs = this.probs;
+        let symbol = encoder.lz.getByte(encoder.readAhead) | 0x100;
+        if (encoder.state.isLiteral()) {
+            let subencoderIndex;
+            let bit;
+            do {
+                subencoderIndex = symbol >>> 8;
+                bit = (symbol >>> 7) & 1;
+                rc.encodeBit(probs, this.literalOffset + subencoderIndex, bit);
+                symbol <<= 1;
+            } while (symbol < 0x10000);
+        }
+        else {
+            let matchByte = encoder.lz.getByte(encoder.reps[0] + 1 + encoder.readAhead);
+            let offset = 0x100;
+            let subencoderIndex;
+            let matchBit;
+            let bit;
+            do {
+                matchByte <<= 1;
+                matchBit = matchByte & offset;
+                subencoderIndex = offset + matchBit + (symbol >>> 8);
+                bit = (symbol >>> 7) & 1;
+                rc.encodeBit(probs, this.literalOffset + subencoderIndex, bit);
+                symbol <<= 1;
+                offset &= ~(matchByte ^ symbol);
+            } while (symbol < 0x10000);
+        }
+        encoder.state.updateLiteral();
     }
-    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);
+    getNormalPrice(symbolIn) {
+        let symbol = symbolIn;
+        const probs = this.probs;
+        let price = 0;
+        let subencoderIndex;
+        let bit;
+        symbol |= 0x100;
+        do {
+            subencoderIndex = symbol >>> 8;
+            bit = (symbol >>> 7) & 1;
+            price += (0, range_encoder_1.getBitPrice)(probs[this.literalOffset + subencoderIndex], bit);
+            symbol <<= 1;
+        } while (symbol < 0x100 << 8);
+        return price;
     }
-}
-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 };
+    getMatchedPrice(symbolIn, matchByteIn) {
+        let symbol = symbolIn;
+        let matchByte = matchByteIn;
+        const probs = this.probs;
+        let price = 0;
+        let offset = 0x100;
+        let subencoderIndex;
+        let matchBit;
+        let bit;
+        symbol |= 0x100;
+        do {
+            matchByte <<= 1;
+            matchBit = matchByte & offset;
+            subencoderIndex = offset + matchBit + (symbol >>> 8);
+            bit = (symbol >>> 7) & 1;
+            price += (0, range_encoder_1.getBitPrice)(probs[this.literalOffset + subencoderIndex], bit);
+            symbol <<= 1;
+            offset &= ~(matchByte ^ symbol);
+        } while (symbol < 0x100 << 8);
+        return price;
     }
-    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;
+class LengthEncoder extends lzma_coder_1.LengthCoder {
+    /**
+     * The prices are updated after at least
+     * `PRICE_UPDATE_INTERVAL` many lengths
+     * have been encoded with the same posState.
+     */
+    static PRICE_UPDATE_INTERVAL = 32;
     counters;
+    prices;
     /** 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;
+        super(probs, 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);
+        // Always allocate at least LOW_SYMBOLS + MID_SYMBOLS because
+        // it makes updatePrices slightly simpler. The prices aren't
+        // usually needed anyway if niceLen < 18.
+        const lenSymbols = Math.max(niceLen - lzma_coder_1.MATCH_LEN_MIN + 1, lzma_coder_1.LOW_SYMBOLS + lzma_coder_1.MID_SYMBOLS);
+        this.prices = newPriceArray(posStates, lenSymbols);
     }
     reset() {
-        // Zero counters force a price update before the prices are needed.
+        // Reset counters to zero to force 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);
+            rc.encodeBit(this.probs, this.coder + lzma_coder_1.LEN_CHOICE, 0);
+            rc.encodeBitTree(this.probs, this.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);
+            rc.encodeBit(this.probs, this.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);
+                rc.encodeBit(this.probs, this.coder + lzma_coder_1.LEN_CHOICE2, 0);
+                rc.encodeBitTree(this.probs, this.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);
+                rc.encodeBit(this.probs, this.coder + lzma_coder_1.LEN_CHOICE2, 1);
+                rc.encodeBitTree(this.probs, this.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];
+        return this.prices[posState][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;
+    getPriceRow(posState) {
+        return this.prices[posState];
     }
     updatePrices() {
         for (let posState = 0; posState < this.counters.length; ++posState) {
             if (this.counters[posState] <= 0) {
-                this.counters[posState] = LEN_PRICE_UPDATE_INTERVAL;
+                this.counters[posState] = LengthEncoder.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);
+            computeLengthPrices(this.probs, this.coder, posState, this.prices[posState]);
         }
         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];
-            }
+            const prices = this.prices[posState];
+            prices.set(getInitialPrices().lengthPrices.subarray(0, prices.length));
         }
     }
 }
 exports.LengthEncoder = LengthEncoder;
+function computeLengthPrices(probs, coder, posState, prices) {
+    let choice0Price = (0, range_encoder_1.getBitPrice)(probs[coder + lzma_coder_1.LEN_CHOICE], 0);
+    let i = 0;
+    for (; i < lzma_coder_1.LOW_SYMBOLS; ++i) {
+        prices[i] = choice0Price + (0, range_encoder_1.getBitTreePrice)(probs, coder + lzma_coder_1.LEN_LOW + posState * lzma_coder_1.LOW_SYMBOLS, 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);
+    for (; i < lzma_coder_1.LOW_SYMBOLS + lzma_coder_1.MID_SYMBOLS; ++i) {
+        prices[i] = choice0Price + choice1Price + (0, range_encoder_1.getBitTreePrice)(probs, coder + lzma_coder_1.LEN_MID + posState * lzma_coder_1.MID_SYMBOLS, 3, i - lzma_coder_1.LOW_SYMBOLS);
+    }
+    choice1Price = (0, range_encoder_1.getBitPrice)(probs[coder + lzma_coder_1.LEN_CHOICE2], 1);
+    for (; i < prices.length; ++i) {
+        prices[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, by the
+ * same functions the encoders use, on an array of initial probabilities.
+ */
+function getInitialPrices() {
+    if (initialPrices === undefined) {
+        const probs = new Uint16Array(lzma_coder_1.LITERAL);
+        (0, range_coder_1.initProbs)(probs);
+        const distSlotPrices = newPriceArray(lzma_coder_1.DIST_STATES, lzma_coder_1.DIST_SLOTS);
+        const fullDistPrices = newPriceArray(lzma_coder_1.DIST_STATES, lzma_coder_1.FULL_DISTANCES);
+        computeDistPrices(probs, lzma_coder_1.DIST_SLOTS, distSlotPrices, fullDistPrices);
+        const alignPrices = new Int32Array(lzma_coder_1.ALIGN_SIZE);
+        computeAlignPrices(probs, alignPrices);
+        const lengthPrices = new Int32Array(lzma_coder_1.MATCH_LEN_MAX - lzma_coder_1.MATCH_LEN_MIN + 1);
+        computeLengthPrices(probs, lzma_coder_1.MATCH_LEN, 0, lengthPrices);
+        initialPrices = { distSlotPrices, fullDistPrices, alignPrices, lengthPrices };
+    }
+    return initialPrices;
+}