lzma1 0.1.2 → 0.3.0

package/lib/index.js

@@ -3,8 +3,8 @@
  * Copyright Filip Seman
  * SPDX-License-Identifier: MIT
  */
-import { LZMA } from "./lzma.js";
-export { LZMA } from "./lzma.js";
+import { LZMA, } from "./lzma.js";
+export { CRC32_TABLE } from "./utils.js";
 /**
  * Compresses data using LZMA algorithm
  *
@@ -13,8 +13,12 @@ export { LZMA } from "./lzma.js";
  * @returns Compressed data as a byte array
  */
 export function compress(data, mode = 5) {
-    const lzma = new LZMA();
-    return new Uint8Array(lzma.compress(data, mode));
+    // Convert ArrayBuffer to Uint8Array if needed
+    const input = data instanceof ArrayBuffer
+        ? new Uint8Array(data)
+        : data;
+    const result = new LZMA().compress(input, mode);
+    return new Uint8Array(result);
 }
 /**
  * Compresses data using LZMA algorithm
@@ -24,8 +28,8 @@ export function compress(data, mode = 5) {
  * @returns Compressed data as byte array
  */
 export function compressString(data, mode = 5) {
-    const lzma = new LZMA();
-    return new Uint8Array(lzma.compressString(data, mode));
+    const compressedData = new LZMA().compressString(data, mode);
+    return new Uint8Array(compressedData);
 }
 /**
  * Decompresses LZMA compressed data
@@ -34,8 +38,11 @@ export function compressString(data, mode = 5) {
  * @returns Decompressed data
  */
 export function decompress(data) {
-    const lzma = new LZMA();
-    return new Uint8Array(lzma.decompress(data));
+    const input = data instanceof ArrayBuffer
+        ? new Uint8Array(data)
+        : data;
+    const decompressedData = new LZMA().decompress(input);
+    return new Uint8Array(decompressedData);
 }
 /**
  * Decompresses LZMA compressed data
@@ -44,6 +51,5 @@ export function decompress(data) {
  * @returns Decompressed data as string
  */
 export function decompressString(data) {
-    const lzma = new LZMA();
-    return lzma.decompressString(data);
+    return new LZMA().decompressString(data);
 }

package/lib/len-coder.js

