lzma1 0.1.2 → 0.2.0

package/lib/lzma.js

@@ -1,381 +1,57 @@
-// const CRC32_TABLE = (() => {
-// 	const crcTable = [];
-// 	for (let i = 0, r; i < 256; ++i, r = i) {
-// 		r = i;
-// 		for (let j = 0; j < 8; ++j) {
-// 			if ((r & 1) != 0) {
-// 				r >>>= 1;
-// 				r ^= -306674912;
-// 			} else {
-// 				r >>>= 1;
-// 			}
-// 		}
-// 		crcTable[i] = r;
-// 	}
-// 	return crcTable;
-// })();
-// dprint-ignore
-const CRC32_TABLE = [
-    0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F,
-    0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
-    0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2,
-    0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
-    0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
-    0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
-    0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,
-    0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
-    0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423,
-    0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
-    0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106,
-    0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
-    0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D,
-    0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
-    0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
-    0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
-    0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7,
-    0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
-    0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA,
-    0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
-    0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
-    0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
-    0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84,
-    0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
-    0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
-    0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
-    0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E,
-    0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
-    0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55,
-    0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
-    0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28,
-    0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
-    0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F,
-    0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
-    0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
-    0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
-    0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69,
-    0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
-    0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC,
-    0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
-    0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693,
-    0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
-    0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
-];
+import { DecoderChunker, EncoderChunker, } from "./chunker.js";
+import { Decoder } from "./decoder.js";
+import { Encoder, } from "./encoder.js";
+import { LzInWindow } from "./lz-in-window.js";
+import { computeHashSize, computeWindowReservSize, ensureCyclicBuffer, isDictionarySizeBelowThreshold, setCutValue, setMatchMaxLen, } from "./match-finder-config.js";
+import { _MAX_UINT32, add64, arraycopy, compare64, CRC32_TABLE, createBitTree, DICTIONARY_SIZE_THRESHOLD, fromInt64, G_FAST_POS, getBitPrice, getLenToPosState, INFINITY_PRICE, initArray, lowBits64, N1_LONG_LIT, P0_LONG_LIT, P1_LONG_LIT, PROB_PRICES, shr64, stateUpdateChar, sub64, } from "./utils.js";
+/**
+ * Compression modes
+ */
+export const MODES = {
+    1: { searchDepth: 0x10, filterStrength: 0x40, modeIndex: 0x00 },
+    2: { searchDepth: 0x14, filterStrength: 0x40, modeIndex: 0x00 },
+    3: { searchDepth: 0x13, filterStrength: 0x40, modeIndex: 0x01 },
+    4: { searchDepth: 0x14, filterStrength: 0x40, modeIndex: 0x01 },
+    5: { searchDepth: 0x15, filterStrength: 0x80, modeIndex: 0x01 },
+    6: { searchDepth: 0x16, filterStrength: 0x80, modeIndex: 0x01 },
+    7: { searchDepth: 0x17, filterStrength: 0x80, modeIndex: 0x01 },
+    8: { searchDepth: 0x18, filterStrength: 0xFF, modeIndex: 0x01 },
+    9: { searchDepth: 0x19, filterStrength: 0xFF, modeIndex: 0x01 },
+};
 export class LZMA {
-    #MAX_UINT32 = 4294967296;
-    #_MAX_UINT32 = 0xFFFFFFFF;
-    #MAX_INT32 = 2147483647;
-    #MIN_INT32 = -2147483648;
-    #MAX_COMPRESSION_SIZE = 9223372036854775807;
-    #kIfinityPrice = 268435455;
-    #dictionarySizeThreshold = 0x3FFFFFFF;
-    #N1_LONG_LIT;
-    #MIN_VALUE;
-    #P0_LONG_LIT = [0, 0];
-    #P1_LONG_LIT = [1, 0];
-    CompressionModes = {
-        1: { searchDepth: 0x10, filterStrength: 0x40, modeIndex: 0x00 },
-        2: { searchDepth: 0x14, filterStrength: 0x40, modeIndex: 0x00 },
-        3: { searchDepth: 0x13, filterStrength: 0x40, modeIndex: 0x01 },
-        4: { searchDepth: 0x14, filterStrength: 0x40, modeIndex: 0x01 },
-        5: { searchDepth: 0x15, filterStrength: 0x80, modeIndex: 0x01 },
-        6: { searchDepth: 0x16, filterStrength: 0x80, modeIndex: 0x01 },
-        7: { searchDepth: 0x17, filterStrength: 0x80, modeIndex: 0x01 },
-        8: { searchDepth: 0x18, filterStrength: 0xFF, modeIndex: 0x01 },
-        9: { searchDepth: 0x19, filterStrength: 0xFF, modeIndex: 0x01 },
-    };
     #encoder;
     #decoder;
-    #probPrices;
-    #gFastPos;
+    #lzInWindow = null;
     #compressor;
     #decompressor;
     constructor() {
-        this.#N1_LONG_LIT = [4294967295, -this.#MAX_UINT32]; // N1_longLit from old.ts
-        this.#MIN_VALUE = [0, -9223372036854775808]; // MIN_VALUE from old.ts
-        this.#encoder = this.#initEncoder();
-        this.#decoder = this.#initDecoder();
-        this.#probPrices = this.#createProbPrices();
-        this.#gFastPos = this.#createFastPos();
+        this.#encoder = new Encoder();
+        this.#decoder = new Decoder();
         this.#compressor = this.#initCompressor();
         this.#decompressor = this.#initDecompressor();
     }
-    #initEncoder() {
-        return {
-            _state: 0,
-            _previousByte: 0,
-            _distTableSize: 0,
-            _longestMatchWasFound: 0,
-            _optimumEndIndex: 0,
-            _optimumCurrentIndex: 0,
-            _additionalOffset: 0,
-            _dictionarySize: 0,
-            _matchFinder: null,
-            _dictionarySizePrev: 0,
-            _numFastBytes: 0,
-            _numLiteralContextBits: 0,
-            _numLiteralPosStateBits: 0,
-            _posStateBits: 0,
-            _posStateMask: 0,
-            _needReleaseMFStream: 0,
-            _inStream: { buf: [], pos: 0, count: 0 },
-            _finished: 0,
-            nowPos64: [0, 0],
-            _repDistances: this.#initArray(4),
-            _optimum: [],
-            _rangeEncoder: {
-                stream: {
-                    buf: [],
-                    count: 0,
-                },
-                rrange: 0,
-                cache: 0,
-                low: [0, 0],
-                cacheSize: 0,
-                position: [0, 0],
-            },
-            _isMatch: this.#initArray(0xC0),
-            _isRep: this.#initArray(0x0C),
-            _isRepG0: this.#initArray(0x0C),
-            _isRepG1: this.#initArray(0x0C),
-            _isRepG2: this.#initArray(0x0C),
-            _isRep0Long: this.#initArray(0xC0),
-            _posSlotEncoder: [],
-            _posEncoders: this.#initArray(0x72),
-            _posAlignEncoder: this.#createBitTreeEncoder(0x04),
-            _lenEncoder: this.#createLenPriceTableEncoder(),
-            _repMatchLenEncoder: this.#createLenPriceTableEncoder(),
-            _literalEncoder: {},
-            _matchDistances: [],
-            _posSlotPrices: [],
-            _distancesPrices: [],
-            _alignPrices: this.#initArray(0x10),
-            _matchPriceCount: 0,
-            _alignPriceCount: 0,
-            reps: this.#initArray(0x04),
-            repLens: this.#initArray(0x04),
-            processedInSize: [this.#P0_LONG_LIT],
-            processedOutSize: [this.#P0_LONG_LIT],
-            finished: [0x00],
-            properties: this.#initArray(0x05),
-            tempPrices: this.#initArray(0x80),
-            _longestMatchLength: 0x00,
-            _matchFinderType: 0x01,
-            _numDistancePairs: 0x00,
-            _numFastBytesPrev: -0x01,
-            backRes: 0x00,
-        };
-    }
-    #initDecoder() {
-        const decoder = {
-            posStateMask: 0,
-            dictSize: 0,
-            dictSizeCheck: 0,
-            state: 0,
-            rep0: 0,
-            rep1: 0,
-            rep2: 0,
-            rep3: 0,
-            outSize: [0, 0],
-            nowPos64: [0, 0],
-            prevByte: 0,
-            alive: 0,
-            encoder: null,
-            decoder: {},
-            inBytesProcessed: [0, 0],
-            outWin: {},
-            rangeDecoder: {},
-            matchDecoders: this.#initArray(0xC0),
-            repDecoders: this.#initArray(0x0C),
-            repG0Decoders: this.#initArray(0x0C),
-            repG1Decoders: this.#initArray(0x0C),
-            repG2Decoders: this.#initArray(0x0C),
-            rep0LongDecoders: this.#initArray(0xC0),
-            posSlotDecoders: this.#initArray(4),
-            posDecoders: this.#initArray(0x72),
-            posAlignDecoder: this.#createBitTreeDecoder(0x04),
-            lenDecoder: this.#createLenDecoder(),
-            repLenDecoder: this.#createLenDecoder(),
-            literalDecoder: {},
-        };
-        for (let i = 0; i < 4; ++i) {
-            decoder.posSlotDecoders[i] = this.#createBitTreeDecoder(0x06);
-        }
-        return decoder;
-    }
     #initCompressor() {
+        const encoderChunker = new EncoderChunker(this);
         return {
-            chunker: {
-                alive: 0x00,
-                encoder: null,
-                decoder: null,
-                inBytesProcessed: [0x00, 0x00],
-            },
+            chunker: encoderChunker,
             output: {
-                buf: this.#initArray(0x20),
-                count: 0x00,
+                buf: initArray(32),
+                count: 0,
+                write: () => { },
             },
         };
     }
     #initDecompressor() {
+        const decoderChunker = new DecoderChunker(this.#decoder);
         return {
-            chunker: {
-                alive: 0x00,
-                encoder: null,
-                decoder: this.#decoder,
-                inBytesProcessed: [0x00, 0x00],
-            },
+            chunker: decoderChunker,
             output: {
-                buf: this.#initArray(0x20),
-                count: 0x00,
+                buf: initArray(0x20),
+                count: 0,
+                write: () => { },
             },
         };
     }
-    #createProbPrices() {
-        const probPrices = [];
-        for (let i = 8; i >= 0; --i) {
-            let start = 1 << (9 - i - 1);
-            let end = 1 << (9 - i);
-            for (let j = start; j < end; ++j) {
-                probPrices[j] = (i << 6) + ((end - j) << 6 >>> (9 - i - 1));
-            }
-        }
-        return probPrices;
-    }
-    #createFastPos() {
-        const gFastPos = [0x00, 0x01];
-        let c = 2;
-        for (let slotFast = 2; slotFast < 22; ++slotFast) {
-            let k = 1 << ((slotFast >> 1) - 1);
-            for (let j = 0; j < k; ++j, ++c) {
-                gFastPos[c] = slotFast;
-            }
-        }
-        return gFastPos;
-    }
-    #initArray(len) {
-        const array = [];
-        // This is MUCH faster than "new Array(len)" in newer versions of v8
-        // (starting with Node.js 0.11.15, which uses v8 3.28.73).
-        array[len - 1] = undefined;
-        return array;
-    }
-    #add(a, b) {
-        return this.#create(a[0] + b[0], a[1] + b[1]);
-    }
-    #and(a, b) {
-        const highBits = ~~Math.max(Math.min(a[1] / this.#MAX_UINT32, this.#MAX_INT32), this.#MIN_INT32) & ~~Math.max(Math.min(b[1] / this.#MAX_UINT32, this.#MAX_INT32), this.#MIN_INT32);
-        const lowBits = this.#lowBits_0(a) & this.#lowBits_0(b);
-        let high = highBits * this.#MAX_UINT32;
-        let low = lowBits;
-        if (lowBits < 0) {
-            low += this.#MAX_UINT32;
-        }
-        return [low, high];
-    }
-    #compare(a, b) {
-        if (a[0] == b[0] && a[1] == b[1]) {
-            return 0;
-        }
-        const nega = a[1] < 0;
-        const negb = b[1] < 0;
-        if (nega && !negb) {
-            return -1;
-        }
-        if (!nega && negb) {
-            return 1;
-        }
-        if (this.#sub(a, b)[1] < 0) {
-            return -1;
-        }
-        return 1;
-    }
-    #create(valueLow, valueHigh) {
-        let diffHigh, diffLow;
-        valueHigh %= 1.8446744073709552E19;
-        valueLow %= 1.8446744073709552E19;
-        diffHigh = valueHigh % this.#MAX_UINT32;
-        diffLow = Math.floor(valueLow / this.#MAX_UINT32) * this.#MAX_UINT32;
-        valueHigh = valueHigh - diffHigh + diffLow;
-        valueLow = valueLow - diffLow + diffHigh;
-        while (valueLow < 0) {
-            valueLow += this.#MAX_UINT32;
-            valueHigh -= this.#MAX_UINT32;
-        }
-        while (valueLow > 4294967295) {
-            valueLow -= this.#MAX_UINT32;
-            valueHigh += this.#MAX_UINT32;
-        }
-        valueHigh = valueHigh % 1.8446744073709552E19;
-        while (valueHigh > 9223372032559808512) {
-            valueHigh -= 1.8446744073709552E19;
-        }
-        while (valueHigh < -9223372036854775808) {
-            valueHigh += 1.8446744073709552E19;
-        }
-        return [valueLow, valueHigh];
-    }
-    #eq(a, b) {
-        return a[0] == b[0] && a[1] == b[1];
-    }
-    #fromInt(value) {
-        if (value >= 0) {
-            return [value, 0];
-        }
-        else {
-            return [value + this.#MAX_UINT32, -this.#MAX_UINT32];
-        }
-    }
-    #lowBits_0(a) {
-        if (a[0] >= 0x80000000) {
-            return ~~Math.max(Math.min(a[0] - this.#MAX_UINT32, this.#MAX_INT32), this.#MIN_INT32);
-        }
-        return ~~Math.max(Math.min(a[0], this.#MAX_INT32), this.#MIN_INT32);
-    }
-    #pwrAsDouble(n) {
-        if (n <= 0x1E) {
-            return 1 << n;
-        }
-        return this.#pwrAsDouble(0x1E) * this.#pwrAsDouble(n - 0x1E);
-    }
-    #shl(a, n) {
-        let diff, newHigh, newLow, twoToN;
-        n &= 0x3F;
-        if (this.#eq(a, this.#MIN_VALUE)) {
-            if (!n) {
-                return a;
-            }
-            return this.#P0_LONG_LIT;
-        }
-        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 % this.#MAX_UINT32;
-        newHigh += diff;
-        newLow -= diff;
-        if (newHigh >= this.#MAX_COMPRESSION_SIZE) {
-            newHigh -= 1.8446744073709552E19;
-        }
-        return [newLow, newHigh];
-    }
-    #shr(a, n) {
-        n &= 0x3F;
-        let shiftFact = this.#pwrAsDouble(n);
-        return this.#create(Math.floor(a[0] / shiftFact), a[1] / shiftFact);
-    }
-    #shru(a, n) {
-        let sr = this.#shr(a, n);
-        n &= 0x3F;
-        if (a[1] < 0) {
-            sr = this.#add(sr, this.#shl([2, 0], 0x3F - n));
-        }
-        return sr;
-    }
-    #sub(a, b) {
-        return this.#create(a[0] - b[0], a[1] - b[1]);
-    }
     #read(inputStream) {
         if (inputStream.pos >= inputStream.count) {
             return -1;
@@ -392,28 +68,6 @@ export class LZMA {
         }
         return value & 0xFF;
     }
