lzma1 0.1.2 → 0.2.0

package/lib/match-finder-config.d.ts

@@ -0,0 +1,34 @@
+import type { MatchFinder } from "./encoder.js";
+/**
+ * Match finder configuration helpers
+ * Pure functions extracted from LZMA class for better modularity
+ */
+/**
+ * Compute window reservation size for match finder buffer allocation
+ */
+export declare function computeWindowReservSize(dictionarySize: number, keepBefore: number, numFastBytes: number, keepAfter: number): number;
+/**
+ * Ensure cyclic buffer is properly sized and allocated
+ */
+export declare function ensureCyclicBuffer(matchFinder: MatchFinder, dictionarySize: number): void;
+interface HashSizeConfig {
+    hashMask: number;
+    hashSizeSum: number;
+}
+/**
+ * Compute hash size for match finder hash table
+ */
+export declare function computeHashSize(dictionarySize: number, hashArrayEnabled: boolean): HashSizeConfig;
+/**
+ * Set cut value for match finder based on fast bytes setting
+ */
+export declare function setCutValue(numFastBytes: number): number;
+/**
+ * Set maximum match length for match finder
+ */
+export declare function setMatchMaxLen(numFastBytes: number): number;
+/**
+ * Check if dictionary size is below threshold requiring special handling
+ */
+export declare function isDictionarySizeBelowThreshold(dictionarySize: number): boolean;
+export {};

package/lib/match-finder-config.js

@@ -0,0 +1,63 @@
+import { DICTIONARY_SIZE_THRESHOLD, initArray, } from "./utils.js";
+/**
+ * Match finder configuration helpers
+ * Pure functions extracted from LZMA class for better modularity
+ */
+/**
+ * Compute window reservation size for match finder buffer allocation
+ */
+export function computeWindowReservSize(dictionarySize, keepBefore, numFastBytes, keepAfter) {
+    return ~~((dictionarySize + keepBefore + numFastBytes + keepAfter) / 2) + 0x100;
+}
+/**
+ * Ensure cyclic buffer is properly sized and allocated
+ */
+export function ensureCyclicBuffer(matchFinder, dictionarySize) {
+    const cyclicBufferSize = dictionarySize + 1;
+    if (matchFinder._cyclicBufferSize !== cyclicBufferSize) {
+        const doubledCyclicBufferSize = (matchFinder._cyclicBufferSize = cyclicBufferSize) * 2;
+        matchFinder._son = initArray(doubledCyclicBufferSize);
+    }
+}
+/**
+ * Compute hash size for match finder hash table
+ */
+export function computeHashSize(dictionarySize, hashArrayEnabled) {
+    let hs = 0x10000;
+    let hashMask = 0;
+    if (hashArrayEnabled) {
+        hs = dictionarySize - 1;
+        hs |= hs >> 1;
+        hs |= hs >> 2;
+        hs |= hs >> 4;
+        hs |= hs >> 0x08;
+        hs >>= 1;
+        hs |= 0xFFFF;
+        if (hs > 0x1000000) {
+            hs >>= 1;
+        }
+        hashMask = hs;
+        hs += 1;
+        // Add kFixHashSize (assumed to be available on matchFinder)
+        // This will be passed in from the calling context
+    }
+    return { hashMask, hashSizeSum: hs };
+}
+/**
+ * Set cut value for match finder based on fast bytes setting
+ */
+export function setCutValue(numFastBytes) {
+    return 0x10 + (numFastBytes >> 1);
+}
+/**
+ * Set maximum match length for match finder
+ */
+export function setMatchMaxLen(numFastBytes) {
+    return numFastBytes;
+}
+/**
+ * Check if dictionary size is below threshold requiring special handling
+ */
+export function isDictionarySizeBelowThreshold(dictionarySize) {
+    return dictionarySize < DICTIONARY_SIZE_THRESHOLD;
+}

package/lib/range-bit-tree-coder.d.ts

