lzma1 0.2.0 → 0.3.0

package/lib/decoder.d.ts

@@ -1,80 +0,0 @@
-import { LzOutWindow } from "./lz-window.js";
-import { RangeDecoder } from "./range-decoder.js";
-import type { BaseStream, BufferWithCount } from "./streams.js";
-import { type BitTree } from "./utils.js";
-interface LenDecoder {
-    choice: number[];
-    lowCoder: BitTree[];
-    midCoder: BitTree[];
-    highCoder: BitTree;
-    numPosStates: number;
-}
-interface LiteralCoder {
-    coders: any[];
-    numPrevBits: number;
-    numPosBits: number;
-    posMask: number;
-    init?(): void;
-}
-export declare class Decoder {
-    rangeDecoder: RangeDecoder;
-    outWindow: LzOutWindow;
-    state: number;
-    rep0: number;
-    rep1: number;
-    rep2: number;
-    rep3: number;
-    prevByte: number;
-    nowPos64: [number, number];
-    outSize: [number, number];
-    posStateMask: number;
-    dictSizeCheck: number;
-    matchDecoders: number[];
-    rep0LongDecoders: number[];
-    repDecoders: number[];
-    repG0Decoders: number[];
-    repG1Decoders: number[];
-    repG2Decoders: number[];
-    posDecoders: number[];
-    literalDecoder: LiteralCoder;
-    posSlotDecoders: BitTree[];
-    lenDecoder: LenDecoder;
-    repLenDecoder: LenDecoder;
-    posAlignDecoder: BitTree;
-    get literalCoder(): LiteralCoder;
-    decoder: Decoder;
-    encoder: null;
-    alive: number;
-    inBytesProcessed: [number, number];
-    constructor();
-    createLenDecoder(): LenDecoder;
-    setDecoderProperties(properties: number[]): boolean;
-    copyBlock(len: number): void;
-    putByte(b: number): void;
-    getByte(distance: number): number;
-    getDecoder(pos: number, prevByte: number): any;
-    initLiteralDecoder(): void;
-    init(): void;
-    initLenDecoder(decoder: LenDecoder): void;
-    outWindowReleaseStream(): void;
-    decodeBit(probs: number[], index: number): 0 | 1;
-    decodeDirectBits(numTotalBits: number): number;
-    initRangeDecoder(): void;
-    rangeBitTreeDecoder(bitTree: BitTree): number;
-    reverseDecode(models: number[], startIndex: number, numBitLevels: number): number;
-    reverseDecodeAlignDecoder(): number;
-    decodeNormalWithRangeDecoder(decoder: any): number;
-    decodeWithMatchByteWithRangeDecoder(encoder: any, matchByte: number): number;
-    decodeLenWithRangeDecoder(decoder: LenDecoder, posState: number): number;
-    codeOneChunk(): 0 | 1 | -1;
-    setupForDecoding(inStream: BaseStream, outSize: [number, number], outputBuffer: BufferWithCount): void;
-    processChunk(): number;
-    writeToOutput(buffer: BufferWithCount, data: number[], offset: number, length: number): void;
-    private isBufferWithCount;
-    flush(): void;
-    /**
-     * Cleanup decoder resources
-     */
-    cleanup(): void;
-}
-export {};

package/lib/encoder.d.ts

