lzma1 0.1.2 → 0.3.0

package/README.md

@@ -1,9 +1,16 @@
-# lzma1
+<div align="center">
 
-This is a [fork][fork-link] of [Nathan Rugg's][fork-author] LZMA-JS package.
+<h1>lzma1</h1>
+
+This is a [fork][fork-link] of [Nathan Rugg's][fork-author] LZMA-JS package and
+inspiration of [Java][7zip-sdk] and Googles [Go][go-sdk] implementations.
+
+</div>
 
 [fork-link]: https://github.com/LZMA-JS/LZMA-JS
 [fork-author]: https://github.com/nmrugg
+[7zip-sdk]: https://www.7-zip.org/sdk.html
+[go-sdk]: https://code.google.com/p/lzma
 
 ## Why
 
@@ -18,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
 
@@ -148,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.
 
@@ -156,7 +170,6 @@ More [information][header_link] about the LZMA header structure.
 
 ## Related
 
-- [7-Zip SDK](https://www.7-zip.org/sdk.html)
 - [lzma-purejs](https://github.com/cscott/lzma-purejs)
 - [lzmajs](https://github.com/glinscott/lzmajs)
 - [lzma-purejs fork](https://github.com/mauron85/lzma-purejs/tree/master)

package/lib/decoder.js

@@ -0,0 +1,468 @@
+import { LzOutWindow } from "./lz-window.js";
+import { RangeDecoder } from "./range-decoder.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;
+    // Decoder state
+    state = 0;
+    rep0 = 0;
+    rep1 = 0;
+    rep2 = 0;
+    rep3 = 0;
+    prevByte = 0;
+    nowPos64 = 0n;
+    outSize = 0n;
+    // Decoder configuration
+    posStateMask = 0;
+    dictSizeCheck = 0;
+    // Probability models for different symbols
+    matchDecoders = [];
+    rep0LongDecoders = [];
+    repDecoders = [];
+    repG0Decoders = [];
+    repG1Decoders = [];
+    repG2Decoders = [];
+    posDecoders = [];
+    // Complex decoders
+    literalDecoder;
+    posSlotDecoders = [];
+    lenDecoder;
+    repLenDecoder;
+    posAlignDecoder;
+    // Alias for compatibility with LZMA class
+    get literalCoder() {
+        return this.literalDecoder;
+    }
+    constructor() {
+        // Initialize range decoder
+        this.rangeDecoder = new RangeDecoder();
+        // Initialize output window using proper LzOutWindow
+        this.outWindow = new LzOutWindow(null, DEFAULT_WINDOW_SIZE);
+        // Initialize probability models
+        this.matchDecoders = initArray(MATCH_DECODERS_SIZE);
+        this.rep0LongDecoders = initArray(MATCH_DECODERS_SIZE);
+        this.repDecoders = initArray(REP_DECODERS_SIZE);
+        this.repG0Decoders = initArray(REP_DECODERS_SIZE);
+        this.repG1Decoders = initArray(REP_DECODERS_SIZE);
+        this.repG2Decoders = initArray(REP_DECODERS_SIZE);
+        this.posDecoders = initArray(POS_DECODERS_SIZE);
+        // Initialize literal decoder
+        this.literalDecoder = {
+            coders: [],
+            numPrevBits: 0,
+            numPosBits: 0,
+            posMask: 0,
+            init: () => this.initLiteralDecoder(),
+        };
+        // Initialize position slot decoders (4 different length-to-position states)
+        for (let i = 0; i < 4; i++) {
+            this.posSlotDecoders[i] = createBitTree(6);
+        }
+        // Initialize length decoders
+        this.lenDecoder = this.createLenDecoder();
+        this.repLenDecoder = this.createLenDecoder();
+        // Initialize position alignment decoder
+        this.posAlignDecoder = createBitTree(4);
+    }
+    /**
+     * 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 = {
+            choice: initArray(CHOICE_ARRAY_SIZE),
+            lowCoder: [],
+            midCoder: [],
+            highCoder: createBitTree(0x08),
+            numPosStates: 0,
+        };
+        return decoder;
+    }
+    setDecoderProperties(properties) {
+        if (properties.length < 5) {
+            return false;
+        }
+        const lc = properties[0] % 9;
+        const remainder = Math.floor(properties[0] / 9);
+        const lp = remainder % 5;
+        const pb = Math.floor(remainder / 5);
+        if (pb > 4) {
+            return false;
+        }
+        // Set literal decoder properties
+        this.literalDecoder.numPrevBits = lc;
+        this.literalDecoder.numPosBits = lp;
+        this.literalDecoder.posMask = (1 << lp) - 1;
+        // Set position state mask
+        this.posStateMask = (1 << pb) - 1;
+        // Calculate dictionary size from properties[1-4]
+        let dictSize = 0;
+        for (let i = 0; i < 4; i++) {
+            // Treat bytes as unsigned (0-255) instead of signed (-128 to 127)
+            const unsignedByte = properties[1 + i] & 0xFF;
+            dictSize += unsignedByte << (i * 8);
+        }
+        // Set dictionary size and check value
+        this.dictSizeCheck = Math.max(dictSize, 1);
+        // Initialize output window
+        if (dictSize > 0) {
+            this.outWindow.windowSize = Math.max(dictSize, 4096);
+            this.outWindow.buffer = new Uint8Array(this.outWindow.windowSize);
+        }
+        // Initialize literal decoder coders
+        const numStates = 1 << (this.literalDecoder.numPrevBits + this.literalDecoder.numPosBits);
+        this.literalDecoder.coders = [];
+        for (let i = 0; i < numStates; i++) {
+            this.literalDecoder.coders[i] = {
+                decoders: initArray(LITERAL_DECODER_SIZE), // 0x300
+            };
+        }
+        // Initialize length decoders
+        this.lenDecoder.numPosStates = 1 << pb;
+        this.repLenDecoder.numPosStates = 1 << pb;
+        // Initialize low and mid coders for length decoders
+        this.lenDecoder.lowCoder = [];
+        this.lenDecoder.midCoder = [];
+        this.repLenDecoder.lowCoder = [];
+        this.repLenDecoder.midCoder = [];
+        for (let posState = 0; posState < (1 << pb); posState++) {
+            this.lenDecoder.lowCoder[posState] = createBitTree(3);
+            this.lenDecoder.midCoder[posState] = createBitTree(3);
+            this.repLenDecoder.lowCoder[posState] = createBitTree(3);
+            this.repLenDecoder.midCoder[posState] = createBitTree(3);
+        }
+        return true;
+    }
+    // Methods that modify decoder state
+    copyBlock(len) {
+        const outputWindow = this.outWindow;
+        const distance = this.rep0;
+        let pos = outputWindow.pos - distance - 1;
+        if (pos < 0) {
+            pos += outputWindow.windowSize;
+        }
+        for (; len != 0; len -= 1) {
+            if (pos >= outputWindow.windowSize) {
+                pos = 0;
+            }
+            outputWindow.buffer[outputWindow.pos] = outputWindow.buffer[pos];
+            outputWindow.pos += 1;
+            pos += 1;
+            if (outputWindow.pos >= outputWindow.windowSize) {
+                this.flush();
+            }
+        }
+    }
+    putByte(b) {
+        this.outWindow.buffer[this.outWindow.pos] = b;
+        this.outWindow.pos += 1;
+        if (this.outWindow.pos >= this.outWindow.windowSize) {
+            this.flush();
+        }
+    }
+    getByte(distance) {
+        const outputWindow = this.outWindow;
+        let pos = outputWindow.pos - distance - 1;
+        if (pos < 0) {
+            pos += outputWindow.windowSize;
+        }
+        return outputWindow.buffer[pos];
+    }
+    getDecoder(pos, prevByte) {
+        // Calculate index based on position and previous byte
+        const positionMask = pos & this.literalDecoder.posMask;
+        const prevBitsMask = (prevByte & 0xFF) >>> (8 - this.literalDecoder.numPrevBits);
+        const index = (positionMask << this.literalDecoder.numPrevBits) + prevBitsMask;
+        // Return decoder at calculated index
+        return this.literalDecoder.coders[index];
+    }
+    initLiteralDecoder() {
+        let numStates = 1 << (this.literalDecoder.numPrevBits + this.literalDecoder.numPosBits);
+        for (let i = 0; i < numStates; ++i) {
+            // Initialize bit models for each coder
+            for (let j = 0; j < this.literalDecoder.coders[i].decoders.length; j++) {
+                this.literalDecoder.coders[i].decoders[j] = 1024;
+            }
+        }
+    }
+    init() {
+        this.outWindow.streamPos = 0;
+        this.outWindow.pos = 0;
+        initBitModels(this.matchDecoders);
+        initBitModels(this.rep0LongDecoders);
+        initBitModels(this.repDecoders);
+        initBitModels(this.repG0Decoders);
+        initBitModels(this.repG1Decoders);
+        initBitModels(this.repG2Decoders);
+        initBitModels(this.posDecoders);
+        this.initLiteralDecoder();
+        for (let i = 0; i < 4; ++i) {
+            initBitModels(this.posSlotDecoders[i].models);
+        }
+        this.initLenDecoder(this.lenDecoder);
+        this.initLenDecoder(this.repLenDecoder);
+        initBitModels(this.posAlignDecoder.models);
+        this.initRangeDecoder();
+    }
+    initLenDecoder(decoder) {
+        initBitModels(decoder.choice);
+        for (let posState = 0; posState < decoder.numPosStates; ++posState) {
+            initBitModels(decoder.lowCoder[posState].models);
+            initBitModels(decoder.midCoder[posState].models);
+        }
+        initBitModels(decoder.highCoder.models);
+    }
+    outWindowReleaseStream() {
+        this.flush();
+        this.outWindow.stream = null;
+    }
+    decodeBit(probs, index) {
+        return this.rangeDecoder.decodeBit(probs, index);
+    }
+    decodeDirectBits(numTotalBits) {
+        return this.rangeDecoder.decodeDirectBits(numTotalBits);
+    }
+    initRangeDecoder() {
+        this.rangeDecoder.init();
+    }
+    rangeBitTreeDecoder(bitTree) {
+        let bitIndex, m = 1;
+        for (bitIndex = bitTree.numBitLevels; bitIndex != 0; bitIndex -= 1) {
+            m = (m << 1) + this.decodeBit(bitTree.models, m);
+        }
+        return m - (1 << bitTree.numBitLevels);
+    }
+    reverseDecode(models, startIndex, numBitLevels) {
+        let symbol = 0;
+        for (let bitIndex = 0, m = 1, bit; bitIndex < numBitLevels; ++bitIndex) {
+            bit = this.decodeBit(models, startIndex + m);
+            m <<= 1;
+            m += bit;
+            symbol |= bit << bitIndex;
+        }
+        return symbol;
+    }
+    reverseDecodeAlignDecoder() {
+        let symbol = 0;
+        for (let m = 1, bitIndex = 0, bit; bitIndex < this.posAlignDecoder.numBitLevels; ++bitIndex) {
+            bit = this.decodeBit(this.posAlignDecoder.models, m);
+            m <<= 1;
+            m += bit;
+            symbol |= bit << bitIndex;
+        }
+        return symbol;
+    }
+    // Update the placeholder implementations with actual logic
+    decodeNormalWithRangeDecoder(decoder) {
+        let symbol = 1;
+        do {
+            symbol = symbol << 1 | this.decodeBit(decoder.decoders, symbol);
+        } while (symbol < 0x100);
+        return symbol << 24 >> 24;
+    }
+    decodeWithMatchByteWithRangeDecoder(encoder, matchByte) {
+        let bit, matchBit, symbol = 1;
+        do {
+            matchBit = (matchByte >> 7) & 1;
+            matchByte <<= 1;
+            bit = this.decodeBit(encoder.decoders, ((1 + matchBit) << 8) + symbol);
+            symbol = symbol << 1 | bit;
+            if (matchBit != bit) {
+                while (symbol < 0x100) {
+                    symbol = symbol << 1 | this.decodeBit(encoder.decoders, symbol);
+                }
+                break;
+            }
+        } while (symbol < 0x100);
+        return symbol << 24 >> 24;
+    }
+    decodeLenWithRangeDecoder(decoder, posState) {
+        if (!this.decodeBit(decoder.choice, 0)) {
+            return this.rangeBitTreeDecoder(decoder.lowCoder[posState]);
+        }
+        let symbol = 0x08;
+        if (!this.decodeBit(decoder.choice, 1)) {
+            symbol += this.rangeBitTreeDecoder(decoder.midCoder[posState]);
+        }
+        else {
+            symbol += 0x08 + this.rangeBitTreeDecoder(decoder.highCoder);
+        }
+        return symbol;
+    }
+    codeOneChunk() {
+        let decoder2, distance, len, numDirectBits, positionSlot;
+        let posState = Number(this.nowPos64 & 0xffffffffn) & this.posStateMask;
+        if (!this.decodeBit(this.matchDecoders, (this.state << 4) + posState)) {
+            decoder2 = this.getDecoder(Number(this.nowPos64 & 0xffffffffn), this.prevByte);
+            if (this.state < 7) {
+                this.prevByte = this.decodeNormalWithRangeDecoder(decoder2);
+            }
+            else {
+                this.prevByte = this.decodeWithMatchByteWithRangeDecoder(decoder2, this.getByte(this.rep0));
+            }
+            this.putByte(this.prevByte);
+            this.state = stateUpdateChar(this.state);
+            this.nowPos64 += 1n;
+        }
+        else {
+            if (this.decodeBit(this.repDecoders, this.state)) {
+                len = 0;
+                if (!this.decodeBit(this.repG0Decoders, this.state)) {
+                    if (!this.decodeBit(this.rep0LongDecoders, (this.state << 4) + posState)) {
+                        this.state = this.state < 7 ? 9 : 11;
+                        len = 1;
+                    }
+                }
+                else {
+                    if (!this.decodeBit(this.repG1Decoders, this.state)) {
+                        distance = this.rep1;
+                    }
+                    else {
+                        if (!this.decodeBit(this.repG2Decoders, this.state)) {
+                            distance = this.rep2;
+                        }
+                        else {
+                            distance = this.rep3;
+                            this.rep3 = this.rep2;
+                        }
+                        this.rep2 = this.rep1;
+                    }
+                    this.rep1 = this.rep0;
+                    this.rep0 = distance;
+                }
+                if (!len) {
+                    len = this.decodeLenWithRangeDecoder(this.repLenDecoder, posState) + 2;
+                    this.state = this.state < 7 ? 0x08 : 11;
+                }
+            }
+            else {
+                this.rep3 = this.rep2;
+                this.rep2 = this.rep1;
+                this.rep1 = this.rep0;
+                len = 2 + this.decodeLenWithRangeDecoder(this.lenDecoder, posState);
+                this.state = this.state < 7 ? 7 : 10;
+                positionSlot = this.rangeBitTreeDecoder(this.posSlotDecoders[getLenToPosState(len)]);
+                if (positionSlot >= 4) {
+                    numDirectBits = (positionSlot >> 1) - 1;
+                    this.rep0 = (2 | (positionSlot & 1)) << numDirectBits;
+                    if (positionSlot < 14) {
+                        this.rep0 += this.reverseDecode(this.posDecoders, this.rep0 - positionSlot - 1, numDirectBits);
+                    }
+                    else {
+                        this.rep0 += this.decodeDirectBits(numDirectBits - 4) << 4;
+                        this.rep0 += this.reverseDecodeAlignDecoder();
+                        if (this.rep0 < 0) {
+                            if (this.rep0 == -1) {
+                                return 1;
+                            }
+                            return -1;
+                        }
+                    }
+                }
+                else {
+                    this.rep0 = positionSlot;
+                }
+            }
+            if (BigInt(this.rep0) >= this.nowPos64 || this.rep0 >= this.dictSizeCheck) {
+                return -1;
+            }
+            this.copyBlock(len);
+            this.nowPos64 += BigInt(len);
+            this.prevByte = this.getByte(0);
+        }
+        return 0;
+    }
+    writeToOutput(buffer, data, offset, length) {
+        buffer.writeBytes(data, offset, length);
+    }
+    flush() {
+        const size = this.outWindow.pos - this.outWindow.streamPos;
+        if (!size) {
+            return;
+        }
+        if (this.outWindow.stream && this.outWindow.buffer) {
+            this.outWindow.stream.writeBytes(this.outWindow.buffer, this.outWindow.streamPos, size);
+        }
+        if (this.outWindow.pos >= this.outWindow.windowSize) {
+            this.outWindow.pos = 0;
+        }
+        this.outWindow.streamPos = this.outWindow.pos;
+    }
+    /**
+     * Cleanup decoder resources
+     */
+    cleanup() {
+        this.outWindow.stream = null;
+        this.rangeDecoder.stream = null;
+    }
+}