lzma1 0.1.2 → 0.2.0

package/lib/index.d.ts

@@ -3,8 +3,9 @@
  * Copyright Filip Seman
  * SPDX-License-Identifier: MIT
  */
-import { LZMA } from "./lzma.js";
+import { type CompressionMode } from "./lzma.js";
 export { LZMA } from "./lzma.js";
+export { CRC32_TABLE } from "./utils.js";
 /**
  * Compresses data using LZMA algorithm
  *
@@ -12,7 +13,7 @@ export { LZMA } from "./lzma.js";
  * @param mode Compression mode (1-9), defaults to 5
  * @returns Compressed data as a byte array
  */
-export declare function compress(data: Uint8Array | ArrayBuffer, mode?: keyof LZMA["CompressionModes"]): Uint8Array;
+export declare function compress(data: Uint8Array | ArrayBuffer, mode?: CompressionMode): Uint8Array;
 /**
  * Compresses data using LZMA algorithm
  *
@@ -20,7 +21,7 @@ export declare function compress(data: Uint8Array | ArrayBuffer, mode?: keyof LZ
  * @param mode Compression mode (1-9), defaults to 5
  * @returns Compressed data as byte array
  */
-export declare function compressString(data: string, mode?: keyof LZMA["CompressionModes"]): Uint8Array;
+export declare function compressString(data: string, mode?: CompressionMode): Uint8Array;
 /**
  * Decompresses LZMA compressed data
  *

package/lib/index.js

@@ -3,8 +3,9 @@
  * Copyright Filip Seman
  * SPDX-License-Identifier: MIT
  */
-import { LZMA } from "./lzma.js";
+import { LZMA, } from "./lzma.js";
 export { LZMA } from "./lzma.js";
+export { CRC32_TABLE } from "./utils.js";
 /**
  * Compresses data using LZMA algorithm
  *
@@ -13,8 +14,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 +29,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 +39,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 +52,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.d.ts

@@ -0,0 +1,70 @@
+import { type BitTree } from "./utils.js";
+/**
+ * Range encoder interface for LenEncoder to communicate with
+ */
+export interface RangeEncoder {
+    encodeBit(probs: number[], index: number, symbol: number): void;
+    encodeBitTree(encoder: BitTree, symbol: number): void;
+}
+/**
+ * Length encoder class for LZMA compression
+ * Handles encoding of match lengths with price optimization
+ */
+export declare class LenEncoder {
+    private choice;
+    private lowCoder;
+    private midCoder;
+    private highCoder;
+    private tableSize;
+    private prices;
+    private counters;
+    constructor();
+    /**
+     * Initialize the encoder with specified number of position states
+     */
+    init(numPosStates: number): void;
+    /**
+     * Encode a length value using the provided range encoder
+     */
+    encode(symbol: number, posState: number, rangeEncoder: RangeEncoder): void;
+    /**
+     * Encode with price table update
+     */
+    encodeWithUpdate(symbol: number, posState: number, rangeEncoder: RangeEncoder): void;
+    /**
+     * Get price for encoding a symbol at the given position state
+     */
+    getPrice(symbol: number, posState: number): number;
+    /**
+     * Initialize as a price table encoder
+     */
+    initPriceTable(): void;
+    /**
+     * Set table size for price optimization
+     */
+    setTableSize(size: number): void;
+    /**
+     * Set table size and update internal counters
+     */
+    setTableSizeAndInitCounters(size: number, numPosStates: number): void;
+    /**
+     * Get table size
+     */
+    getTableSize(): number;
+    /**
+     * Update price tables for all position states
+     */
+    updateTables(numPosStates: number): void;
+    /**
+     * Calculate price for bit tree encoder
+     */
+    private getBitTreePrice;
+    /**
+     * Get price for a single bit
+     */
+    private getBitPrice;
+    /**
+     * Set prices for all symbols in a position state range
+     */
+    private setPrices;
+}

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.d.ts

@@ -0,0 +1,63 @@
+import { type BasicRangeDecoder, type BasicRangeEncoder } from "./utils.js";
+export declare class LitSubCoder {
+    private coders;
+    constructor();
+    /**
+     * Decode normal literal symbol
+     */
+    decodeNormal(rd: BasicRangeDecoder): number;
+    /**
+     * Decode literal symbol with match byte context
+     */
+    decodeWithMatchByte(rd: BasicRangeDecoder, matchByte: number): number;
+    /**
+     * Encode literal symbol
+     */
+    encode(re: BasicRangeEncoder, symbol: number): void;
+    /**
+     * Encode literal symbol with match byte context
+     */
+    encodeMatched(re: BasicRangeEncoder, matchByte: number, symbol: number): void;
+    /**
+     * Get price for encoding literal symbol
+     */
+    getPrice(matchMode: boolean, matchByte: number, symbol: number): number;
+    /**
+     * Reset coder to initial state
+     */
+    reset(): void;
+    /**
+     * Get decoders array (for compatibility with LiteralDecoderEncoder2)
+     */
+    get decoders(): number[];
+}
+export declare class LitCoder {
+    private _coders;
+    private _numPrevBits;
+    private _posMask;
+    constructor(numPosBits: number, numPrevBits: number);
+    /**
+     * Get sub-coder for position and previous byte
+     */
+    getSubCoder(pos: number, prevByte: number): LitSubCoder;
+    /**
+     * Reset all sub-coders
+     */
+    reset(): void;
+    /**
+     * Get number of previous bits (for compatibility)
+     */
+    get numPrevBits(): number;
+    /**
+     * Get number of position bits (for compatibility)
+     */
+    get numPosBits(): number;
+    /**
+     * Get position mask (for compatibility)
+     */
+    get posMask(): number;
+    /**
+     * Get coders array (for compatibility)
+     */
+    get coders(): LitSubCoder[];
+}

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-in-window.d.ts

@@ -0,0 +1,43 @@
+import { MatchFinder } from "./encoder.js";
+/**
+ * LzInWindow - Input Window helper for LZMA encoding
+ *
+ * This class manages the input window operations for LZMA encoding,
+ * including buffer management, position tracking, and input stream reading.
+ */
+export declare class LzInWindow {
+    private matchFinder;
+    constructor(matchFinder: MatchFinder);
+    /**
+     * Get a byte at the specified index relative to current position
+     */
+    getIndexByte(index: number): number;
+    /**
+     * Calculate match length between current position and a previous position
+     */
+    getMatchLen(index: number, distance: number, limit: number): number;
+    /**
+     * Get number of available bytes in the input window
+     */
+    getNumAvailableBytes(): number;
+    /**
+     * Move buffer block when reaching buffer boundaries
+     */
+    moveBlock(): void;
+    /**
+     * Move position by one and handle buffer management
+     */
+    movePos(): void;
+    /**
+     * Read a block of data from the input stream
+     */
+    readBlock(): void;
+    /**
+     * Reduce all position offsets by the specified value
+     */
+    reduceOffsets(subValue: number): void;
+    /**
+     * Read data from the input stream into the buffer
+     */
+    private readFromStream;
+}