@@ -1,266 +0,0 @@
-import { LenEncoder, type RangeEncoder as LenRangeEncoder } from "./len-coder.js";
-import { LitCoder } from "./lit-coder.js";
-import type { BaseStream } from "./streams.js";
-import type { LiteralDecoderEncoder2 } from "./utils.js";
-import { type BitTree } from "./utils.js";
-export interface MatchFinder {
-    _posLimit: number;
-    _bufferBase: number[];
-    _pos: number;
-    _streamPos: number;
-    _streamEndWasReached: number;
-    _bufferOffset: number;
-    _blockSize: number;
-    _keepSizeBefore: number;
-    _keepSizeAfter: number;
-    _pointerToLastSafePosition: number;
-    _stream: BaseStream | null;
-    HASH_ARRAY: boolean;
-    kNumHashDirectBytes: number;
-    kMinMatchCheck: number;
-    kFixHashSize: number;
-    _hashMask: number;
-    _hashSizeSum: number;
-    _hash: number[];
-    _cyclicBufferSize: number;
-    _cyclicBufferPos: number;
-    _son: number[];
-    _matchMaxLen: number;
-    _cutValue: number;
-}
-export interface Optimum {
-    state?: number;
-    price?: number;
-    posPrev?: number;
-    backPrev?: number;
-    prev1IsChar?: number;
-    prev2?: number;
-    posPrev2?: number;
-    backPrev2?: number;
-    backs0?: number;
-    backs1?: number;
-    backs2?: number;
-    backs3?: number;
-}
-interface RangeEncoder {
-    stream: {
-        buf: number[];
-        count: number;
-    } | null;
-    rrange: number;
-    cache: number;
-    low: [number, number];
-    cacheSize: number;
-    position: [number, number];
-    encodeBit(probs: number[], index: number, bit: number): void;
-    encodeBitTree(tree: BitTree, symbol: number): void;
-    encodeDirectBits(value: number, bits: number): void;
-}
-/**
- * LZMA Encoder class that handles compression operations
- */
-export declare class Encoder implements LenRangeEncoder {
-    private encoderState;
-    private positionEncoder;
-    _state: number;
-    _previousByte: number;
-    _distTableSize: number;
-    _longestMatchWasFound: number;
-    _optimumEndIndex: number;
-    _optimumCurrentIndex: number;
-    _additionalOffset: number;
-    _dictionarySize: number;
-    _matchFinder: MatchFinder | null;
-    _dictionarySizePrev: number;
-    _numFastBytes: number;
-    _numLiteralContextBits: number;
-    _numLiteralPosStateBits: number;
-    _posStateBits: number;
-    _posStateMask: number;
-    _needReleaseMFStream: number;
-    _inStream: BaseStream | null;
-    _finished: number;
-    nowPos64: [number, number];
-    _repDistances: number[];
-    _optimum: Optimum[];
-    _rangeEncoder: RangeEncoder;
-    _isMatch: number[];
-    _isRep: number[];
-    _isRepG0: number[];
-    _isRepG1: number[];
-    _isRepG2: number[];
-    _isRep0Long: number[];
-    _posSlotEncoder: BitTree[];
-    _posEncoders: number[];
-    _posAlignEncoder: BitTree | null;
-    _lenEncoder: LenEncoder | null;
-    _repMatchLenEncoder: LenEncoder | null;
-    _literalEncoder: LitCoder | null;
-    _matchDistances: number[];
-    _posSlotPrices: number[];
-    _distancesPrices: number[];
-    _alignPrices: number[];
-    _matchPriceCount: number;
-    _alignPriceCount: number;
-    reps: number[];
-    repLens: number[];
-    processedInSize: [number, number][];
-    processedOutSize: [number, number][];
-    finished: number[];
-    properties: number[];
-    tempPrices: number[];
-    _longestMatchLength: number;
-    _matchFinderType: number;
-    _numDistancePairs: number;
-    _numFastBytesPrev: number;
-    backRes: number;
-    constructor();
-    /**
-     * Initialize basic encoder state
-     */
-    baseInit(): void;
-    /**
-     * Get optimum array
-     */
-    getOptimum(): Optimum[];
-    /**
-     * Get back result
-     */
-    getBackRes(): number;
-    setBackRes(backRes: number): void;
-    init(): void;
-    /**
-     * Initialize encoder range coder
-     */
-    initEncoderState(): void;
-    /**
-     * Initialize literal encoder
-     */
-    initLiteralEncoder(): void;
-    /**
-     * Create optimum structures
-     */
-    createOptimumStructures(): void;
-    /**
-     * Create length price table encoder
-     */
-    createLenPriceTableEncoder(): LenEncoder;
-    /**
-     * Create literal encoder encoder2
-     */
-    createLiteralEncoderEncoder2(): LiteralDecoderEncoder2;
-    /**
-     * Create literal encoder
-     */
-    createLiteralEncoder(): void;
-    /**
-     * Initialize completely with proper encoder state
-     */
-    initialize(): void;
-    /**
-     * Configure encoder settings
-     */
-    configure(mode: {
-        searchDepth: number;
-        filterStrength: number;
-        modeIndex: number;
-    }): void;
-    /**
-     * Set dictionary size
-     */
-    setDictionarySize(dictionarySize: number): void;
-    /**
-     * Encode a bit using range coder
-     */
-    encodeBit(probs: number[], index: number, symbol: number): void;
-    /**
-     * Encode bit tree
-     */
-    encodeBitTree(encoder: BitTree, symbol: number): void;
-    /**
-     * Encode literal
-     */
-    encodeLiteral(encoder: LiteralDecoderEncoder2, symbol: number): void;
-    /**
-     * Encode matched literal
-     */
-    encodeMatched(encoder: LiteralDecoderEncoder2, matchByte: number, symbol: number): void;
-    /**
-     * Encode length using direct method calls
-     */
-    encodeLength(encoder: LenEncoder, symbol: number, posState: number): void;
-    /**
-     * Encode direct bits
-     */
-    encodeDirectBits(valueToEncode: number, numTotalBits: number): void;
-    /**
-     * Reverse encode
-     */
-    reverseEncode(symbol: number): void;
-    /**
-     * Reverse encode range
-     */
-    reverseEncodeRange(startIndex: number, numBitLevels: number, symbol: number): void;
-    /**
-     * Write end marker
-     */
-    writeEndMarker(positionState: number): void;
-    /**
-     * Encode length with price table update
-     */
-    encodeLengthWithPriceUpdate(encoder: LenEncoder, symbol: number, posState: number): void;
-    private and64;
-    private shru64;
-    private shl64;
-    private pwrAsDouble;
-    /**
-     * Shift low helper (proper implementation) - public method for external access
-     */
-    shiftLow(): void;
-    /**
-     * Write byte to stream
-     */
-    private writeToStream;
-    initRangeEncoder(): void;
-    /**
-     * Fill alignment prices for position alignment encoder
-     */
-    fillAlignPrices(): void;
-    /**
-     * Fill distance prices for position encoders
-     */
-    fillDistancesPrices(): void;
-    /**
-     * Get position slot for a distance value
-     */
-    getPosSlot(pos: number): number;
-    /**
-     * Get reverse price for bit tree encoder
-     */
-    reverseGetPrice(encoder: BitTree, symbol: number): number;
-    /**
-     * Get reverse price for array of models
-     */
-    reverseGetPriceArray(Models: number[], startIndex: number, NumBitLevels: number, symbol: number): number;
-    /**
-     * Get price for probability model (optimized)
-     */
-    getPrice(Prob: number, symbol: number): number;
-    /**
-     * Get price for bit tree encoder (optimized)
-     */
-    rangeCoder_Encoder_GetPrice_1(encoder: BitTree, symbol: number): number;
-    /**
-     * Create encoder optimization structures (optimized)
-     */
-    createEncoderStructures(): void;
-    /**
-     * Create match finder and encoder structures (replaces #Create_2)
-     */
-    createMatchFinderAndStructures(): void;
-    /**
-     * Get literal encoder subcoder (utility method)
-     */
-    getSubCoderUtility(pos: number, prevByte: number): LiteralDecoderEncoder2;
-}
-export {};