@@ -0,0 +1,34 @@
+import { type BasicRangeDecoder, type BasicRangeEncoder } from "./utils.js";
+export declare class RangeBitTreeCoder {
+    private models;
+    private numBitLevels;
+    constructor(numBitLevels: number);
+    /**
+     * Decode symbol using range decoder
+     */
+    decode(rd: BasicRangeDecoder): number;
+    /**
+     * Reverse decode symbol using range decoder
+     */
+    reverseDecode(rd: BasicRangeDecoder): number;
+    /**
+     * Encode symbol using range encoder
+     */
+    encode(re: BasicRangeEncoder, symbol: number): void;
+    /**
+     * Reverse encode symbol using range encoder
+     */
+    reverseEncode(re: BasicRangeEncoder, symbol: number): void;
+    /**
+     * Get price for encoding symbol
+     */
+    getPrice(symbol: number): number;
+    /**
+     * Get price for reverse encoding symbol
+     */
+    reverseGetPrice(symbol: number): number;
+    /**
+     * Reset models to initial state
+     */
+    reset(): void;
+}

package/lib/range-bit-tree-coder.js

@@ -0,0 +1,95 @@
+import { getBitPrice, initArray, } from "./utils.js";
+export class RangeBitTreeCoder {
+    models;
+    numBitLevels;
+    constructor(numBitLevels) {
+        this.numBitLevels = numBitLevels;
+        this.models = initArray(1 << numBitLevels, 1024); // Initialize with default probability
+    }
+    /**
+     * Decode symbol using range decoder
+     */
+    decode(rd) {
+        let res = 1;
+        for (let bitIndex = this.numBitLevels; bitIndex !== 0; bitIndex--) {
+            const bit = rd.decodeBit(this.models, res);
+            res = (res << 1) + bit;
+        }
+        res -= 1 << this.numBitLevels;
+        return res;
+    }
+    /**
+     * Reverse decode symbol using range decoder
+     */
+    reverseDecode(rd) {
+        let index = 1;
+        let res = 0;
+        for (let bitIndex = 0; bitIndex < this.numBitLevels; bitIndex++) {
+            const bit = rd.decodeBit(this.models, index);
+            index <<= 1;
+            index += bit;
+            res |= bit << bitIndex;
+        }
+        return res;
+    }
+    /**
+     * Encode symbol using range encoder
+     */
+    encode(re, symbol) {
+        let m = 1;
+        for (let bitIndex = this.numBitLevels; bitIndex !== 0;) {
+            bitIndex--;
+            const bit = (symbol >> bitIndex) & 1;
+            re.encodeBit(this.models, m, bit);
+            m = (m << 1) | bit;
+        }
+    }
+    /**
+     * Reverse encode symbol using range encoder
+     */
+    reverseEncode(re, symbol) {
+        let m = 1;
+        for (let i = 0; i < this.numBitLevels; i++) {
+            const bit = symbol & 1;
+            re.encodeBit(this.models, m, bit);
+            m = (m << 1) | bit;
+            symbol >>= 1;
+        }
+    }
+    /**
+     * Get price for encoding symbol
+     */
+    getPrice(symbol) {
+        let res = 0;
+        let m = 1;
+        for (let bitIndex = this.numBitLevels; bitIndex !== 0;) {
+            bitIndex--;
+            const bit = (symbol >> bitIndex) & 1;
+            res += getBitPrice(this.models[m], bit);
+            m = (m << 1) + bit;
+        }
+        return res;
+    }
+    /**
+     * Get price for reverse encoding symbol
+     */
+    reverseGetPrice(symbol) {
+        let res = 0;
+        let m = 1;
+        for (let i = this.numBitLevels; i !== 0; i--) {
+            const bit = symbol & 1;
+            symbol >>= 1;
+            res += getBitPrice(this.models[m], bit);
+            m = (m << 1) | bit;
+        }
+        return res;
+    }
+    /**
+     * Reset models to initial state
+     */
+    reset() {
+        for (let i = 0; i < this.models.length; i++) {
+            this.models[i] = 1024; // Default probability
+        }
+    }
+}

package/lib/range-decoder.d.ts

@@ -0,0 +1,34 @@
+import type { BaseStream } from "./streams.js";
+export declare class RangeDecoder {
+    stream: BaseStream | null;
+    code: number;
+    rrange: number;
+    /**
+     * Set input stream for decoding
+     */
+    setStream(stream: BaseStream | null): void;
+    /**
+     * Initialize range decoder
+     */
+    init(): void;
+    /**
+     * Decode a single bit using probability model
+     */
+    decodeBit(probs: number[], index: number): 0 | 1;
+    /**
+     * Decode direct bits (without probability model)
+     */
+    decodeDirectBits(numTotalBits: number): number;
+    /**
+     * Get current code value (for compatibility)
+     */
+    get currentCode(): number;
+    /**
+     * Get current range value (for compatibility)
+     */
+    get currentRange(): number;
+    /**
+     * Read a single byte from the input stream
+     */
+    private readFromStream;
+}

