lzma1 0.2.0 → 0.3.0

package/lib/lz-window.d.ts

@@ -1,35 +0,0 @@
-import type { Writer } from "./streams.js";
-export declare class LzOutWindow {
-    buffer: number[] | null;
-    pos: number;
-    streamPos: number;
-    stream: Writer | null;
-    windowSize: number;
-    private w;
-    private buf;
-    constructor(writer?: Writer | null, windowSize?: number);
-    /**
-     * Copy a block of data from a previous position (LZ77-style)
-     */
-    copyBlock(distance: number, length: number): void;
-    /**
-     * Put a single byte into the window
-     */
-    putByte(byte: number): void;
-    /**
-     * Get a byte from a relative position
-     */
-    getByte(relativePos: number): number;
-    /**
-     * Flush buffered data to output writer
-     */
-    flush(): void;
-    /**
-     * Check if the window is empty
-     */
-    isEmpty(): boolean;
-    /**
-     * Reset the window
-     */
-    reset(): void;
-}

package/lib/lzma.d.ts

@@ -1,107 +0,0 @@
-import type { BaseStream, BufferWithCount } from "./streams.js";
-import { type BitTree, type LiteralDecoderEncoder2 } from "./utils.js";
-/**
- * Range coder interface
- */
-interface RangeCoder {
-    stream: BaseStream | BufferWithCount | null;
-}
-/**
- * Range decoder
- */
-export interface RangeDecoder extends RangeCoder {
-    code: number;
-    rrange: number;
-    stream: BaseStream | null;
-    init?(): void;
-    decodeBit?(probs: number[], index: number): 0 | 1;
-}
-/**
- * Literal coder interface
- */
-export interface LiteralCoder {
-    coders: LiteralDecoderEncoder2[];
-    numPrevBits: number;
-    numPosBits: number;
-    posMask: number;
-    init?(): void;
-}
-/**
- * Length coder
- */
-export interface LenCoder {
-    choice: number[];
-    lowCoder: BitTree[];
-    midCoder: BitTree[];
-    highCoder: BitTree;
-}
-/**
- * LZMA compression mode levels (1-9)
- * Higher values provide better compression but are slower
- */
-export type CompressionMode = keyof typeof MODES;
-/**
- * Compression modes
- */
-export declare const MODES: {
-    readonly 1: {
-        readonly searchDepth: 16;
-        readonly filterStrength: 64;
-        readonly modeIndex: 0;
-    };
-    readonly 2: {
-        readonly searchDepth: 20;
-        readonly filterStrength: 64;
-        readonly modeIndex: 0;
-    };
-    readonly 3: {
-        readonly searchDepth: 19;
-        readonly filterStrength: 64;
-        readonly modeIndex: 1;
-    };
-    readonly 4: {
-        readonly searchDepth: 20;
-        readonly filterStrength: 64;
-        readonly modeIndex: 1;
-    };
-    readonly 5: {
-        readonly searchDepth: 21;
-        readonly filterStrength: 128;
-        readonly modeIndex: 1;
-    };
-    readonly 6: {
-        readonly searchDepth: 22;
-        readonly filterStrength: 128;
-        readonly modeIndex: 1;
-    };
-    readonly 7: {
-        readonly searchDepth: 23;
-        readonly filterStrength: 128;
-        readonly modeIndex: 1;
-    };
-    readonly 8: {
-        readonly searchDepth: 24;
-        readonly filterStrength: 255;
-        readonly modeIndex: 1;
-    };
-    readonly 9: {
-        readonly searchDepth: 25;
-        readonly filterStrength: 255;
-        readonly modeIndex: 1;
-    };
-};
-export declare class LZMA {
-    #private;
-    constructor();
-    writeHeaderProperties(): void;
-    GetPosSlot2(pos: number): number;
-    ReverseEncode(startIndex: number, NumBitLevels: number, symbol: number): void;
-    encodeString(inputString: string): number[];
-    compress(data: Uint8Array | ArrayBuffer, mode?: CompressionMode): Int8Array;
-    compressString(data: string, mode?: CompressionMode): Int8Array;
-    decompress(bytearray: Uint8Array | ArrayBuffer): number[];
-    decompressString(bytearray: Uint8Array | ArrayBuffer): string;
-    codeOneBlock(): void;
-    releaseStreams(): void;
-}
-export {};

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

@@ -1,34 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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-decoder.d.ts

@@ -1,34 +0,0 @@
-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-encoder.d.ts

@@ -1,46 +0,0 @@
-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/streams.d.ts

@@ -1,32 +0,0 @@
-/**
- * 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/utils.d.ts

@@ -1,127 +0,0 @@
-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[];