lzma1 0.2.0 → 0.3.0

package/README.md

@@ -25,9 +25,9 @@ to read and maintain.
 
 - Encode and decode LZMA streams
 - Supports both string and Uint8Array data
-- Supports both browser and Node.js environments
-- Pure JavaScript implementation with TypeScript types
 - No dependencies on runtime-specific APIs
+- Pure JavaScript implementation with TypeScript types
+- Isomorphic browser- and runtime-independent implementation
 
 ## Installation
 
@@ -155,7 +155,14 @@ commonly used in the 7z archive format.
 The LZMA compressed data begins with a header that contains information needed
 for decompression:
 
-![lzma](./docs/lzma.svg)
+```mermaid
+packet-beta
+  0-7: "lc (literal context)"
+  8-11: "lp (literal pos)"
+  12-15: "pb (position bits)"
+  16-47: "Dictionary Size (32-bit, LE)"
+  48-111: "Uncompressed Size (64-bit, LE)"
+```
 
 More [information][header_link] about the LZMA header structure.
 

package/lib/decoder.js

@@ -1,6 +1,6 @@
 import { LzOutWindow } from "./lz-window.js";
 import { RangeDecoder } from "./range-decoder.js";
-import { add64, CHOICE_ARRAY_SIZE, compare64, createBitTree, DEFAULT_WINDOW_SIZE, getLenToPosState, initArray, initBitModels, LITERAL_DECODER_SIZE, lowBits64, MATCH_DECODERS_SIZE, POS_DECODERS_SIZE, REP_DECODERS_SIZE, stateUpdateChar, } from "./utils.js";
+import { _MAX_UINT32, CHOICE_ARRAY_SIZE, createBitTree, DEFAULT_WINDOW_SIZE, getLenToPosState, initArray, initBitModels, LITERAL_DECODER_SIZE, MATCH_DECODERS_SIZE, POS_DECODERS_SIZE, REP_DECODERS_SIZE, stateUpdateChar, } from "./utils.js";
 export class Decoder {
     rangeDecoder;
     outWindow;
@@ -11,8 +11,8 @@ export class Decoder {
     rep2 = 0;
     rep3 = 0;
     prevByte = 0;
-    nowPos64 = [0, 0];
-    outSize = [0, 0];
+    nowPos64 = 0n;
+    outSize = 0n;
     // Decoder configuration
     posStateMask = 0;
     dictSizeCheck = 0;
@@ -34,11 +34,6 @@ export class Decoder {
     get literalCoder() {
         return this.literalDecoder;
     }
-    // Chunker properties for compatibility
-    decoder;
-    encoder = null;
-    alive = 0;
-    inBytesProcessed = [0, 0];
     constructor() {
         // Initialize range decoder
         this.rangeDecoder = new RangeDecoder();
@@ -69,8 +64,79 @@ export class Decoder {
         this.repLenDecoder = this.createLenDecoder();
         // Initialize position alignment decoder
         this.posAlignDecoder = createBitTree(4);
-        // Initialize self-reference for chunker compatibility
-        this.decoder = this;
+    }
+    /**
+     * Read LZMA header, configure decoder, and prepare for decompression.
+     */
+    initDecompression(input, output) {
+        // Read 5-byte header properties
+        const properties = [];
+        for (let i = 0; i < 5; ++i) {
+            const r = input.readByte();
+            if (r === -1) {
+                throw new Error("truncated input");
+            }
+            properties[i] = r << 24 >> 24;
+        }
+        if (!this.setDecoderProperties(properties)) {
+            throw new Error("corrupted input");
+        }
+        // Read 8-byte uncompressed length from header
+        let outSize;
+        {
+            let value = 0n;
+            for (let i = 0; i < 8; i++) {
+                const r = input.readByte();
+                if (r === -1) {
+                    throw new Error("truncated input");
+                }
+                value += BigInt(r & 0xFF) << BigInt(i * 8);
+            }
+            // Check for unknown size marker (all 0xFF bytes)
+            if (value === 0xffffffffffffffffn) {
+                outSize = -1n;
+            }
+            else if (value > BigInt(_MAX_UINT32)) {
+                outSize = -1n;
+            }
+            else {
+                outSize = value;
+            }
+        }
+        // Set up range decoder and output window
+        this.rangeDecoder.setStream(input);
+        this.flush();
+        this.outWindow.stream = null;
+        this.outWindow.stream = output;
+        // Initialize decoder state
+        this.init();
+        this.state = 0;
+        this.rep0 = 0;
+        this.rep1 = 0;
+        this.rep2 = 0;
+        this.rep3 = 0;
+        this.outSize = outSize;
+        this.nowPos64 = 0n;
+        this.prevByte = 0;
+    }
+    /**
+     * Full decompression: read header, decode all chunks, flush and cleanup.
+     */
+    decompress(input, output) {
+        this.initDecompression(input, output);
+        while (true) {
+            const result = this.codeOneChunk();
+            if (result === -1) {
+                throw new Error("corrupted input");
+            }
+            const isOutputComplete = (this.outSize >= 0n)
+                && (this.nowPos64 >= this.outSize);
+            if (result || isOutputComplete) {
+                this.flush();
+                this.cleanup();
+                return;
+            }
+        }
     }
     createLenDecoder() {
         const decoder = {
@@ -111,7 +177,7 @@ export class Decoder {
         // Initialize output window
         if (dictSize > 0) {
             this.outWindow.windowSize = Math.max(dictSize, 4096);
-            this.outWindow.buffer = initArray(this.outWindow.windowSize);
+            this.outWindow.buffer = new Uint8Array(this.outWindow.windowSize);
         }
         // Initialize literal decoder coders
         const numStates = 1 << (this.literalDecoder.numPrevBits + this.literalDecoder.numPosBits);
@@ -295,9 +361,9 @@ export class Decoder {
     }
     codeOneChunk() {
         let decoder2, distance, len, numDirectBits, positionSlot;
-        let posState = lowBits64(this.nowPos64) & this.posStateMask;
+        let posState = Number(this.nowPos64 & 0xffffffffn) & this.posStateMask;
         if (!this.decodeBit(this.matchDecoders, (this.state << 4) + posState)) {
-            decoder2 = this.getDecoder(lowBits64(this.nowPos64), this.prevByte);
+            decoder2 = this.getDecoder(Number(this.nowPos64 & 0xffffffffn), this.prevByte);
             if (this.state < 7) {
                 this.prevByte = this.decodeNormalWithRangeDecoder(decoder2);
             }
@@ -306,7 +372,7 @@ export class Decoder {
             }
             this.putByte(this.prevByte);
             this.state = stateUpdateChar(this.state);
-            this.nowPos64 = add64(this.nowPos64, [1, 0]);
+            this.nowPos64 += 1n;
         }
         else {
             if (this.decodeBit(this.repDecoders, this.state)) {
@@ -367,76 +433,17 @@ export class Decoder {
                     this.rep0 = positionSlot;
                 }
             }
-            if (compare64([this.rep0, 0], this.nowPos64) >= 0 || this.rep0 >= this.dictSizeCheck) {
+            if (BigInt(this.rep0) >= this.nowPos64 || this.rep0 >= this.dictSizeCheck) {
                 return -1;
             }
             this.copyBlock(len);
-            this.nowPos64 = add64(this.nowPos64, [len, 0]);
+            this.nowPos64 += BigInt(len);
             this.prevByte = this.getByte(0);
         }
         return 0;
     }
-    // Setup decoder for chunk processing
-    setupForDecoding(inStream, outSize, outputBuffer) {
-        this.rangeDecoder.setStream(inStream);
-        this.outSize = outSize;
-        this.outWindowReleaseStream();
-        this.outWindow.stream = outputBuffer;
-        this.init();
-        this.state = 0;
-        this.rep0 = 0;
-        this.rep1 = 0;
-        this.rep2 = 0;
-        this.rep3 = 0;
-        this.outSize = outSize;
-        this.nowPos64 = [0, 0];
-        this.prevByte = 0;
-        this.decoder = this;
-        this.encoder = null;
-        this.alive = 1;
-    }
-    // Process chunk and return alive status
-    processChunk() {
-        if (!this.alive) {
-            throw new Error("Bad state");
-        }
-        if (this.encoder) {
-            throw new Error("No encoding");
-        }
-        const result = this.codeOneChunk();
-        if (result === -1) {
-            throw new Error("Corrupted input");
-        }
-        const isOutputComplete = (compare64(this.outSize, [0, 0]) >= 0)
-            && (compare64(this.nowPos64, this.outSize) >= 0);
-        if (result || isOutputComplete) {
-            this.flush();
-            this.outWindowReleaseStream();
-            this.rangeDecoder.setStream(null);
-            this.alive = 0;
-        }
-        return this.alive;
-    }
     writeToOutput(buffer, data, offset, length) {
-        // Ensure buffer has enough capacity
-        const requiredSize = buffer.count + length;
-        if (requiredSize > buffer.buf.length) {
-            const newSize = Math.max(buffer.buf.length * 2, requiredSize);
-            const newBuf = new Array(newSize);
-            for (let i = 0; i < buffer.count; i++) {
-                newBuf[i] = buffer.buf[i];
-            }
-            buffer.buf = newBuf;
-        }
-        // Copy data
-        for (let i = 0; i < length; i++) {
-            buffer.buf[buffer.count + i] = data[offset + i];
-        }
-        buffer.count += length;
-    }
-    isBufferWithCount(x) {
-        const s = x;
-        return !!s && Array.isArray(s.buf) && typeof s.count === "number" && typeof s.write === "function";
+        buffer.writeBytes(data, offset, length);
     }
     flush() {
         const size = this.outWindow.pos - this.outWindow.streamPos;
@@ -444,15 +451,7 @@ export class Decoder {
             return;
         }
         if (this.outWindow.stream && this.outWindow.buffer) {
-            const outputBuffer = this.outWindow.stream;
-            if (this.isBufferWithCount(outputBuffer)) {
-                this.writeToOutput(outputBuffer, this.outWindow.buffer, this.outWindow.streamPos, size);
-            }
-            else if (typeof outputBuffer.write === "function") {
-                // Fallback: write directly if it's a plain Writer
-                const slice = this.outWindow.buffer.slice(this.outWindow.streamPos, this.outWindow.streamPos + size);
-                outputBuffer.write(slice);
-            }
+            this.outWindow.stream.writeBytes(this.outWindow.buffer, this.outWindow.streamPos, size);
         }
         if (this.outWindow.pos >= this.outWindow.windowSize) {
             this.outWindow.pos = 0;