-    #read_0(off, len) {
-        const encoder = this.#compressor.chunker.encoder;
-        const stream = encoder._matchFinder._stream;
-        const buffer = encoder._matchFinder._bufferBase;
-        if (stream.pos >= stream.count) {
-            return -1;
-        }
-        let srcBuf;
-        if (stream.buf instanceof Uint8Array) {
-            srcBuf = Array.from(stream.buf);
-        }
-        else if (stream.buf instanceof ArrayBuffer) {
-            srcBuf = Array.from(new Uint8Array(stream.buf));
-        }
-        else {
-            srcBuf = stream.buf;
-        }
-        len = Math.min(len, stream.count - stream.pos);
-        this.#arraycopy(srcBuf, stream.pos, buffer, off, len);
-        stream.pos += len;
-        return len;
-    }
     #toByteArray(output) {
         const data = output.buf.slice(0, output.count);
         return data;
@@ -421,7 +75,6 @@ export class LZMA {
     #write(buffer, b) {
         if (!buffer)
             return;
-        // Ensure buffer has enough capacity
         if (buffer.count >= buffer.buf.length) {
             const newSize = Math.max(buffer.buf.length * 2, buffer.count + 1);
             const newBuf = new Array(newSize);
@@ -433,7 +86,6 @@ export class LZMA {
         buffer.buf[buffer.count++] = b << 24 >> 24;
     }
     #write_0(buffer, buf, off, len) {
-        // Ensure buffer has enough capacity
         const requiredSize = buffer.count + len;
         if (requiredSize > buffer.buf.length) {
             const newSize = Math.max(buffer.buf.length * 2, requiredSize);
@@ -443,7 +95,7 @@ export class LZMA {
             }
             buffer.buf = newBuf;
         }
-        this.#arraycopy(buf, off, buffer.buf, buffer.count, len);
+        arraycopy(buf, off, buffer.buf, buffer.count, len);
         buffer.count += len;
     }
     #getChars(inputString, srcBegin, srcEnd, dst, dstBegin) {
@@ -451,44 +103,12 @@ export class LZMA {
             dst[dstBegin++] = inputString.charCodeAt(srcIdx);
         }
     }
-    #arraycopy(src, srcOfs, dest, destOfs, len) {
-        // Bounds checking
-        if (srcOfs < 0
-            || destOfs < 0
-            || len < 0
-            || srcOfs + len > src.length
-            || destOfs + len > dest.length) {
-            return;
-        }
-        if (src === dest
-            && srcOfs < destOfs
-            && destOfs < srcOfs + len) {
-            // Overlapping regions - copy backwards
-            for (let i = len - 1; i >= 0; i--) {
-                dest[destOfs + i] = src[srcOfs + i];
-            }
-        }
-        else {
-            // Non-overlapping or forward copy
-            for (let i = 0; i < len; i++) {
-                dest[destOfs + i] = src[srcOfs + i];
-            }
-        }
-    }
     #configure(mode) {
-        this.#SetDictionarySize_0(0x1 << mode.searchDepth);
-        this.#encoder._numFastBytes = mode.filterStrength;
-        this.#SetMatchFinder(mode.modeIndex);
-        // lc is always 3
-        // lp is always 0
-        // pb is always 2
-        this.#encoder._numLiteralContextBits = 0x3;
-        this.#encoder._numLiteralPosStateBits = 0x0;
-        this.#encoder._posStateBits = 0x2;
-        this.#encoder._posStateMask = 0x3;
+        this.#encoder.initialize();
+        this.#encoder.configure(mode);
     }
     #initCompression(input, len, mode) {
-        if (this.#compare(len, this.#N1_LONG_LIT) < 0) {
+        if (compare64(len, N1_LONG_LIT) < 0) {
             throw new Error("invalid length " + len);
         }
         this.#compressor.length_0 = len;
@@ -496,43 +116,34 @@ export class LZMA {
         this.#configure(mode);
         this.writeHeaderProperties();
         for (let i = 0; i < 64; i += 8) {
-            this.#write(this.#compressor.output, this.#lowBits_0(this.#shr(len, i)) & 0xFF);
+            this.#write(this.#compressor.output, lowBits64(shr64(len, i)) & 0xFF);
         }
-        // Initialize encoder stream and properties
-        this.#encoder._needReleaseMFStream = 0x00;
+        this.#encoder._needReleaseMFStream = 0;
         this.#encoder._inStream = input;
-        this.#encoder._finished = 0x00;
-        // Create and configure encoder
+        this.#encoder._finished = 0;
         this.#Create_2();
         this.#encoder._rangeEncoder.stream = this.#compressor.output;
-        this.#Init_4();
-        // Initialize pricing tables
-        this.#FillDistancesPrices(this.#encoder);
-        this.#FillAlignPrices(this.#encoder);
-        // Configure length encoders
-        this.#encoder._lenEncoder.tableSize = this.#encoder._numFastBytes + 1 - 2;
-        this.#LZMA_LenPriceTableEncoder_UpdateTablesUpdateTables(this.#encoder._lenEncoder, 1 << this.#encoder._posStateBits);
-        this.#encoder._repMatchLenEncoder.tableSize = this.#encoder._numFastBytes + 1 - 2;
-        this.#LZMA_LenPriceTableEncoder_UpdateTablesUpdateTables(this.#encoder._repMatchLenEncoder, 1 << this.#encoder._posStateBits);
-        // Reset position counter
-        this.#encoder.nowPos64 = this.#P0_LONG_LIT;
-        // Create new chunker with configured encoder
-        this.#compressor.chunker = {
-            encoder: this.#encoder,
-            decoder: null,
-            alive: 1,
-        };
+        this.#encoder.init();
+        this.#encoder.fillDistancesPrices();
+        this.#encoder.fillAlignPrices();
+        this.#encoder._lenEncoder.setTableSize(this.#encoder._numFastBytes + 1 - 2);
+        this.#encoder._lenEncoder.updateTables(1 << this.#encoder._posStateBits);
+        this.#encoder._repMatchLenEncoder.setTableSize(this.#encoder._numFastBytes + 1 - 2);
+        this.#encoder._repMatchLenEncoder.updateTables(1 << this.#encoder._posStateBits);
+        this.#encoder.nowPos64 = P0_LONG_LIT;
+        this.#compressor.chunker.encoder = this.#encoder;
+        this.#compressor.chunker.alive = 1;
     }
     #byteArrayCompressor(data, mode) {
-        // Initialize output buffer with estimated size for compression
         const inputSize = data instanceof ArrayBuffer ? data.byteLength : data.length;
         const estimatedOutputSize = Math.max(32, Math.ceil(inputSize * 1.2));
         this.#compressor.output = {
-            buf: this.#initArray(estimatedOutputSize),
+            buf: initArray(estimatedOutputSize),
             count: 0,
+            write: () => { },
         };
         const inputBuffer = {
-            pos: 0x00,
+            pos: 0,
             buf: data instanceof ArrayBuffer
                 ? new Uint8Array(data)
                 : data,
@@ -540,7 +151,7 @@ export class LZMA {
                 ? new Uint8Array(data).length
                 : data.length,
         };
-        this.#initCompression(inputBuffer, this.#fromInt(data instanceof ArrayBuffer ? data.byteLength : data.length), mode);
+        this.#initCompression(inputBuffer, fromInt64(data instanceof ArrayBuffer ? data.byteLength : data.length), mode);
     }
     #initDecompression(input) {
         let hex_length = "", properties = [], r, tmp_length;
@@ -551,7 +162,10 @@ export class LZMA {
             }
             properties[i] = r << 24 >> 24;
         }
-        if (!this.#SetDecoderProperties(properties)) {
+        const isDecoderInitialized = !this.#decoder.setDecoderProperties(properties)
+            ? 1
+            : 0;
+        if (isDecoderInitialized) {
             throw new Error("corrupted input");
         }
         for (let i = 0; i < 64; i += 8) {
@@ -569,8 +183,7 @@ export class LZMA {
          * length is all f"s).
          */
         if (/^0+$|^f+$/i.test(hex_length)) {
-            // The length is unknown, so set to -1.
-            this.#compressor.length_0 = this.#N1_LONG_LIT;
+            this.#compressor.length_0 = N1_LONG_LIT;
         }
         else {
             /**
@@ -578,25 +191,24 @@ export class LZMA {
              * you can always set the length to -1 (N1_longLit) which means unknown.
              */
             tmp_length = parseInt(hex_length, 0x10);
-            // If the length is too long to handle, just set it to unknown.
-            if (tmp_length > this.#_MAX_UINT32) {
-                this.#compressor.length_0 = this.#N1_LONG_LIT;
+            if (tmp_length > _MAX_UINT32) {
+                this.#compressor.length_0 = N1_LONG_LIT;
             }
             else {
-                this.#compressor.length_0 = this.#fromInt(tmp_length);
+                this.#compressor.length_0 = fromInt64(tmp_length);
             }
         }
         this.#decompressor.chunker = this.#CodeInChunks(input, this.#compressor.length_0);
     }
     #byteArrayDecompressor(data) {
-        // Calculate initial buffer size for decompression
         const inputDataSize = data instanceof ArrayBuffer ? data.byteLength : data.length;
         const minBufferSize = 0x20; // 32 bytes minimum
         const estimatedOutputSize = inputDataSize * 2; // Estimate 2x expansion for decompression
         const initialBufferSize = Math.max(minBufferSize, estimatedOutputSize);
         this.#decompressor.output = {
-            buf: this.#initArray(initialBufferSize),
+            buf: initArray(initialBufferSize),
             count: 0,
+            write: () => { },
         };
         const inputBuffer = {
             buf: data,
@@ -611,52 +223,11 @@ export class LZMA {
         this.#encoder._matchFinder._keepSizeAfter = keepSizeAfter;
         blockSize = keepSizeBefore + keepSizeAfter + keepSizeReserv;
         if (this.#encoder._matchFinder._bufferBase == null || this.#encoder._matchFinder._blockSize != blockSize) {
-            this.#encoder._matchFinder._bufferBase = this.#initArray(blockSize);
+            this.#encoder._matchFinder._bufferBase = initArray(blockSize);
             this.#encoder._matchFinder._blockSize = blockSize;
         }
         this.#encoder._matchFinder._pointerToLastSafePosition = this.#encoder._matchFinder._blockSize - keepSizeAfter;
     }
-    #GetIndexByte(index) {
-        const byte = this.#compressor.chunker.encoder._matchFinder._bufferBase[this.#compressor.chunker.encoder._matchFinder._bufferOffset
-            + this.#compressor.chunker.encoder._matchFinder._pos
-            + index];
-        return byte;
-    }
-    #GetMatchLen(index, distance, limit) {
-        const encoder = this.#compressor.chunker.encoder;
-        if (encoder._matchFinder._streamEndWasReached) {
-            if (encoder._matchFinder._pos + index + limit
-                > encoder._matchFinder._streamPos) {
-                limit = encoder._matchFinder._streamPos
-                    - (encoder._matchFinder._pos + index);
-            }
-        }
-        ++distance;
-        let i, pby = encoder._matchFinder._bufferOffset
-            + encoder._matchFinder._pos
-            + index;
-        for (i = 0; i < limit
-            && encoder._matchFinder._bufferBase[pby + i]
-                == encoder._matchFinder._bufferBase[pby + i - distance]; ++i)
-            ;
-        return i;
-    }
-    #GetNumAvailableBytes() {
-        const encoder = this.#compressor.chunker.encoder;
-        return encoder._matchFinder._streamPos - encoder._matchFinder._pos;
-    }
-    #MoveBlock() {
-        const matchFinder = this.#compressor.chunker.encoder._matchFinder;
-        let offset = matchFinder._bufferOffset + matchFinder._pos - matchFinder._keepSizeBefore;
-        if (offset > 0) {
-            --offset;
-        }
-        let numBytes = matchFinder._bufferOffset + matchFinder._streamPos - offset;
-        for (let i = 0; i < numBytes; ++i) {
-            matchFinder._bufferBase[i] = matchFinder._bufferBase[offset + i];
-        }
-        matchFinder._bufferOffset -= offset;
-    }
     #MovePos_1() {
         const matchFinder = this.#compressor.chunker.encoder._matchFinder;
         let pointerToPostion;
@@ -664,77 +235,34 @@ export class LZMA {
         if (matchFinder._pos > matchFinder._posLimit) {
             pointerToPostion = matchFinder._bufferOffset + matchFinder._pos;
             if (pointerToPostion > matchFinder._pointerToLastSafePosition) {
-                this.#MoveBlock();
+                this.#lzInWindow.moveBlock();
             }
-            this.#ReadBlock();
+            this.#lzInWindow.readBlock();
         }
     }
-    #ReadBlock() {
-        const matchFinder = this.#compressor.chunker.encoder._matchFinder;
-        let bytesRead, pointerToPostion, size;
-        if (matchFinder._streamEndWasReached) {
-            return;
-        }
-        while (1) {
-            size = -matchFinder._bufferOffset + matchFinder._blockSize - matchFinder._streamPos;
-            if (!size) {
-                return;
-            }
-            bytesRead = this.#read_0(matchFinder._bufferOffset + matchFinder._streamPos, size);
-            if (bytesRead == -1) {
-                matchFinder._posLimit = matchFinder._streamPos;
-                pointerToPostion = matchFinder._bufferOffset + matchFinder._posLimit;
-                if (pointerToPostion > matchFinder._pointerToLastSafePosition) {
-                    matchFinder._posLimit = matchFinder._pointerToLastSafePosition - matchFinder._bufferOffset;
-                }
-                matchFinder._streamEndWasReached = 1;
-                return;
-            }
-            matchFinder._streamPos += bytesRead;
-            if (matchFinder._streamPos >= matchFinder._pos + matchFinder._keepSizeAfter) {
-                matchFinder._posLimit = matchFinder._streamPos - matchFinder._keepSizeAfter;
-            }
-        }
-    }
-    #ReduceOffsets(subValue) {
-        this.#compressor.chunker.encoder._matchFinder._bufferOffset += subValue;
-        this.#compressor.chunker.encoder._matchFinder._posLimit -= subValue;
-        this.#compressor.chunker.encoder._matchFinder._pos -= subValue;
-        this.#compressor.chunker.encoder._matchFinder._streamPos -= subValue;
-    }
     #Create_3(keepAddBufferBefore, keepAddBufferAfter) {
         const dictionarySize = this.#encoder._dictionarySize;
         const numFastBytes = this.#encoder._numFastBytes;