package/lib/index.d.ts

@@ -1,38 +0,0 @@
-/**
- * @license
- * Copyright Filip Seman
- * SPDX-License-Identifier: MIT
- */
-import { type CompressionMode } from "./lzma.js";
-export { LZMA } from "./lzma.js";
-export { CRC32_TABLE } from "./utils.js";
-/**
- * Compresses data using LZMA algorithm
- *
- * @param data Data to compress - can be Uint8Array or ArrayBuffer
- * @param mode Compression mode (1-9), defaults to 5
- * @returns Compressed data as a byte array
- */
-export declare function compress(data: Uint8Array | ArrayBuffer, mode?: CompressionMode): Uint8Array;
-/**
- * Compresses data using LZMA algorithm
- *
- * @param data String to compress
- * @param mode Compression mode (1-9), defaults to 5
- * @returns Compressed data as byte array
- */
-export declare function compressString(data: string, mode?: CompressionMode): Uint8Array;
-/**
- * Decompresses LZMA compressed data
- *
- * @param data Compressed data as Uint8Array or ArrayBuffer
- * @returns Decompressed data
- */
-export declare function decompress(data: Uint8Array | ArrayBuffer): Uint8Array;
-/**
- * Decompresses LZMA compressed data
- *
- * @param data Compressed data as Uint8Array or ArrayBuffer
- * @returns Decompressed data as string
- */
-export declare function decompressString(data: Uint8Array | ArrayBuffer): string;

package/lib/len-coder.d.ts

@@ -1,70 +0,0 @@
-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/lit-coder.d.ts

@@ -1,63 +0,0 @@
-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/lz-in-window.d.ts

@@ -1,43 +0,0 @@
-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;
-}

package/lib/lz-in-window.js

