lzma1 0.2.0 → 0.3.0

package/lib/match-finder.js

@@ -0,0 +1,402 @@
+import { CRC32_TABLE, DICTIONARY_SIZE_THRESHOLD, } from "./utils.js";
+/**
+ * BinTreeMatchFinder — Binary tree match finder for LZMA encoding.
+ *
+ * Combines input window management, hash-based match finding, and
+ * binary tree search into a single cohesive class.
+ */
+export class BinTreeMatchFinder {
+    // Input window fields
+    _posLimit = 0;
+    _bufferBase = new Uint8Array(0);
+    _pos = 0;
+    _streamPos = 0;
+    _streamEndWasReached = 0;
+    _bufferOffset = 0;
+    _blockSize = 0;
+    _keepSizeBefore = 0;
+    _keepSizeAfter = 0;
+    _pointerToLastSafePosition = 0;
+    _stream = null;
+    // Hash and tree fields
+    HASH_ARRAY = true;
+    kNumHashDirectBytes = 0;
+    kMinMatchCheck = 4;
+    kFixHashSize = 66560;
+    _hashMask = 0;
+    _hashSizeSum = 0;
+    _hash = new Int32Array(0);
+    _cyclicBufferSize = 0;
+    _cyclicBufferPos = 0;
+    _son = new Int32Array(0);
+    _matchMaxLen = 0;
+    _cutValue = 0xff;
+    // --- LzInWindow methods ---
+    getIndexByte(index) {
+        return this._bufferBase[this._bufferOffset + this._pos + index];
+    }
+    getMatchLen(index, distance, limit) {
+        if (this._streamEndWasReached) {
+            if (this._pos + index + limit > this._streamPos) {
+                limit = this._streamPos - (this._pos + index);
+            }
+        }
+        ++distance;
+        let i;
+        const pby = this._bufferOffset + this._pos + index;
+        for (i = 0; i < limit
+            && this._bufferBase[pby + i]
+                == this._bufferBase[pby + i - distance]; ++i)
+            ;
+        return i;
+    }
+    getNumAvailableBytes() {
+        return this._streamPos - this._pos;
+    }
+    moveBlock() {
+        let offset = this._bufferOffset + this._pos - this._keepSizeBefore;
+        if (offset > 0) {
+            --offset;
+        }
+        const numBytes = this._bufferOffset + this._streamPos - offset;
+        this._bufferBase.copyWithin(0, offset, offset + numBytes);
+        this._bufferOffset -= offset;
+    }
+    movePosInWindow() {
+        this._pos += 1;
+        if (this._pos > this._posLimit) {
+            const pointerToPosition = this._bufferOffset + this._pos;
+            if (pointerToPosition > this._pointerToLastSafePosition) {
+                this.moveBlock();
+            }
+            this.readBlock();
+        }
+    }
+    readBlock() {
+        if (this._streamEndWasReached) {
+            return;
+        }
+        while (true) {
+            const size = -this._bufferOffset + this._blockSize - this._streamPos;
+            if (!size) {
+                return;
+            }
+            const bytesRead = this.readFromStream(this._bufferOffset + this._streamPos, size);
+            if (bytesRead == -1) {
+                this._posLimit = this._streamPos;
+                const pointerToPosition = this._bufferOffset + this._posLimit;
+                if (pointerToPosition > this._pointerToLastSafePosition) {
+                    this._posLimit = this._pointerToLastSafePosition - this._bufferOffset;
+                }
+                this._streamEndWasReached = 1;
+                return;
+            }
+            this._streamPos += bytesRead;
+            if (this._streamPos >= this._pos + this._keepSizeAfter) {
+                this._posLimit = this._streamPos - this._keepSizeAfter;
+            }
+        }
+    }
+    reduceOffsets(subValue) {
+        this._bufferOffset += subValue;
+        this._posLimit -= subValue;
+        this._pos -= subValue;
+        this._streamPos -= subValue;
+    }
+    readFromStream(off, len) {
+        const stream = this._stream;
+        const buffer = this._bufferBase;
+        return stream.readBytes(buffer, off, len);
+    }
+    // --- Match finder configuration methods ---
+    createBuffers(keepSizeBefore, keepSizeAfter, keepSizeReserv) {
+        this._keepSizeBefore = keepSizeBefore;
+        this._keepSizeAfter = keepSizeAfter;
+        const blockSize = keepSizeBefore + keepSizeAfter + keepSizeReserv;
+        if (this._blockSize != blockSize) {
+            this._bufferBase = new Uint8Array(blockSize);
+            this._blockSize = blockSize;
+        }
+        this._pointerToLastSafePosition = this._blockSize - keepSizeAfter;
+    }
+    create(dictionarySize, numFastBytes, keepAddBufferBefore, keepAddBufferAfter) {
+        if (dictionarySize < DICTIONARY_SIZE_THRESHOLD) {
+            this._cutValue = 0x10 + (numFastBytes >> 1);
+            const windowReservSize = ~~((dictionarySize + keepAddBufferBefore + numFastBytes + keepAddBufferAfter) / 2) + 0x100;
+            this.createBuffers(dictionarySize + keepAddBufferBefore, numFastBytes + keepAddBufferAfter, windowReservSize);
+            this._matchMaxLen = numFastBytes;
+            // Ensure cyclic buffer
+            const cyclicBufferSize = dictionarySize + 1;
+            if (this._cyclicBufferSize !== cyclicBufferSize) {
+                this._cyclicBufferSize = cyclicBufferSize;
+                this._son = new Int32Array(cyclicBufferSize * 2);
+            }
+            // Compute hash size
+            let hs = 0x10000;
+            if (this.HASH_ARRAY) {
+                hs = dictionarySize - 1;
+                hs |= hs >> 1;
+                hs |= hs >> 2;
+                hs |= hs >> 4;
+                hs |= hs >> 0x08;
+                hs >>= 1;
+                hs |= 0xFFFF;
+                if (hs > 0x1000000) {
+                    hs >>= 1;
+                }
+                this._hashMask = hs;
+                hs += 1;
+                const finalHashSizeSum = hs + this.kFixHashSize;
+                if (finalHashSizeSum !== this._hashSizeSum) {
+                    this._hashSizeSum = finalHashSizeSum;
+                    this._hash = new Int32Array(finalHashSizeSum);
+                }
+            }
+            else {
+                if (hs !== this._hashSizeSum) {
+                    this._hashSizeSum = hs;
+                    this._hash = new Int32Array(hs);
+                }
+            }
+        }
+    }
+    // --- Match finding methods ---
+    getMatches(distances) {
+        let count, cur, curMatch, curMatch2, curMatch3, cyclicPos, delta, hash2Value, hash3Value, hashValue, len, len0, len1, lenLimit, matchMinPos, maxLen, offset, pby1, ptr0, ptr1, temp;
+        if (this._pos + this._matchMaxLen <= this._streamPos) {
+            lenLimit = this._matchMaxLen;
+        }
+        else {
+            lenLimit = this._streamPos - this._pos;
+            if (lenLimit < this.kMinMatchCheck) {
+                this.movePos();
+                return 0;
+            }
+        }
+        offset = 0;
+        matchMinPos = this._pos > this._cyclicBufferSize
+            ? this._pos - this._cyclicBufferSize
+            : 0;
+        cur = this._bufferOffset + this._pos;
+        maxLen = 1;
+        hash2Value = 0;
+        hash3Value = 0;
+        if (this.HASH_ARRAY) {
+            temp = CRC32_TABLE[this._bufferBase[cur]] ^ this._bufferBase[cur + 1];
+            hash2Value = temp & 0x3FF;
+            temp ^= this._bufferBase[cur + 2] << 0x08;
+            hash3Value = temp & 0xFFFF;
+            hashValue = (temp ^ (CRC32_TABLE[this._bufferBase[cur + 3]] << 5)) & this._hashMask;
+        }
+        else {
+            hashValue = this._bufferBase[cur] ^ (this._bufferBase[cur + 1] << 0x08);
+        }
+        curMatch = this._hash[this.kFixHashSize + hashValue] || 0;
+        if (this.HASH_ARRAY) {
+            curMatch2 = this._hash[hash2Value] || 0;
+            curMatch3 = this._hash[0x400 + hash3Value] || 0;
+            this._hash[hash2Value] = this._pos;
+            this._hash[0x400 + hash3Value] = this._pos;
+            if (curMatch2 > matchMinPos) {
+                if (this._bufferBase[this._bufferOffset + curMatch2] == this._bufferBase[cur]) {
+                    distances[offset++] = maxLen = 2;
+                    distances[offset++] = this._pos - curMatch2 - 1;
+                }
+            }
+            if (curMatch3 > matchMinPos) {
+                if (this._bufferBase[this._bufferOffset + curMatch3] == this._bufferBase[cur]) {
+                    if (curMatch3 == curMatch2) {
+                        offset -= 2;
+                    }
+                    distances[offset++] = maxLen = 3;
+                    distances[offset++] = this._pos - curMatch3 - 1;
+                    curMatch2 = curMatch3;
+                }
+            }
+            if (offset != 0 && curMatch2 == curMatch) {
+                offset -= 2;
+                maxLen = 1;
+            }
+        }
+        this._hash[this.kFixHashSize + hashValue] = this._pos;
+        ptr0 = (this._cyclicBufferPos << 1) + 1;
+        ptr1 = this._cyclicBufferPos << 1;
+        len0 = len1 = this.kNumHashDirectBytes;
+        if (this.kNumHashDirectBytes != 0) {
+            if (curMatch > matchMinPos) {
+                if (this._bufferBase[this._bufferOffset + curMatch + this.kNumHashDirectBytes] != this._bufferBase[cur + this.kNumHashDirectBytes]) {
+                    distances[offset++] = maxLen = this.kNumHashDirectBytes;
+                    distances[offset++] = this._pos - curMatch - 1;
+                }
+            }
+        }
+        count = this._cutValue;
+        while (1) {
+            if (curMatch <= matchMinPos || count == 0) {
+                count -= 1;
+                this._son[ptr0] = this._son[ptr1] = 0;
+                break;
+            }
+            delta = this._pos - curMatch;
+            cyclicPos = (delta <= this._cyclicBufferPos
+                ? this._cyclicBufferPos - delta
+                : this._cyclicBufferPos - delta + this._cyclicBufferSize) << 1;
+            pby1 = this._bufferOffset + curMatch;
+            len = len0 < len1 ? len0 : len1;
+            if (this._bufferBase[pby1 + len] == this._bufferBase[cur + len]) {
+                while ((len += 1) != lenLimit) {
+                    if (this._bufferBase[pby1 + len] != this._bufferBase[cur + len]) {
+                        break;
+                    }
+                }
+                if (maxLen < len) {
+                    distances[offset++] = maxLen = len;
+                    distances[offset++] = delta - 1;
+                    if (len == lenLimit) {
+                        this._son[ptr1] = this._son[cyclicPos];
+                        this._son[ptr0] = this._son[cyclicPos + 1];
+                        break;
+                    }
+                }
+            }
+            if (this._bufferBase[pby1 + len] < this._bufferBase[cur + len]) {
+                this._son[ptr1] = curMatch;
+                ptr1 = cyclicPos + 1;
+                curMatch = this._son[ptr1];
+                len1 = len;
+            }
+            else {
+                this._son[ptr0] = curMatch;
+                ptr0 = cyclicPos;
+                curMatch = this._son[ptr0];
+                len0 = len;
+            }
+        }
+        this.movePos();
+        return offset;
+    }
+    skip(num) {
+        let count, cur, curMatch, cyclicPos, delta, hash2Value, hash3Value, hashValue, len, len0, len1, lenLimit, matchMinPos, pby1, ptr0, ptr1, temp;
+        do {
+            if (this._pos + this._matchMaxLen <= this._streamPos) {
+                lenLimit = this._matchMaxLen;
+            }
+            else {
+                lenLimit = this._streamPos - this._pos;
+                if (lenLimit < this.kMinMatchCheck) {
+                    this.movePos();
+                    continue;
+                }
+            }
+            matchMinPos = this._pos > this._cyclicBufferSize
+                ? this._pos - this._cyclicBufferSize
+                : 0;
+            cur = this._bufferOffset + this._pos;
+            if (this.HASH_ARRAY) {
+                temp = CRC32_TABLE[this._bufferBase[cur]] ^ this._bufferBase[cur + 1];
+                hash2Value = temp & 0x3FF;
+                this._hash[hash2Value] = this._pos;
+                temp ^= this._bufferBase[cur + 2] << 0x08;
+                hash3Value = temp & 0xFFFF;
+                this._hash[0x400 + hash3Value] = this._pos;
+                hashValue = (temp ^ (CRC32_TABLE[this._bufferBase[cur + 3]] << 5)) & this._hashMask;
+            }
+            else {
+                hashValue = this._bufferBase[cur] ^ (this._bufferBase[cur + 1] << 0x08);
+            }
+            curMatch = this._hash[this.kFixHashSize + hashValue];
+            this._hash[this.kFixHashSize + hashValue] = this._pos;
+            ptr0 = (this._cyclicBufferPos << 1) + 1;
+            ptr1 = this._cyclicBufferPos << 1;
+            len0 = len1 = this.kNumHashDirectBytes;
+            count = this._cutValue;
+            while (1) {
+                if (curMatch <= matchMinPos || count == 0) {
+                    count -= 1;
+                    this._son[ptr0] = this._son[ptr1] = 0;
+                    break;
+                }
+                delta = this._pos - curMatch;
+                cyclicPos = (delta <= this._cyclicBufferPos
+                    ? this._cyclicBufferPos - delta
+                    : this._cyclicBufferPos - delta + this._cyclicBufferSize) << 1;
+                pby1 = this._bufferOffset + curMatch;
+                len = len0 < len1 ? len0 : len1;
+                if (this._bufferBase[pby1 + len] == this._bufferBase[cur + len]) {
+                    while ((len += 1) != lenLimit) {
+                        if (this._bufferBase[pby1 + len] != this._bufferBase[cur + len]) {
+                            break;
+                        }
+                    }
+                    if (len == lenLimit) {
+                        this._son[ptr1] = this._son[cyclicPos];
+                        this._son[ptr0] = this._son[cyclicPos + 1];
+                        break;
+                    }
+                }
+                if (this._bufferBase[pby1 + len] < this._bufferBase[cur + len]) {
+                    this._son[ptr1] = curMatch;
+                    ptr1 = cyclicPos + 1;
+                    curMatch = this._son[ptr1];
+                    len1 = len;
+                }
+                else {
+                    this._son[ptr0] = curMatch;
+                    ptr0 = cyclicPos;
+                    curMatch = this._son[ptr0];
+                    len0 = len;
+                }
+            }
+            this.movePos();
+        } while ((num -= 1) != 0);
+    }
+    movePos() {
+        if ((this._cyclicBufferPos += 1) >= this._cyclicBufferSize) {
+            this._cyclicBufferPos = 0;
+        }
+        this.movePosInWindow();
+        if (this._pos == DICTIONARY_SIZE_THRESHOLD) {
+            const subValue = this._pos - this._cyclicBufferSize;
+            this.normalizeLinks(this._son, this._cyclicBufferSize * 2, subValue);
+            this.normalizeLinks(this._hash, this._hashSizeSum, subValue);
+            this.reduceOffsets(subValue);
+        }
+    }
+    init() {
+        this._bufferOffset = 0;
+        this._pos = 0;
+        this._streamPos = 0;
+        this._streamEndWasReached = 0;
+        this.readBlock();
+        this._cyclicBufferPos = 0;
+        this.reduceOffsets(-1);
+    }
+    /**
+     * This is only called after reading one whole gigabyte.
+     */
+    normalizeLinks(items, numItems, subValue) {
+        for (let i = 0; i < numItems; ++i) {
+            let value = items[i];
+            if (value <= subValue) {
+                value = 0;
+            }
+            else {
+                value -= subValue;
+            }
+            items[i] = value;
+        }
+    }
+    setType(numHashBytes) {
+        this.HASH_ARRAY = numHashBytes > 2;
+        if (this.HASH_ARRAY) {
+            this.kNumHashDirectBytes = 0;
+            this.kMinMatchCheck = 4;
+            this.kFixHashSize = 66560;
+        }
+        else {
+            this.kNumHashDirectBytes = 2;
+            this.kMinMatchCheck = 3;
+            this.kFixHashSize = 0;
+        }
+    }
+}

