lzma1 0.2.0 → 0.3.0

package/lib/encoder.js

@@ -1,6 +1,7 @@
 import { LenEncoder, } from "./len-coder.js";
 import { LitCoder } from "./lit-coder.js";
-import { add64, compare64, create64, createBitTree, fromInt64, G_FAST_POS, getBitPrice, getLenToPosState, initArray, initBitModels, lowBits64, PROB_PRICES, } from "./utils.js";
+import { BinTreeMatchFinder } from "./match-finder.js";
+import { createBitTree, G_FAST_POS, getBitPrice, getLenToPosState, INFINITY_PRICE, initArray, initBitModels, PROB_PRICES, stateUpdateChar, } from "./utils.js";
 const bitTreePriceCache = new Map();
 /**
  * Calculate price for direct bit encoding
@@ -12,7 +13,7 @@ function getDirectBitsPrice(numBits) {
  * Get price for bit tree encoding with caching
  */
 function getBitTreePrice(bitTree, symbol) {
-    const cacheKey = `${bitTree.numBitLevels}-${symbol}`;
+    const cacheKey = (bitTree.numBitLevels << 16) | symbol;
     if (bitTreePriceCache.has(cacheKey)) {
         return bitTreePriceCache.get(cacheKey);
     }
@@ -35,7 +36,7 @@ class EncoderState {
     // Core state
     state = 0;
     previousByte = 0;
-    position = [0, 0];
+    position = 0n;
     // Repetition distances (LZ77 back-references)
     repDistances = [0, 0, 0, 0];
     // Match finding state
@@ -203,21 +204,18 @@ export class Encoder {
     _needReleaseMFStream = 0;
     _inStream = null;
     _finished = 0;
-    nowPos64 = [0, 0];
+    nowPos64 = 0n;
     // Distance and repetition arrays
     _repDistances = initArray(4);
     _optimum = [];
     // Range encoder
     _rangeEncoder = {
-        stream: {
-            buf: [],
-            count: 0,
-        },
+        stream: null,
         rrange: 0,
         cache: 0,
-        low: [0, 0],
+        low: 0n,
         cacheSize: 0,
-        position: [0, 0],
+        position: 0n,
         encodeBit: () => { },
         encodeBitTree: () => { },
         encodeDirectBits: () => { },
@@ -249,10 +247,10 @@ export class Encoder {
     reps = initArray(4);
     repLens = initArray(4);
     // Processing counters
-    processedInSize = [[0, 0]];
-    processedOutSize = [[0, 0]];
+    processedInSize = [0n];
+    processedOutSize = [0n];
     finished = [0];
-    properties = initArray(5);
+    properties = new Uint8Array(5);
     tempPrices = initArray(0x80); // 128
     // Match finding properties
     _longestMatchLength = 0;
@@ -328,11 +326,11 @@ export class Encoder {
      * Initialize encoder range coder
      */
     initEncoderState() {
-        this._rangeEncoder.low = [0, 0];
+        this._rangeEncoder.low = 0n;
         this._rangeEncoder.rrange = 0xFFFFFFFF;
         this._rangeEncoder.cacheSize = 1;
         this._rangeEncoder.cache = 0;
-        this._rangeEncoder.position = [0, 0];
+        this._rangeEncoder.position = 0n;
     }
     /**
      * Initialize literal encoder
@@ -432,13 +430,12 @@ export class Encoder {
         newBound = (rangeEncoder.rrange >>> 11) * prob;
         if (!symbol) {
             rangeEncoder.rrange = newBound;
-            probs[index] = prob + (2048 - prob >>> 5) << 16 >> 16;
+            probs[index] = prob + ((2048 - prob) >>> 5);
         }
         else {
-            // Need helper methods for 64-bit arithmetic
-            rangeEncoder.low = add64(rangeEncoder.low, this.and64(fromInt64(newBound), [0xFFFFFFFF, 0]));
+            rangeEncoder.low += BigInt(newBound >>> 0);
             rangeEncoder.rrange -= newBound;
-            probs[index] = prob - (prob >>> 5) << 16 >> 16;
+            probs[index] = prob - (prob >>> 5);
         }
         if (!(rangeEncoder.rrange & -0x1000000)) {
             rangeEncoder.rrange <<= 8;
@@ -499,7 +496,7 @@ export class Encoder {
         for (let i = numTotalBits - 1; i >= 0; i -= 1) {
             rangeEncoder.rrange >>>= 1;
             if ((valueToEncode >>> i & 1) == 1) {
-                rangeEncoder.low = add64(rangeEncoder.low, fromInt64(rangeEncoder.rrange));
+                rangeEncoder.low += BigInt(rangeEncoder.rrange >>> 0);
             }
             if (!(rangeEncoder.rrange & -0x1000000)) {
                 rangeEncoder.rrange <<= 8;
@@ -554,71 +551,24 @@ export class Encoder {
     encodeLengthWithPriceUpdate(encoder, symbol, posState) {
         encoder.encodeWithUpdate(symbol, posState, this);
     }
-    and64(a, b) {
-        const highBits = ~~Math.max(Math.min(a[1] / 0x100000000, 0x7FFFFFFF), -0x80000000) & ~~Math.max(Math.min(b[1] / 0x100000000, 0x7FFFFFFF), -0x80000000);
-        const lowBits = lowBits64(a) & lowBits64(b);
-        let high = highBits * 0x100000000;
-        let low = lowBits;
-        if (lowBits < 0) {
-            low += 0x100000000;
-        }
-        return [low, high];
-    }
-    shru64(a, n) {
-        n &= 0x3F;
-        let shiftFact = this.pwrAsDouble(n);
-        let sr = create64(Math.floor(a[0] / shiftFact), a[1] / shiftFact);
-        if (a[1] < 0) {
-            sr = add64(sr, this.shl64([2, 0], 0x3F - n));
-        }
-        return sr;
-    }
-    shl64(a, n) {
-        let diff, newHigh, newLow, twoToN;
-        n &= 0x3F;
-        if (a[0] == 0 && a[1] == -9223372036854775808) {
-            if (!n) {
-                return a;
-            }
-            return [0, 0];
-        }
-        if (a[1] < 0) {
-            throw new Error("Neg");
-        }
-        twoToN = this.pwrAsDouble(n);
-        newHigh = a[1] * twoToN % 1.8446744073709552E19;
-        newLow = a[0] * twoToN;
-        diff = newLow - newLow % 0x100000000;
-        newHigh += diff;
-        newLow -= diff;
-        if (newHigh >= 9223372036854775807) {
-            newHigh -= 1.8446744073709552E19;
-        }
-        return [newLow, newHigh];
-    }
-    pwrAsDouble(n) {
-        if (n <= 0x1E) {
-            return 1 << n;
-        }
-        return this.pwrAsDouble(0x1E) * this.pwrAsDouble(n - 0x1E);
-    }
     /**
      * Shift low helper (proper implementation) - public method for external access
      */
     shiftLow() {
         const rangeEncoder = this._rangeEncoder;
-        const LowHi = lowBits64(this.shru64(rangeEncoder.low, 32));
-        if (LowHi != 0 || compare64(rangeEncoder.low, [4278190080, 0]) < 0) {
-            rangeEncoder.position = add64(rangeEncoder.position, fromInt64(rangeEncoder.cacheSize));
+        const lowHi = Number((rangeEncoder.low >> 32n) & 0xffffffffn);
+        const lowLow = Number(rangeEncoder.low & 0xffffffffn);
+        if (lowHi != 0 || lowLow < 0xFF000000) {
+            rangeEncoder.position += BigInt(rangeEncoder.cacheSize);
             let temp = rangeEncoder.cache;
             do {
-                this.writeToStream(rangeEncoder.stream, temp + LowHi);
+                this.writeToStream(rangeEncoder.stream, temp + lowHi);
                 temp = 255;
             } while ((rangeEncoder.cacheSize -= 1) != 0);
-            rangeEncoder.cache = lowBits64(rangeEncoder.low) >>> 24;
+            rangeEncoder.cache = (lowLow >>> 24) & 0xFF;
         }
         rangeEncoder.cacheSize += 1;
-        rangeEncoder.low = this.shl64(this.and64(rangeEncoder.low, [16777215, 0]), 8);
+        rangeEncoder.low = BigInt(lowLow & 0xFFFFFF) << 8n;
     }
     /**
      * Write byte to stream
@@ -626,20 +576,11 @@ export class Encoder {
     writeToStream(stream, b) {
         if (!stream)
             return;
-        // Ensure buffer has enough capacity
-        if (stream.count >= stream.buf.length) {
-            const newSize = Math.max(stream.buf.length * 2, stream.count + 1);
-            const newBuf = new Array(newSize);
-            for (let i = 0; i < stream.count; i++) {
-                newBuf[i] = stream.buf[i];
-            }
-            stream.buf = newBuf;
-        }
-        stream.buf[stream.count++] = b << 24 >> 24;
+        stream.writeByte(b << 24 >> 24);
     }
     initRangeEncoder() {
-        this._rangeEncoder.position = [0, 0];
-        this._rangeEncoder.low = [0, 0];
+        this._rangeEncoder.position = 0n;
+        this._rangeEncoder.low = 0n;
         this._rangeEncoder.rrange = -1;
         this._rangeEncoder.cacheSize = 1;
         this._rangeEncoder.cache = 0;
@@ -668,7 +609,7 @@ export class Encoder {
             bitTreeEncoder = this._posSlotEncoder[lenToPosState];
             st = lenToPosState << 6;
             for (posSlot = 0; posSlot < this._distTableSize; posSlot += 1) {
-                this._posSlotPrices[st + posSlot] = this.rangeCoder_Encoder_GetPrice_1(bitTreeEncoder, posSlot);
+                this._posSlotPrices[st + posSlot] = this.getEncoderBitTreePrice(bitTreeEncoder, posSlot);
             }
             for (posSlot = 14; posSlot < this._distTableSize; posSlot += 1) {
                 this._posSlotPrices[st + posSlot] += (posSlot >> 1) - 1 - 4 << 6;
@@ -711,12 +652,12 @@ export class Encoder {
     /**
      * Get reverse price for array of models
      */
-    reverseGetPriceArray(Models, startIndex, NumBitLevels, symbol) {
+    reverseGetPriceArray(models, startIndex, numBitLevels, symbol) {
         let bit, m = 1, price = 0;
-        for (let i = NumBitLevels; i != 0; i -= 1) {
+        for (let i = numBitLevels; i != 0; i -= 1) {
             bit = symbol & 1;
             symbol >>>= 1;
-            price += PROB_PRICES[((Models[startIndex + m] - bit ^ -bit) & 2047) >>> 2];
+            price += PROB_PRICES[((models[startIndex + m] - bit ^ -bit) & 2047) >>> 2];
             m = m << 1 | bit;
         }
         return price;
@@ -724,13 +665,13 @@ export class Encoder {
     /**
      * Get price for probability model (optimized)
      */
-    getPrice(Prob, symbol) {
-        return getBitPrice(Prob, symbol);
+    getPrice(prob, symbol) {
+        return getBitPrice(prob, symbol);
     }
     /**
-     * Get price for bit tree encoder (optimized)
+     * Get price for bit tree encoder
      */
-    rangeCoder_Encoder_GetPrice_1(encoder, symbol) {
+    getEncoderBitTreePrice(encoder, symbol) {
         return getBitTreePrice(encoder, symbol);
     }
     /**
@@ -753,70 +694,780 @@ export class Encoder {
         }
     }
     /**
-     * Create match finder and encoder structures (replaces #Create_2)
+     * Get literal encoder subcoder (utility method)
      */
-    createMatchFinderAndStructures() {
-        // Create match finder if needed
+    getSubCoderUtility(pos, prevByte) {
+        // Calculate position mask bits
+        const posBits = pos & this._literalEncoder.posMask;
+        const posShifted = posBits << this._literalEncoder.numPrevBits;
+        // Calculate previous byte bits
+        const prevByteShift = 0x08 - this._literalEncoder.numPrevBits;
+        const prevByteBits = (prevByte & 0xFF) >>> prevByteShift;
+        // Combine position and prevByte bits to get final index
+        const coderIndex = posShifted + prevByteBits;
+        return this._literalEncoder.coders[coderIndex];
+    }
+    // ── Encoding orchestration methods (moved from LZMA) ──
+    makeAsChar(optimum) {
+        optimum.backPrev = -1;
+        optimum.prev1IsChar = 0;
+    }
+    makeAsShortRep(optimum) {
+        optimum.backPrev = 0;
+        optimum.prev1IsChar = 0;
+    }
+    releaseMFStream() {
+        if (this._matchFinder && this._needReleaseMFStream) {
+            this._matchFinder._stream = null;
+            this._needReleaseMFStream = 0;
+        }
+    }
+    releaseStreams() {
+        this.releaseMFStream();
+        this._rangeEncoder.stream = null;
+    }
+    getProcessedSizeAdd() {
+        return BigInt(this._rangeEncoder.cacheSize) + this._rangeEncoder.position + 4n;
+    }
+    getSubCoder(pos, prevByte) {
+        const subCoder = this._literalEncoder.getSubCoder(pos, prevByte);
+        return { decoders: subCoder.decoders };
+    }
+    getLiteralPrice(encoder, matchMode, matchByte, symbol) {
+        let bit, context = 1, i = 7, matchBit, price = 0;
+        if (matchMode) {
+            for (; i >= 0; --i) {
+                matchBit = (matchByte >> i) & 1;
+                bit = (symbol >> i) & 1;
+                price += getBitPrice(encoder.decoders[((1 + matchBit) << 8) + context], bit);
+                context = context << 1 | bit;
+                if (matchBit != bit) {
+                    --i;
+                    break;
+                }
+            }
+        }
+        for (; i >= 0; --i) {
+            bit = symbol >> i & 1;
+            price += getBitPrice(encoder.decoders[context], bit);
+            context = context << 1 | bit;
+        }
+        return price;
+    }
+    getPosLenPrice(pos, len, posState) {
+        let price, lenToPosState = getLenToPosState(len);
+        if (pos < 128) {
+            price = this._distancesPrices[lenToPosState * 128 + pos];
+        }
+        else {
+            const position = (lenToPosState << 6) + this.getPosSlot2(pos);
+            price = this._posSlotPrices[position] + this._alignPrices[pos & 15];
+        }
+        return price + this._lenEncoder.getPrice(len - 2, posState);
+    }
+    getPureRepPrice(repIndex, state, posState) {
+        let price;
+        if (!repIndex) {
+            price = PROB_PRICES[(this._isRepG0[state]) >>> 2];
+            price += PROB_PRICES[0x800 - this._isRep0Long[(state << 4) + posState] >>> 2];
+        }
+        else {
+            price = PROB_PRICES[(0x800 - this._isRepG0[state]) >>> 2];
+            if (repIndex == 1) {
+                price += PROB_PRICES[(this._isRepG1[state]) >>> 2];
+            }
+            else {
+                price += PROB_PRICES[(0x800 - this._isRepG1[state]) >>> 2];
+                price += getBitPrice(this._isRepG2[state], repIndex - 2);
+            }
+        }
+        return price;
+    }
+    getRepLen1Price(posState) {
+        const repG0Price = PROB_PRICES[(this._isRepG0[this._state]) >>> 2];
+        const rep0LongPrice = PROB_PRICES[this._isRep0Long[(this._state << 4) + posState] >>> 2];
+        return repG0Price + rep0LongPrice;
+    }
+    getPosSlot2(pos) {
+        if (pos < 0x20000) {
+            return G_FAST_POS[pos >> 6] + 12;
+        }
+        if (pos < 0x8000000) {
+            return G_FAST_POS[pos >> 16] + 32;
+        }
+        return G_FAST_POS[pos >> 26] + 52;
+    }
+    movePosHelper(num) {
+        if (num > 0) {
+            this._matchFinder.skip(num);
+            this._additionalOffset += num;
+        }
+    }
+    readMatchDistances() {
+        let lenRes = 0;
+        this._numDistancePairs = this._matchFinder.getMatches(this._matchDistances);
+        if (this._numDistancePairs > 0) {
+            lenRes = this._matchDistances[this._numDistancePairs - 2];
+            if (lenRes == this._numFastBytes) {
+                lenRes += this._matchFinder.getMatchLen(lenRes - 1, this._matchDistances[this._numDistancePairs - 1], 0x0111 - lenRes);
+            }
+        }
+        this._additionalOffset += 1;
+        return lenRes;
+    }
+    flushEncoding(nowPos) {
+        this.releaseMFStream();
+        this.writeEndMarker(nowPos & this._posStateMask);
+        for (let i = 0; i < 5; ++i) {
+            this.shiftLow();
+        }
+    }
+    backward(cur) {
+        let backCur, backMem, posMem, posPrev;
+        this._optimumEndIndex = cur;
+        posMem = this._optimum[cur].posPrev;
+        backMem = this._optimum[cur].backPrev;
+        do {
+            if (this._optimum[cur].prev1IsChar) {
+                this.makeAsChar(this._optimum[posMem]);
+                this._optimum[posMem].posPrev = posMem - 1;
+                if (this._optimum[cur].prev2) {
+                    this._optimum[posMem - 1].prev1IsChar = 0;
+                    this._optimum[posMem - 1].posPrev = this._optimum[cur].posPrev2;
+                    this._optimum[posMem - 1].backPrev = this._optimum[cur].backPrev2;
+                }
+            }
+            posPrev = posMem;
+            backCur = backMem;
+            backMem = this._optimum[posPrev].backPrev;
+            posMem = this._optimum[posPrev].posPrev;
+            this._optimum[posPrev].backPrev = backCur;
+            this._optimum[posPrev].posPrev = cur;
+            cur = posPrev;
+        } while (cur > 0);
+        this.backRes = this._optimum[0].backPrev;
+        this._optimumCurrentIndex = this._optimum[0].posPrev;
+        return this._optimumCurrentIndex;
+    }
+    getOptimumLength(position) {
+        let cur, curAnd1Price, curAndLenCharPrice, curAndLenPrice, curBack, curPrice, currentByte, distance, len, lenEnd, lenMain, lenTest, lenTest2, lenTestTemp, matchByte, matchPrice, newLen, nextIsChar, nextMatchPrice, nextOptimum, nextRepMatchPrice, normalMatchPrice, numAvailableBytes, numAvailableBytesFull, numDistancePairs, offs, offset, opt, optimum, pos, posPrev, posState, posStateNext, price_4, repIndex, repLen, repMatchPrice, repMaxIndex, shortRepPrice, startLen, state, state2, t, price, price_0, price_1, price_2, price_3, lenRes;
+        if (this._optimumEndIndex != this._optimumCurrentIndex) {
+            lenRes = this._optimum[this._optimumCurrentIndex].posPrev - this._optimumCurrentIndex;
+            this.backRes = this._optimum[this._optimumCurrentIndex].backPrev;
+            this._optimumCurrentIndex = this._optimum[this._optimumCurrentIndex].posPrev;
+            return lenRes;
+        }
+        this._optimumCurrentIndex = this._optimumEndIndex = 0;
+        if (this._longestMatchWasFound) {
+            lenMain = this._longestMatchLength;
+            this._longestMatchWasFound = 0;
+        }
+        else {
+            lenMain = this.readMatchDistances();
+        }
+        numDistancePairs = this._numDistancePairs;
+        numAvailableBytes = this._matchFinder.getNumAvailableBytes() + 1;
+        if (numAvailableBytes < 2) {
+            this.backRes = -1;
+            return 1;
+        }
+        if (numAvailableBytes > 0x0111) {
+            numAvailableBytes = 0x0111;
+        }
+        repMaxIndex = 0;
+        for (let i = 0; i < 4; ++i) {
+            this.reps[i] = this._repDistances[i];
+            this.repLens[i] = this._matchFinder.getMatchLen(-1, this.reps[i], 0x0111);
+            if (this.repLens[i] > this.repLens[repMaxIndex]) {
+                repMaxIndex = i;
+            }
+        }
+        if (this.repLens[repMaxIndex] >= this._numFastBytes) {
+            this.backRes = repMaxIndex;
+            lenRes = this.repLens[repMaxIndex];
+            this.movePosHelper(lenRes - 1);
+            return lenRes;
+        }
+        if (lenMain >= this._numFastBytes) {
+            this.backRes = this._matchDistances[numDistancePairs - 1] + 4;
+            this.movePosHelper(lenMain - 1);
+            return lenMain;
+        }
+        currentByte = this._matchFinder.getIndexByte(-1);
+        matchByte = this._matchFinder.getIndexByte(-this._repDistances[0] - 1 - 1);
+        if (lenMain < 2 && currentByte != matchByte && this.repLens[repMaxIndex] < 2) {
+            this.backRes = -1;
+            return 1;
+        }
+        this._optimum[0].state = this._state;
+        posState = position & this._posStateMask;
+        this._optimum[1].price = PROB_PRICES[(this._isMatch[(this._state << 4) + posState]) >>> 2] + this.getLiteralPrice(this.getSubCoder(position, this._previousByte), this._state >= 7, matchByte, currentByte);
+        this.makeAsChar(this._optimum[1]);
+        matchPrice = PROB_PRICES[(2048 - this._isMatch[(this._state << 4) + posState])
+            >>> 2];
+        repMatchPrice = matchPrice + PROB_PRICES[(2048 - this._isRep[this._state]) >>> 2];
+        if (matchByte == currentByte) {
+            shortRepPrice = repMatchPrice + this.getRepLen1Price(posState);
+            if (shortRepPrice < this._optimum[1].price) {
+                this._optimum[1].price = shortRepPrice;
+                this.makeAsShortRep(this._optimum[1]);
+            }
+        }
+        lenEnd = lenMain >= this.repLens[repMaxIndex]
+            ? lenMain
+            : this.repLens[repMaxIndex];
+        if (lenEnd < 2) {
+            this.backRes = this._optimum[1].backPrev;
+            return 1;
+        }
+        this._optimum[1].posPrev = 0;
+        this._optimum[0].backs0 = this.reps[0];
+        this._optimum[0].backs1 = this.reps[1];
+        this._optimum[0].backs2 = this.reps[2];
+        this._optimum[0].backs3 = this.reps[3];
+        len = lenEnd;
+        do {
+            this._optimum[len].price = INFINITY_PRICE;
+            len -= 1;
+        } while (len >= 2);
+        for (let i = 0; i < 4; ++i) {
+            repLen = this.repLens[i];
+            if (repLen < 2) {
+                continue;
+            }
+            price_4 = repMatchPrice + this.getPureRepPrice(i, this._state, posState);
+            do {
+                curAndLenPrice = price_4 + this._repMatchLenEncoder.getPrice(repLen - 2, posState);
+                optimum = this._optimum[repLen];
+                if (curAndLenPrice < optimum.price) {
+                    optimum.price = curAndLenPrice;
+                    optimum.posPrev = 0;
+                    optimum.backPrev = i;
+                    optimum.prev1IsChar = 0;
+                }
+            } while ((repLen -= 1) >= 2);
+        }
+        normalMatchPrice = matchPrice
+            + PROB_PRICES[(this._isRep[this._state]) >>> 2];
+        len = this.repLens[0] >= 2 ? this.repLens[0] + 1 : 2;
+        if (len <= lenMain) {
+            offs = 0;
+            while (len > this._matchDistances[offs]) {
+                offs += 2;
+            }
+            for (;; len += 1) {
+                distance = this._matchDistances[offs + 1];
+                curAndLenPrice = normalMatchPrice + this.getPosLenPrice(distance, len, posState);
+                optimum = this._optimum[len];
+                if (curAndLenPrice < optimum.price) {
+                    optimum.price = curAndLenPrice;
+                    optimum.posPrev = 0;
+                    optimum.backPrev = distance + 4;
+                    optimum.prev1IsChar = 0;
+                }
+                if (len == this._matchDistances[offs]) {
+                    offs += 2;
+                    if (offs == numDistancePairs) {
+                        break;
+                    }
+                }
+            }
+        }
+        cur = 0;
+        while (1) {
+            ++cur;
+            if (cur == lenEnd) {
+                return this.backward(cur);
+            }
+            newLen = this.readMatchDistances();
+            numDistancePairs = this._numDistancePairs;
+            if (newLen >= this._numFastBytes) {
+                this._longestMatchLength = newLen;
+                this._longestMatchWasFound = 0x01;
+                return this.backward(cur);
+            }
+            position += 0x01;
+            posPrev = this._optimum[cur].posPrev;
+            if (this._optimum[cur].prev1IsChar) {
+                posPrev -= 0x01;
+                if (this._optimum[cur].prev2) {
+                    state = this._optimum[this._optimum[cur].posPrev2].state;
+                    if (this._optimum[cur].backPrev2 < 0x04) {
+                        state = (state < 0x07) ? 0x08 : 0x0B;
+                    }
+                    else {
+                        state = (state < 0x07) ? 0x07 : 0x0A;
+                    }
+                }
+                else {
+                    state = this._optimum[posPrev].state;
+                }
+                state = stateUpdateChar(state);
+            }
+            else {
+                state = this._optimum[posPrev].state;
+            }
+            if (posPrev == cur - 1) {
+                if (!this._optimum[cur].backPrev) {
+                    state = state < 7 ? 9 : 11;
+                }
+                else {
+                    state = stateUpdateChar(state);
+                }
+            }
+            else {
+                if (this._optimum[cur].prev1IsChar
+                    && this._optimum[cur].prev2) {
+                    posPrev = this._optimum[cur].posPrev2;
+                    pos = this._optimum[cur].backPrev2;
+                    state = state < 0x07 ? 0x08 : 0x0B;
+                }
+                else {
+                    pos = this._optimum[cur].backPrev;
+                    if (pos < 4) {
+                        state = state < 0x07 ? 0x08 : 0x0B;
+                    }
+                    else {
+                        state = state < 0x07 ? 0x07 : 0x0A;
+                    }
+                }
+                opt = this._optimum[posPrev];
+                if (pos < 4) {
+                    if (!pos) {
+                        this.reps[0] = opt.backs0;
+                        this.reps[1] = opt.backs1;
+                        this.reps[2] = opt.backs2;
+                        this.reps[3] = opt.backs3;
+                    }
+                    else if (pos == 1) {
+                        this.reps[0] = opt.backs1;
+                        this.reps[1] = opt.backs0;
+                        this.reps[2] = opt.backs2;
+                        this.reps[3] = opt.backs3;
+                    }
+                    else if (pos == 2) {
+                        this.reps[0] = opt.backs2;
+                        this.reps[1] = opt.backs0;
+                        this.reps[2] = opt.backs1;
+                        this.reps[3] = opt.backs3;
+                    }
+                    else {
+                        this.reps[0] = opt.backs3;
+                        this.reps[1] = opt.backs0;
+                        this.reps[2] = opt.backs1;
+                        this.reps[3] = opt.backs2;
+                    }
+                }
+                else {
+                    this.reps[0] = pos - 4;
+                    this.reps[1] = opt.backs0;
+                    this.reps[2] = opt.backs1;
+                    this.reps[3] = opt.backs2;
+                }
+            }
+            this._optimum[cur].state = state;
+            this._optimum[cur].backs0 = this.reps[0];
+            this._optimum[cur].backs1 = this.reps[1];
+            this._optimum[cur].backs2 = this.reps[2];
+            this._optimum[cur].backs3 = this.reps[3];
+            curPrice = this._optimum[cur].price;
+            currentByte = this._matchFinder.getIndexByte(-0x01);
+            matchByte = this._matchFinder.getIndexByte(-this.reps[0] - 1 - 1);
+            posState = position & this._posStateMask;
+            curAnd1Price = curPrice
+                + PROB_PRICES[(this._isMatch[(state << 0x04) + posState]) >>> 2]
+                + this.getLiteralPrice(this.getSubCoder(position, this._matchFinder.getIndexByte(-2)), state >= 7, matchByte, currentByte);
+            nextOptimum = this._optimum[cur + 1];
+            nextIsChar = 0;
+            if (curAnd1Price < nextOptimum.price) {
+                nextOptimum.price = curAnd1Price;
+                nextOptimum.posPrev = cur;
+                nextOptimum.backPrev = -0x01;
+                nextOptimum.prev1IsChar = 0;
+                nextIsChar = 1;
+            }
+            matchPrice = curPrice + PROB_PRICES[(2048 - this._isMatch[(state << 4) + posState]) >>> 2];
+            repMatchPrice = matchPrice + PROB_PRICES[(2048 - this._isRep[state]) >>> 2];
+            if (matchByte == currentByte && !(nextOptimum.posPrev < cur && !nextOptimum.backPrev)) {
+                shortRepPrice = repMatchPrice
+                    + (PROB_PRICES[(this._isRepG0[state]) >>> 0x02] + PROB_PRICES[(this._isRep0Long[(state << 0x04) + posState]) >>> 0x02]);
+                if (shortRepPrice <= nextOptimum.price) {
+                    nextOptimum.price = shortRepPrice;
+                    nextOptimum.posPrev = cur;
+                    nextOptimum.backPrev = 0;
+                    nextOptimum.prev1IsChar = 0;
+                    nextIsChar = 1;
+                }
+            }
+            numAvailableBytesFull = this._matchFinder.getNumAvailableBytes() + 1;
+            numAvailableBytesFull = 0xFFF - cur < numAvailableBytesFull
+                ? 0xFFF - cur
+                : numAvailableBytesFull;
+            numAvailableBytes = numAvailableBytesFull;
+            if (numAvailableBytes < 2) {
+                continue;
+            }
+            if (numAvailableBytes > this._numFastBytes) {
+                numAvailableBytes = this._numFastBytes;
+            }
+            if (!nextIsChar && matchByte != currentByte) {
+                t = Math.min(numAvailableBytesFull - 1, this._numFastBytes);
+                lenTest2 = this._matchFinder.getMatchLen(0, this.reps[0], t);
+                if (lenTest2 >= 2) {
+                    state2 = stateUpdateChar(state);
+                    posStateNext = position + 1 & this._posStateMask;
+                    nextRepMatchPrice = curAnd1Price
+                        + PROB_PRICES[(2048 - this._isMatch[(state2 << 4) + posStateNext]) >>> 2]
+                        + PROB_PRICES[(2048 - this._isRep[state2]) >>> 2];
+                    offset = cur + 1 + lenTest2;
+                    while (lenEnd < offset) {
+                        this._optimum[lenEnd += 1].price = INFINITY_PRICE;
+                    }
+                    curAndLenPrice = nextRepMatchPrice + (price = this._repMatchLenEncoder.getPrice(lenTest2 - 2, posStateNext),
+                        price + this.getPureRepPrice(0, state2, posStateNext));
+                    optimum = this._optimum[offset];
+                    if (curAndLenPrice < optimum.price) {
+                        optimum.price = curAndLenPrice;
+                        optimum.posPrev = cur + 1;
+                        optimum.backPrev = 0;
+                        optimum.prev1IsChar = 1;
+                        optimum.prev2 = 0;
+                    }
+                }
+            }
+            startLen = 0x02;
+            for (repIndex = 0; repIndex < 4; ++repIndex) {
+                lenTest = this._matchFinder.getMatchLen(-0x01, this.reps[repIndex], numAvailableBytes);
+                if (lenTest < 2) {
+                    continue;
+                }
+                lenTestTemp = lenTest;
+                do {
+                    while (lenEnd < cur + lenTest) {
+                        this._optimum[lenEnd += 1].price = INFINITY_PRICE;
+                    }
+                    curAndLenPrice = repMatchPrice + (price_0 = this._repMatchLenEncoder.getPrice(lenTest - 2, posState),
+                        price_0 + this.getPureRepPrice(repIndex, state, posState));
+                    optimum = this._optimum[cur + lenTest];
+                    if (curAndLenPrice < optimum.price) {
+                        optimum.price = curAndLenPrice;
+                        optimum.posPrev = cur;
+                        optimum.backPrev = repIndex;
+                        optimum.prev1IsChar = 0;
+                    }
+                } while ((lenTest -= 1) >= 2);
+                lenTest = lenTestTemp;
+                if (!repIndex) {
+                    startLen = lenTest + 1;
+                }
+                if (lenTest < numAvailableBytesFull) {
+                    t = Math.min(numAvailableBytesFull - 1 - lenTest, this._numFastBytes);
+                    lenTest2 = this._matchFinder.getMatchLen(lenTest, this.reps[repIndex], t);
+                    if (lenTest2 >= 2) {
+                        state2 = state < 7 ? 0x08 : 11;
+                        posStateNext = position + lenTest & this._posStateMask;
+                        curAndLenCharPrice = repMatchPrice
+                            + (price_1 = this._repMatchLenEncoder.getPrice(lenTest - 2, posState), price_1 + this.getPureRepPrice(repIndex, state, posState))
+                            + PROB_PRICES[(this._isMatch[(state2 << 4) + posStateNext]) >>> 2]
+                            + this.getLiteralPrice(this.getSubCoder(position + lenTest, this._matchFinder.getIndexByte(lenTest - 1 - 1)), true, this._matchFinder.getIndexByte(lenTest - 1 - (this.reps[repIndex] + 1)), this._matchFinder.getIndexByte(lenTest - 1));
+                        state2 = stateUpdateChar(state2);
+                        posStateNext = position + lenTest + 1 & this._posStateMask;
+                        nextMatchPrice = curAndLenCharPrice + PROB_PRICES[(2048 - this._isMatch[(state2 << 4) + posStateNext]) >>> 2];
+                        nextRepMatchPrice = nextMatchPrice + PROB_PRICES[(2048 - this._isRep[state2]) >>> 2];
+                        offset = lenTest + 1 + lenTest2;
+                        while (lenEnd < cur + offset) {
+                            this._optimum[lenEnd += 1].price = INFINITY_PRICE;
+                        }
+                        curAndLenPrice = nextRepMatchPrice + (price_2 = this._repMatchLenEncoder.getPrice(lenTest2 - 2, posStateNext), price_2 + this.getPureRepPrice(0, state2, posStateNext));
+                        optimum = this._optimum[cur + offset];
+                        if (curAndLenPrice < optimum.price) {
+                            optimum.price = curAndLenPrice;
+                            optimum.posPrev = cur + lenTest + 1;
+                            optimum.backPrev = 0;
+                            optimum.prev1IsChar = 1;
+                            optimum.prev2 = 1;
+                            optimum.posPrev2 = cur;
+                            optimum.backPrev2 = repIndex;
+                        }
+                    }
+                }
+            }
+            if (newLen > numAvailableBytes) {
+                newLen = numAvailableBytes;
+                for (numDistancePairs = 0; newLen > this._matchDistances[numDistancePairs]; numDistancePairs += 2) { }
+                this._matchDistances[numDistancePairs] = newLen;
+                numDistancePairs += 2;
+            }
+            if (newLen >= startLen) {
+                normalMatchPrice = matchPrice + PROB_PRICES[(this._isRep[state]) >>> 2];
+                while (lenEnd < cur + newLen) {
+                    this._optimum[lenEnd += 1].price = INFINITY_PRICE;
+                }
+                offs = 0;
+                while (startLen > this._matchDistances[offs]) {
+                    offs += 2;
+                }
+                for (lenTest = startLen;; lenTest += 1) {
+                    curBack = this._matchDistances[offs + 1];
+                    curAndLenPrice = normalMatchPrice + this.getPosLenPrice(curBack, lenTest, posState);
+                    optimum = this._optimum[cur + lenTest];
+                    if (curAndLenPrice < optimum.price) {
+                        optimum.price = curAndLenPrice;
+                        optimum.posPrev = cur;
+                        optimum.backPrev = curBack + 4;
+                        optimum.prev1IsChar = 0;
+                    }
+                    if (lenTest == this._matchDistances[offs]) {
+                        if (lenTest < numAvailableBytesFull) {
+                            t = Math.min(numAvailableBytesFull - 1 - lenTest, this._numFastBytes);
+                            lenTest2 = this._matchFinder.getMatchLen(lenTest, curBack, t);
+                            if (lenTest2 >= 2) {
+                                state2 = state < 7 ? 7 : 10;
+                                posStateNext = position + lenTest & this._posStateMask;
+                                curAndLenCharPrice = curAndLenPrice
+                                    + PROB_PRICES[(this._isMatch[(state2 << 4) + posStateNext]) >>> 2]
+                                    + this.getLiteralPrice(this.getSubCoder(position + lenTest, this._matchFinder.getIndexByte(lenTest - 1 - 1)), true, this._matchFinder.getIndexByte(lenTest - (curBack + 1) - 1), this._matchFinder.getIndexByte(lenTest - 1));
+                                state2 = stateUpdateChar(state2);
+                                posStateNext = position + lenTest + 1 & this._posStateMask;
+                                nextMatchPrice = curAndLenCharPrice + PROB_PRICES[(2048 - this._isMatch[(state2 << 4) + posStateNext]) >>> 2];
+                                nextRepMatchPrice = nextMatchPrice + PROB_PRICES[(2048 - this._isRep[state2]) >>> 2];
+                                offset = lenTest + 1 + lenTest2;
+                                while (lenEnd < cur + offset) {
+                                    this._optimum[lenEnd += 1].price = INFINITY_PRICE;
+                                }
+                                curAndLenPrice = nextRepMatchPrice + (price_3 = this._repMatchLenEncoder.getPrice(lenTest2 - 2, posStateNext), price_3 + this.getPureRepPrice(0, state2, posStateNext));
+                                optimum = this._optimum[cur + offset];
+                                if (curAndLenPrice < optimum.price) {
+                                    optimum.price = curAndLenPrice;
+                                    optimum.posPrev = cur + lenTest + 1;
+                                    optimum.backPrev = 0;
+                                    optimum.prev1IsChar = 1;
+                                    optimum.prev2 = 1;
+                                    optimum.posPrev2 = cur;
+                                    optimum.backPrev2 = curBack + 4;
+                                }
+                            }
+                        }
+                        offs += 2;
+                        if (offs == numDistancePairs) {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        // Fallback return - should not be reached in normal execution
+        return 1;
+    }
+    codeOneBlock() {
+        let baseVal, complexState, curByte, distance, footerBits, len, lenToPosState, matchByte, pos, posReduced, posSlot, posState, progressPosValuePrev, subCoder;
+        this.processedInSize[0] = 0n;
+        this.processedOutSize[0] = 0n;
+        this.finished[0] = 1;
+        progressPosValuePrev = this.nowPos64;
+        if (this._inStream) {
+            this._matchFinder._stream = this._inStream;
+            this._matchFinder.init();
+            this._needReleaseMFStream = 1;
+            this._inStream = null;
+        }
+        if (this._finished) {
+            return;
+        }
+        this._finished = 1;
+        if (this.nowPos64 === 0n) {
+            if (!this._matchFinder.getNumAvailableBytes()) {
+                this.flushEncoding(Number(this.nowPos64 & 0xffffffffn));
+                return;
+            }
+            this.readMatchDistances();
+            posState = Number(this.nowPos64 & 0xffffffffn) & this._posStateMask;
+            this.encodeBit(this._isMatch, (this._state << 4) + posState, 0);
+            this._state = stateUpdateChar(this._state);
+            curByte = this._matchFinder.getIndexByte(-this._additionalOffset);
+            this.encodeLiteral(this.getSubCoder(Number(this.nowPos64 & 0xffffffffn), this._previousByte), curByte);
+            this._previousByte = curByte;
+            this._additionalOffset -= 1;
+            this.nowPos64 += 1n;
+        }
+        if (!this._matchFinder.getNumAvailableBytes()) {
+            this.flushEncoding(Number(this.nowPos64 & 0xffffffffn));
+            return;
+        }
+        while (1) {
+            len = this.getOptimumLength(Number(this.nowPos64 & 0xffffffffn));
+            pos = this.backRes;
+            posState = Number(this.nowPos64 & 0xffffffffn) & this._posStateMask;
+            complexState = (this._state << 4) + posState;
+            if (len == 1 && pos == -1) {
+                this.encodeBit(this._isMatch, complexState, 0);
+                curByte = this._matchFinder.getIndexByte(-this._additionalOffset);
+                subCoder = this.getSubCoder(Number(this.nowPos64 & 0xffffffffn), this._previousByte);
+                if (this._state < 7) {
+                    this.encodeLiteral(subCoder, curByte);
+                }
+                else {
+                    matchByte = this._matchFinder.getIndexByte(-this._repDistances[0]
+                        - 1
+                        - this._additionalOffset);
+                    this.encodeMatched(subCoder, matchByte, curByte);
+                }
+                this._previousByte = curByte;
+                this._state = stateUpdateChar(this._state);
+            }
+            else {
+                this.encodeBit(this._isMatch, complexState, 1);
+                if (pos < 4) {
+                    this.encodeBit(this._isRep, this._state, 1);
+                    if (!pos) {
+                        this.encodeBit(this._isRepG0, this._state, 0);
+                        if (len == 1) {
+                            this.encodeBit(this._isRep0Long, complexState, 0);
+                        }
+                        else {
+                            this.encodeBit(this._isRep0Long, complexState, 1);
+                        }
+                    }
+                    else {
+                        this.encodeBit(this._isRepG0, this._state, 1);
+                        if (pos == 1) {
+                            this.encodeBit(this._isRepG1, this._state, 0);
+                        }
+                        else {
+                            this.encodeBit(this._isRepG1, this._state, 1);
+                            this.encodeBit(this._isRepG2, this._state, pos - 2);
+                        }
+                    }
+                    if (len == 1) {
+                        this._state = this._state < 7 ? 9 : 11;
+                    }
+                    else {
+                        this.encodeLength(this._repMatchLenEncoder, len - 2, posState);
+                        this._state = this._state < 7
+                            ? 0x08
+                            : 11;
+                    }
+                    distance = this._repDistances[pos];
+                    if (pos != 0) {
+                        for (let i = pos; i >= 1; --i) {
+                            this._repDistances[i] = this._repDistances[i - 1];
+                        }
+                        this._repDistances[0] = distance;
+                    }
+                }
+                else {
+                    this.encodeBit(this._isRep, this._state, 0);
+                    this._state = this._state < 7 ? 7 : 10;
+                    this.encodeLength(this._lenEncoder, len - 0x02, posState);
+                    pos -= 0x04;
+                    posSlot = this.getPosSlot(pos);
+                    lenToPosState = getLenToPosState(len);
+                    this.encodeBitTree(this._posSlotEncoder[lenToPosState], posSlot);
+                    if (posSlot >= 0x04) {
+                        footerBits = (posSlot >> 0x01) - 0x01;
+                        baseVal = (0x02 | (posSlot & 0x01)) << footerBits;
+                        posReduced = pos - baseVal;
+                        if (posSlot < 0x0E) {
+                            this.reverseEncodeRange(baseVal - posSlot - 0x01, footerBits, posReduced);
+                        }
+                        else {
+                            this.encodeDirectBits(posReduced >> 0x04, footerBits - 4);
+                            this.reverseEncode(posReduced & 0x0F);
+                            this._alignPriceCount += 1;
+                        }
+                    }
+                    distance = pos;
+                    for (let i = 3; i >= 1; --i) {
+                        this._repDistances[i] = this._repDistances[i - 1];
+                    }
+                    this._repDistances[0] = distance;
+                    this._matchPriceCount += 0x01;
+                }
+                this._previousByte = this._matchFinder.getIndexByte(len - 1 - this._additionalOffset);
+            }
+            this._additionalOffset -= len;
+            this.nowPos64 += BigInt(len);
+            if (!this._additionalOffset) {
+                if (this._matchPriceCount >= 0x80) {
+                    this.fillDistancesPrices();
+                }
+                if (this._alignPriceCount >= 0x10) {
+                    this.fillAlignPrices();
+                }
+                this.processedInSize[0] = this.nowPos64;
+                this.processedOutSize[0] = this.getProcessedSizeAdd();
+                if (!this._matchFinder.getNumAvailableBytes()) {
+                    this.flushEncoding(Number(this.nowPos64 & 0xffffffffn));
+                    return;
+                }
+                if ((this.nowPos64 - progressPosValuePrev) >= 0x1000n) {
+                    this._finished = 0;
+                    this.finished[0] = 0;
+                    return;
+                }
+            }
+        }
+    }
+    createMatchFinder() {
         if (!this._matchFinder) {
-            const binTree = {};
+            const binTree = new BinTreeMatchFinder();
             let numHashBytes = 4;
             if (!this._matchFinderType) {
                 numHashBytes = 2;
             }
-            // Set match finder type (replaces #SetType)
-            binTree.HASH_ARRAY = numHashBytes > 2;
-            if (binTree.HASH_ARRAY) {
-                binTree.kNumHashDirectBytes = 0;
-                binTree.kMinMatchCheck = 4;
-                binTree.kFixHashSize = 66560;
-            }
-            else {
-                binTree.kNumHashDirectBytes = 2;
-                binTree.kMinMatchCheck = 3;
-                binTree.kFixHashSize = 0;
-            }
-            // Initialize other match finder properties
-            binTree._cyclicBufferSize = 0;
-            binTree._cyclicBufferPos = 0;
-            binTree._streamPos = 0;
-            binTree._cutValue = 0xff;
-            binTree._matchMaxLen = 0;
-            binTree._streamEndWasReached = 0;
-            binTree._pos = 0;
-            binTree._posLimit = 0;
-            binTree._son = [];
-            binTree._hash = [];
-            binTree._bufferBase = [];
-            binTree._blockSize = 0;
-            binTree._keepSizeAfter = 0;
-            binTree._keepSizeBefore = 0;
-            binTree._pointerToLastSafePosition = 0;
+            binTree.setType(numHashBytes);
             this._matchFinder = binTree;
         }
-        // Create literal encoder if needed
         this.createLiteralEncoder();
-        // Check if we need to recreate structures
         if (this._dictionarySize == this._dictionarySizePrev
             && this._numFastBytesPrev == this._numFastBytes) {
             return;
         }
-        // This would call equivalent of #Create_3(0x1000, 0x0112) logic
-        // For now, we'll handle the basic setup
+        this._matchFinder.create(this._dictionarySize, this._numFastBytes, 0x1000, 0x0112);
         this._dictionarySizePrev = this._dictionarySize;
         this._numFastBytesPrev = this._numFastBytes;
     }
-    /**
-     * Get literal encoder subcoder (utility method)
-     */
-    getSubCoderUtility(pos, prevByte) {
-        // Calculate position mask bits
-        const posBits = pos & this._literalEncoder.posMask;
-        const posShifted = posBits << this._literalEncoder.numPrevBits;
-        // Calculate previous byte bits
-        const prevByteShift = 0x08 - this._literalEncoder.numPrevBits;
-        const prevByteBits = (prevByte & 0xFF) >>> prevByteShift;
-        // Combine position and prevByte bits to get final index
-        const coderIndex = posShifted + prevByteBits;
-        return this._literalEncoder.coders[coderIndex];
+    writeHeaderProperties(output) {
+        this.properties[0] = ((this._posStateBits * 5 + this._numLiteralPosStateBits) * 9 + this._numLiteralContextBits) & 0xFF;
+        for (let byteIndex = 0; byteIndex < 4; byteIndex++) {
+            this.properties[1 + byteIndex] = (this._dictionarySize >> (0x08 * byteIndex)) & 0xFF;
+        }
+        for (let i = 0; i < 5; i++) {
+            output.writeByte(this.properties[i]);
+        }
+    }
+    initCompression(input, output, len, mode) {
+        if (len < -1n) {
+            throw new Error("invalid length " + len);
+        }
+        this.initialize();
+        this.configure(mode);
+        this.writeHeaderProperties(output);
+        for (let i = 0; i < 64; i += 8) {
+            output.writeByte((Number((len >> BigInt(i)) & 0xffn)) << 24 >> 24);
+        }
+        this._needReleaseMFStream = 0;
+        this._inStream = input;
+        this._finished = 0;
+        this.createMatchFinder();
+        this._rangeEncoder.stream = output;
+        this.init();
+        this.fillDistancesPrices();
+        this.fillAlignPrices();
+        this._lenEncoder.setTableSize(this._numFastBytes + 1 - 2);
+        this._lenEncoder.updateTables(1 << this._posStateBits);
+        this._repMatchLenEncoder.setTableSize(this._numFastBytes + 1 - 2);
+        this._repMatchLenEncoder.updateTables(1 << this._posStateBits);
+        this.nowPos64 = 0n;
+    }
+    compress(input, output, mode) {
+        this.initCompression(input, output, BigInt(input.count), mode);
+        do {
+            this.codeOneBlock();
+            if (this.finished[0]) {
+                this.releaseStreams();
+                break;
+            }
+        } while (true);
     }
 }