@@ -1,132 +0,0 @@
-import { arraycopy } from "./utils.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 class LzInWindow {
-    matchFinder;
-    constructor(matchFinder) {
-        this.matchFinder = matchFinder;
-    }
-    /**
-     * Get a byte at the specified index relative to current position
-     */
-    getIndexByte(index) {
-        const byte = this.matchFinder._bufferBase[this.matchFinder._bufferOffset + this.matchFinder._pos + index];
-        return byte;
-    }
-    /**
-     * Calculate match length between current position and a previous position
-     */
-    getMatchLen(index, distance, limit) {
-        if (this.matchFinder._streamEndWasReached) {
-            if (this.matchFinder._pos + index + limit > this.matchFinder._streamPos) {
-                limit = this.matchFinder._streamPos - (this.matchFinder._pos + index);
-            }
-        }
-        ++distance;
-        let i;
-        const pby = this.matchFinder._bufferOffset + this.matchFinder._pos + index;
-        for (i = 0; i < limit
-            && this.matchFinder._bufferBase[pby + i]
-                == this.matchFinder._bufferBase[pby + i - distance]; ++i)
-            ;
-        return i;
-    }
-    /**
-     * Get number of available bytes in the input window
-     */
-    getNumAvailableBytes() {
-        return this.matchFinder._streamPos - this.matchFinder._pos;
-    }
-    /**
-     * Move buffer block when reaching buffer boundaries
-     */
-    moveBlock() {
-        let offset = this.matchFinder._bufferOffset + this.matchFinder._pos - this.matchFinder._keepSizeBefore;
-        if (offset > 0) {
-            --offset;
-        }
-        const numBytes = this.matchFinder._bufferOffset + this.matchFinder._streamPos - offset;
-        for (let i = 0; i < numBytes; ++i) {
-            this.matchFinder._bufferBase[i] = this.matchFinder._bufferBase[offset + i];
-        }
-        this.matchFinder._bufferOffset -= offset;
-    }
-    /**
-     * Move position by one and handle buffer management
-     */
-    movePos() {
-        this.matchFinder._pos += 1;
-        if (this.matchFinder._pos > this.matchFinder._posLimit) {
-            const pointerToPosition = this.matchFinder._bufferOffset + this.matchFinder._pos;
-            if (pointerToPosition > this.matchFinder._pointerToLastSafePosition) {
-                this.moveBlock();
-            }
-            this.readBlock();
-        }
-    }
-    /**
-     * Read a block of data from the input stream
-     */
-    readBlock() {
-        if (this.matchFinder._streamEndWasReached) {
-            return;
-        }
-        while (true) {
-            const size = -this.matchFinder._bufferOffset + this.matchFinder._blockSize - this.matchFinder._streamPos;
-            if (!size) {
-                return;
-            }
-            const bytesRead = this.readFromStream(this.matchFinder._bufferOffset + this.matchFinder._streamPos, size);
-            if (bytesRead == -1) {
-                this.matchFinder._posLimit = this.matchFinder._streamPos;
-                const pointerToPosition = this.matchFinder._bufferOffset + this.matchFinder._posLimit;
-                if (pointerToPosition > this.matchFinder._pointerToLastSafePosition) {
-                    this.matchFinder._posLimit = this.matchFinder._pointerToLastSafePosition - this.matchFinder._bufferOffset;
-                }
-                this.matchFinder._streamEndWasReached = 1;
-                return;
-            }
-            this.matchFinder._streamPos += bytesRead;
-            if (this.matchFinder._streamPos >= this.matchFinder._pos + this.matchFinder._keepSizeAfter) {
-                this.matchFinder._posLimit = this.matchFinder._streamPos - this.matchFinder._keepSizeAfter;
-            }
-        }
-    }
-    /**
-     * Reduce all position offsets by the specified value
-     */
-    reduceOffsets(subValue) {
-        this.matchFinder._bufferOffset += subValue;
-        this.matchFinder._posLimit -= subValue;
-        this.matchFinder._pos -= subValue;
-        this.matchFinder._streamPos -= subValue;
-    }
-    /**
-     * Read data from the input stream into the buffer
-     */
-    readFromStream(off, len) {
-        const stream = this.matchFinder._stream;
-        const buffer = this.matchFinder._bufferBase;
-        if (stream.pos >= stream.count) {
-            return -1;
-        }
-        let srcBuf;
-        if (stream.buf instanceof Uint8Array) {
-            srcBuf = Array.from(stream.buf);
-        }
-        else if (stream.buf instanceof ArrayBuffer) {
-            srcBuf = Array.from(new Uint8Array(stream.buf));
-        }
-        else {
-            srcBuf = stream.buf;
-        }
-        len = Math.min(len, stream.count - stream.pos);
-        arraycopy(srcBuf, stream.pos, buffer, off, len);
-        stream.pos += len;
-        return len;
-    }
-}