lzma1 0.0.4 → 0.4.0-next.0

package/dist/lzma.js

@@ -63,6 +63,7 @@ export class LZMA {
     #MIN_VALUE;
     #P0_LONG_LIT = [0, 0];
     #P1_LONG_LIT = [1, 0];
+    #kIfinityPrice = 268435455;
     CompressionModes = {
         1: { searchDepth: 16, filterStrength: 64, modeIndex: 0 },
         2: { searchDepth: 20, filterStrength: 64, modeIndex: 0 },
@@ -146,8 +147,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 +162,7 @@ export class LZMA {
                 alive: 0,
                 encoder: null,
                 decoder: null,
-                inBytesProcessed: [],
+                inBytesProcessed: [0, 0],
             },
             output: {
                 buf: this.#initArray(32),
@@ -175,7 +176,7 @@ export class LZMA {
                 alive: 0,
                 encoder: null,
                 decoder: null,
-                inBytesProcessed: [],
+                inBytesProcessed: [0, 0],
             },
             output: {
                 buf: this.#initArray(32),
@@ -409,9 +410,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
@@ -513,26 +514,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;
@@ -796,7 +798,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 +888,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 +900,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 +971,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 +995,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 +1024,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 +1067,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 +1119,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 +1145,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 +1154,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 +1166,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 +1210,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 +1222,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;
     }
-    #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;
     }
-    #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 +1320,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 +1338,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 +1461,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 +1496,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 +1572,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 +1599,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 +1609,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 +1629,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 +1748,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 +1791,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 +1814,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 +1836,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 +1871,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 +1879,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 +1894,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 +1902,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 +1927,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 +1991,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 +2015,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 +2049,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 +2072,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 +2110,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 +2146,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 +2168,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 +2190,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 +2208,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 +2234,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 +2253,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 +2289,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 +2327,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;
@@ -2400,7 +2401,7 @@ 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;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "lzma1",
 	"type": "module",
-	"version": "0.0.4",
+	"version": "0.4.0-next.0",
 	"license": "Apache-2.0",
 	"authors": [
 		"Filip Seman <filip.seman@pm.me>",
@@ -27,8 +27,6 @@
 		"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"
 	},