@@ -0,0 +1,171 @@
+import { createBitTree, getBitPrice, initArray, initBitModels, } from "./utils.js";
+/**
+ * Length encoder class for LZMA compression
+ * Handles encoding of match lengths with price optimization
+ */
+export class LenEncoder {
+    // Choice probability arrays for length range selection
+    choice = initArray(2);
+    // Low range coders (for lengths 2-9)
+    lowCoder = [];
+    // Mid range coders (for lengths 10-17)
+    midCoder = [];
+    // High range coder (for lengths 18+)
+    highCoder = createBitTree(8);
+    // Price optimization properties
+    tableSize = 0;
+    prices = [];
+    counters = [];
+    constructor() {
+        // Initialize low and mid coders for all position states (up to 16)
+        for (let posState = 0; posState < 16; ++posState) {
+            this.lowCoder[posState] = createBitTree(3);
+            this.midCoder[posState] = createBitTree(3);
+        }
+    }
+    /**
+     * Initialize the encoder with specified number of position states
+     */
+    init(numPosStates) {
+        // Initialize choice probability models
+        initBitModels(this.choice);
+        // Initialize low and mid coders for each position state
+        for (let posState = 0; posState < numPosStates; ++posState) {
+            initBitModels(this.lowCoder[posState].models);
+            initBitModels(this.midCoder[posState].models);
+        }
+        // Initialize high coder
+        initBitModels(this.highCoder.models);
+    }
+    /**
+     * Encode a length value using the provided range encoder
+     */
+    encode(symbol, posState, rangeEncoder) {
+        if (symbol < 8) {
+            // Length 2-9: use low coder
+            rangeEncoder.encodeBit(this.choice, 0, 0);
+            rangeEncoder.encodeBitTree(this.lowCoder[posState], symbol);
+        }
+        else {
+            symbol -= 8;
+            rangeEncoder.encodeBit(this.choice, 0, 1);
+            if (symbol < 8) {
+                // Length 10-17: use mid coder
+                rangeEncoder.encodeBit(this.choice, 1, 0);
+                rangeEncoder.encodeBitTree(this.midCoder[posState], symbol);
+            }
+            else {
+                // Length 18+: use high coder
+                rangeEncoder.encodeBit(this.choice, 1, 1);
+                rangeEncoder.encodeBitTree(this.highCoder, symbol - 8);
+            }
+        }
+    }
+    /**
+     * Encode with price table update
+     */
+    encodeWithUpdate(symbol, posState, rangeEncoder) {
+        this.encode(symbol, posState, rangeEncoder);
+        if (this.counters && (this.counters[posState] -= 1) == 0) {
+            // Reset counter and update prices if needed
+            this.counters[posState] = this.tableSize;
+        }
+    }
+    /**
+     * Get price for encoding a symbol at the given position state
+     */
+    getPrice(symbol, posState) {
+        return this.prices[posState * 0x110 + symbol];
+    }
+    /**
+     * Initialize as a price table encoder
+     */
+    initPriceTable() {
+        this.prices = [];
+        this.counters = [];
+    }
+    /**
+     * Set table size for price optimization
+     */
+    setTableSize(size) {
+        this.tableSize = size;
+    }
+    /**
+     * Set table size and update internal counters
+     */
+    setTableSizeAndInitCounters(size, numPosStates) {
+        this.tableSize = size;
+        if (this.counters) {
+            for (let posState = 0; posState < numPosStates; ++posState) {
+                this.counters[posState] = size;
+            }
+        }
+    }
+    /**
+     * Get table size
+     */
+    getTableSize() {
+        return this.tableSize;
+    }
+    /**
+     * Update price tables for all position states
+     */
+    updateTables(numPosStates) {
+        if (!this.prices || !this.counters) {
+            this.initPriceTable();
+        }
+        for (let posState = 0; posState < numPosStates; ++posState) {
+            this.setPrices(posState, this.tableSize, this.prices, 0);
+            if (this.counters) {
+                this.counters[posState] = this.tableSize;
+            }
+        }
+    }
+    // Private methods for internal state management
+    /**
+     * Calculate price for bit tree encoder
+     */
+    getBitTreePrice(encoder, symbol) {
+        let bit, bitIndex, m = 1, price = 0;
+        for (bitIndex = encoder.numBitLevels; bitIndex != 0;) {
+            bitIndex -= 1;
+            bit = symbol >>> bitIndex & 1;
+            price += this.getBitPrice(encoder.models[m], bit);
+            m = (m << 1) + bit;
+        }
+        return price;
+    }
+    /**
+     * Get price for a single bit
+     */
+    getBitPrice(prob, symbol) {
+        return getBitPrice(prob, symbol);
+    }
+    /**
+     * Set prices for all symbols in a position state range
+     */
+    setPrices(posState, numSymbols, prices, priceIndex) {
+        const a0 = this.getBitPrice(this.choice[0], 0);
+        const a1 = this.getBitPrice(this.choice[0], 1);
+        const b0 = a1 + this.getBitPrice(this.choice[1], 0);
+        const b1 = a1 + this.getBitPrice(this.choice[1], 1);
+        let i = 0;
+        const st = priceIndex + posState * 0x110;
+        // Set prices for low range (lengths 2-9)
+        for (i = 0; i < 8; ++i) {
+            if (i >= numSymbols)
+                return;
+            prices[st + i] = a0 + this.getBitTreePrice(this.lowCoder[posState], i);
+        }
+        // Set prices for mid range (lengths 10-17)
+        for (; i < 16; ++i) {
+            if (i >= numSymbols)
+                return;
+            prices[st + i] = b0 + this.getBitTreePrice(this.midCoder[posState], i - 8);
+        }
+        // Set prices for high range (lengths 18+)
+        for (; i < numSymbols; ++i) {
+            prices[st + i] = b1 + this.getBitTreePrice(this.highCoder, i - 8 - 8);
+        }
+    }
+}

package/lib/lit-coder.js

