lzma1 0.1.2 → 0.2.0

package/lib/lz-in-window.js

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

package/lib/lz-window.d.ts

@@ -0,0 +1,35 @@
+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/lz-window.js

@@ -0,0 +1,89 @@
+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 Array(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) {
+            const dataToWrite = this.buffer.slice(0, this.pos);
+            this.w.write(dataToWrite);
+            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);
+        }
+    }
+}

package/lib/lzma.d.ts

@@ -1,66 +1,107 @@
+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;
-    readonly CompressionModes: {
-        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;
-        };
-    };
     constructor();
-    GetLenToPosState(len: number): number;
-    StateUpdateChar(index: number): number;
     writeHeaderProperties(): void;
-    GetPosSlot(pos: number): number;
     GetPosSlot2(pos: number): number;
-    reverseDecode(Models: number[], startIndex: number, NumBitLevels: number): number;
     ReverseEncode(startIndex: number, NumBitLevels: number, symbol: number): void;
-    ReverseGetPrice(Models: number[], startIndex: number, NumBitLevels: number, symbol: number): number;
-    InitBitModels(probs: number[]): void;
-    GetPrice(Prob: number, symbol: number): number;
     encodeString(inputString: string): number[];
-    compress(data: Uint8Array | ArrayBuffer, mode?: keyof typeof this.CompressionModes): Int8Array;
-    compressString(data: string, mode?: keyof typeof this.CompressionModes): Int8Array;
+    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 {};