package/lib/range-decoder.js

@@ -0,0 +1,98 @@
+export class RangeDecoder {
+    stream = null;
+    code = 0;
+    rrange = 0;
+    /**
+     * Set input stream for decoding
+     */
+    setStream(stream) {
+        this.stream = stream;
+    }
+    /**
+     * Initialize range decoder
+     */
+    init() {
+        this.code = 0;
+        this.rrange = -1;
+        for (let i = 0; i < 5; ++i) {
+            this.code = this.code << 8 | this.readFromStream();
+        }
+    }
+    /**
+     * Decode a single bit using probability model
+     */
+    decodeBit(probs, index) {
+        let newBound, prob = probs[index];
+        newBound = (this.rrange >>> 11) * prob;
+        if ((this.code ^ -0x80000000) < (newBound ^ -0x80000000)) {
+            this.rrange = newBound;
+            probs[index] = prob + (2048 - prob >>> 5) << 16 >> 16;
+            if (!(this.rrange & -0x1000000)) {
+                this.code = this.code << 8 | this.readFromStream();
+                this.rrange <<= 8;
+            }
+            return 0;
+        }
+        else {
+            this.rrange -= newBound;
+            this.code -= newBound;
+            probs[index] = prob - (prob >>> 5) << 16 >> 16;
+            if (!(this.rrange & -0x1000000)) {
+                this.code = this.code << 8 | this.readFromStream();
+                this.rrange <<= 8;
+            }
+            return 1;
+        }
+    }
+    /**
+     * Decode direct bits (without probability model)
+     */
+    decodeDirectBits(numTotalBits) {
+        let result = 0;
+        for (let i = numTotalBits; i != 0; i -= 1) {
+            this.rrange >>>= 1;
+            let t = (this.code - this.rrange) >>> 31;
+            this.code -= this.rrange & (t - 1);
+            result = result << 1 | 1 - t;
+            if (!(this.rrange & -0x1000000)) {
+                this.code = this.code << 8 | this.readFromStream();
+                this.rrange <<= 8;
+            }
+        }
+        return result;
+    }
+    /**
+     * Get current code value (for compatibility)
+     */
+    get currentCode() {
+        return this.code;
+    }
+    /**
+     * Get current range value (for compatibility)
+     */
+    get currentRange() {
+        return this.rrange;
+    }
+    /**
+     * Read a single byte from the input stream
+     */
+    readFromStream() {
+        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;
+    }
+}

package/lib/range-encoder.d.ts

@@ -0,0 +1,46 @@
+import type { BufferWithCount } from "./streams.js";
+export declare class RangeEncoder {
+    private stream;
+    private low;
+    private rrange;
+    private cache;
+    private cacheSize;
+    private position;
+    constructor();
+    /**
+     * Set output stream for encoding
+     */
+    setStream(stream: BufferWithCount | null): void;
+    /**
+     * Initialize range encoder
+     */
+    init(): void;
+    /**
+     * Encode a single bit using probability model
+     */
+    encodeBit(probs: number[], index: number, bit: number): void;
+    /**
+     * Encode direct bits (without probability model)
+     */
+    encodeDirectBits(value: number, numTotalBits: number): void;
+    /**
+     * Encode bit tree symbol
+     */
+    encodeBitTree(numBitLevels: number, models: number[], symbol: number, startIndex?: number): void;
+    /**
+     * Reverse encode bits
+     */
+    reverseEncodeBits(numBitLevels: number, models: number[], symbol: number, startIndex: number): void;
+    /**
+     * Finish encoding and flush remaining data
+     */
+    finish(): void;
+    /**
+     * Shift low value and write to stream
+     */
+    private shiftLow;
+    /**
+     * Write byte to output stream
+     */
+    private writeToStream;
+}

package/lib/range-encoder.js