package/lib/range-decoder.js

@@ -26,7 +26,7 @@ export class RangeDecoder {
         newBound = (this.rrange >>> 11) * prob;
         if ((this.code ^ -0x80000000) < (newBound ^ -0x80000000)) {
             this.rrange = newBound;
-            probs[index] = prob + (2048 - prob >>> 5) << 16 >> 16;
+            probs[index] = prob + ((2048 - prob) >>> 5);
             if (!(this.rrange & -0x1000000)) {
                 this.code = this.code << 8 | this.readFromStream();
                 this.rrange <<= 8;
@@ -36,7 +36,7 @@ export class RangeDecoder {
         else {
             this.rrange -= newBound;
             this.code -= newBound;
-            probs[index] = prob - (prob >>> 5) << 16 >> 16;
+            probs[index] = prob - (prob >>> 5);
             if (!(this.rrange & -0x1000000)) {
                 this.code = this.code << 8 | this.readFromStream();
                 this.rrange <<= 8;
@@ -80,19 +80,6 @@ export class RangeDecoder {
         if (!this.stream) {
             return 0;
         }
-        if (this.stream.pos >= this.stream.count) {
-            return -1;
-        }
-        let value;
-        if (this.stream.buf instanceof ArrayBuffer) {
-            value = new Uint8Array(this.stream.buf)[this.stream.pos++];
-        }
-        else if (this.stream.buf instanceof Uint8Array) {
-            value = this.stream.buf[this.stream.pos++];
-        }
-        else {
-            value = this.stream.buf[this.stream.pos++];
-        }
-        return value & 0xFF;
+        return this.stream.readByte();
     }
 }

package/lib/range-encoder.js

@@ -1,11 +1,10 @@
-import { add64, fromInt64, lowBits64, } from "./utils.js";
 export class RangeEncoder {
     stream = null;
-    low = [0, 0];
+    low = 0n;
     rrange = 0;
     cache = 0;
     cacheSize = 0;
-    position = [0, 0];
+    position = 0n;
     constructor() {
         // Initialize with default values
     }
@@ -19,8 +18,8 @@ export class RangeEncoder {
      * Initialize range encoder
      */
     init() {
-        this.position = [0, 0];
-        this.low = [0, 0];
+        this.position = 0n;
+        this.low = 0n;
         this.rrange = -1;
         this.cacheSize = 1;
         this.cache = 0;
@@ -33,12 +32,12 @@ export class RangeEncoder {
         const newBound = (this.rrange >>> 11) * prob;
         if (bit === 0) {
             this.rrange = newBound;
-            probs[index] = prob + ((2048 - prob) >>> 5) << 16 >> 16;
+            probs[index] = prob + ((2048 - prob) >>> 5);
         }
         else {
-            this.low = add64(this.low, fromInt64(newBound));
+            this.low += BigInt(newBound);
             this.rrange -= newBound;
-            probs[index] = prob - (prob >>> 5) << 16 >> 16;
+            probs[index] = prob - (prob >>> 5);
         }
         if (!(this.rrange & -0x1000000)) {
             this.rrange <<= 8;
@@ -52,7 +51,7 @@ export class RangeEncoder {
         for (let i = numTotalBits - 1; i >= 0; i--) {
             this.rrange >>>= 1;
             if (((value >>> i) & 1) === 1) {
-                this.low = add64(this.low, fromInt64(this.rrange));
+                this.low += BigInt(this.rrange);
             }
             if (!(this.rrange & -0x1000000)) {
                 this.rrange <<= 8;
@@ -95,18 +94,18 @@ export class RangeEncoder {
      * Shift low value and write to stream
      */
     shiftLow() {
-        const lowHi = lowBits64([this.low[1], 0]);
-        if (lowHi !== 0 || this.low[0] < 0xFF000000) {
-            this.position = add64(this.position, fromInt64(this.cacheSize));
+        const lowHi = Number((this.low >> 32n) & 0xffffffffn);
+        if (lowHi !== 0 || Number(this.low & 0xffffffffn) < 0xFF000000) {
+            this.position += BigInt(this.cacheSize);
             let temp = this.cache;
             do {
                 this.writeToStream(temp + lowHi);
                 temp = 255;
             } while (--this.cacheSize !== 0);
-            this.cache = (this.low[0] >>> 24) & 0xFF;
+            this.cache = (Number(this.low & 0xffffffffn) >>> 24) & 0xFF;
         }
         this.cacheSize++;
-        this.low = [(this.low[0] & 0xFFFFFF) << 8, this.low[1]];
+        this.low = BigInt(Number(this.low & 0xffffffffn) & 0xFFFFFF) << 8n;
     }
     /**
      * Write byte to output stream
@@ -115,15 +114,6 @@ export class RangeEncoder {
         if (!this.stream) {
             return;
         }
-        // Ensure buffer has enough capacity
-        if (this.stream.count >= this.stream.buf.length) {
-            const newSize = Math.max(this.stream.buf.length * 2, this.stream.count + 1);
-            const newBuf = new Array(newSize);
-            for (let i = 0; i < this.stream.count; i++) {
-                newBuf[i] = this.stream.buf[i];
-            }
-            this.stream.buf = newBuf;
-        }
-        this.stream.buf[this.stream.count++] = value & 0xFF;
+        this.stream.writeByte(value & 0xFF);
     }
 }

package/lib/streams.js

@@ -1 +1,64 @@
-export {};
+/**
+ * Read-only input buffer wrapping a Uint8Array.
+ */
+export class InputBuffer {
+    buf;
+    pos = 0;
+    count;
+    constructor(data) {
+        this.buf = data;
+        this.count = data.length;
+    }
+    readByte() {
+        if (this.pos >= this.count)
+            return -1;
+        return this.buf[this.pos++] & 0xFF;
+    }
+    readBytes(dest, off, len) {
+        if (this.pos >= this.count)
+            return -1;
+        len = Math.min(len, this.count - this.pos);
+        dest.set(this.buf.subarray(this.pos, this.pos + len), off);
+        this.pos += len;
+        return len;
+    }
+    get remaining() {
+        return this.count - this.pos;
+    }
+}
+/**
+ * Growable output buffer backed by a Uint8Array.
+ */
+export class OutputBuffer {
+    buf;
+    count = 0;
+    constructor(capacity = 32) {
+        this.buf = new Uint8Array(capacity);
+    }
+    grow(requiredSize) {
+        const newSize = Math.max(this.buf.length * 2, requiredSize);
+        const newBuf = new Uint8Array(newSize);
+        newBuf.set(this.buf.subarray(0, this.count));
+        this.buf = newBuf;
+    }
+    writeByte(b) {
+        if (this.count >= this.buf.length) {
+            this.grow(this.count + 1);
+        }
+        this.buf[this.count++] = b;
+    }
+    writeBytes(src, off, len) {
+        const requiredSize = this.count + len;
+        if (requiredSize > this.buf.length) {
+            this.grow(requiredSize);
+        }
+        this.buf.set(src.subarray(off, off + len), this.count);
+        this.count += len;
+    }
+    write(buf) {
+        this.writeBytes(buf, 0, buf.length);
+    }
+    toArray() {
+        return this.buf.slice(0, this.count);
+    }
+}