@@ -0,0 +1,162 @@
+import { getBitPrice, initArray, } from "./utils.js";
+export class LitSubCoder {
+    coders;
+    constructor() {
+        this.coders = initArray(0x300, 0x400);
+    }
+    /**
+     * Decode normal literal symbol
+     */
+    decodeNormal(rd) {
+        let symbol = 1;
+        while (symbol < 0x100) {
+            const i = rd.decodeBit(this.coders, symbol);
+            symbol = (symbol << 1) | i;
+        }
+        return symbol & 0xFF;
+    }
+    /**
+     * Decode literal symbol with match byte context
+     */
+    decodeWithMatchByte(rd, matchByte) {
+        let uMatchByte = matchByte;
+        let symbol = 1;
+        while (symbol < 0x100) {
+            const matchBit = (uMatchByte >> 7) & 1;
+            uMatchByte <<= 1;
+            const bit = rd.decodeBit(this.coders, ((1 + matchBit) << 8) + symbol);
+            symbol = (symbol << 1) | bit;
+            if (matchBit !== bit) {
+                while (symbol < 0x100) {
+                    const i = rd.decodeBit(this.coders, symbol);
+                    symbol = (symbol << 1) | i;
+                }
+                break;
+            }
+        }
+        return symbol & 0xFF;
+    }
+    /**
+     * Encode literal symbol
+     */
+    encode(re, symbol) {
+        let context = 1;
+        for (let i = 7; i >= 0; i--) {
+            const bit = (symbol >> i) & 1;
+            re.encodeBit(this.coders, context, bit);
+            context = (context << 1) | bit;
+        }
+    }
+    /**
+     * Encode literal symbol with match byte context
+     */
+    encodeMatched(re, matchByte, symbol) {
+        let uMatchByte = matchByte;
+        let context = 1;
+        let same = true;
+        for (let i = 7; i >= 0; i--) {
+            const bit = (symbol >> i) & 1;
+            let state = context;
+            if (same) {
+                const matchBit = (uMatchByte >> i) & 1;
+                state += (1 + matchBit) << 8;
+                same = matchBit === bit;
+            }
+            re.encodeBit(this.coders, state, bit);
+            context = (context << 1) | bit;
+        }
+    }
+    /**
+     * Get price for encoding literal symbol
+     */
+    getPrice(matchMode, matchByte, symbol) {
+        let uMatchByte = matchByte;
+        let price = 0;
+        let context = 1;
+        let i = 7;
+        if (matchMode) {
+            while (i >= 0) {
+                const matchBit = (uMatchByte >> i) & 1;
+                const bit = (symbol >> i) & 1;
+                price += getBitPrice(this.coders[(1 + matchBit) << 8 + context], bit);
+                context = (context << 1) | bit;
+                if (matchBit !== bit) {
+                    i--;
+                    break;
+                }
+                i--;
+            }
+        }
+        while (i >= 0) {
+            const bit = (symbol >> i) & 1;
+            price += getBitPrice(this.coders[context], bit);
+            context = (context << 1) | bit;
+            i--;
+        }
+        return price;
+    }
+    /**
+     * Reset coder to initial state
+     */
+    reset() {
+        this.coders.fill(1024);
+    }
+    /**
+     * Get decoders array (for compatibility with LiteralDecoderEncoder2)
+     */
+    get decoders() {
+        return this.coders;
+    }
+}
+export class LitCoder {
+    _coders;
+    _numPrevBits;
+    _posMask;
+    constructor(numPosBits, numPrevBits) {
+        const numStates = 1 << (numPrevBits + numPosBits);
+        this._coders = [];
+        this._numPrevBits = numPrevBits;
+        this._posMask = (1 << numPosBits) - 1;
+        for (let i = 0; i < numStates; i++) {
+            this._coders[i] = new LitSubCoder();
+        }
+    }
+    /**
+     * Get sub-coder for position and previous byte
+     */
+    getSubCoder(pos, prevByte) {
+        return this._coders[((pos & this._posMask) << this._numPrevBits)
+            + (prevByte >> (8 - this._numPrevBits))];
+    }
+    /**
+     * Reset all sub-coders
+     */
+    reset() {
+        this._coders.forEach((coder) => coder.reset());
+    }
+    /**
+     * Get number of previous bits (for compatibility)
+     */
+    get numPrevBits() {
+        return this._numPrevBits;
+    }
+    /**
+     * Get number of position bits (for compatibility)
+     */
+    get numPosBits() {
+        // Calculate from posMask
+        return Math.log2(this._posMask + 1);
+    }
+    /**
+     * Get position mask (for compatibility)
+     */
+    get posMask() {
+        return this._posMask;
+    }
+    /**
+     * Get coders array (for compatibility)
+     */
+    get coders() {
+        return this._coders;
+    }
+}

package/lib/lz-window.js

@@ -0,0 +1,88 @@
+export class LzOutWindow {
+    buffer = null;
+    pos = 0;
+    streamPos = 0;
+    stream = null;
+    windowSize = 0;
+    // Private Go-style properties
+    w = null;
+    buf;
+    constructor(writer = null, windowSize = 4096) {
+        this.w = writer;
+        this.stream = writer;
+        this.windowSize = windowSize;
+        this.buf = new Uint8Array(windowSize);
+        this.buffer = this.buf;
+        this.pos = 0;
+        this.streamPos = 0;
+    }
+    /**
+     * Copy a block of data from a previous position (LZ77-style)
+     */
+    copyBlock(distance, length) {
+        if (!this.buffer)
+            return;
+        for (let i = 0; i < length; i++) {
+            // Get byte from previous position
+            let sourcePos = this.pos - distance - 1;
+            if (sourcePos < 0) {
+                sourcePos += this.windowSize;
+            }
+            const byte = this.buffer[sourcePos];
+            this.putByte(byte);
+        }
+    }
+    /**
+     * Put a single byte into the window
+     */
+    putByte(byte) {
+        if (!this.buffer)
+            return;
+        this.buffer[this.pos] = byte;
+        this.pos++;
+        this.streamPos++;
+        if (this.pos >= this.windowSize) {
+            this.flush();
+        }
+    }
+    /**
+     * Get a byte from a relative position
+     */
+    getByte(relativePos) {
+        if (!this.buffer)
+            return 0;
+        let pos = this.pos + relativePos;
+        if (pos < 0) {
+            pos += this.windowSize;
+        }
+        else if (pos >= this.windowSize) {
+            pos -= this.windowSize;
+        }
+        return this.buffer[pos];
+    }
+    /**
+     * Flush buffered data to output writer
+     */
+    flush() {
+        if (this.w && this.buffer && this.pos > 0) {
+            this.w.writeBytes(this.buffer, 0, this.pos);
+            this.pos = 0;
+        }
+    }
+    /**
+     * Check if the window is empty
+     */
+    isEmpty() {
+        return this.streamPos === 0;
+    }
+    /**
+     * Reset the window
+     */
+    reset() {
+        this.pos = 0;
+        this.streamPos = 0;
+        if (this.buffer) {
+            this.buffer.fill(0);
+        }
+    }
+}