@@ -0,0 +1,129 @@
+import { add64, fromInt64, lowBits64, } from "./utils.js";
+export class RangeEncoder {
+    stream = null;
+    low = [0, 0];
+    rrange = 0;
+    cache = 0;
+    cacheSize = 0;
+    position = [0, 0];
+    constructor() {
+        // Initialize with default values
+    }
+    /**
+     * Set output stream for encoding
+     */
+    setStream(stream) {
+        this.stream = stream;
+    }
+    /**
+     * Initialize range encoder
+     */
+    init() {
+        this.position = [0, 0];
+        this.low = [0, 0];
+        this.rrange = -1;
+        this.cacheSize = 1;
+        this.cache = 0;
+    }
+    /**
+     * Encode a single bit using probability model
+     */
+    encodeBit(probs, index, bit) {
+        const prob = probs[index];
+        const newBound = (this.rrange >>> 11) * prob;
+        if (bit === 0) {
+            this.rrange = newBound;
+            probs[index] = prob + ((2048 - prob) >>> 5) << 16 >> 16;
+        }
+        else {
+            this.low = add64(this.low, fromInt64(newBound));
+            this.rrange -= newBound;
+            probs[index] = prob - (prob >>> 5) << 16 >> 16;
+        }
+        if (!(this.rrange & -0x1000000)) {
+            this.rrange <<= 8;
+            this.shiftLow();
+        }
+    }
+    /**
+     * Encode direct bits (without probability model)
+     */
+    encodeDirectBits(value, numTotalBits) {
+        for (let i = numTotalBits - 1; i >= 0; i--) {
+            this.rrange >>>= 1;
+            if (((value >>> i) & 1) === 1) {
+                this.low = add64(this.low, fromInt64(this.rrange));
+            }
+            if (!(this.rrange & -0x1000000)) {
+                this.rrange <<= 8;
+                this.shiftLow();
+            }
+        }
+    }
+    /**
+     * Encode bit tree symbol
+     */
+    encodeBitTree(numBitLevels, models, symbol, startIndex = 1) {
+        let m = 1;
+        for (let bitIndex = numBitLevels; bitIndex !== 0; bitIndex--) {
+            const bit = (symbol >>> (bitIndex - 1)) & 1;
+            this.encodeBit(models, startIndex + m - 1, bit);
+            m = (m << 1) | bit;
+        }
+    }
+    /**
+     * Reverse encode bits
+     */
+    reverseEncodeBits(numBitLevels, models, symbol, startIndex) {
+        let m = 1;
+        for (let i = 0; i < numBitLevels; i++) {
+            const bit = symbol & 1;
+            this.encodeBit(models, startIndex + m, bit);
+            m = (m << 1) | bit;
+            symbol >>>= 1;
+        }
+    }
+    /**
+     * Finish encoding and flush remaining data
+     */
+    finish() {
+        for (let i = 0; i < 5; i++) {
+            this.shiftLow();
+        }
+    }
+    /**
+     * 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));
+            let temp = this.cache;
+            do {
+                this.writeToStream(temp + lowHi);
+                temp = 255;
+            } while (--this.cacheSize !== 0);
+            this.cache = (this.low[0] >>> 24) & 0xFF;
+        }
+        this.cacheSize++;
+        this.low = [(this.low[0] & 0xFFFFFF) << 8, this.low[1]];
+    }
+    /**
+     * Write byte to output stream
+     */
+    writeToStream(value) {
+        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;
+    }
+}

package/lib/streams.d.ts

@@ -0,0 +1,32 @@
+/**
+ * RelativeIndexable is a generic interface for array-like structures
+ * that can be indexed with a number
+ */
+export type RelativeIndexable<T> = {
+    [key: number]: T;
+    length: number;
+};
+/**
+ * Base stream interface for input/output operations
+ */
+export interface BaseStream {
+    buf: RelativeIndexable<number> | Uint8Array | ArrayBuffer | number[];
+    pos: number;
+    count: number;
+}
+/**
+ * Represents a buffer with a count of used elements
+ */
+export interface BufferWithCount {
+    buf: number[];
+    count: number;
+    write(buf: number[]): void;
+}
+/**
+ * Writer interface for output operations
+ */
+export interface Writer {
+    buf?: number[];
+    count?: number;
+    write(buf: number[]): void;
+}

package/lib/streams.js

@@ -0,0 +1 @@
+export {};

package/lib/utils.d.ts