-        if (dictionarySize < this.#dictionarySizeThreshold) {
-            this.#encoder._matchFinder._cutValue = 0x10 + (numFastBytes >> 1);
-            const windowReservSize = ~~((dictionarySize
-                + keepAddBufferBefore
-                + numFastBytes
-                + keepAddBufferAfter) / 2) + 0x100;
+        if (isDictionarySizeBelowThreshold(dictionarySize)) {
+            this.#encoder._matchFinder._cutValue = setCutValue(numFastBytes);
+            const windowReservSize = computeWindowReservSize(dictionarySize, keepAddBufferBefore, numFastBytes, keepAddBufferAfter);
             this.#Create_4(dictionarySize + keepAddBufferBefore, numFastBytes + keepAddBufferAfter, windowReservSize);
-            this.#encoder._matchFinder._matchMaxLen = numFastBytes;
-            let cyclicBufferSize = dictionarySize + 1;
-            if (this.#encoder._matchFinder._cyclicBufferSize != cyclicBufferSize) {
-                this.#encoder._matchFinder._son = this.#initArray((this.#encoder._matchFinder._cyclicBufferSize = cyclicBufferSize) * 2);
-            }
-            let hs = 0x10000;
+            this.#encoder._matchFinder._matchMaxLen = setMatchMaxLen(numFastBytes);
+            ensureCyclicBuffer(this.#encoder._matchFinder, dictionarySize);
+            const { hashMask, hashSizeSum } = computeHashSize(dictionarySize, this.#encoder._matchFinder.HASH_ARRAY);
             if (this.#encoder._matchFinder.HASH_ARRAY) {
-                hs = dictionarySize - 1;
-                hs |= hs >> 1;
-                hs |= hs >> 2;
-                hs |= hs >> 4;
-                hs |= hs >> 0x08;
-                hs >>= 1;
-                hs |= 0xFFFF;
-                if (hs > 0x1000000) {
-                    hs >>= 1;
+                this.#encoder._matchFinder._hashMask = hashMask;
+                const finalHashSizeSum = hashSizeSum + this.#encoder._matchFinder.kFixHashSize;
+                if (finalHashSizeSum !== this.#encoder._matchFinder._hashSizeSum) {
+                    this.#encoder._matchFinder._hashSizeSum = finalHashSizeSum;
+                    this.#encoder._matchFinder._hash = initArray(finalHashSizeSum);
                 }
-                this.#encoder._matchFinder._hashMask = hs;
-                hs += 1;
-                hs += this.#encoder._matchFinder.kFixHashSize;
             }
-            if (hs != this.#encoder._matchFinder._hashSizeSum) {
-                this.#encoder._matchFinder._hash = this.#initArray(this.#encoder._matchFinder._hashSizeSum = hs);
+            else {
+                if (hashSizeSum !== this.#encoder._matchFinder._hashSizeSum) {
+                    this.#encoder._matchFinder._hashSizeSum = hashSizeSum;
+                    this.#encoder._matchFinder._hash = initArray(hashSizeSum);
+                }
             }
         }
     }
@@ -859,9 +387,9 @@ export class LZMA {
         this.#compressor.chunker.encoder._matchFinder._pos = 0;
         this.#compressor.chunker.encoder._matchFinder._streamPos = 0;
         this.#compressor.chunker.encoder._matchFinder._streamEndWasReached = 0;
-        this.#ReadBlock();
+        this.#lzInWindow.readBlock();
         this.#compressor.chunker.encoder._matchFinder._cyclicBufferPos = 0;
-        this.#ReduceOffsets(-1);
+        this.#lzInWindow.reduceOffsets(-1);
     }
     #MovePos_0() {
         let subValue;
@@ -870,11 +398,11 @@ export class LZMA {
             matchFinder._cyclicBufferPos = 0;
         }
         this.#MovePos_1();
-        if (matchFinder._pos == this.#dictionarySizeThreshold) {
+        if (matchFinder._pos == DICTIONARY_SIZE_THRESHOLD) {
             subValue = matchFinder._pos - matchFinder._cyclicBufferSize;
             this.#NormalizeLinks(matchFinder._cyclicBufferSize * 2, subValue);
             this.#NormalizeLinks(matchFinder._hashSizeSum, subValue);
-            this.#ReduceOffsets(subValue);
+            this.#lzInWindow.reduceOffsets(subValue);
         }
     }
     /**
@@ -982,122 +510,11 @@ export class LZMA {
             this.#MovePos_0();
         } while ((num -= 1) != 0);
     }
-    #CopyBlock(len) {
-        const outputWindow = this.#decompressor.chunker.decoder.outWin;
-        const distance = this.#decompressor.chunker.decoder.rep0;
-        let pos = outputWindow._pos - distance - 1;
-        if (pos < 0) {
-            pos += outputWindow._windowSize;
-        }
-        for (; len != 0; len -= 1) {
-            if (pos >= outputWindow._windowSize) {
-                pos = 0;
-            }
-            outputWindow._buffer[outputWindow._pos] = outputWindow._buffer[pos];
-            outputWindow._pos += 1;
-            pos += 1;
-            if (outputWindow._pos >= outputWindow._windowSize) {
-                this.#Flush_0();
-            }
-        }
-    }
-    #OutWindow_Create(windowSize) {
-        const outWin = this.#decoder.outWin;
-        if (outWin._buffer == null || outWin._windowSize != windowSize) {
-            outWin._buffer = this.#initArray(windowSize);
-        }
-        outWin._windowSize = windowSize;
-        outWin._pos = 0;
-        outWin._streamPos = 0;
-    }
-    #Flush_0() {
-        let size = this.#decoder.outWin._pos - this.#decoder.outWin._streamPos;
-        if (!size) {
-            return;
-        }
-        this.#write_0(this.#decoder.outWin._stream, this.#decoder.outWin._buffer, this.#decoder.outWin._streamPos, size);
-        if (this.#decoder.outWin._pos >= this.#decoder.outWin._windowSize) {
-            this.#decoder.outWin._pos = 0;
-        }
-        this.#decoder.outWin._streamPos = this.#decoder.outWin._pos;
-    }
-    #GetByte(distance) {
-        const outputWindow = this.#decompressor.chunker.decoder.outWin;
-        let pos = outputWindow._pos - distance - 1;
-        if (pos < 0) {
-            pos += outputWindow._windowSize;
-        }
-        return outputWindow._buffer[pos];
-    }
-    #PutByte(b) {
-        this.#decoder.outWin._buffer[this.#decoder.outWin._pos] = b;
-        this.#decoder.outWin._pos += 1;
-        if (this.#decoder.outWin._pos >= this.#decoder.outWin._windowSize) {
-            this.#Flush_0();
-        }
-    }
-    #OutWindow_ReleaseStream() {
-        this.#Flush_0();
-        this.#decoder.outWin._stream = null;
-    }
-    GetLenToPosState(len) {
-        len -= 2;
-        if (len < 4) {
-            return len;
-        }
-        return 3;
-    }
-    StateUpdateChar(index) {
-        if (index < 4) {
-            return 0;
-        }
-        if (index < 10) {
-            return index - 3;
-        }
-        return index - 6;
-    }
-    #processChunkDecode() {
-        if (!this.#decompressor.chunker.alive) {
-            throw new Error("Bad state");
-        }
-        if (this.#decompressor.chunker.encoder) {
-            throw new Error("No encoding");
-        }
-        const result = this.#CodeOneChunk();
-        if (result === -1) {
-            throw new Error("Corrupted input");
-        }
-        const decoder = this.#decompressor.chunker.decoder;
-        this.#decompressor.chunker.inBytesProcessed = decoder.nowPos64;
-        const isOutputComplete = (this.#compare(decoder.outSize, this.#P0_LONG_LIT) >= 0)
-            && (this.#compare(decoder.nowPos64, decoder.outSize) >= 0);
-        if (result || isOutputComplete) {
-            this.#Flush_0();
-            this.#OutWindow_ReleaseStream();
-            decoder.rangeDecoder.stream = null;
-            this.#decompressor.chunker.alive = 0;
-        }
-        return this.#decompressor.chunker.alive;
-    }
-    #processChunkEncode() {
-        if (!this.#compressor.chunker.alive) {
-            throw new Error("bad state");
-        }
-        if (!this.#compressor.chunker.encoder) {
-            throw new Error("No decoding");
-        }
-        this.#CodeOneBlock();
-        this.#compressor.chunker.inBytesProcessed = this.#compressor.chunker.encoder.processedInSize[0];
-        if (this.#compressor.chunker.encoder.finished[0]) {
-            this.#ReleaseStreams();
-            this.#compressor.chunker.alive = 0;
-        }
-        return this.#compressor.chunker.alive;
-    }
     #CodeInChunks(inStream, outSize) {
         this.#decoder.rangeDecoder.stream = inStream;
-        this.#OutWindow_ReleaseStream();
-        this.#decoder.outWin._stream = this.#decompressor.output;
+        this.#decoder.flush();
+        this.#decoder.outWindow.stream = null;
+        this.#decoder.outWindow.stream = this.#decompressor.output;
         this.#Init_1();
         this.#decoder.state = 0;
         this.#decoder.rep0 = 0;
@@ -1105,259 +522,15 @@ export class LZMA {
         this.#decoder.rep2 = 0;
         this.#decoder.rep3 = 0;
         this.#decoder.outSize = outSize;
-        this.#decoder.nowPos64 = this.#P0_LONG_LIT;
+        this.#decoder.nowPos64 = P0_LONG_LIT;
         this.#decoder.prevByte = 0;
-        this.#decoder.decoder = this.#decoder;
-        this.#decoder.encoder = null;
-        this.#decoder.alive = 1;
-        return this.#decoder;
-    }
-    #CodeOneChunk() {
-        const decoder = this.#decompressor.chunker.decoder;
-        let decoder2, distance, len, numDirectBits, positionSlot;
-        let posState = this.#lowBits_0(decoder.nowPos64)
-            & decoder.posStateMask;
-        if (!this.#decodeBit(decoder.matchDecoders, (decoder.state << 4) + posState)) {
-            decoder2 = this.#GetDecoder(this.#lowBits_0(decoder.nowPos64), decoder.prevByte);
-            if (decoder.state < 7) {
-                decoder.prevByte = this.#DecodeNormal(decoder2);
-            }
-            else {
-                decoder.prevByte = this.#DecodeWithMatchByte(decoder2, this.#GetByte(decoder.rep0));
-            }
-            this.#PutByte(decoder.prevByte);
-            decoder.state = this.StateUpdateChar(decoder.state);
-            decoder.nowPos64 = this.#add(decoder.nowPos64, this.#P1_LONG_LIT);
-        }
-        else {
-            if (this.#decodeBit(decoder.repDecoders, decoder.state)) {
-                len = 0;
-                if (!this.#decodeBit(decoder.repG0Decoders, decoder.state)) {
-                    if (!this.#decodeBit(decoder.rep0LongDecoders, (decoder.state << 4) + posState)) {
-                        decoder.state = decoder.state < 7
-                            ? 9
-                            : 11;
-                        len = 1;
-                    }
-                }
-                else {
-                    if (!this.#decodeBit(decoder.repG1Decoders, decoder.state)) {
-                        distance = decoder.rep1;
-                    }
-                    else {
-                        if (!this.#decodeBit(decoder.repG2Decoders, decoder.state)) {
-                            distance = decoder.rep2;
-                        }
-                        else {
-                            distance = decoder.rep3;
-                            decoder.rep3 = decoder.rep2;
-                        }
-                        decoder.rep2 = decoder.rep1;
-                    }
-                    decoder.rep1 = decoder.rep0;
-                    decoder.rep0 = distance;
-                }
-                if (!len) {
-                    len = this.#Decode(decoder.repLenDecoder, posState) + 2;
-                    decoder.state = decoder.state < 7 ? 0x08 : 11;
-                }
-            }
-            else {
-                decoder.rep3 = decoder.rep2;
-                decoder.rep2 = decoder.rep1;
-                decoder.rep1 = decoder.rep0;
-                len = 2 + this.#Decode(decoder.lenDecoder, posState);
-                decoder.state = decoder.state < 7 ? 7 : 10;
-                positionSlot = this.#RangeCoder_BitTreeDecoder_Decoder(decoder.posSlotDecoders[this.GetLenToPosState(len)]);
-                if (positionSlot >= 4) {
-                    numDirectBits = (positionSlot >> 1) - 1;
-                    decoder.rep0 = (2 | (positionSlot & 1)) << numDirectBits;
-                    if (positionSlot < 14) {
-                        decoder.rep0 += this.reverseDecode(decoder.posDecoders, decoder.rep0 - positionSlot - 1, numDirectBits);
-                    }
-                    else {
-                        decoder.rep0 += this.#DecodeDirectBits(numDirectBits - 4) << 4;
-                        decoder.rep0 += this.#ReverseDecode();
-                        if (decoder.rep0 < 0) {
-                            if (decoder.rep0 == -1) {
-                                return 1;
-                            }
-                            return -1;
-                        }
-                    }
-                }
-                else {
-                    decoder.rep0 = positionSlot;
-                }
-            }
-            if (this.#compare(this.#fromInt(decoder.rep0), decoder.nowPos64) >= 0
-                || decoder.rep0 >= decoder.dictSizeCheck) {
-                return -1;
-            }
-            this.#CopyBlock(len);
-            decoder.nowPos64 = this.#add(decoder.nowPos64, this.#fromInt(len));
-            decoder.prevByte = this.#GetByte(0);
-        }
-        return 0;
+        // Create and return decoder chunker
+        const decoderChunker = new DecoderChunker(this.#decoder);
+        decoderChunker.alive = 1;
+        return decoderChunker;
     }
     #Init_1() {
-        this.#decoder.outWin._streamPos = 0;
-        this.#decoder.outWin._pos = 0;
-        this.InitBitModels(this.#decoder.matchDecoders);
-        this.InitBitModels(this.#decoder.rep0LongDecoders);
-        this.InitBitModels(this.#decoder.repDecoders);
-        this.InitBitModels(this.#decoder.repG0Decoders);
-        this.InitBitModels(this.#decoder.repG1Decoders);
-        this.InitBitModels(this.#decoder.repG2Decoders);
-        this.InitBitModels(this.#decoder.posDecoders);
-        this.#Init_0(this.#decoder.literalDecoder);
-        for (let i = 0; i < 4; ++i) {
-            this.InitBitModels(this.#decoder.posSlotDecoders[i].models);
-        }
-        this.#Init(this.#decoder.lenDecoder);
-        this.#Init(this.#decoder.repLenDecoder);
-        this.InitBitModels(this.#decoder.posAlignDecoder.models);
-        this.#Init_8();
-    }
-    #SetDecoderProperties(properties) {
-        let dictionarySize, i, lc, lp, pb, remainder, val;
-        if (properties.length < 5) {
-            return 0;
-        }
-        val = properties[0] & 0xFF;
-        lc = val % 9;
-        remainder = ~~(val / 9);
-        lp = remainder % 5;
-        pb = ~~(remainder / 5);
-        dictionarySize = 0;
-        for (i = 0; i < 4; ++i) {
-            dictionarySize += (properties[1 + i] & 0xFF) << (i * 0x08);
-        }
-        // NOTE: If the input is bad, it might call for an insanely large dictionary size, which would crash the script.
-        if (dictionarySize > 0x5F5E0FF || !this.#SetLcLpPb(lc, lp, pb)) {
-            return 0;
-        }
-        return this.#SetDictionarySize(dictionarySize);
-    }
-    #SetDictionarySize(dictionarySize) {
-        if (dictionarySize < 0) {
-            return 0;
-        }
-        if (this.#decoder.dictSize != dictionarySize) {
-            this.#decoder.dictSize = dictionarySize;
-            this.#decoder.dictSizeCheck = Math.max(this.#decoder.dictSize, 1);
-            this.#OutWindow_Create(Math.max(this.#decoder.dictSizeCheck, 0x1000));
-        }
-        return 1;
-    }
-    #SetLcLpPb(lc, lp, pb) {
-        if (lc > 0x08 || lp > 4 || pb > 4) {
-            return 0;
-        }
-        this.#Create_0(lp, lc);
-        let numPosStates = 0x01 << pb;
-        this.#Create(this.#decoder.lenDecoder, numPosStates);
-        this.#Create(this.#decoder.repLenDecoder, numPosStates);
-        this.#decoder.posStateMask = numPosStates - 1;
-        return 1;
-    }
-    #Create(decoder, numPosStates) {
-        for (; decoder.numPosStates < numPosStates; decoder.numPosStates += 1) {
-            decoder.lowCoder[decoder.numPosStates] = this.#createBitTreeDecoder(3);
-            decoder.midCoder[decoder.numPosStates] = this.#createBitTreeDecoder(3);
-        }
-    }
-    #Decode(decoder, posState) {
-        if (!this.#decodeBit(decoder.choice, 0)) {
-            return this.#RangeCoder_BitTreeDecoder_Decoder(decoder.lowCoder[posState]);
-        }
-        let symbol = 0x08;
-        if (!this.#decodeBit(decoder.choice, 1)) {
-            symbol += this.#RangeCoder_BitTreeDecoder_Decoder(decoder.midCoder[posState]);
-        }
-        else {
-            symbol += 0x08 + this.#RangeCoder_BitTreeDecoder_Decoder(decoder.highCoder);
-        }
-        return symbol;
-    }
-    #createLenDecoder() {
-        const decoder = {
-            choice: this.#initArray(2),
-            lowCoder: [],
-            midCoder: [],
-            highCoder: this.#createBitTreeDecoder(0x08),
-            numPosStates: 0x00,
-        };
-        return decoder;
-    }
-    #Init(decoder) {
-        this.InitBitModels(decoder.choice);
-        for (let posState = 0; posState < decoder.numPosStates; ++posState) {
-            this.InitBitModels(decoder.lowCoder[posState].models);
-            this.InitBitModels(decoder.midCoder[posState].models);
-        }
-        this.InitBitModels(decoder.highCoder.models);
-    }
-    #Create_0(numPosBits, numPrevBits) {
-        let i, numStates;
-        if (this.#decoder.literalDecoder.coders !== null
-            && this.#decoder.literalDecoder.numPrevBits == numPrevBits
-            && this.#decoder.literalDecoder.numPosBits == numPosBits) {
-            return;
-        }
-        this.#decoder.literalDecoder.numPosBits = numPosBits;
-        this.#decoder.literalDecoder.posMask = (1 << numPosBits) - 1;
-        this.#decoder.literalDecoder.numPrevBits = numPrevBits;
-        numStates = 1 << (this.#decoder.literalDecoder.numPrevBits + this.#decoder.literalDecoder.numPosBits);
-        this.#decoder.literalDecoder.coders = [];
-        for (i = 0; i < numStates; ++i) {
-            this.#decoder.literalDecoder.coders[i] = this.#createLiteralDecoderEncoder2();
-        }
-    }
-    #GetDecoder(pos, prevByte) {
-        const literalDecoder = this.#decompressor.chunker.decoder.literalDecoder;
-        // Calculate index based on position and previous byte
-        const positionMask = pos & literalDecoder.posMask;
-        const prevBitsMask = (prevByte & 0xFF) >>> (8 - literalDecoder.numPrevBits);
-        const index = (positionMask << literalDecoder.numPrevBits) + prevBitsMask;
-        // Return decoder at calculated index
-        return literalDecoder.coders[index];
-    }
-    #Init_0(decoder) {
-        let i, numStates;
-        numStates = 1 << (decoder.numPrevBits + decoder.numPosBits);
-        for (i = 0; i < numStates; ++i) {
-            this.InitBitModels(decoder.coders[i].decoders);
-        }
-    }
-    #DecodeNormal(decoder) {
-        let symbol = 1;
-        do {
-            symbol = symbol << 1 | this.#decodeBit(decoder.decoders, symbol);
-        } while (symbol < 0x100);
-        return symbol << 24 >> 24;
-    }
-    #DecodeWithMatchByte(encoder, matchByte) {
-        let bit, matchBit, symbol = 1;
-        do {
-            matchBit = (matchByte >> 7) & 1;
-            matchByte <<= 1;
-            bit = this.#decodeBit(encoder.decoders, ((1 + matchBit) << 8) + symbol);
-            symbol = symbol << 1 | bit;
-            if (matchBit != bit) {
-                while (symbol < 0x100) {
-                    symbol = symbol << 1 | this.#decodeBit(encoder.decoders, symbol);
-                }
-                break;
-            }
-        } while (symbol < 0x100);
-        return symbol << 24 >> 24;
-    }
-    #createLiteralDecoderEncoder2() {
-        const literalDecoder = {
-            decoders: this.#initArray(0x300),
-        };
-        return literalDecoder;
+        this.#decoder.init();
     }
     #Backward(cur) {
         const encoder = this.#compressor.chunker.encoder;
@@ -1387,17 +560,10 @@ export class LZMA {
         encoder._optimumCurrentIndex = encoder._optimum[0].posPrev;
         return encoder._optimumCurrentIndex;
     }
-    #BaseInit() {
-        this.#encoder._state = 0;
-        this.#encoder._previousByte = 0;
-        for (let i = 0; i < 4; ++i) {
-            this.#encoder._repDistances[i] = 0;
-        }
-    }
     #CodeOneBlock() {
         let baseVal, complexState, curByte, distance, footerBits, len, lenToPosState, matchByte, pos, posReduced, posSlot, posState, progressPosValuePrev, subCoder;
-        this.#compressor.chunker.encoder.processedInSize[0] = this.#P0_LONG_LIT;
-        this.#compressor.chunker.encoder.processedOutSize[0] = this.#P0_LONG_LIT;
+        this.#compressor.chunker.encoder.processedInSize[0] = P0_LONG_LIT;
+        this.#compressor.chunker.encoder.processedOutSize[0] = P0_LONG_LIT;
         this.#compressor.chunker.encoder.finished[0] = 1;
         progressPosValuePrev = this.#compressor.chunker.encoder.nowPos64;
         if (this.#compressor.chunker.encoder._inStream) {
@@ -1410,74 +576,74 @@ export class LZMA {
             return;
         }
         this.#compressor.chunker.encoder._finished = 1;
-        if (this.#eq(this.#compressor.chunker.encoder.nowPos64, this.#P0_LONG_LIT)) {
-            if (!this.#GetNumAvailableBytes()) {
-                this.#Flush(this.#lowBits_0(this.#compressor.chunker.encoder.nowPos64));
+        if (compare64(this.#compressor.chunker.encoder.nowPos64, P0_LONG_LIT) === 0) {
+            if (!this.#lzInWindow.getNumAvailableBytes()) {
+                this.#Flush(lowBits64(this.#compressor.chunker.encoder.nowPos64));
                 return;
             }
             this.#ReadMatchDistances();
-            posState = this.#lowBits_0(this.#compressor.chunker.encoder.nowPos64) & this.#compressor.chunker.encoder._posStateMask;
-            this.#Encode_3(this.#compressor.chunker.encoder._isMatch, (this.#compressor.chunker.encoder._state << 4) + posState, 0);
-            this.#compressor.chunker.encoder._state = this.StateUpdateChar(this.#compressor.chunker.encoder._state);
-            curByte = this.#GetIndexByte(-this.#compressor.chunker.encoder._additionalOffset);
-            this.#Encode_1(this.#LZMA_Encoder_GetSubCoder(this.#lowBits_0(this.#compressor.chunker.encoder.nowPos64), this.#compressor.chunker.encoder._previousByte), curByte);
+            posState = lowBits64(this.#compressor.chunker.encoder.nowPos64) & this.#compressor.chunker.encoder._posStateMask;
+            this.#compressor.chunker.encoder.encodeBit(this.#compressor.chunker.encoder._isMatch, (this.#compressor.chunker.encoder._state << 4) + posState, 0);
+            this.#compressor.chunker.encoder._state = stateUpdateChar(this.#compressor.chunker.encoder._state);
+            curByte = this.#lzInWindow.getIndexByte(-this.#compressor.chunker.encoder._additionalOffset);
+            this.#compressor.chunker.encoder.encodeLiteral(this.#LZMA_Encoder_GetSubCoder(lowBits64(this.#compressor.chunker.encoder.nowPos64), this.#compressor.chunker.encoder._previousByte), curByte);
             this.#compressor.chunker.encoder._previousByte = curByte;
             this.#compressor.chunker.encoder._additionalOffset -= 1;
-            this.#compressor.chunker.encoder.nowPos64 = this.#add(this.#compressor.chunker.encoder.nowPos64, this.#P1_LONG_LIT);
+            this.#compressor.chunker.encoder.nowPos64 = add64(this.#compressor.chunker.encoder.nowPos64, P1_LONG_LIT);
         }
-        if (!this.#GetNumAvailableBytes()) {
-            this.#Flush(this.#lowBits_0(this.#compressor.chunker.encoder.nowPos64));
+        if (!this.#lzInWindow.getNumAvailableBytes()) {
+            this.#Flush(lowBits64(this.#compressor.chunker.encoder.nowPos64));
             return;
         }
         while (1) {
-            len = this.#GetOptimum(this.#lowBits_0(this.#compressor.chunker.encoder.nowPos64));
+            len = this.#GetOptimum(lowBits64(this.#compressor.chunker.encoder.nowPos64));
             pos = this.#compressor.chunker.encoder.backRes;
-            posState = this.#lowBits_0(this.#compressor.chunker.encoder.nowPos64) & this.#compressor.chunker.encoder._posStateMask;
+            posState = lowBits64(this.#compressor.chunker.encoder.nowPos64) & this.#compressor.chunker.encoder._posStateMask;
             complexState = (this.#compressor.chunker.encoder._state << 4) + posState;
             if (len == 1 && pos == -1) {
-                this.#Encode_3(this.#compressor.chunker.encoder._isMatch, complexState, 0);
-                curByte = this.#GetIndexByte(-this.#compressor.chunker.encoder._additionalOffset);
-                subCoder = this.#LZMA_Encoder_GetSubCoder(this.#lowBits_0(this.#compressor.chunker.encoder.nowPos64), this.#compressor.chunker.encoder._previousByte);
+                this.#compressor.chunker.encoder.encodeBit(this.#compressor.chunker.encoder._isMatch, complexState, 0);
+                curByte = this.#lzInWindow.getIndexByte(-this.#compressor.chunker.encoder._additionalOffset);
+                subCoder = this.#LZMA_Encoder_GetSubCoder(lowBits64(this.#compressor.chunker.encoder.nowPos64), this.#compressor.chunker.encoder._previousByte);
                 if (this.#compressor.chunker.encoder._state < 7) {
-                    this.#Encode_1(subCoder, curByte);
+                    this.#compressor.chunker.encoder.encodeLiteral(subCoder, curByte);
                 }
                 else {
-                    matchByte = this.#GetIndexByte(-this.#compressor.chunker.encoder._repDistances[0]
+                    matchByte = this.#lzInWindow.getIndexByte(-this.#compressor.chunker.encoder._repDistances[0]
                         - 1
                         - this.#compressor.chunker.encoder._additionalOffset);
-                    this.#EncodeMatched(subCoder, matchByte, curByte);
+                    this.#compressor.chunker.encoder.encodeMatched(subCoder, matchByte, curByte);
                 }
                 this.#compressor.chunker.encoder._previousByte = curByte;
-                this.#compressor.chunker.encoder._state = this.StateUpdateChar(this.#compressor.chunker.encoder._state);
+                this.#compressor.chunker.encoder._state = stateUpdateChar(this.#compressor.chunker.encoder._state);
             }
             else {
-                this.#Encode_3(this.#compressor.chunker.encoder._isMatch, complexState, 1);
+                this.#compressor.chunker.encoder.encodeBit(this.#compressor.chunker.encoder._isMatch, complexState, 1);
                 if (pos < 4) {
-                    this.#Encode_3(this.#compressor.chunker.encoder._isRep, this.#compressor.chunker.encoder._state, 1);
+                    this.#compressor.chunker.encoder.encodeBit(this.#compressor.chunker.encoder._isRep, this.#compressor.chunker.encoder._state, 1);
                     if (!pos) {
-                        this.#Encode_3(this.#compressor.chunker.encoder._isRepG0, this.#compressor.chunker.encoder._state, 0);
+                        this.#compressor.chunker.encoder.encodeBit(this.#compressor.chunker.encoder._isRepG0, this.#compressor.chunker.encoder._state, 0);
                         if (len == 1) {
-                            this.#Encode_3(this.#compressor.chunker.encoder._isRep0Long, complexState, 0);
+                            this.#compressor.chunker.encoder.encodeBit(this.#compressor.chunker.encoder._isRep0Long, complexState, 0);
                         }
                         else {
-                            this.#Encode_3(this.#compressor.chunker.encoder._isRep0Long, complexState, 1);
+                            this.#compressor.chunker.encoder.encodeBit(this.#compressor.chunker.encoder._isRep0Long, complexState, 1);
                         }
                     }
                     else {
-                        this.#Encode_3(this.#compressor.chunker.encoder._isRepG0, this.#compressor.chunker.encoder._state, 1);
+                        this.#compressor.chunker.encoder.encodeBit(this.#compressor.chunker.encoder._isRepG0, this.#compressor.chunker.encoder._state, 1);
                         if (pos == 1) {
-                            this.#Encode_3(this.#compressor.chunker.encoder._isRepG1, this.#compressor.chunker.encoder._state, 0);
+                            this.#compressor.chunker.encoder.encodeBit(this.#compressor.chunker.encoder._isRepG1, this.#compressor.chunker.encoder._state, 0);
                         }
                         else {
-                            this.#Encode_3(this.#compressor.chunker.encoder._isRepG1, this.#compressor.chunker.encoder._state, 1);
-                            this.#Encode_3(this.#compressor.chunker.encoder._isRepG2, this.#compressor.chunker.encoder._state, pos - 2);
+                            this.#compressor.chunker.encoder.encodeBit(this.#compressor.chunker.encoder._isRepG1, this.#compressor.chunker.encoder._state, 1);
+                            this.#compressor.chunker.encoder.encodeBit(this.#compressor.chunker.encoder._isRepG2, this.#compressor.chunker.encoder._state, pos - 2);
                         }
                     }
                     if (len == 1) {
                         this.#compressor.chunker.encoder._state = this.#compressor.chunker.encoder._state < 7 ? 9 : 11;
                     }
                     else {
-                        this.#Encode_0(this.#compressor.chunker.encoder._repMatchLenEncoder, len - 2, posState);
+                        this.#compressor.chunker.encoder.encodeLength(this.#compressor.chunker.encoder._repMatchLenEncoder, len - 2, posState);
                         this.#compressor.chunker.encoder._state = this.#compressor.chunker.encoder._state < 7
                             ? 0x08
                             : 11;
@@ -1492,23 +658,23 @@ export class LZMA {
                     }
                 }
                 else {
-                    this.#Encode_3(this.#compressor.chunker.encoder._isRep, this.#compressor.chunker.encoder._state, 0x00);
+                    this.#compressor.chunker.encoder.encodeBit(this.#compressor.chunker.encoder._isRep, this.#compressor.chunker.encoder._state, 0);
                     this.#compressor.chunker.encoder._state = this.#compressor.chunker.encoder._state < 7 ? 7 : 10;
-                    this.#Encode_0(this.#compressor.chunker.encoder._lenEncoder, len - 0x02, posState);
+                    this.#compressor.chunker.encoder.encodeLength(this.#compressor.chunker.encoder._lenEncoder, len - 0x02, posState);
                     pos -= 0x04;
-                    posSlot = this.GetPosSlot(pos);
-                    lenToPosState = this.GetLenToPosState(len);
-                    this.#Encode_2(this.#compressor.chunker.encoder._posSlotEncoder[lenToPosState], posSlot);
+                    posSlot = this.#compressor.chunker.encoder.getPosSlot(pos);
+                    lenToPosState = getLenToPosState(len);
+                    this.#compressor.chunker.encoder.encodeBitTree(this.#compressor.chunker.encoder._posSlotEncoder[lenToPosState], posSlot);
                     if (posSlot >= 0x04) {
                         footerBits = (posSlot >> 0x01) - 0x01;
                         baseVal = (0x02 | (posSlot & 0x01)) << footerBits;
                         posReduced = pos - baseVal;
                         if (posSlot < 0x0E) {
-                            this.ReverseEncode(baseVal - posSlot - 0x01, footerBits, posReduced);
+                            this.#compressor.chunker.encoder.reverseEncodeRange(baseVal - posSlot - 0x01, footerBits, posReduced);
                         }
                         else {
-                            this.#EncodeDirectBits(posReduced >> 0x04, footerBits - 4);
-                            this.#ReverseEncode(posReduced & 0x0F);
+                            this.#compressor.chunker.encoder.encodeDirectBits(posReduced >> 0x04, footerBits - 4);
+                            this.#compressor.chunker.encoder.reverseEncode(posReduced & 0x0F);
                             this.#compressor.chunker.encoder._alignPriceCount += 1;
                         }
                     }
@@ -1520,24 +686,24 @@ export class LZMA {
                     encoder2._repDistances[0] = distance;
                     encoder2._matchPriceCount += 0x01;
                 }
-                this.#compressor.chunker.encoder._previousByte = this.#GetIndexByte(len - 1 - this.#compressor.chunker.encoder._additionalOffset);
+                this.#compressor.chunker.encoder._previousByte = this.#lzInWindow.getIndexByte(len - 1 - this.#compressor.chunker.encoder._additionalOffset);
             }
             this.#compressor.chunker.encoder._additionalOffset -= len;
-            this.#compressor.chunker.encoder.nowPos64 = this.#add(this.#compressor.chunker.encoder.nowPos64, this.#fromInt(len));
+            this.#compressor.chunker.encoder.nowPos64 = add64(this.#compressor.chunker.encoder.nowPos64, fromInt64(len));
             if (!this.#compressor.chunker.encoder._additionalOffset) {
-                if (this.#compressor.chunker.encoder._matchPriceCount >= 128) {
-                    this.#FillDistancesPrices(this.#compressor.chunker.encoder);
+                if (this.#compressor.chunker.encoder._matchPriceCount >= 0x80) {
+                    this.#compressor.chunker.encoder.fillDistancesPrices();
                 }
-                if (this.#compressor.chunker.encoder._alignPriceCount >= 16) {
+                if (this.#compressor.chunker.encoder._alignPriceCount >= 0x10) {
                     this.#FillAlignPrices(this.#compressor.chunker.encoder);
                 }
                 this.#compressor.chunker.encoder.processedInSize[0] = this.#compressor.chunker.encoder.nowPos64;
                 this.#compressor.chunker.encoder.processedOutSize[0] = this.#GetProcessedSizeAdd();
-                if (!this.#GetNumAvailableBytes()) {
-                    this.#Flush(this.#lowBits_0(this.#compressor.chunker.encoder.nowPos64));
+                if (!this.#lzInWindow.getNumAvailableBytes()) {
+                    this.#Flush(lowBits64(this.#compressor.chunker.encoder.nowPos64));
                     return;
                 }
-                if (this.#compare(this.#sub(this.#compressor.chunker.encoder.nowPos64, progressPosValuePrev), [0x1000, 0]) >= 0) {
+                if (compare64(sub64(this.#compressor.chunker.encoder.nowPos64, progressPosValuePrev), [0x1000, 0]) >= 0) {
                     this.#compressor.chunker.encoder._finished = 0;
                     this.#compressor.chunker.encoder.finished[0] = 0;
                     return;
@@ -1555,8 +721,9 @@ export class LZMA {
             }
             this.#SetType(binTree, numHashBytes);
             this.#encoder._matchFinder = binTree;
+            this.#lzInWindow = new LzInWindow(binTree);
         }
-        this.#LZMA_Encoder_LiteralEncoder_Create();
+        this.#encoder.createLiteralEncoder();
         if (this.#encoder._dictionarySize == this.#encoder._dictionarySizePrev
             && this.#encoder._numFastBytesPrev == this.#encoder._numFastBytes) {
             return;
@@ -1570,7 +737,7 @@ export class LZMA {
             this.#encoder._optimum[i] = {};
         }
         for (let i = 0; i < 4; ++i) {
-            this.#encoder._posSlotEncoder[i] = this.#createBitTreeEncoder(6);
+            this.#encoder._posSlotEncoder[i] = createBitTree(6);
         }
     }
     #FillAlignPrices(encoder) {
@@ -1579,38 +746,11 @@ export class LZMA {
         }
         encoder._alignPriceCount = 0;
     }
-    #FillDistancesPrices(encoder) {
-        let baseVal, bitTreeEncoder, footerBits, posSlot, st, st2;
-        for (let i = 4; i < 128; ++i) {
-            posSlot = this.GetPosSlot(i);
-            footerBits = (posSlot >> 1) - 1;
-            baseVal = (2 | (posSlot & 1)) << footerBits;
-            encoder.tempPrices[i] = this.ReverseGetPrice(encoder._posEncoders, baseVal - posSlot - 1, footerBits, i - baseVal);
-        }
-        for (let lenToPosState = 0; lenToPosState < 4; ++lenToPosState) {
-            bitTreeEncoder = encoder._posSlotEncoder[lenToPosState];
-            st = lenToPosState << 6;
-            for (posSlot = 0; posSlot < encoder._distTableSize; posSlot += 1) {
-                encoder._posSlotPrices[st + posSlot] = this.#RangeCoder_Encoder_GetPrice_1(bitTreeEncoder, posSlot);
-            }
-            for (posSlot = 14; posSlot < encoder._distTableSize; posSlot += 1) {
-                encoder._posSlotPrices[st + posSlot] += (posSlot >> 1) - 1 - 4 << 6;
-            }
-            st2 = lenToPosState * 128;
-            for (let i = 0; i < 4; ++i) {
-                encoder._distancesPrices[st2 + i] = encoder._posSlotPrices[st + i];
-            }
-            for (let i = 4; i < 128; ++i) {
-                encoder._distancesPrices[st2 + i] = encoder._posSlotPrices[st + this.GetPosSlot(i)] + encoder.tempPrices[i];
-            }
-        }
-        encoder._matchPriceCount = 0;
-    }
     #Flush(nowPos) {
         this.#ReleaseMFStream();
-        this.#WriteEndMarker(nowPos & this.#compressor.chunker.encoder._posStateMask);
+        this.#compressor.chunker.encoder.writeEndMarker(nowPos & this.#compressor.chunker.encoder._posStateMask);
         for (let i = 0; i < 5; ++i) {
-            this.#ShiftLow();
+            this.#compressor.chunker.encoder.shiftLow();
         }
     }
     #GetOptimum(position) {
@@ -1631,7 +771,7 @@ export class LZMA {
             lenMain = this.#ReadMatchDistances();
         }
         numDistancePairs = encoder._numDistancePairs;
-        numAvailableBytes = this.#GetNumAvailableBytes() + 1;
+        numAvailableBytes = this.#lzInWindow.getNumAvailableBytes() + 1;
         if (numAvailableBytes < 2) {
             encoder.backRes = -1;
             return 1;
@@ -1642,7 +782,7 @@ export class LZMA {
         repMaxIndex = 0;
         for (let i = 0; i < 4; ++i) {
             encoder.reps[i] = encoder._repDistances[i];
-            encoder.repLens[i] = this.#GetMatchLen(-1, encoder.reps[i], 0x0111);
+            encoder.repLens[i] = this.#lzInWindow.getMatchLen(-1, encoder.reps[i], 0x0111);
             if (encoder.repLens[i] > encoder.repLens[repMaxIndex]) {
                 repMaxIndex = i;
             }
@@ -1658,19 +798,19 @@ export class LZMA {
             this.#MovePos(lenMain - 1);
             return lenMain;
         }
-        currentByte = this.#GetIndexByte(-1);
-        matchByte = this.#GetIndexByte(-encoder._repDistances[0] - 1 - 1);
+        currentByte = this.#lzInWindow.getIndexByte(-1);
+        matchByte = this.#lzInWindow.getIndexByte(-encoder._repDistances[0] - 1 - 1);
         if (lenMain < 2 && currentByte != matchByte && encoder.repLens[repMaxIndex] < 2) {
             encoder.backRes = -1;
             return 1;
         }
         encoder._optimum[0].state = encoder._state;
         posState = position & encoder._posStateMask;
-        encoder._optimum[1].price = this.#probPrices[(encoder._isMatch[(encoder._state << 4) + posState]) >>> 2] + this.#RangeCoder_Encoder_GetPrice_0(this.#LZMA_Encoder_GetSubCoder(position, encoder._previousByte), encoder._state >= 7, matchByte, currentByte);
+        encoder._optimum[1].price = PROB_PRICES[(encoder._isMatch[(encoder._state << 4) + posState]) >>> 2] + this.#RangeCoder_Encoder_GetPrice_0(this.#LZMA_Encoder_GetSubCoder(position, encoder._previousByte), encoder._state >= 7, matchByte, currentByte);
         this.#MakeAsChar(encoder._optimum[1]);
-        matchPrice = this.#probPrices[(2048 - encoder._isMatch[(encoder._state << 4) + posState])
+        matchPrice = PROB_PRICES[(2048 - encoder._isMatch[(encoder._state << 4) + posState])
             >>> 2];
-        repMatchPrice = matchPrice + this.#probPrices[(2048 - encoder._isRep[encoder._state]) >>> 2];
+        repMatchPrice = matchPrice + PROB_PRICES[(2048 - encoder._isRep[encoder._state]) >>> 2];
         if (matchByte == currentByte) {
             shortRepPrice = repMatchPrice + this.#GetRepLen1Price(posState);
             if (shortRepPrice < encoder._optimum[1].price) {
@@ -1692,7 +832,7 @@ export class LZMA {
         encoder._optimum[0].backs3 = encoder.reps[3];
         len = lenEnd;
         do {
-            encoder._optimum[len].price = this.#kIfinityPrice;
+            encoder._optimum[len].price = INFINITY_PRICE;
             len -= 1;
         } while (len >= 2);
         for (let i = 0; i < 4; ++i) {
@@ -1702,7 +842,7 @@ export class LZMA {
             }
             price_4 = repMatchPrice + this.#GetPureRepPrice(i, encoder._state, posState);
             do {
-                curAndLenPrice = price_4 + this.#RangeCoder_Encoder_GetPrice(encoder._repMatchLenEncoder, repLen - 2, posState);
+                curAndLenPrice = price_4 + encoder._repMatchLenEncoder.getPrice(repLen - 2, posState);
                 optimum = encoder._optimum[repLen];
                 if (curAndLenPrice < optimum.price) {
                     optimum.price = curAndLenPrice;
@@ -1713,7 +853,7 @@ export class LZMA {
             } while ((repLen -= 1) >= 2);
         }
         normalMatchPrice = matchPrice
-            + this.#probPrices[(encoder._isRep[encoder._state]) >>> 2];
+            + PROB_PRICES[(encoder._isRep[encoder._state]) >>> 2];
         len = encoder.repLens[0] >= 2 ? encoder.repLens[0] + 1 : 2;
         if (len <= lenMain) {
             offs = 0;
@@ -1767,7 +907,7 @@ export class LZMA {
                 else {
                     state = encoder._optimum[posPrev].state;
                 }
-                state = this.StateUpdateChar(state);
+                state = stateUpdateChar(state);
             }
             else {
                 state = encoder._optimum[posPrev].state;
@@ -1777,7 +917,7 @@ export class LZMA {
                     state = state < 7 ? 9 : 11;
                 }
                 else {
-                    state = this.StateUpdateChar(state);
+                    state = stateUpdateChar(state);
                 }
             }
             else {
@@ -1836,26 +976,26 @@ export class LZMA {
             encoder._optimum[cur].backs2 = encoder.reps[2];
             encoder._optimum[cur].backs3 = encoder.reps[3];
             curPrice = encoder._optimum[cur].price;
-            currentByte = this.#GetIndexByte(-0x01);
-            matchByte = this.#GetIndexByte(-encoder.reps[0] - 1 - 1);
+            currentByte = this.#lzInWindow.getIndexByte(-0x01);
+            matchByte = this.#lzInWindow.getIndexByte(-encoder.reps[0] - 1 - 1);
             posState = position & encoder._posStateMask;
             curAnd1Price = curPrice
-                + this.#probPrices[(encoder._isMatch[(state << 0x04) + posState]) >>> 2]
-                + this.#RangeCoder_Encoder_GetPrice_0(this.#LZMA_Encoder_GetSubCoder(position, this.#GetIndexByte(-2)), state >= 7, matchByte, currentByte);
+                + PROB_PRICES[(encoder._isMatch[(state << 0x04) + posState]) >>> 2]
+                + this.#RangeCoder_Encoder_GetPrice_0(this.#LZMA_Encoder_GetSubCoder(position, this.#lzInWindow.getIndexByte(-2)), state >= 7, matchByte, currentByte);
             nextOptimum = encoder._optimum[cur + 1];
             nextIsChar = 0;
             if (curAnd1Price < nextOptimum.price) {
                 nextOptimum.price = curAnd1Price;
                 nextOptimum.posPrev = cur;
                 nextOptimum.backPrev = -0x01;
-                nextOptimum.prev1IsChar = 0x00;
+                nextOptimum.prev1IsChar = 0;
                 nextIsChar = 1;
             }
-            matchPrice = curPrice + this.#probPrices[(2048 - encoder._isMatch[(state << 4) + posState]) >>> 2];
-            repMatchPrice = matchPrice + this.#probPrices[(2048 - encoder._isRep[state]) >>> 2];
+            matchPrice = curPrice + PROB_PRICES[(2048 - encoder._isMatch[(state << 4) + posState]) >>> 2];
+            repMatchPrice = matchPrice + PROB_PRICES[(2048 - encoder._isRep[state]) >>> 2];
             if (matchByte == currentByte && !(nextOptimum.posPrev < cur && !nextOptimum.backPrev)) {
                 shortRepPrice = repMatchPrice
-                    + (this.#probPrices[(encoder._isRepG0[state]) >>> 0x02] + this.#probPrices[(encoder._isRep0Long[(state << 0x04) + posState]) >>> 0x02]);
+                    + (PROB_PRICES[(encoder._isRepG0[state]) >>> 0x02] + PROB_PRICES[(encoder._isRep0Long[(state << 0x04) + posState]) >>> 0x02]);
                 if (shortRepPrice <= nextOptimum.price) {
                     nextOptimum.price = shortRepPrice;
                     nextOptimum.posPrev = cur;
@@ -1864,12 +1004,12 @@ export class LZMA {
                     nextIsChar = 1;
                 }
             }
-            numAvailableBytesFull = this.#GetNumAvailableBytes() + 1;
+            numAvailableBytesFull = this.#lzInWindow.getNumAvailableBytes() + 1;
             numAvailableBytesFull = 0xFFF - cur < numAvailableBytesFull
                 ? 0xFFF - cur
                 : numAvailableBytesFull;
             numAvailableBytes = numAvailableBytesFull;
-            if (numAvailableBytes < 0x02) {
+            if (numAvailableBytes < 2) {
                 continue;
             }
             if (numAvailableBytes > encoder._numFastBytes) {
@@ -1877,19 +1017,19 @@ export class LZMA {
             }
             if (!nextIsChar && matchByte != currentByte) {
                 t = Math.min(numAvailableBytesFull - 1, encoder._numFastBytes);
-                lenTest2 = this.#GetMatchLen(0x00, encoder.reps[0], t);
-                if (lenTest2 >= 0x02) {
-                    state2 = this.StateUpdateChar(state);
+                lenTest2 = this.#lzInWindow.getMatchLen(0, encoder.reps[0], t);
+                if (lenTest2 >= 2) {
+                    state2 = stateUpdateChar(state);
                     posStateNext = position + 1 & encoder._posStateMask;
                     nextRepMatchPrice = curAnd1Price
-                        + this.#probPrices[(0x800 - encoder._isMatch[(state2 << 4) + posStateNext]) >>> 2]
-                        + this.#probPrices[(0x800 - encoder._isRep[state2]) >>> 2];
+                        + PROB_PRICES[(2048 - encoder._isMatch[(state2 << 4) + posStateNext]) >>> 2]
+                        + PROB_PRICES[(2048 - encoder._isRep[state2]) >>> 2];
                     offset = cur + 1 + lenTest2;
                     while (lenEnd < offset) {
-                        encoder._optimum[lenEnd += 1].price = this.#kIfinityPrice;
+                        encoder._optimum[lenEnd += 1].price = INFINITY_PRICE;
                     }
-                    curAndLenPrice = nextRepMatchPrice + (price = this.#RangeCoder_Encoder_GetPrice(encoder._repMatchLenEncoder, lenTest2 - 0x02, posStateNext),
-                        price + this.#GetPureRepPrice(0x00, state2, posStateNext));
+                    curAndLenPrice = nextRepMatchPrice + (price = encoder._repMatchLenEncoder.getPrice(lenTest2 - 2, posStateNext),
+                        price + this.#GetPureRepPrice(0, state2, posStateNext));
                     optimum = encoder._optimum[offset];
                     if (curAndLenPrice < optimum.price) {
                         optimum.price = curAndLenPrice;
@@ -1902,16 +1042,16 @@ export class LZMA {
             }
             startLen = 0x02;
             for (repIndex = 0; repIndex < 4; ++repIndex) {
-                lenTest = this.#GetMatchLen(-0x01, encoder.reps[repIndex], numAvailableBytes);
+                lenTest = this.#lzInWindow.getMatchLen(-0x01, encoder.reps[repIndex], numAvailableBytes);
                 if (lenTest < 2) {
                     continue;
                 }
                 lenTestTemp = lenTest;
                 do {
                     while (lenEnd < cur + lenTest) {
-                        encoder._optimum[lenEnd += 1].price = this.#kIfinityPrice;
+                        encoder._optimum[lenEnd += 1].price = INFINITY_PRICE;
                     }
-                    curAndLenPrice = repMatchPrice + (price_0 = this.#RangeCoder_Encoder_GetPrice(encoder._repMatchLenEncoder, lenTest - 2, posState),
+                    curAndLenPrice = repMatchPrice + (price_0 = encoder._repMatchLenEncoder.getPrice(lenTest - 2, posState),
                         price_0 + this.#GetPureRepPrice(repIndex, state, posState));
                     optimum = encoder._optimum[cur + lenTest];
                     if (curAndLenPrice < optimum.price) {
@@ -1927,23 +1067,23 @@ export class LZMA {
                 }
                 if (lenTest < numAvailableBytesFull) {
                     t = Math.min(numAvailableBytesFull - 1 - lenTest, encoder._numFastBytes);
-                    lenTest2 = this.#GetMatchLen(lenTest, encoder.reps[repIndex], t);
+                    lenTest2 = this.#lzInWindow.getMatchLen(lenTest, encoder.reps[repIndex], t);
                     if (lenTest2 >= 2) {
                         state2 = state < 7 ? 0x08 : 11;
                         posStateNext = position + lenTest & encoder._posStateMask;
                         curAndLenCharPrice = repMatchPrice
-                            + (price_1 = this.#RangeCoder_Encoder_GetPrice(encoder._repMatchLenEncoder, lenTest - 2, posState), price_1 + this.#GetPureRepPrice(repIndex, state, posState))
-                            + this.#probPrices[(encoder._isMatch[(state2 << 4) + posStateNext]) >>> 2]
-                            + this.#RangeCoder_Encoder_GetPrice_0(this.#LZMA_Encoder_GetSubCoder(position + lenTest, this.#GetIndexByte(lenTest - 1 - 1)), true, this.#GetIndexByte(lenTest - 1 - (encoder.reps[repIndex] + 1)), this.#GetIndexByte(lenTest - 1));
-                        state2 = this.StateUpdateChar(state2);
+                            + (price_1 = encoder._repMatchLenEncoder.getPrice(lenTest - 2, posState), price_1 + this.#GetPureRepPrice(repIndex, state, posState))
+                            + PROB_PRICES[(encoder._isMatch[(state2 << 4) + posStateNext]) >>> 2]
+                            + this.#RangeCoder_Encoder_GetPrice_0(this.#LZMA_Encoder_GetSubCoder(position + lenTest, this.#lzInWindow.getIndexByte(lenTest - 1 - 1)), true, this.#lzInWindow.getIndexByte(lenTest - 1 - (encoder.reps[repIndex] + 1)), this.#lzInWindow.getIndexByte(lenTest - 1));
+                        state2 = stateUpdateChar(state2);
                         posStateNext = position + lenTest + 1 & encoder._posStateMask;
-                        nextMatchPrice = curAndLenCharPrice + this.#probPrices[(0x800 - encoder._isMatch[(state2 << 4) + posStateNext]) >>> 2];
-                        nextRepMatchPrice = nextMatchPrice + this.#probPrices[(0x800 - encoder._isRep[state2]) >>> 2];
+                        nextMatchPrice = curAndLenCharPrice + PROB_PRICES[(2048 - encoder._isMatch[(state2 << 4) + posStateNext]) >>> 2];
+                        nextRepMatchPrice = nextMatchPrice + PROB_PRICES[(2048 - encoder._isRep[state2]) >>> 2];
                         offset = lenTest + 1 + lenTest2;
                         while (lenEnd < cur + offset) {
-                            encoder._optimum[lenEnd += 1].price = this.#kIfinityPrice;
+                            encoder._optimum[lenEnd += 1].price = INFINITY_PRICE;
                         }
-                        curAndLenPrice = nextRepMatchPrice + (price_2 = this.#RangeCoder_Encoder_GetPrice(encoder._repMatchLenEncoder, lenTest2 - 2, posStateNext), price_2 + this.#GetPureRepPrice(0, state2, posStateNext));
+                        curAndLenPrice = nextRepMatchPrice + (price_2 = encoder._repMatchLenEncoder.getPrice(lenTest2 - 2, posStateNext), price_2 + this.#GetPureRepPrice(0, state2, posStateNext));
                         optimum = encoder._optimum[cur + offset];
                         if (curAndLenPrice < optimum.price) {
                             optimum.price = curAndLenPrice;
@@ -1964,9 +1104,9 @@ export class LZMA {
                 numDistancePairs += 2;
             }
             if (newLen >= startLen) {
-                normalMatchPrice = matchPrice + this.#probPrices[(encoder._isRep[state]) >>> 2];
+                normalMatchPrice = matchPrice + PROB_PRICES[(encoder._isRep[state]) >>> 2];
                 while (lenEnd < cur + newLen) {
-                    encoder._optimum[lenEnd += 1].price = this.#kIfinityPrice;
+                    encoder._optimum[lenEnd += 1].price = INFINITY_PRICE;
                 }
                 offs = 0;
                 while (startLen > encoder._matchDistances[offs]) {
@@ -1985,22 +1125,22 @@ export class LZMA {
                     if (lenTest == encoder._matchDistances[offs]) {
                         if (lenTest < numAvailableBytesFull) {
                             t = Math.min(numAvailableBytesFull - 1 - lenTest, encoder._numFastBytes);
-                            lenTest2 = this.#GetMatchLen(lenTest, curBack, t);
+                            lenTest2 = this.#lzInWindow.getMatchLen(lenTest, curBack, t);
                             if (lenTest2 >= 2) {
                                 state2 = state < 7 ? 7 : 10;
                                 posStateNext = position + lenTest & encoder._posStateMask;
                                 curAndLenCharPrice = curAndLenPrice
-                                    + this.#probPrices[(encoder._isMatch[(state2 << 4) + posStateNext]) >>> 2]
-                                    + this.#RangeCoder_Encoder_GetPrice_0(this.#LZMA_Encoder_GetSubCoder(position + lenTest, this.#GetIndexByte(lenTest - 1 - 1)), true, this.#GetIndexByte(lenTest - (curBack + 1) - 1), this.#GetIndexByte(lenTest - 1));
-                                state2 = this.StateUpdateChar(state2);
+                                    + PROB_PRICES[(encoder._isMatch[(state2 << 4) + posStateNext]) >>> 2]
+                                    + this.#RangeCoder_Encoder_GetPrice_0(this.#LZMA_Encoder_GetSubCoder(position + lenTest, this.#lzInWindow.getIndexByte(lenTest - 1 - 1)), true, this.#lzInWindow.getIndexByte(lenTest - (curBack + 1) - 1), this.#lzInWindow.getIndexByte(lenTest - 1));
+                                state2 = stateUpdateChar(state2);
                                 posStateNext = position + lenTest + 1 & encoder._posStateMask;
-                                nextMatchPrice = curAndLenCharPrice + this.#probPrices[(2048 - encoder._isMatch[(state2 << 4) + posStateNext]) >>> 2];
-                                nextRepMatchPrice = nextMatchPrice + this.#probPrices[(2048 - encoder._isRep[state2]) >>> 2];
+                                nextMatchPrice = curAndLenCharPrice + PROB_PRICES[(2048 - encoder._isMatch[(state2 << 4) + posStateNext]) >>> 2];
+                                nextRepMatchPrice = nextMatchPrice + PROB_PRICES[(2048 - encoder._isRep[state2]) >>> 2];
                                 offset = lenTest + 1 + lenTest2;
                                 while (lenEnd < cur + offset) {
-                                    encoder._optimum[lenEnd += 1].price = this.#kIfinityPrice;
+                                    encoder._optimum[lenEnd += 1].price = INFINITY_PRICE;
                                 }
-                                curAndLenPrice = nextRepMatchPrice + (price_3 = this.#RangeCoder_Encoder_GetPrice(encoder._repMatchLenEncoder, lenTest2 - 2, posStateNext), price_3 + this.#GetPureRepPrice(0, state2, posStateNext));
+                                curAndLenPrice = nextRepMatchPrice + (price_3 = encoder._repMatchLenEncoder.getPrice(lenTest2 - 2, posStateNext), price_3 + this.#GetPureRepPrice(0, state2, posStateNext));
                                 optimum = encoder._optimum[cur + offset];
                                 if (curAndLenPrice < optimum.price) {
                                     optimum.price = curAndLenPrice;
@@ -2026,7 +1166,7 @@ export class LZMA {
     }
     #LZMA_Encoder_GetPosLenPrice(pos, len, posState) {
         const encoder = this.#compressor.chunker.encoder;
-        let price, lenToPosState = this.GetLenToPosState(len);
+        let price, lenToPosState = getLenToPosState(len);
         if (pos < 128) {
             price = encoder._distancesPrices[lenToPosState * 128 + pos];
         }
@@ -2034,55 +1174,33 @@ export class LZMA {
             const position = (lenToPosState << 6) + this.GetPosSlot2(pos);
             price = encoder._posSlotPrices[position] + encoder._alignPrices[pos & 15];
         }
-        return price + this.#RangeCoder_Encoder_GetPrice(encoder._lenEncoder, len - 2, posState);
+        return price + encoder._lenEncoder.getPrice(len - 2, posState);
     }
     #GetPureRepPrice(repIndex, state, posState) {
         const encoder = this.#compressor.chunker.encoder;
         let price;
         if (!repIndex) {
-            price = this.#probPrices[(encoder._isRepG0[state]) >>> 2];
-            price += this.#probPrices[0x800 - this.#compressor.chunker.encoder._isRep0Long[(state << 4) + posState] >>> 2];
+            price = PROB_PRICES[(encoder._isRepG0[state]) >>> 2];
+            price += PROB_PRICES[0x800 - this.#compressor.chunker.encoder._isRep0Long[(state << 4) + posState] >>> 2];
         }
         else {
-            price = this.#probPrices[(0x800 - this.#compressor.chunker.encoder._isRepG0[state]) >>> 2];
+            price = PROB_PRICES[(0x800 - this.#compressor.chunker.encoder._isRepG0[state]) >>> 2];
             if (repIndex == 1) {
-                price += this.#probPrices[(this.#compressor.chunker.encoder._isRepG1[state]) >>> 2];
+                price += PROB_PRICES[(this.#compressor.chunker.encoder._isRepG1[state]) >>> 2];
             }
             else {
-                price += this.#probPrices[(0x800 - this.#compressor.chunker.encoder._isRepG1[state]) >>> 2];
-                price += this.GetPrice(this.#compressor.chunker.encoder._isRepG2[state], repIndex - 2);
+                price += PROB_PRICES[(0x800 - this.#compressor.chunker.encoder._isRepG1[state]) >>> 2];
+                price += getBitPrice(this.#compressor.chunker.encoder._isRepG2[state], repIndex - 2);
             }
         }
         return price;
     }
     #GetRepLen1Price(posState) {
         const encoder = this.#compressor.chunker.encoder;
-        const repG0Price = this.#probPrices[(encoder._isRepG0[encoder._state]) >>> 2];
-        const rep0LongPrice = this.#probPrices[encoder._isRep0Long[(encoder._state << 4) + posState] >>> 2];
+        const repG0Price = PROB_PRICES[(encoder._isRepG0[encoder._state]) >>> 2];
+        const rep0LongPrice = PROB_PRICES[encoder._isRep0Long[(encoder._state << 4) + posState] >>> 2];
         return repG0Price + rep0LongPrice;
     }
-    #Init_4() {
-        this.#BaseInit();
-        this.#Init_9();
-        this.InitBitModels(this.#encoder._isMatch);
-        this.InitBitModels(this.#encoder._isRep0Long);
-        this.InitBitModels(this.#encoder._isRep);
-        this.InitBitModels(this.#encoder._isRepG0);
-        this.InitBitModels(this.#encoder._isRepG1);
-        this.InitBitModels(this.#encoder._isRepG2);
-        this.InitBitModels(this.#encoder._posEncoders);
-        this.#Init_3();
-        for (let i = 0; i < 4; ++i) {
-            this.InitBitModels(this.#encoder._posSlotEncoder[i].models);
-        }
-        this.#Init_2(this.#encoder._lenEncoder, 1 << this.#encoder._posStateBits);
-        this.#Init_2(this.#encoder._repMatchLenEncoder, 1 << this.#encoder._posStateBits);
-        this.InitBitModels(this.#encoder._posAlignEncoder.models);
-        this.#encoder._longestMatchWasFound = 0;
-        this.#encoder._optimumEndIndex = 0;
-        this.#encoder._optimumCurrentIndex = 0;
-        this.#encoder._additionalOffset = 0;
-    }
     #MovePos(num) {
         if (num > 0) {
             this.#Skip(num);
@@ -2096,7 +1214,7 @@ export class LZMA {
         if (encoder._numDistancePairs > 0) {
             lenRes = encoder._matchDistances[encoder._numDistancePairs - 2];
             if (lenRes == encoder._numFastBytes) {
-                lenRes += this.#GetMatchLen(lenRes - 1, encoder._matchDistances[encoder._numDistancePairs - 1], 0x0111 - lenRes);
+                lenRes += this.#lzInWindow.getMatchLen(lenRes - 1, encoder._matchDistances[encoder._numDistancePairs - 1], 0x0111 - lenRes);
             }
         }
         encoder._additionalOffset += 1;
@@ -2113,21 +1231,6 @@ export class LZMA {
         this.#ReleaseMFStream();
         this.#compressor.chunker.encoder._rangeEncoder.stream = null;
     }
-    #SetDictionarySize_0(dictionarySize) {
-        this.#encoder._dictionarySize = dictionarySize;
-        let dicLogSize = 0;
-        for (; dictionarySize > (1 << dicLogSize); ++dicLogSize)
-            ;
-        this.#encoder._distTableSize = dicLogSize * 2;
-    }
-    #SetMatchFinder(matchFinderIndex) {
-        const matchFinderIndexPrev = this.#encoder._matchFinderType;
-        this.#encoder._matchFinderType = matchFinderIndex;
-        if (this.#encoder._matchFinder && matchFinderIndexPrev != this.#encoder._matchFinderType) {
-            this.#encoder._dictionarySizePrev = -1;
-            this.#encoder._matchFinder = null;
-        }
-    }
     writeHeaderProperties() {
         const HEADER_SIZE = 0x5; // Total header size in bytes
         // First byte combines posStateBits, literalPosStateBits and literalContextBits
@@ -2138,184 +1241,20 @@ export class LZMA {
             // Shift dictionary size right by appropriate number of bits and mask to byte
             this.#encoder.properties[1 + byteIndex] = (this.#encoder._dictionarySize >> (0x08 * byteIndex)) & 0xFF;
         }
-        // Write the 5-byte header to output
-        this.#write_0(this.#compressor.output, this.#encoder.properties, 0, // Starting from index 0
-        HEADER_SIZE);
-    }
-    #WriteEndMarker(positionState) {
-        const encoder = this.#compressor.chunker.encoder;
-        this.#Encode_3(encoder._isMatch, (encoder._state << 4) + positionState, 1);
-        this.#Encode_3(encoder._isRep, encoder._state, 0);
-        encoder._state = encoder._state < 7 ? 7 : 10;
-        this.#Encode_0(encoder._lenEncoder, 0, positionState);
-        let lenToPosState = this.GetLenToPosState(2);
-        this.#Encode_2(encoder._posSlotEncoder[lenToPosState], 63);
-        this.#EncodeDirectBits(67108863, 26);
-        this.#ReverseEncode(15);
-    }
-    GetPosSlot(pos) {
-        if (pos < 2048) {
-            return this.#gFastPos[pos];
-        }
-        if (pos < 2097152) {
-            return this.#gFastPos[pos >> 10] + 20;
-        }
-        return this.#gFastPos[pos >> 20] + 40;
+        this.#write_0(this.#compressor.output, this.#encoder.properties, 0, HEADER_SIZE);
     }
     GetPosSlot2(pos) {
-        if (pos < 131072) {
-            return this.#gFastPos[pos >> 6] + 12;
-        }
-        if (pos < 134217728) {
-            return this.#gFastPos[pos >> 16] + 32;
-        }
-        return this.#gFastPos[pos >> 26] + 52;
-    }
-    #Encode(encoder, symbol, posState) {
-        if (symbol < 8) {
-            this.#Encode_3(encoder.choice, 0, 0);
-            this.#Encode_2(encoder.lowCoder[posState], symbol);
-        }
-        else {
-            symbol -= 8;
-            this.#Encode_3(encoder.choice, 0, 1);
-            if (symbol < 8) {
-                this.#Encode_3(encoder.choice, 1, 0);
-                this.#Encode_2(encoder.midCoder[posState], symbol);
-            }
-            else {
-                this.#Encode_3(encoder.choice, 1, 1);
-                this.#Encode_2(encoder.highCoder, symbol - 8);
-            }
+        if (pos < 0x20000) {
+            return G_FAST_POS[pos >> 6] + 12;
         }
-    }
-    #createLenEncoder() {
-        const encoder = {};
-        encoder.choice = this.#initArray(2);
-        encoder.lowCoder = [];
-        encoder.midCoder = [];
-        encoder.highCoder = this.#createBitTreeEncoder(8);
-        for (let posState = 0; posState < 16; ++posState) {
-            encoder.lowCoder[posState] = this.#createBitTreeEncoder(3);
-            encoder.midCoder[posState] = this.#createBitTreeEncoder(3);
-        }
-        return encoder;
-    }
-    #Init_2(encoder, numPosStates) {
-        this.InitBitModels(encoder.choice);
-        for (let posState = 0; posState < numPosStates; ++posState) {
-            this.InitBitModels(encoder.lowCoder[posState].models);
-            this.InitBitModels(encoder.midCoder[posState].models);
-        }
-        this.InitBitModels(encoder.highCoder.models);
-    }
-    #SetPrices(encoder, posState, numSymbols, prices, st) {
-        let a0 = this.#probPrices[encoder.choice[0] >>> 2];
-        let a1 = this.#probPrices[2048 - encoder.choice[0] >>> 2];
-        let b0 = a1 + this.#probPrices[encoder.choice[1] >>> 2];
-        let b1 = a1 + this.#probPrices[2048 - encoder.choice[1] >>> 2];
-        let i = 0;
-        for (i = 0; i < 8; ++i) {
-            if (i >= numSymbols) {
-                return;
-            }
-            prices[st + i] = a0 + this.#RangeCoder_Encoder_GetPrice_1(encoder.lowCoder[posState], i);
-        }
-        for (; i < 16; ++i) {
-            if (i >= numSymbols) {
-                return;
-            }
-            prices[st + i] = b0 + this.#RangeCoder_Encoder_GetPrice_1(encoder.midCoder[posState], i - 8);
-        }
-        for (; i < numSymbols; ++i) {
-            prices[st + i] = b1 + this.#RangeCoder_Encoder_GetPrice_1(encoder.highCoder, i - 8 - 8);
-        }
-    }
-    #Encode_0(encoder, symbol, posState) {
-        this.#Encode(encoder, symbol, posState);
-        if ((encoder.counters[posState] -= 1) == 0) {
-            this.#SetPrices(encoder, posState, encoder.tableSize, encoder.prices, posState * 272);
-            encoder.counters[posState] = encoder.tableSize;
-        }
-    }
-    #createLenPriceTableEncoder() {
-        const encoder = this.#createLenEncoder();
-        encoder.prices = [];
-        encoder.counters = [];
-        return encoder;
-    }
-    #RangeCoder_Encoder_GetPrice(encoder, symbol, posState) {
-        return encoder.prices[posState * 272 + symbol];
-    }
-    #LZMA_LenPriceTableEncoder_UpdateTablesUpdateTables(encoder, numPosStates) {
-        for (let posState = 0; posState < numPosStates; ++posState) {
-            this.#SetPrices(encoder, posState, encoder.tableSize, encoder.prices, posState * 272);
-            encoder.counters[posState] = encoder.tableSize;
-        }
-    }
-    #LZMA_Encoder_LiteralEncoder_Create() {
-        const encoder = this.#encoder._literalEncoder;
-        let i, numStates;
-        if (encoder.coders != null
-            && encoder.numPrevBits == this.#encoder._numLiteralContextBits
-            && encoder.numPosBits == this.#encoder._numLiteralPosStateBits) {
-            return;
-        }
-        encoder.numPosBits = this.#encoder._numLiteralPosStateBits;
-        encoder.posMask = (1 << this.#encoder._numLiteralPosStateBits) - 1;
-        encoder.numPrevBits = this.#encoder._numLiteralContextBits;
-        numStates = 1 << (encoder.numPrevBits + encoder.numPosBits);
-        encoder.coders = [];
-        for (i = 0; i < numStates; ++i) {
-            encoder.coders[i] = this.#createLiteralEncoderEncoder2();
+        if (pos < 0x8000000) {
+            return G_FAST_POS[pos >> 16] + 32;
         }
+        return G_FAST_POS[pos >> 26] + 52;
     }
     #LZMA_Encoder_GetSubCoder(pos, prevByte) {
-        const literalEncoder = this.#compressor.chunker.encoder._literalEncoder;
-        // Calculate position mask bits
-        const posBits = pos & literalEncoder.posMask;
-        const posShifted = posBits << literalEncoder.numPrevBits;
-        // Calculate previous byte bits
-        const prevByteShift = 0x08 - literalEncoder.numPrevBits;
-        const prevByteBits = (prevByte & 0xFF) >>> prevByteShift;
-        // Combine position and prevByte bits to get final index
-        const coderIndex = posShifted + prevByteBits;
-        return literalEncoder.coders[coderIndex];
-    }
-    #Init_3() {
-        const totalStates = 1 << (this.#encoder._literalEncoder.numPrevBits
-            + this.#encoder._literalEncoder.numPosBits);
-        for (let i = 0; i < totalStates; ++i) {
-            this.InitBitModels(this.#encoder._literalEncoder.coders[i].decoders);
-        }
-    }
-    #Encode_1(encoder, symbol) {
-        let bit, context = 1;
-        for (let i = 7; i >= 0; --i) {
-            bit = (symbol >> i) & 1;
-            this.#Encode_3(encoder.decoders, context, bit);
-            context = context << 1 | bit;
-        }
-    }
-    #EncodeMatched(encoder, matchByte, symbol) {
-        let bit, matchBit, state, same = true, context = 1;
-        for (let i = 7; i >= 0; --i) {
-            bit = (symbol >> i) & 1;
-            state = context;
-            if (same) {
-                matchBit = (matchByte >> i) & 1;
-                state += (1 + matchBit) << 8;
-                same = matchBit === bit;
-            }
-            this.#Encode_3(encoder.decoders, state, bit);
-            context = context << 1 | bit;
-        }
-    }
-    #createLiteralEncoderEncoder2() {
-        const encoder = {
-            decoders: this.#initArray(0x300),
-        };
-        return encoder;
+        const subCoder = this.#compressor.chunker.encoder._literalEncoder.getSubCoder(pos, prevByte);
+        return { decoders: subCoder.decoders };
     }
     #RangeCoder_Encoder_GetPrice_0(encoder, matchMode, matchByte, symbol) {
         let bit, context = 1, i = 7, matchBit, price = 0;
@@ -2323,7 +1262,7 @@ export class LZMA {
             for (; i >= 0; --i) {
                 matchBit = (matchByte >> i) & 1;
                 bit = (symbol >> i) & 1;
-                price += this.GetPrice(encoder.decoders[((1 + matchBit) << 8) + context], bit);
+                price += getBitPrice(encoder.decoders[((1 + matchBit) << 8) + context], bit);
                 context = context << 1 | bit;
                 if (matchBit != bit) {
                     --i;
@@ -2333,7 +1272,7 @@ export class LZMA {
         }
         for (; i >= 0; --i) {
             bit = symbol >> i & 1;
-            price += this.GetPrice(encoder.decoders[context], bit);
+            price += getBitPrice(encoder.decoders[context], bit);
             context = context << 1 | bit;
         }
         return price;
@@ -2346,80 +1285,11 @@ export class LZMA {
         optimum.backPrev = 0;
         optimum.prev1IsChar = 0;
     }
-    #createBitTreeDecoder(numBitLevels) {
-        return {
-            numBitLevels: numBitLevels,
-            models: this.#initArray(1 << numBitLevels),
-        };
-    }
-    #RangeCoder_BitTreeDecoder_Decoder(rangeDecoder) {
-        let bitIndex, m = 1;
-        for (bitIndex = rangeDecoder.numBitLevels; bitIndex != 0; bitIndex -= 1) {
-            m = (m << 1) + this.#decodeBit(rangeDecoder.models, m);
-        }
-        return m - (1 << rangeDecoder.numBitLevels);
-    }
-    #ReverseDecode() {
-        const positionAlignmentDecoder = this.#decompressor.chunker.decoder.posAlignDecoder;
-        let symbol = 0;
-        for (let m = 1, bitIndex = 0, bit; bitIndex < positionAlignmentDecoder.numBitLevels; ++bitIndex) {
-            bit = this.#decodeBit(positionAlignmentDecoder.models, m);
-            m <<= 1;
-            m += bit;
-            symbol |= bit << bitIndex;
-        }
-        return symbol;
-    }
-    reverseDecode(Models, startIndex, NumBitLevels) {
-        let symbol = 0;
-        for (let bitIndex = 0, m = 1, bit; bitIndex < NumBitLevels; ++bitIndex) {
-            bit = this.#decodeBit(Models, startIndex + m);
-            m <<= 1;
-            m += bit;
-            symbol |= bit << bitIndex;
-        }
-        return symbol;
-    }
-    #createBitTreeEncoder(numBitLevels) {
-        return {
-            numBitLevels: numBitLevels,
-            models: this.#initArray(1 << numBitLevels),
-        };
-    }
-    #Encode_2(encoder, symbol) {
-        let bit, bitIndex, m = 1;
-        for (bitIndex = encoder.numBitLevels; bitIndex != 0;) {
-            bitIndex -= 1;
-            bit = symbol >>> bitIndex & 1;
-            this.#Encode_3(encoder.models, m, bit);
-            m = m << 1 | bit;
-        }
-    }
-    #RangeCoder_Encoder_GetPrice_1(encoder, symbol) {
-        let bit, bitIndex, m = 1, price = 0;
-        for (bitIndex = encoder.numBitLevels; bitIndex != 0;) {
-            bitIndex -= 1;
-            bit = symbol >>> bitIndex & 1;
-            price += this.GetPrice(encoder.models[m], bit);
-            m = (m << 1) + bit;
-        }
-        return price;
-    }
-    #ReverseEncode(symbol) {
-        const posAlignEncoder = this.#compressor.chunker.encoder._posAlignEncoder;
-        let bit, m = 1;
-        for (let i = 0; i < posAlignEncoder.numBitLevels; ++i) {
-            bit = symbol & 1;
-            this.#Encode_3(posAlignEncoder.models, m, bit);
-            m = m << 1 | bit;
-            symbol >>= 1;
-        }
-    }
     ReverseEncode(startIndex, NumBitLevels, symbol) {
         let bit, m = 1;
         for (let i = 0; i < NumBitLevels; ++i) {
             bit = symbol & 1;
-            this.#Encode_3(this.#compressor.chunker.encoder._posEncoders, startIndex + m, bit);
+            this.#compressor.chunker.encoder.encodeBit(this.#compressor.chunker.encoder._posEncoders, startIndex + m, bit);
             m = m << 1 | bit;
             symbol >>= 1;
         }
@@ -2429,132 +1299,14 @@ export class LZMA {
         for (let i = encoder.numBitLevels; i != 0; i -= 1) {
             bit = symbol & 1;
             symbol >>>= 1;
-            price += this.GetPrice(encoder.models[m], bit);
+            price += getBitPrice(encoder.models[m], bit);
             m = m << 1 | bit;
         }
         return price;
     }
-    ReverseGetPrice(Models, startIndex, NumBitLevels, symbol) {
-        let bit, m = 1, price = 0;
-        for (let i = NumBitLevels; i != 0; i -= 1) {
-            bit = symbol & 1;
-            symbol >>>= 1;
-            price += this.#probPrices[((Models[startIndex + m] - bit ^ -bit) & 2047) >>> 2];
-            m = m << 1 | bit;
-        }
-        return price;
-    }
-    #decodeBit(probs, index) {
-        const rangeDecoder = this.#decompressor.chunker.decoder.rangeDecoder;
-        let newBound, prob = probs[index];
-        newBound = (rangeDecoder.rrange >>> 11) * prob;
-        if ((rangeDecoder.code ^ this.#MIN_INT32) < (newBound ^ this.#MIN_INT32)) {
-            rangeDecoder.rrange = newBound;
-            probs[index] = prob + (2048 - prob >>> 5) << 16 >> 16;
-            if (!(rangeDecoder.rrange & -16777216)) {
-                rangeDecoder.code = rangeDecoder.code << 8 | this.#read(rangeDecoder.stream);
-                rangeDecoder.rrange <<= 8;
-            }
-            return 0;
-        }
-        else {
-            rangeDecoder.rrange -= newBound;
-            rangeDecoder.code -= newBound;
-            probs[index] = prob - (prob >>> 5) << 16 >> 16;
-            if (!(rangeDecoder.rrange & -16777216)) {
-                rangeDecoder.code = rangeDecoder.code << 8 | this.#read(rangeDecoder.stream);
-                rangeDecoder.rrange <<= 8;
-            }
-            return 1;
-        }
-    }
-    #DecodeDirectBits(numTotalBits) {
-        const rangeDecoder = this.#decompressor.chunker.decoder.rangeDecoder;
-        let result = 0;
-        for (let i = numTotalBits; i != 0; i -= 1) {
-            rangeDecoder.rrange >>>= 1;
-            let t = (rangeDecoder.code - rangeDecoder.rrange) >>> 31;
-            rangeDecoder.code -= rangeDecoder.rrange & (t - 1);
-            result = result << 1 | 1 - t;
-            if (!(rangeDecoder.rrange & -16777216)) {
-                rangeDecoder.code = rangeDecoder.code << 8 | this.#read(rangeDecoder.stream);
-                rangeDecoder.rrange <<= 8;
-            }
-        }
-        return result;
-    }
-    #Init_8() {
-        this.#decoder.rangeDecoder.code = 0;
-        this.#decoder.rangeDecoder.rrange = -1;
-        for (let i = 0; i < 5; ++i) {
-            this.#decoder.rangeDecoder.code = this.#decoder.rangeDecoder.code << 8
-                | this.#read(this.#decoder.rangeDecoder.stream);
-        }
-    }
-    InitBitModels(probs) {
-        for (let i = probs.length - 1; i >= 0; --i) {
-            probs[i] = 1024;
-        }
-    }
-    #Encode_3(probs, index, symbol) {
-        const rangeEncoder = this.#compressor.chunker.encoder._rangeEncoder;
-        let newBound, prob = probs[index];
-        newBound = (rangeEncoder.rrange >>> 11) * prob;
-        if (!symbol) {
-            rangeEncoder.rrange = newBound;
-            probs[index] = prob + (2048 - prob >>> 5) << 16 >> 16;
-        }
-        else {
-            rangeEncoder.low = this.#add(rangeEncoder.low, this.#and(this.#fromInt(newBound), [4294967295, 0]));
-            rangeEncoder.rrange -= newBound;
-            probs[index] = prob - (prob >>> 5) << 16 >> 16;
-        }
-        if (!(rangeEncoder.rrange & -16777216)) {
-            rangeEncoder.rrange <<= 8;
-            this.#ShiftLow();
-        }
-    }
-    #EncodeDirectBits(valueToEncode, numTotalBits) {
-        const rangeEncoder = this.#compressor.chunker.encoder._rangeEncoder;
-        for (let i = numTotalBits - 1; i >= 0; i -= 1) {
-            rangeEncoder.rrange >>>= 1;
-            if ((valueToEncode >>> i & 1) == 1) {
-                rangeEncoder.low = this.#add(rangeEncoder.low, this.#fromInt(rangeEncoder.rrange));
-            }
-            if (!(rangeEncoder.rrange & -16777216)) {
-                rangeEncoder.rrange <<= 8;
-                this.#ShiftLow();
-            }
-        }
-    }
     #GetProcessedSizeAdd() {
-        const processedCacheSize = this.#add(this.#fromInt(this.#compressor.chunker.encoder._rangeEncoder.cacheSize), this.#compressor.chunker.encoder._rangeEncoder.position);
-        return this.#add(processedCacheSize, [4, 0]);
-    }
-    #Init_9() {
-        this.#encoder._rangeEncoder.position = this.#P0_LONG_LIT;
-        this.#encoder._rangeEncoder.low = this.#P0_LONG_LIT;
-        this.#encoder._rangeEncoder.rrange = -1;
-        this.#encoder._rangeEncoder.cacheSize = 1;
-        this.#encoder._rangeEncoder.cache = 0;
-    }
-    #ShiftLow() {
-        const rangeEncoder = this.#compressor.chunker.encoder._rangeEncoder;
-        const LowHi = this.#lowBits_0(this.#shru(rangeEncoder.low, 32));
-        if (LowHi != 0 || this.#compare(rangeEncoder.low, [4278190080, 0]) < 0) {
-            rangeEncoder.position = this.#add(rangeEncoder.position, this.#fromInt(rangeEncoder.cacheSize));
-            let temp = rangeEncoder.cache;
-            do {
-                this.#write(rangeEncoder.stream, temp + LowHi);
-                temp = 255;
-            } while ((rangeEncoder.cacheSize -= 1) != 0);
-            rangeEncoder.cache = this.#lowBits_0(rangeEncoder.low) >>> 24;
-        }
-        rangeEncoder.cacheSize += 1;
-        rangeEncoder.low = this.#shl(this.#and(rangeEncoder.low, [16777215, 0]), 8);
-    }
-    GetPrice(Prob, symbol) {
-        return this.#probPrices[((Prob - symbol ^ -symbol) & 2047) >>> 2];
+        const processedCacheSize = add64(fromInt64(this.#compressor.chunker.encoder._rangeEncoder.cacheSize), this.#compressor.chunker.encoder._rangeEncoder.position);
+        return add64(processedCacheSize, [4, 0]);
     }
     #decodeString(utf) {
         let j = 0, x, y, z, l = utf.length, buf = [], charCodes = [];
@@ -2638,25 +1390,25 @@ export class LZMA {
         elen = 0;
         for (let i = 0; i < l; ++i) {
             ch = chars[i];
-            if (ch >= 1 && ch <= 127) {
+            if (ch >= 1 && ch <= 0x7F) { // 127
                 data[elen++] = ch << 24 >> 24;
             }
-            else if (!ch || ch >= 128 && ch <= 2047) {
-                data[elen++] = (192 | ch >> 6 & 31) << 24 >> 24;
-                data[elen++] = (128 | ch & 63) << 24 >> 24;
+            else if (!ch || ch >= 0x80 && ch <= 0x7FF) {
+                data[elen++] = (0xC0 | ch >> 6 & 0x1F) << 24 >> 24;
+                data[elen++] = (0x80 | ch & 0x3F) << 24 >> 24;
             }
             else {
-                data[elen++] = (224 | ch >> 12 & 15) << 24 >> 24;
-                data[elen++] = (128 | ch >> 6 & 63) << 24 >> 24;
-                data[elen++] = (128 | ch & 63) << 24 >> 24;
+                data[elen++] = (0xE0 | ch >> 12 & 0x0F) << 24 >> 24;
+                data[elen++] = (0x80 | ch >> 6 & 0x3F) << 24 >> 24;
+                data[elen++] = (0x80 | ch & 0x3F) << 24 >> 24;
             }
         }
         return data;
     }
     compress(data, mode = 5) {
-        const compressionMode = this.CompressionModes[mode];
+        const compressionMode = MODES[mode];
         this.#byteArrayCompressor(data, compressionMode);
-        while (this.#processChunkEncode())
+        while (this.#compressor.chunker.processChunk())
             ;
         const result = this.#toByteArray(this.#compressor.output);
         return new Int8Array(result);
@@ -2667,13 +1419,13 @@ export class LZMA {
     }
     decompress(bytearray) {
         this.#byteArrayDecompressor(bytearray);
-        while (this.#processChunkDecode())
+        while (this.#decompressor.chunker.processChunk())
             ;
         return this.#toByteArray(this.#decompressor.output);
     }
     decompressString(bytearray) {
         this.#byteArrayDecompressor(bytearray);
-        while (this.#processChunkDecode())
+        while (this.#decompressor.chunker.processChunk())
             ;
         const decodedByteArray = this.#toByteArray(this.#decompressor.output);
         const result = this.#decodeString(decodedByteArray);
@@ -2685,4 +1437,11 @@ export class LZMA {
             return String.fromCharCode(...result);
         }
     }
+    // Public methods for chunker access
+    codeOneBlock() {
+        this.#CodeOneBlock();
+    }
+    releaseStreams() {
+        this.#ReleaseStreams();
+    }
 }