lzma1 0.0.4 → 0.5.0

package/README.md

@@ -1,6 +1,7 @@
 # lzma1
 
-This is a simplified [fork][fork-link] of [Nathan Rugg's][fork-author] package.
+This is a [fork][fork-link] of [Nathan Rugg's][fork-author] package that adds
+types and makes the logic more structured and readable.
 
 [fork-link]: https://github.com/LZMA-JS/LZMA-JS
 [fork-author]: https://github.com/nmrugg
@@ -64,8 +65,16 @@ const decompressed = decompress(result);
 // data === decompressed
 ```
 
+## LZMA header
+
+More [information][header_link] about the LZMA header.
+
+![lzma](./docs/lzma.svg)
+
 ## Related
 
 - <https://github.com/cscott/lzma-purejs>
 - <https://github.com/glinscott/lzmajs>
 - <https://github.com/mauron85/lzma-purejs/tree/master>
+
+[header_link]: https://docs.fileformat.com/compression/lzma/#lzma-header

package/dist/lzma.d.ts

@@ -47,6 +47,7 @@ export declare class LZMA {
             readonly modeIndex: 1;
         };
     };
+    readonly bitMaskForRange = -16777216;
     constructor();
     GetLenToPosState(len: number): number;
     StateUpdateChar(index: number): number;

package/dist/lzma.js

@@ -55,10 +55,16 @@ const CRC32_TABLE = [
     0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
 ];
 export class LZMA {
-    #MAX_UINT32 = 4_294_967_296;
-    #MAX_INT32 = 2_147_483_647;
-    #MIN_INT32 = -2_147_483_648;
-    #MAX_COMPRESSION_SIZE = 9_223_372_036_854_775_807;
+    #MAX_UINT32 = 0x100000000; // 2^32
+    #_MAX_UINT32 = 0xFFFFFFFF; // 2^32 - 1
+    #MAX_INT32 = 0x7FFFFFFF; // 2^31 - 1
+    #MIN_INT32 = -0x80000000; // -2^31
+    #MAX_UINT64 = 0x10000000000000000; // 2^64
+    #MAX_INT64 = 0x7FFFFFFFFFFFFFFF; // 2^63
+    #MIN_INT64 = -0x8000000000000000; // -2^63
+    #MAX_COMPRESSION_SIZE = 0x7FFFFFFFFFFFFFFF; // 2^63 - 1
+    #kIfinityPrice = 0xFFFFFFF; // 2^28 - 1
+    #dictionarySizeThreshold = 0x3FFFFFFF;
     #N1_LONG_LIT;
     #MIN_VALUE;
     #P0_LONG_LIT = [0, 0];
@@ -80,9 +86,10 @@ export class LZMA {
     #gFastPos;
     #compressor;
     #decompressor;
+    bitMaskForRange = -16777216;
     constructor() {
-        this.#N1_LONG_LIT = [4294967295, -this.#MAX_UINT32];
-        this.#MIN_VALUE = [0, -9223372036854775808];
+        this.#N1_LONG_LIT = [this.#_MAX_UINT32, -this.#MAX_UINT32];
+        this.#MIN_VALUE = [0, this.#MIN_INT64];
         this.#encoder = this.#initEncoder();
         this.#decoder = this.#initDecoder();
         this.#probPrices = this.#createProbPrices();
@@ -146,8 +153,8 @@ export class LZMA {
             m_PosSlotDecoder: this.#initArray(4),
             m_PosDecoders: this.#initArray(114),
             m_PosAlignDecoder: this.#createBitTreeDecoder(4),
-            m_LenDecoder: this.#createLenDecoder({}),
-            m_RepLenDecoder: this.#createLenDecoder({}),
+            m_LenDecoder: this.#createLenDecoder(),
+            m_RepLenDecoder: this.#createLenDecoder(),
             m_LiteralDecoder: {},
         };
         for (let i = 0; i < 4; ++i) {
@@ -161,7 +168,7 @@ export class LZMA {
                 alive: 0,
                 encoder: null,
                 decoder: null,
-                inBytesProcessed: [],
+                inBytesProcessed: [0, 0],
             },
             output: {
                 buf: this.#initArray(32),
@@ -175,7 +182,7 @@ export class LZMA {
                 alive: 0,
                 encoder: null,
                 decoder: null,
-                inBytesProcessed: [],
+                inBytesProcessed: [0, 0],
             },
             output: {
                 buf: this.#initArray(32),
@@ -244,8 +251,8 @@ export class LZMA {
     }
     #create(valueLow, valueHigh) {
         let diffHigh, diffLow;
-        valueHigh %= 1.8446744073709552E19;
-        valueLow %= 1.8446744073709552E19;
+        valueHigh %= this.#MAX_UINT64;
+        valueLow %= this.#MAX_UINT64;
         diffHigh = valueHigh % this.#MAX_UINT32;
         diffLow = Math.floor(valueLow / this.#MAX_UINT32) * this.#MAX_UINT32;
         valueHigh = valueHigh - diffHigh + diffLow;
@@ -254,16 +261,16 @@ export class LZMA {
             valueLow += this.#MAX_UINT32;
             valueHigh -= this.#MAX_UINT32;
         }
-        while (valueLow > 4294967295) {
+        while (valueLow > this.#MAX_UINT32) {
             valueLow -= this.#MAX_UINT32;
             valueHigh += this.#MAX_UINT32;
         }
-        valueHigh = valueHigh % 1.8446744073709552E19;
-        while (valueHigh > 9223372032559808512) {
-            valueHigh -= 1.8446744073709552E19;
+        valueHigh = valueHigh % this.#MAX_UINT64;
+        while (valueHigh > this.#MAX_INT64) {
+            valueHigh -= this.#MAX_UINT64;
         }
-        while (valueHigh < -9223372036854775808) {
-            valueHigh += 1.8446744073709552E19;
+        while (valueHigh < this.#MIN_INT64) {
+            valueHigh += this.#MAX_UINT64;
         }
         return [valueLow, valueHigh];
     }
@@ -303,13 +310,13 @@ export class LZMA {
             throw new Error("Neg");
         }
         twoToN = this.#pwrAsDouble(n);
-        newHigh = a[1] * twoToN % 1.8446744073709552E19;
+        newHigh = a[1] * twoToN % this.#MAX_UINT64;
         newLow = a[0] * twoToN;
         diff = newLow - newLow % this.#MAX_UINT32;
         newHigh += diff;
         newLow -= diff;
         if (newHigh >= this.#MAX_COMPRESSION_SIZE) {
-            newHigh -= 1.8446744073709552E19;
+            newHigh -= this.#MAX_UINT64;
         }
         return [newLow, newHigh];
     }
@@ -351,12 +358,12 @@ export class LZMA {
         data.length = output.count;
         return data;
     }
-    #write(obj, b) {
-        obj.buf[obj.count++] = b << 24 >> 24;
+    #write(buffer, b) {
+        buffer.buf[buffer.count++] = b & 0xFF;
     }
-    #write_0(obj, buf, off, len) {
-        this.#arraycopy(buf, off, obj.buf, obj.count, len);
-        obj.count += len;
+    #write_0(buffer, buf, off, len) {
+        this.#arraycopy(buf, off, buffer.buf, buffer.count, len);
+        buffer.count += len;
     }
     #getChars(inputString, srcBegin, srcEnd, dst, dstBegin) {
         for (let srcIdx = srcBegin; srcIdx < srcEnd; ++srcIdx) {
@@ -409,9 +416,9 @@ export class LZMA {
         this.#FillAlignPrices(this.#encoder);
         // Configure length encoders
         this.#encoder._lenEncoder._tableSize = this.#encoder._numFastBytes + 1 - 2;
-        this.#UpdateTables(this.#encoder._lenEncoder, 1 << this.#encoder._posStateBits);
+        this.#LZMA_LenPriceTableEncoder_UpdateTablesUpdateTables(this.#encoder._lenEncoder, 1 << this.#encoder._posStateBits);
         this.#encoder._repMatchLenEncoder._tableSize = this.#encoder._numFastBytes + 1 - 2;
-        this.#UpdateTables(this.#encoder._repMatchLenEncoder, 1 << this.#encoder._posStateBits);
+        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
@@ -444,7 +451,7 @@ export class LZMA {
             if (r == -1) {
                 throw new Error("truncated input");
             }
-            properties[i] = r << 24 >> 24;
+            properties[i] = r & 0xFF;
         }
         if (!this.#SetDecoderProperties(properties)) {
             throw new Error("corrupted input");
@@ -474,7 +481,7 @@ export class LZMA {
              */
             tmp_length = parseInt(hex_length, 16);
             // If the length is too long to handle, just set it to unknown.
-            if (tmp_length > 4294967295) {
+            if (tmp_length > this.#_MAX_UINT32) {
                 this.#compressor.length_0 = this.#N1_LONG_LIT;
             }
             else {
@@ -513,26 +520,27 @@ export class LZMA {
             + index];
     }
     #GetMatchLen(index, distance, limit) {
-        if (this.#compressor.chunker.encoder._matchFinder._streamEndWasReached) {
-            if (this.#compressor.chunker.encoder._matchFinder._pos + index + limit
-                > this.#compressor.chunker.encoder._matchFinder._streamPos) {
-                limit = this.#compressor.chunker.encoder._matchFinder._streamPos
-                    - (this.#compressor.chunker.encoder._matchFinder._pos + index);
+        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 = this.#compressor.chunker.encoder._matchFinder._bufferOffset
-            + this.#compressor.chunker.encoder._matchFinder._pos
+        let i, pby = encoder._matchFinder._bufferOffset
+            + encoder._matchFinder._pos
             + index;
         for (i = 0; i < limit
-            && this.#compressor.chunker.encoder._matchFinder._bufferBase[pby + i]
-                == this.#compressor.chunker.encoder._matchFinder._bufferBase[pby + i - distance]; ++i)
+            && encoder._matchFinder._bufferBase[pby + i]
+                == encoder._matchFinder._bufferBase[pby + i - distance]; ++i)
             ;
         return i;
     }
     #GetNumAvailableBytes() {
-        return (this.#compressor.chunker.encoder._matchFinder._streamPos
-            - this.#compressor.chunker.encoder._matchFinder._pos);
+        const encoder = this.#compressor.chunker.encoder;
+        return encoder._matchFinder._streamPos - encoder._matchFinder._pos;
     }
     #MoveBlock() {
         const matchFinder = this.#compressor.chunker.encoder._matchFinder;
@@ -592,7 +600,7 @@ export class LZMA {
         this.#compressor.chunker.encoder._matchFinder._streamPos -= subValue;
     }
     #Create_3(keepAddBufferBefore, keepAddBufferAfter) {
-        if (this.#encoder._dictionarySize < 1073741567) {
+        if (this.#encoder._dictionarySize < this.#dictionarySizeThreshold) {
             this.#encoder._matchFinder._cutValue = 16 + (this.#encoder._numFastBytes >> 1);
             const windowReservSize = ~~((this.#encoder._dictionarySize
                 + keepAddBufferBefore
@@ -796,7 +804,7 @@ export class LZMA {
     }
     #Skip(num) {
         const matchFinder = this.#compressor.chunker.encoder._matchFinder;
-        var count, cur, curMatch, cyclicPos, delta, hash2Value, hash3Value, hashValue, len, len0, len1, lenLimit, matchMinPos, pby1, ptr0, ptr1, temp;
+        let count, cur, curMatch, cyclicPos, delta, hash2Value, hash3Value, hashValue, len, len0, len1, lenLimit, matchMinPos, pby1, ptr0, ptr1, temp;
         do {
             if (matchFinder._pos + matchFinder._matchMaxLen <= matchFinder._streamPos) {
                 lenLimit = matchFinder._matchMaxLen;
@@ -886,11 +894,11 @@ export class LZMA {
             outputWindow._pos += 1;
             pos += 1;
             if (outputWindow._pos >= outputWindow._windowSize) {
-                this.#Flush_0(outputWindow);
+                this.#Flush_0();
             }
         }
     }
-    #Create_5(m_OutWindow, windowSize) {
+    #OutWindow_Create(m_OutWindow, windowSize) {
         if (m_OutWindow._buffer == null || m_OutWindow._windowSize != windowSize) {
             m_OutWindow._buffer = this.#initArray(windowSize);
         }
@@ -898,35 +906,35 @@ export class LZMA {
         m_OutWindow._pos = 0;
         m_OutWindow._streamPos = 0;
     }
-    #Flush_0(obj) {
-        var size = obj._pos - obj._streamPos;
+    #Flush_0() {
+        let size = this.#decoder.m_OutWindow._pos - this.#decoder.m_OutWindow._streamPos;
         if (!size) {
             return;
         }
-        this.#write_0(obj._stream, obj._buffer, obj._streamPos, size);
-        if (obj._pos >= obj._windowSize) {
-            obj._pos = 0;
+        this.#write_0(this.#decoder.m_OutWindow._stream, this.#decoder.m_OutWindow._buffer, this.#decoder.m_OutWindow._streamPos, size);
+        if (this.#decoder.m_OutWindow._pos >= this.#decoder.m_OutWindow._windowSize) {
+            this.#decoder.m_OutWindow._pos = 0;
         }
-        obj._streamPos = obj._pos;
+        this.#decoder.m_OutWindow._streamPos = this.#decoder.m_OutWindow._pos;
     }
     #GetByte(distance) {
         const outputWindow = this.#decompressor.chunker.decoder.m_OutWindow;
-        var pos = outputWindow._pos - distance - 1;
+        let pos = outputWindow._pos - distance - 1;
         if (pos < 0) {
             pos += outputWindow._windowSize;
         }
         return outputWindow._buffer[pos];
     }
-    #PutByte(obj, b) {
-        obj._buffer[obj._pos] = b;
-        obj._pos += 1;
-        if (obj._pos >= obj._windowSize) {
-            this.#Flush_0(obj);
+    #PutByte(b) {
+        this.#decoder.m_OutWindow._buffer[this.#decoder.m_OutWindow._pos] = b;
+        this.#decoder.m_OutWindow._pos += 1;
+        if (this.#decoder.m_OutWindow._pos >= this.#decoder.m_OutWindow._windowSize) {
+            this.#Flush_0();
         }
     }
-    #ReleaseStream(obj) {
-        this.#Flush_0(obj);
-        obj._stream = null;
+    #OutWindow_ReleaseStream() {
+        this.#Flush_0();
+        this.#decoder.m_OutWindow._stream = null;
     }
     GetLenToPosState(len) {
         len -= 2;
@@ -969,8 +977,8 @@ export class LZMA {
         if (result
             || this.#compare(decoder.outSize, this.#P0_LONG_LIT) >= 0
                 && this.#compare(decoder.nowPos64, decoder.outSize) >= 0) {
-            this.#Flush_0(decoder.m_OutWindow);
-            this.#ReleaseStream(decoder.m_OutWindow);
+            this.#Flush_0();
+            this.#OutWindow_ReleaseStream();
             decoder.m_RangeDecoder.Stream = null;
             this.#decompressor.chunker.alive = 0;
         }
@@ -993,7 +1001,7 @@ export class LZMA {
     }
     #CodeInChunks(inStream, outSize) {
         this.#decoder.m_RangeDecoder.Stream = inStream;
-        this.#ReleaseStream(this.#decoder.m_OutWindow);
+        this.#OutWindow_ReleaseStream();
         this.#decoder.m_OutWindow._stream = this.#decompressor.output;
         this.#Init_1();
         this.#decoder.state = 0;
@@ -1022,7 +1030,7 @@ export class LZMA {
             else {
                 decoder.prevByte = this.#DecodeWithMatchByte(decoder2, this.#GetByte(decoder.rep0));
             }
-            this.#PutByte(decoder.m_OutWindow, decoder.prevByte);
+            this.#PutByte(decoder.prevByte);
             decoder.state = this.StateUpdateChar(decoder.state);
             decoder.nowPos64 = this.#add(decoder.nowPos64, this.#P1_LONG_LIT);
         }
@@ -1065,7 +1073,7 @@ export class LZMA {
                 decoder.rep1 = decoder.rep0;
                 len = 2 + this.#Decode(decoder.m_LenDecoder, posState);
                 decoder.state = decoder.state < 7 ? 7 : 10;
-                positionSlot = this.#Decode_0(decoder.m_PosSlotDecoder[this.GetLenToPosState(len)]);
+                positionSlot = this.#RangeCoder_BitTreeDecoder_Decoder(decoder.m_PosSlotDecoder[this.GetLenToPosState(len)]);
                 if (positionSlot >= 4) {
                     numDirectBits = (positionSlot >> 1) - 1;
                     decoder.rep0 = (2 | positionSlot & 1) << numDirectBits;
@@ -1117,7 +1125,7 @@ export class LZMA {
         this.#Init_8();
     }
     #SetDecoderProperties(properties) {
-        var dictionarySize, i, lc, lp, pb, remainder, val;
+        let dictionarySize, i, lc, lp, pb, remainder, val;
         if (properties.length < 5) {
             return 0;
         }
@@ -1143,7 +1151,7 @@ export class LZMA {
         if (this.#decoder.m_DictionarySize != dictionarySize) {
             this.#decoder.m_DictionarySize = dictionarySize;
             this.#decoder.m_DictionarySizeCheck = Math.max(this.#decoder.m_DictionarySize, 1);
-            this.#Create_5(this.#decoder.m_OutWindow, Math.max(this.#decoder.m_DictionarySizeCheck, 4096));
+            this.#OutWindow_Create(this.#decoder.m_OutWindow, Math.max(this.#decoder.m_DictionarySizeCheck, 4096));
         }
         return 1;
     }
@@ -1152,7 +1160,7 @@ export class LZMA {
             return 0;
         }
         this.#Create_0(lp, lc);
-        var numPosStates = 1 << pb;
+        let numPosStates = 1 << pb;
         this.#Create(this.#decoder.m_LenDecoder, numPosStates);
         this.#Create(this.#decoder.m_RepLenDecoder, numPosStates);
         this.#decoder.m_PosStateMask = numPosStates - 1;
@@ -1164,34 +1172,36 @@ export class LZMA {
             decoder.m_MidCoder[decoder.m_NumPosStates] = this.#createBitTreeDecoder(3);
         }
     }
-    #Decode(obj, posState) {
-        if (!this.#decodeBit(obj.m_Choice, 0)) {
-            return this.#Decode_0(obj.m_LowCoder[posState]);
+    #Decode(decoder, posState) {
+        if (!this.#decodeBit(decoder.m_Choice, 0)) {
+            return this.#RangeCoder_BitTreeDecoder_Decoder(decoder.m_LowCoder[posState]);
         }
         let symbol = 8;
-        if (!this.#decodeBit(obj.m_Choice, 1)) {
-            symbol += this.#Decode_0(obj.m_MidCoder[posState]);
+        if (!this.#decodeBit(decoder.m_Choice, 1)) {
+            symbol += this.#RangeCoder_BitTreeDecoder_Decoder(decoder.m_MidCoder[posState]);
         }
         else {
-            symbol += 8 + this.#Decode_0(obj.m_HighCoder);
+            symbol += 8 + this.#RangeCoder_BitTreeDecoder_Decoder(decoder.m_HighCoder);
         }
         return symbol;
     }
-    #createLenDecoder(obj) {
-        obj.m_Choice = this.#initArray(2);
-        obj.m_LowCoder = this.#initArray(16);
-        obj.m_MidCoder = this.#initArray(16);
-        obj.m_HighCoder = this.#createBitTreeDecoder(8);
-        obj.m_NumPosStates = 0;
-        return obj;
+    #createLenDecoder() {
+        const decoder = {
+            m_Choice: this.#initArray(2),
+            m_LowCoder: this.#initArray(16),
+            m_MidCoder: this.#initArray(16),
+            m_HighCoder: this.#createBitTreeDecoder(8),
+            m_NumPosStates: 0,
+        };
+        return decoder;
     }
-    #Init(obj) {
-        this.InitBitModels(obj.m_Choice);
-        for (let posState = 0; posState < obj.m_NumPosStates; ++posState) {
-            this.InitBitModels(obj.m_LowCoder[posState].Models);
-            this.InitBitModels(obj.m_MidCoder[posState].Models);
+    #Init(decoder) {
+        this.InitBitModels(decoder.m_Choice);
+        for (let posState = 0; posState < decoder.m_NumPosStates; ++posState) {
+            this.InitBitModels(decoder.m_LowCoder[posState].Models);
+            this.InitBitModels(decoder.m_MidCoder[posState].Models);
         }
-        this.InitBitModels(obj.m_HighCoder.Models);
+        this.InitBitModels(decoder.m_HighCoder.Models);
     }
     #Create_0(numPosBits, numPrevBits) {
         let i, numStates;
@@ -1206,7 +1216,7 @@ export class LZMA {
         numStates = 1 << this.#decoder.m_LiteralDecoder.m_NumPrevBits + this.#decoder.m_LiteralDecoder.m_NumPosBits;
         this.#decoder.m_LiteralDecoder.m_Coders = this.#initArray(numStates);
         for (i = 0; i < numStates; ++i) {
-            this.#decoder.m_LiteralDecoder.m_Coders[i] = this.#createLiteralDecoderEncoder2({});
+            this.#decoder.m_LiteralDecoder.m_Coders[i] = this.#createLiteralDecoderEncoder2();
         }
     }
     #GetDecoder(pos, prevByte) {
@@ -1218,68 +1228,69 @@ export class LZMA {
         // Return decoder at calculated index
         return literalDecoder.m_Coders[index];
     }
-    #Init_0(obj) {
+    #Init_0(decoder) {
         let i, numStates;
-        numStates = 1 << obj.m_NumPrevBits + obj.m_NumPosBits;
+        numStates = 1 << decoder.m_NumPrevBits + decoder.m_NumPosBits;
         for (i = 0; i < numStates; ++i) {
-            this.InitBitModels(obj.m_Coders[i].m_Decoders);
+            this.InitBitModels(decoder.m_Coders[i].m_Decoders);
         }
     }
-    #DecodeNormal(rangeDecoder) {
-        const _rangeDecoder = this.#decompressor.chunker.decoder.m_RangeDecoder;
-        var symbol = 1;
+    #DecodeNormal(decoder) {
+        let symbol = 1;
         do {
-            symbol = symbol << 1 | this.#decodeBit(rangeDecoder.m_Decoders, symbol);
+            symbol = symbol << 1 | this.#decodeBit(decoder.m_Decoders, symbol);
         } while (symbol < 256);
-        return symbol << 24 >> 24;
+        return symbol & 0xFF;
     }
-    #DecodeWithMatchByte(obj, matchByte) {
+    #DecodeWithMatchByte(encoder, matchByte) {
         let bit, matchBit, symbol = 1;
         do {
             matchBit = matchByte >> 7 & 1;
             matchByte <<= 1;
-            bit = this.#decodeBit(obj.m_Decoders, (1 + matchBit << 8) + symbol);
+            bit = this.#decodeBit(encoder.m_Decoders, (1 + matchBit << 8) + symbol);
             symbol = symbol << 1 | bit;
             if (matchBit != bit) {
                 while (symbol < 256) {
-                    symbol = symbol << 1 | this.#decodeBit(obj.m_Decoders, symbol);
+                    symbol = symbol << 1 | this.#decodeBit(encoder.m_Decoders, symbol);
                 }
                 break;
             }
         } while (symbol < 256);
-        return symbol << 24 >> 24;
+        return symbol & 0xFF;
     }
-    #createLiteralDecoderEncoder2(obj) {
-        obj.m_Decoders = this.#initArray(768);
-        return obj;
+    #createLiteralDecoderEncoder2() {
+        const literalDecoder = {
+            m_Decoders: this.#initArray(0x300),
+        };
+        return literalDecoder;
     }
     #Backward(cur) {
-        const obj = this.#compressor.chunker.encoder;
+        const encoder = this.#compressor.chunker.encoder;
         let backCur, backMem, posMem, posPrev;
-        obj._optimumEndIndex = cur;
-        posMem = obj._optimum[cur].PosPrev;
-        backMem = obj._optimum[cur].BackPrev;
+        encoder._optimumEndIndex = cur;
+        posMem = encoder._optimum[cur].PosPrev;
+        backMem = encoder._optimum[cur].BackPrev;
         do {
-            if (obj._optimum[cur].Prev1IsChar) {
-                this.#MakeAsChar(obj._optimum[posMem]);
-                obj._optimum[posMem].PosPrev = posMem - 1;
-                if (obj._optimum[cur].Prev2) {
-                    obj._optimum[posMem - 1].Prev1IsChar = 0;
-                    obj._optimum[posMem - 1].PosPrev = obj._optimum[cur].PosPrev2;
-                    obj._optimum[posMem - 1].BackPrev = obj._optimum[cur].BackPrev2;
+            if (encoder._optimum[cur].Prev1IsChar) {
+                this.#MakeAsChar(encoder._optimum[posMem]);
+                encoder._optimum[posMem].PosPrev = posMem - 1;
+                if (encoder._optimum[cur].Prev2) {
+                    encoder._optimum[posMem - 1].Prev1IsChar = 0;
+                    encoder._optimum[posMem - 1].PosPrev = encoder._optimum[cur].PosPrev2;
+                    encoder._optimum[posMem - 1].BackPrev = encoder._optimum[cur].BackPrev2;
                 }
             }
             posPrev = posMem;
             backCur = backMem;
-            backMem = obj._optimum[posPrev].BackPrev;
-            posMem = obj._optimum[posPrev].PosPrev;
-            obj._optimum[posPrev].BackPrev = backCur;
-            obj._optimum[posPrev].PosPrev = cur;
+            backMem = encoder._optimum[posPrev].BackPrev;
+            posMem = encoder._optimum[posPrev].PosPrev;
+            encoder._optimum[posPrev].BackPrev = backCur;
+            encoder._optimum[posPrev].PosPrev = cur;
             cur = posPrev;
         } while (cur > 0);
-        obj.backRes = obj._optimum[0].BackPrev;
-        obj._optimumCurrentIndex = obj._optimum[0].PosPrev;
-        return obj._optimumCurrentIndex;
+        encoder.backRes = encoder._optimum[0].BackPrev;
+        encoder._optimumCurrentIndex = encoder._optimum[0].PosPrev;
+        return encoder._optimumCurrentIndex;
     }
     #BaseInit() {
         this.#encoder._state = 0;
@@ -1315,7 +1326,7 @@ export class LZMA {
             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.#GetSubCoder(this.#lowBits_0(this.#compressor.chunker.encoder.nowPos64), this.#compressor.chunker.encoder._previousByte), curByte);
+            this.#Encode_1(this.#LZMA_Encoder_GetSubCoder(this.#lowBits_0(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);
@@ -1333,7 +1344,7 @@ export class LZMA {
             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.#GetSubCoder(this.#lowBits_0(this.#compressor.chunker.encoder.nowPos64), this.#compressor.chunker.encoder._previousByte);
+                subCoder = this.#LZMA_Encoder_GetSubCoder(this.#lowBits_0(this.#compressor.chunker.encoder.nowPos64), this.#compressor.chunker.encoder._previousByte);
                 if (this.#compressor.chunker.encoder._state < 7) {
                     this.#Encode_1(subCoder, curByte);
                 }
@@ -1456,7 +1467,7 @@ export class LZMA {
             this.#SetType(binTree, numHashBytes);
             this.#encoder._matchFinder = binTree;
         }
-        this.#Create_1();
+        this.#LZMA_Encoder_LiteralEncoder_Create();
         if (this.#encoder._dictionarySize == this.#encoder._dictionarySizePrev
             && this.#encoder._numFastBytesPrev == this.#encoder._numFastBytes) {
             return;
@@ -1491,7 +1502,7 @@ export class LZMA {
             encoder = obj._posSlotEncoder[lenToPosState];
             st = lenToPosState << 6;
             for (posSlot = 0; posSlot < obj._distTableSize; posSlot += 1) {
-                obj._posSlotPrices[st + posSlot] = this.#GetPrice_1(encoder, posSlot);
+                obj._posSlotPrices[st + posSlot] = this.#RangeCoder_Encoder_GetPrice_1(encoder, posSlot);
             }
             for (posSlot = 14; posSlot < obj._distTableSize; posSlot += 1) {
                 obj._posSlotPrices[st + posSlot] += (posSlot >> 1) - 1 - 4 << 6;
@@ -1567,7 +1578,7 @@ export class LZMA {
         }
         encoder._optimum[0].State = encoder._state;
         posState = position & encoder._posStateMask;
-        encoder._optimum[1].Price = this.#probPrices[encoder._isMatch[(encoder._state << 4) + posState] >>> 2] + this.#GetPrice_0(this.#GetSubCoder(position, encoder._previousByte), encoder._state >= 7, matchByte, currentByte);
+        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);
         this.#MakeAsChar(encoder._optimum[1]);
         matchPrice = this.#probPrices[2_048
             - encoder._isMatch[(encoder._state << 4) + posState]
@@ -1594,7 +1605,7 @@ export class LZMA {
         encoder._optimum[0].Backs3 = encoder.reps[3];
         len = lenEnd;
         do {
-            encoder._optimum[len].Price = 268_435_455;
+            encoder._optimum[len].Price = this.#kIfinityPrice;
             len -= 1;
         } while (len >= 2);
         for (let i = 0; i < 4; ++i) {
@@ -1604,7 +1615,7 @@ export class LZMA {
             }
             price_4 = repMatchPrice + this.#GetPureRepPrice(i, encoder._state, posState);
             do {
-                curAndLenPrice = price_4 + this.#GetPrice(encoder._repMatchLenEncoder, repLen - 2, posState);
+                curAndLenPrice = price_4 + this.#RangeCoder_Encoder_GetPrice(encoder._repMatchLenEncoder, repLen - 2, posState);
                 optimum = encoder._optimum[repLen];
                 if (curAndLenPrice < optimum.Price) {
                     optimum.Price = curAndLenPrice;
@@ -1624,7 +1635,7 @@ export class LZMA {
             }
             for (;; len += 1) {
                 distance = encoder._matchDistances[offs + 1];
-                curAndLenPrice = normalMatchPrice + this.#GetPosLenPrice(distance, len, posState);
+                curAndLenPrice = normalMatchPrice + this.#LZMA_Encoder_GetPosLenPrice(distance, len, posState);
                 optimum = encoder._optimum[len];
                 if (curAndLenPrice < optimum.Price) {
                     optimum.Price = curAndLenPrice;
@@ -1743,7 +1754,7 @@ export class LZMA {
             posState = position & encoder._posStateMask;
             curAnd1Price = curPrice
                 + this.#probPrices[encoder._isMatch[(state << 4) + posState] >>> 2]
-                + this.#GetPrice_0(this.#GetSubCoder(position, this.#GetIndexByte(-2)), state >= 7, matchByte, currentByte);
+                + this.#RangeCoder_Encoder_GetPrice_0(this.#LZMA_Encoder_GetSubCoder(position, this.#GetIndexByte(-2)), state >= 7, matchByte, currentByte);
             nextOptimum = encoder._optimum[cur + 1];
             nextIsChar = 0;
             if (curAnd1Price < nextOptimum.Price) {
@@ -1786,9 +1797,9 @@ export class LZMA {
                     nextRepMatchPrice = curAnd1Price + this.#probPrices[2_048 - encoder._isMatch[(state2 << 4) + posStateNext] >>> 2] + this.#probPrices[2_048 - encoder._isRep[state2] >>> 2];
                     offset = cur + 1 + lenTest2;
                     while (lenEnd < offset) {
-                        encoder._optimum[lenEnd += 1].Price = 268_435_455;
+                        encoder._optimum[lenEnd += 1].Price = this.#kIfinityPrice;
                     }
-                    curAndLenPrice = nextRepMatchPrice + (price = this.#GetPrice(encoder._repMatchLenEncoder, lenTest2 - 2, posStateNext),
+                    curAndLenPrice = nextRepMatchPrice + (price = this.#RangeCoder_Encoder_GetPrice(encoder._repMatchLenEncoder, lenTest2 - 2, posStateNext),
                         price + this.#GetPureRepPrice(0, state2, posStateNext));
                     optimum = encoder._optimum[offset];
                     if (curAndLenPrice < optimum.Price) {
@@ -1809,9 +1820,9 @@ export class LZMA {
                 lenTestTemp = lenTest;
                 do {
                     while (lenEnd < cur + lenTest) {
-                        encoder._optimum[lenEnd += 1].Price = 268_435_455;
+                        encoder._optimum[lenEnd += 1].Price = this.#kIfinityPrice;
                     }
-                    curAndLenPrice = repMatchPrice + (price_0 = this.#GetPrice(encoder._repMatchLenEncoder, lenTest - 2, posState),
+                    curAndLenPrice = repMatchPrice + (price_0 = this.#RangeCoder_Encoder_GetPrice(encoder._repMatchLenEncoder, lenTest - 2, posState),
                         price_0 + this.#GetPureRepPrice(repIndex, state, posState));
                     optimum = encoder._optimum[cur + lenTest];
                     if (curAndLenPrice < optimum.Price) {
@@ -1831,18 +1842,18 @@ export class LZMA {
                     if (lenTest2 >= 2) {
                         state2 = state < 7 ? 8 : 11;
                         posStateNext = position + lenTest & encoder._posStateMask;
-                        curAndLenCharPrice = repMatchPrice + (price_1 = this.#GetPrice(encoder._repMatchLenEncoder, lenTest - 2, posState),
+                        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.#GetPrice_0(this.#GetSubCoder(position + lenTest, this.#GetIndexByte(lenTest - 1 - 1)), 1, this.#GetIndexByte(lenTest - 1 - (encoder.reps[repIndex] + 1)), this.#GetIndexByte(lenTest - 1));
+                            + this.#probPrices[encoder._isMatch[(state2 << 4) + posStateNext] >>> 2] + this.#RangeCoder_Encoder_GetPrice_0(this.#LZMA_Encoder_GetSubCoder(position + lenTest, this.#GetIndexByte(lenTest - 1 - 1)), 1, this.#GetIndexByte(lenTest - 1 - (encoder.reps[repIndex] + 1)), this.#GetIndexByte(lenTest - 1));
                         state2 = this.StateUpdateChar(state2);
                         posStateNext = position + lenTest + 1 & encoder._posStateMask;
                         nextMatchPrice = curAndLenCharPrice + this.#probPrices[2_048 - encoder._isMatch[(state2 << 4) + posStateNext] >>> 2];
                         nextRepMatchPrice = nextMatchPrice + this.#probPrices[2_048 - encoder._isRep[state2] >>> 2];
                         offset = cur + 1 + lenTest + lenTest2;
                         while (lenEnd < cur + offset) {
-                            encoder._optimum[lenEnd += 1].Price = 268_435_455;
+                            encoder._optimum[lenEnd += 1].Price = this.#kIfinityPrice;
                         }
-                        curAndLenPrice = nextRepMatchPrice + (price_2 = this.#GetPrice(encoder._repMatchLenEncoder, lenTest2 - 2, posStateNext),
+                        curAndLenPrice = nextRepMatchPrice + (price_2 = this.#RangeCoder_Encoder_GetPrice(encoder._repMatchLenEncoder, lenTest2 - 2, posStateNext),
                             price_2 + this.#GetPureRepPrice(0, state2, posStateNext));
                         optimum = encoder._optimum[cur + offset];
                         if (curAndLenPrice < optimum.Price) {
@@ -1866,7 +1877,7 @@ export class LZMA {
             if (newLen >= startLen) {
                 normalMatchPrice = matchPrice + this.#probPrices[encoder._isRep[state] >>> 2];
                 while (lenEnd < cur + newLen) {
-                    encoder._optimum[lenEnd += 1].Price = 268_435_455;
+                    encoder._optimum[lenEnd += 1].Price = this.#kIfinityPrice;
                 }
                 offs = 0;
                 while (startLen > encoder._matchDistances[offs]) {
@@ -1874,7 +1885,7 @@ export class LZMA {
                 }
                 for (lenTest = startLen;; lenTest += 1) {
                     curBack = encoder._matchDistances[offs + 1];
-                    curAndLenPrice = normalMatchPrice + this.#GetPosLenPrice(curBack, lenTest, posState);
+                    curAndLenPrice = normalMatchPrice + this.#LZMA_Encoder_GetPosLenPrice(curBack, lenTest, posState);
                     optimum = encoder._optimum[cur + lenTest];
                     if (curAndLenPrice < optimum.Price) {
                         optimum.Price = curAndLenPrice;
@@ -1889,7 +1900,7 @@ export class LZMA {
                             if (lenTest2 >= 2) {
                                 state2 = state < 7 ? 7 : 10;
                                 posStateNext = position + lenTest & encoder._posStateMask;
-                                curAndLenCharPrice = curAndLenPrice + this.#probPrices[encoder._isMatch[(state2 << 4) + posStateNext] >>> 2] + this.#GetPrice_0(this.#GetSubCoder(position + lenTest, this.#GetIndexByte(lenTest - 1 - 1)), 1, this.#GetIndexByte(lenTest - (curBack + 1) - 1), this.#GetIndexByte(lenTest - 1));
+                                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)), 1, this.#GetIndexByte(lenTest - (curBack + 1) - 1), this.#GetIndexByte(lenTest - 1));
                                 state2 = this.StateUpdateChar(state2);
                                 posStateNext = position + lenTest + 1 & encoder._posStateMask;
                                 nextMatchPrice = curAndLenCharPrice + this.#probPrices[2_048 - encoder._isMatch[(state2 << 4) + posStateNext]
@@ -1897,9 +1908,9 @@ export class LZMA {
                                 nextRepMatchPrice = nextMatchPrice + this.#probPrices[2_048 - encoder._isRep[state2] >>> 2];
                                 offset = lenTest + 1 + lenTest2;
                                 while (lenEnd < cur + offset) {
-                                    encoder._optimum[lenEnd += 1].Price = 268_435_455;
+                                    encoder._optimum[lenEnd += 1].Price = this.#kIfinityPrice;
                                 }
-                                curAndLenPrice = nextRepMatchPrice + (price_3 = this.#GetPrice(encoder._repMatchLenEncoder, lenTest2 - 2, posStateNext),
+                                curAndLenPrice = nextRepMatchPrice + (price_3 = this.#RangeCoder_Encoder_GetPrice(encoder._repMatchLenEncoder, lenTest2 - 2, posStateNext),
                                     price_3 + this.#GetPureRepPrice(0, state2, posStateNext));
                                 optimum = encoder._optimum[cur + offset];
                                 if (curAndLenPrice < optimum.Price) {
@@ -1922,19 +1933,20 @@ export class LZMA {
             }
         }
     }
-    #GetPosLenPrice(pos, len, posState) {
+    #LZMA_Encoder_GetPosLenPrice(pos, len, posState) {
+        const encoder = this.#compressor.chunker.encoder;
         let price, lenToPosState = this.GetLenToPosState(len);
         if (pos < 128) {
-            price = this.#compressor.chunker.encoder._distancesPrices[lenToPosState * 128 + pos];
+            price = encoder._distancesPrices[lenToPosState * 128 + pos];
         }
         else {
-            price = this.#compressor.chunker.encoder._posSlotPrices[(lenToPosState << 6) + this.GetPosSlot2(pos)]
-                + this.#compressor.chunker.encoder._alignPrices[pos & 15];
+            const position = (lenToPosState << 6) + this.GetPosSlot2(pos);
+            price = encoder._posSlotPrices[position] + encoder._alignPrices[pos & 15];
         }
-        return price + this.#GetPrice(this.#compressor.chunker.encoder._lenEncoder, len - 2, posState);
+        return price + this.#RangeCoder_Encoder_GetPrice(encoder._lenEncoder, len - 2, posState);
     }
     #GetPureRepPrice(repIndex, state, posState) {
-        var price;
+        let price;
         if (!repIndex) {
             price = this.#probPrices[this.#compressor.chunker.encoder._isRepG0[state] >>> 2];
             price += this.#probPrices[2_048 - this.#compressor.chunker.encoder._isRep0Long[(state << 4) + posState] >>> 2];
@@ -1985,23 +1997,16 @@ export class LZMA {
         }
     }
     #ReadMatchDistances() {
-        var lenRes = 0;
-        this.#compressor.chunker.encoder._numDistancePairs = this.#GetMatches();
-        if (this.#compressor.chunker.encoder._numDistancePairs > 0) {
-            lenRes = this
-                .#compressor
-                .chunker
-                .encoder
-                ._matchDistances[this.#compressor.chunker.encoder._numDistancePairs - 2];
-            if (lenRes == this.#compressor.chunker.encoder._numFastBytes) {
-                lenRes += this.#GetMatchLen(lenRes - 1, this
-                    .#compressor
-                    .chunker
-                    .encoder
-                    ._matchDistances[this.#compressor.chunker.encoder._numDistancePairs - 1], 273 - lenRes);
-            }
-        }
-        this.#compressor.chunker.encoder._additionalOffset += 1;
+        let lenRes = 0;
+        const encoder = this.#compressor.chunker.encoder;
+        encoder._numDistancePairs = this.#GetMatches();
+        if (encoder._numDistancePairs > 0) {
+            lenRes = encoder._matchDistances[encoder._numDistancePairs - 2];
+            if (lenRes == encoder._numFastBytes) {
+                lenRes += this.#GetMatchLen(lenRes - 1, encoder._matchDistances[encoder._numDistancePairs - 1], 273 - lenRes);
+            }
+        }
+        encoder._additionalOffset += 1;
         return lenRes;
     }
     #ReleaseMFStream() {
@@ -2016,7 +2021,8 @@ export class LZMA {
     }
     #SetDictionarySize_0(dictionarySize) {
         this.#encoder._dictionarySize = dictionarySize;
-        for (var dicLogSize = 0; dictionarySize > (1 << dicLogSize); ++dicLogSize)
+        let dicLogSize = 0;
+        for (; dictionarySize > (1 << dicLogSize); ++dicLogSize)
             ;
         this.#encoder._distTableSize = dicLogSize * 2;
     }
@@ -2049,7 +2055,7 @@ export class LZMA {
         this.#Encode_3(encoder._isRep, encoder._state, 0);
         encoder._state = encoder._state < 7 ? 7 : 10;
         this.#Encode_0(encoder._lenEncoder, 0, positionState);
-        var lenToPosState = this.GetLenToPosState(2);
+        let lenToPosState = this.GetLenToPosState(2);
         this.#Encode_2(encoder._posSlotEncoder[lenToPosState], 63);
         this.#EncodeDirectBits(67108863, 26);
         this.#ReverseEncode(15);
@@ -2072,21 +2078,21 @@ export class LZMA {
         }
         return this.#gFastPos[pos >> 26] + 52;
     }
-    #Encode(obj, symbol, posState) {
+    #Encode(encoder, symbol, posState) {
         if (symbol < 8) {
-            this.#Encode_3(obj._choice, 0, 0);
-            this.#Encode_2(obj._lowCoder[posState], symbol);
+            this.#Encode_3(encoder._choice, 0, 0);
+            this.#Encode_2(encoder._lowCoder[posState], symbol);
         }
         else {
             symbol -= 8;
-            this.#Encode_3(obj._choice, 0, 1);
+            this.#Encode_3(encoder._choice, 0, 1);
             if (symbol < 8) {
-                this.#Encode_3(obj._choice, 1, 0);
-                this.#Encode_2(obj._midCoder[posState], symbol);
+                this.#Encode_3(encoder._choice, 1, 0);
+                this.#Encode_2(encoder._midCoder[posState], symbol);
             }
             else {
-                this.#Encode_3(obj._choice, 1, 1);
-                this.#Encode_2(obj._highCoder, symbol - 8);
+                this.#Encode_3(encoder._choice, 1, 1);
+                this.#Encode_2(encoder._highCoder, symbol - 8);
             }
         }
     }
@@ -2110,34 +2116,34 @@ export class LZMA {
         }
         this.InitBitModels(obj._highCoder.Models);
     }
-    #SetPrices(obj, posState, numSymbols, prices, st) {
+    #SetPrices(encoder, posState, numSymbols, prices, st) {
         let a0, a1, b0, b1, i;
-        a0 = this.#probPrices[obj._choice[0] >>> 2];
-        a1 = this.#probPrices[2_048 - obj._choice[0] >>> 2];
-        b0 = a1 + this.#probPrices[obj._choice[1] >>> 2];
-        b1 = a1 + this.#probPrices[2_048 - obj._choice[1] >>> 2];
+        a0 = this.#probPrices[encoder._choice[0] >>> 2];
+        a1 = this.#probPrices[2_048 - encoder._choice[0] >>> 2];
+        b0 = a1 + this.#probPrices[encoder._choice[1] >>> 2];
+        b1 = a1 + this.#probPrices[2_048 - encoder._choice[1] >>> 2];
         i = 0;
         for (i = 0; i < 8; ++i) {
             if (i >= numSymbols) {
                 return;
             }
-            prices[st + i] = a0 + this.#GetPrice_1(obj._lowCoder[posState], i);
+            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.#GetPrice_1(obj._midCoder[posState], i - 8);
+            prices[st + i] = b0 + this.#RangeCoder_Encoder_GetPrice_1(encoder._midCoder[posState], i - 8);
         }
         for (; i < numSymbols; ++i) {
-            prices[st + i] = b1 + this.#GetPrice_1(obj._highCoder, i - 8 - 8);
+            prices[st + i] = b1 + this.#RangeCoder_Encoder_GetPrice_1(encoder._highCoder, i - 8 - 8);
         }
     }
-    #Encode_0(obj, symbol, posState) {
-        this.#Encode(obj, symbol, posState);
-        if ((obj._counters[posState] -= 1) == 0) {
-            this.#SetPrices(obj, posState, obj._tableSize, obj._prices, posState * 272);
-            obj._counters[posState] = obj._tableSize;
+    #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() {
@@ -2146,16 +2152,16 @@ export class LZMA {
         encoder._counters = [];
         return encoder;
     }
-    #GetPrice(obj, symbol, posState) {
-        return obj._prices[posState * 272 + symbol];
+    #RangeCoder_Encoder_GetPrice(encoder, symbol, posState) {
+        return encoder._prices[posState * 272 + symbol];
     }
-    #UpdateTables(obj, numPosStates) {
+    #LZMA_LenPriceTableEncoder_UpdateTablesUpdateTables(encoder, numPosStates) {
         for (let posState = 0; posState < numPosStates; ++posState) {
-            this.#SetPrices(obj, posState, obj._tableSize, obj._prices, posState * 272);
-            obj._counters[posState] = obj._tableSize;
+            this.#SetPrices(encoder, posState, encoder._tableSize, encoder._prices, posState * 272);
+            encoder._counters[posState] = encoder._tableSize;
         }
     }
-    #Create_1() {
+    #LZMA_Encoder_LiteralEncoder_Create() {
         let i, numStates;
         if (this.#encoder._literalEncoder.m_Coders != null
             && this.#encoder._literalEncoder.m_NumPrevBits == this.#encoder._numLiteralContextBits
@@ -2168,10 +2174,10 @@ export class LZMA {
         numStates = 1 << this.#encoder._literalEncoder.m_NumPrevBits + this.#encoder._literalEncoder.m_NumPosBits;
         this.#encoder._literalEncoder.m_Coders = this.#initArray(numStates);
         for (i = 0; i < numStates; ++i) {
-            this.#encoder._literalEncoder.m_Coders[i] = this.#createLiteralEncoderEncoder2({});
+            this.#encoder._literalEncoder.m_Coders[i] = this.#createLiteralEncoderEncoder2();
         }
     }
-    #GetSubCoder(pos, prevByte) {
+    #LZMA_Encoder_GetSubCoder(pos, prevByte) {
         const literalEncoder = this.#compressor.chunker.encoder._literalEncoder;
         // Calculate position mask bits
         const posBits = pos & literalEncoder.m_PosMask;
@@ -2190,15 +2196,15 @@ export class LZMA {
             this.InitBitModels(this.#encoder._literalEncoder.m_Coders[i].m_Encoders);
         }
     }
-    #Encode_1(obj, symbol) {
-        var bit, context = 1;
+    #Encode_1(encoder, symbol) {
+        let bit, context = 1;
         for (let i = 7; i >= 0; --i) {
             bit = symbol >> i & 1;
-            this.#Encode_3(obj.m_Encoders, context, bit);
+            this.#Encode_3(encoder.m_Encoders, context, bit);
             context = context << 1 | bit;
         }
     }
-    #EncodeMatched(obj, matchByte, symbol) {
+    #EncodeMatched(encoder, matchByte, symbol) {
         let bit, matchBit, state, same = true, context = 1;
         for (let i = 7; i >= 0; --i) {
             bit = symbol >> i & 1;
@@ -2208,21 +2214,23 @@ export class LZMA {
                 state += 1 + matchBit << 8;
                 same = matchBit === bit;
             }
-            this.#Encode_3(obj.m_Encoders, state, bit);
+            this.#Encode_3(encoder.m_Encoders, state, bit);
             context = context << 1 | bit;
         }
     }
-    #createLiteralEncoderEncoder2(obj) {
-        obj.m_Encoders = this.#initArray(768);
-        return obj;
+    #createLiteralEncoderEncoder2() {
+        const encoder = {
+            m_Encoders: this.#initArray(768),
+        };
+        return encoder;
     }
-    #GetPrice_0(obj, matchMode, matchByte, symbol) {
+    #RangeCoder_Encoder_GetPrice_0(encoder, matchMode, matchByte, symbol) {
         let bit, context = 1, i = 7, matchBit, price = 0;
         if (matchMode) {
             for (; i >= 0; --i) {
                 matchBit = matchByte >> i & 1;
                 bit = symbol >> i & 1;
-                price += this.GetPrice(obj.m_Encoders[(1 + matchBit << 8) + context], bit);
+                price += this.GetPrice(encoder.m_Encoders[(1 + matchBit << 8) + context], bit);
                 context = context << 1 | bit;
                 if (matchBit != bit) {
                     --i;
@@ -2232,18 +2240,18 @@ export class LZMA {
         }
         for (; i >= 0; --i) {
             bit = symbol >> i & 1;
-            price += this.GetPrice(obj.m_Encoders[context], bit);
+            price += this.GetPrice(encoder.m_Encoders[context], bit);
             context = context << 1 | bit;
         }
         return price;
     }
-    #MakeAsChar(obj) {
-        obj.BackPrev = -1;
-        obj.Prev1IsChar = 0;
+    #MakeAsChar(optimum) {
+        optimum.BackPrev = -1;
+        optimum.Prev1IsChar = 0;
     }
-    #MakeAsShortRep(obj) {
-        obj.BackPrev = 0;
-        obj.Prev1IsChar = 0;
+    #MakeAsShortRep(optimum) {
+        optimum.BackPrev = 0;
+        optimum.Prev1IsChar = 0;
     }
     #createBitTreeDecoder(numBitLevels) {
         return {
@@ -2251,8 +2259,7 @@ export class LZMA {
             Models: this.#initArray(1 << numBitLevels),
         };
     }
-    // BitTreeDecoder.Decoder
-    #Decode_0(rangeDecoder) {
+    #RangeCoder_BitTreeDecoder_Decoder(rangeDecoder) {
         const _rangeDecoder = this.#decompressor.chunker.decoder.m_RangeDecoder;
         let bitIndex, m = 1;
         for (bitIndex = rangeDecoder.NumBitLevels; bitIndex != 0; bitIndex -= 1) {
@@ -2288,28 +2295,28 @@ export class LZMA {
             Models: this.#initArray(1 << numBitLevels),
         };
     }
-    #Encode_2(obj, symbol) {
-        var bit, bitIndex, m = 1;
-        for (bitIndex = obj.NumBitLevels; bitIndex != 0;) {
+    #Encode_2(encoder, symbol) {
+        let bit, bitIndex, m = 1;
+        for (bitIndex = encoder.NumBitLevels; bitIndex != 0;) {
             bitIndex -= 1;
             bit = symbol >>> bitIndex & 1;
-            this.#Encode_3(obj.Models, m, bit);
+            this.#Encode_3(encoder.Models, m, bit);
             m = m << 1 | bit;
         }
     }
-    #GetPrice_1(obj, symbol) {
-        var bit, bitIndex, m = 1, price = 0;
-        for (bitIndex = obj.NumBitLevels; bitIndex != 0;) {
+    #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(obj.Models[m], bit);
+            price += this.GetPrice(encoder.Models[m], bit);
             m = (m << 1) + bit;
         }
         return price;
     }
     #ReverseEncode(symbol) {
         const posAlignEncoder = this.#compressor.chunker.encoder._posAlignEncoder;
-        var bit, m = 1;
+        let bit, m = 1;
         for (let i = 0; i < posAlignEncoder.NumBitLevels; ++i) {
             bit = symbol & 1;
             this.#Encode_3(posAlignEncoder.Models, m, bit);
@@ -2326,18 +2333,18 @@ export class LZMA {
             symbol >>= 1;
         }
     }
-    #ReverseGetPrice(obj, symbol) {
+    #ReverseGetPrice(encoder, symbol) {
         let bit, m = 1, price = 0;
-        for (let i = obj.NumBitLevels; i != 0; i -= 1) {
+        for (let i = encoder.NumBitLevels; i != 0; i -= 1) {
             bit = symbol & 1;
             symbol >>>= 1;
-            price += this.GetPrice(obj.Models[m], bit);
+            price += this.GetPrice(encoder.Models[m], bit);
             m = m << 1 | bit;
         }
         return price;
     }
     ReverseGetPrice(Models, startIndex, NumBitLevels, symbol) {
-        var bit, m = 1, price = 0;
+        let bit, m = 1, price = 0;
         for (let i = NumBitLevels; i != 0; i -= 1) {
             bit = symbol & 1;
             symbol >>>= 1;
@@ -2353,7 +2360,7 @@ export class LZMA {
         if ((rangeDecoder.Code ^ this.#MIN_INT32) < (newBound ^ this.#MIN_INT32)) {
             rangeDecoder.Range = newBound;
             probs[index] = prob + (2_048 - prob >>> 5) << 16 >> 16;
-            if (!(rangeDecoder.Range & -16777216)) {
+            if (!(rangeDecoder.Range & this.bitMaskForRange)) {
                 rangeDecoder.Code = rangeDecoder.Code << 8 | this.#read(rangeDecoder.Stream);
                 rangeDecoder.Range <<= 8;
             }
@@ -2363,7 +2370,7 @@ export class LZMA {
             rangeDecoder.Range -= newBound;
             rangeDecoder.Code -= newBound;
             probs[index] = prob - (prob >>> 5) << 16 >> 16;
-            if (!(rangeDecoder.Range & -16777216)) {
+            if (!(rangeDecoder.Range & this.bitMaskForRange)) {
                 rangeDecoder.Code = rangeDecoder.Code << 8 | this.#read(rangeDecoder.Stream);
                 rangeDecoder.Range <<= 8;
             }
@@ -2378,7 +2385,7 @@ export class LZMA {
             let t = rangeDecoder.Code - rangeDecoder.Range >>> 31;
             rangeDecoder.Code -= rangeDecoder.Range & t - 1;
             result = result << 1 | 1 - t;
-            if (!(rangeDecoder.Range & -16777216)) {
+            if (!(rangeDecoder.Range & this.bitMaskForRange)) {
                 rangeDecoder.Code = rangeDecoder.Code << 8 | this.#read(rangeDecoder.Stream);
                 rangeDecoder.Range <<= 8;
             }
@@ -2400,18 +2407,18 @@ export class LZMA {
     }
     #Encode_3(probs, index, symbol) {
         const rangeEncoder = this.#compressor.chunker.encoder._rangeEncoder;
-        var newBound, prob = probs[index];
+        let newBound, prob = probs[index];
         newBound = (rangeEncoder.Range >>> 11) * prob;
         if (!symbol) {
             rangeEncoder.Range = newBound;
             probs[index] = prob + (2_048 - prob >>> 5) << 16 >> 16;
         }
         else {
-            rangeEncoder.Low = this.#add(rangeEncoder.Low, this.#and(this.#fromInt(newBound), [4294967295, 0]));
+            rangeEncoder.Low = this.#add(rangeEncoder.Low, this.#and(this.#fromInt(newBound), [this.#_MAX_UINT32, 0]));
             rangeEncoder.Range -= newBound;
             probs[index] = prob - (prob >>> 5) << 16 >> 16;
         }
-        if (!(rangeEncoder.Range & -16777216)) {
+        if (!(rangeEncoder.Range & this.bitMaskForRange)) {
             rangeEncoder.Range <<= 8;
             this.#ShiftLow();
         }
@@ -2423,7 +2430,7 @@ export class LZMA {
             if ((valueToEncode >>> i & 1) == 1) {
                 rangeEncoder.Low = this.#add(rangeEncoder.Low, this.#fromInt(rangeEncoder.Range));
             }
-            if (!(rangeEncoder.Range & -16777216)) {
+            if (!(rangeEncoder.Range & this.bitMaskForRange)) {
                 rangeEncoder.Range <<= 8;
                 this.#ShiftLow();
             }
@@ -2547,16 +2554,16 @@ export class LZMA {
         for (let i = 0; i < l; ++i) {
             ch = chars[i];
             if (ch >= 1 && ch <= 127) {
-                data[elen++] = ch << 24 >> 24;
+                data[elen++] = ch & 0xFF;
             }
             else if (!ch || ch >= 128 && ch <= 2047) {
-                data[elen++] = (192 | ch >> 6 & 31) << 24 >> 24;
-                data[elen++] = (128 | ch & 63) << 24 >> 24;
+                data[elen++] = (192 | ch >> 6 & 31) & 0xFF;
+                data[elen++] = (128 | ch & 63) & 0xFF;
             }
             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++] = (224 | ch >> 12 & 15) & 0xFF;
+                data[elen++] = (128 | ch >> 6 & 63) & 0xFF;
+                data[elen++] = (128 | ch & 63) & 0xFF;
             }
         }
         return data;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "lzma1",
 	"type": "module",
-	"version": "0.0.4",
+	"version": "0.5.0",
 	"license": "Apache-2.0",
 	"authors": [
 		"Filip Seman <filip.seman@pm.me>",
@@ -27,14 +27,12 @@
 		"fmt": "dprint fmt",
 		"fmt:check": "dprint check",
 		"typecheck": "tsc --noEmit",
-		"version": "git checkout develop && npm test",
-		"postversion": "echo 'Now run npm run build && npm publish'",
 		"test": "TS_NODE_TRANSPILE_ONLY=true node --no-warnings --test --test-reporter=spec --loader=ts-node/esm ./*.test.ts",
 		"test:watch": "TS_NODE_TRANSPILE_ONLY=true node --no-warnings --test --watch --test-reporter=spec --loader=ts-node/esm ./*.test.ts"
 	},
 	"dependencies": {},
 	"devDependencies": {
-		"@types/node": ">=18.8",
+		"@types/node": "^22.10.0",
 		"dprint": "~0.47.0",
 		"ts-node": "~10.9.0",
 		"typescript": "^5.7.0"