@@ -0,0 +1,127 @@
+export interface BitTree {
+    numBitLevels: number;
+    models: number[];
+}
+/**
+ * Literal decoder/encoder for optimization
+ */
+export interface LiteralDecoderEncoder2 {
+    decoders: number[];
+}
+/**
+ * Basic range encoder interface for bit operations
+ */
+export interface BasicRangeEncoder {
+    encodeBit(probs: number[], index: number, bit: number): void;
+}
+/**
+ * Basic range decoder interface for bit operations
+ */
+export interface BasicRangeDecoder {
+    decodeBit(probs: number[], index: number): number;
+}
+export declare const INFINITY_PRICE = 268435455;
+export declare const _MAX_UINT32 = 4294967295;
+export declare const DICTIONARY_SIZE_THRESHOLD = 1073741823;
+export declare const kTopValue: number;
+export declare const kNumBitModelTotalBits = 11;
+export declare const kBitModelTotal: number;
+export declare const kNumMoveBits = 5;
+export declare const kNumMoveReducingBits = 2;
+export declare const kNumBitPriceShiftBits = 6;
+export declare const MATCH_DECODERS_SIZE = 192;
+export declare const REP_DECODERS_SIZE = 12;
+export declare const POS_DECODERS_SIZE = 114;
+export declare const LITERAL_DECODER_SIZE = 768;
+export declare const DEFAULT_WINDOW_SIZE = 4096;
+export declare const CHOICE_ARRAY_SIZE = 2;
+export declare const N1_LONG_LIT: [number, number];
+export declare const MIN_VALUE: [number, number];
+export declare const P0_LONG_LIT: [number, number];
+export declare const P1_LONG_LIT: [number, number];
+export declare const ZERO_64: [number, number];
+/**
+ * CRC32 lookup table for hash calculations
+ * dprint-ignore
+ */
+export declare const CRC32_TABLE: number[];
+/**
+ * Pre-computed static instances for common use
+ */
+export declare const PROB_PRICES: number[];
+export declare const G_FAST_POS: number[];
+/**
+ * Initialize array with specified length and default value
+ * This is MUCH faster than "new Array(len)" in newer versions of v8
+ * (starting with Node.js 0.11.15, which uses v8 3.28.73).
+ */
+export declare function initArray(len: number, value?: number): number[];
+/**
+ * Copy array data with bounds checking and overlap handling
+ */
+export declare function arraycopy(src: number[], srcOfs: number, dest: number[], destOfs: number, len: number): void;
+/**
+ * Get bit price using pre-computed probability prices
+ */
+export declare function getBitPrice(probability: number, bit: number): number;
+/**
+ * Create a 64-bit number from low and high parts
+ */
+export declare function create64(valueLow: number, valueHigh: number): [number, number];
+/**
+ * Add two 64-bit numbers
+ */
+export declare function add64(a: [number, number], b: [number, number]): [number, number];
+/**
+ * Subtract two 64-bit numbers
+ */
+export declare function sub64(a: [number, number], b: [number, number]): [number, number];
+/**
+ * Compare two 64-bit numbers
+ */
+export declare function compare64(a: [number, number], b: [number, number]): 0 | 1 | -1;
+/**
+ * Extract low bits from 64-bit number
+ */
+export declare function lowBits64(a: [number, number]): number;
+/**
+ * Create 64-bit number from integer
+ */
+export declare function fromInt64(value: number): [number, number];
+/**
+ * Right shift 64-bit number
+ */
+export declare function shr64(a: [number, number], n: number): [number, number];
+/**
+ * Bit model operations
+ */
+/**
+ * Initialize bit models with default probability
+ */
+export declare function initBitModels(probs: number[]): void;
+/**
+ * Position and state operations
+ */
+/**
+ * Get length to position state mapping
+ */
+export declare function getLenToPosState(len: number): number;
+/**
+ * Update state after character encoding/decoding
+ */
+export declare function stateUpdateChar(index: number): number;
+/**
+ * Bit tree operations
+ */
+/**
+ * Create a bit tree with specified number of bit levels
+ */
+export declare function createBitTree(numBitLevels: number): BitTree;
+/**
+ * Create probability prices lookup table
+ */
+export declare function createProbPrices(): number[];
+/**
+ * Create fast position lookup table
+ */
+export declare function createFastPos(): number[];