xz-compat 0.1.0

package/dist/esm/lzma/sync/LzmaDecoder.js

@@ -0,0 +1,545 @@
+/**
+ * Synchronous LZMA1 Decoder
+ *
+ * Decodes LZMA1 compressed data from a buffer.
+ * All operations are synchronous.
+ */ import { allocBufferUnsafe, bufferFrom } from 'extract-base-iterator';
+import { getLenToPosState, initBitModels, kEndPosModelIndex, kMatchMinLen, kNumAlignBits, kNumFullDistances, kNumLenToPosStates, kNumLitContextBitsMax, kNumPosSlotBits, kNumPosStatesBitsMax, kNumStates, kStartPosModelIndex, parseProperties, stateIsCharState, stateUpdateChar, stateUpdateMatch, stateUpdateRep, stateUpdateShortRep } from '../types.js';
+import { BitTreeDecoder, RangeDecoder, reverseDecodeFromArray } from './RangeDecoder.js';
+/**
+ * Length decoder for match/rep lengths
+ */ let LenDecoder = class LenDecoder {
+    create(numPosStates) {
+        for(; this.numPosStates < numPosStates; this.numPosStates++){
+            this.lowCoder[this.numPosStates] = new BitTreeDecoder(3);
+            this.midCoder[this.numPosStates] = new BitTreeDecoder(3);
+        }
+    }
+    init() {
+        initBitModels(this.choice);
+        for(let i = this.numPosStates - 1; i >= 0; i--){
+            this.lowCoder[i].init();
+            this.midCoder[i].init();
+        }
+        this.highCoder.init();
+    }
+    decode(rangeDecoder, posState) {
+        if (rangeDecoder.decodeBit(this.choice, 0) === 0) {
+            return this.lowCoder[posState].decode(rangeDecoder);
+        }
+        if (rangeDecoder.decodeBit(this.choice, 1) === 0) {
+            return 8 + this.midCoder[posState].decode(rangeDecoder);
+        }
+        return 16 + this.highCoder.decode(rangeDecoder);
+    }
+    constructor(){
+        this.choice = initBitModels(null, 2);
+        this.lowCoder = [];
+        this.midCoder = [];
+        this.highCoder = new BitTreeDecoder(8);
+        this.numPosStates = 0;
+    }
+};
+/**
+ * Single literal decoder (decodes one byte)
+ */ let LiteralDecoder2 = class LiteralDecoder2 {
+    init() {
+        initBitModels(this.decoders);
+    }
+    decodeNormal(rangeDecoder) {
+        let symbol = 1;
+        do {
+            symbol = symbol << 1 | rangeDecoder.decodeBit(this.decoders, symbol);
+        }while (symbol < 0x100)
+        return symbol & 0xff;
+    }
+    decodeWithMatchByte(rangeDecoder, matchByte) {
+        let symbol = 1;
+        do {
+            const matchBit = matchByte >> 7 & 1;
+            matchByte <<= 1;
+            const bit = rangeDecoder.decodeBit(this.decoders, (1 + matchBit << 8) + symbol);
+            symbol = symbol << 1 | bit;
+            if (matchBit !== bit) {
+                while(symbol < 0x100){
+                    symbol = symbol << 1 | rangeDecoder.decodeBit(this.decoders, symbol);
+                }
+                break;
+            }
+        }while (symbol < 0x100)
+        return symbol & 0xff;
+    }
+    constructor(){
+        this.decoders = initBitModels(null, 0x300);
+    }
+};
+/**
+ * Literal decoder (array of single decoders)
+ */ let LiteralDecoder = class LiteralDecoder {
+    create(numPosBits, numPrevBits) {
+        if (this.coders.length > 0 && this.numPrevBits === numPrevBits && this.numPosBits === numPosBits) {
+            return;
+        }
+        this.numPosBits = numPosBits;
+        this.posMask = (1 << numPosBits) - 1;
+        this.numPrevBits = numPrevBits;
+        this.coders = [];
+    }
+    init() {
+        for(let i = 0; i < this.coders.length; i++){
+            if (this.coders[i]) {
+                var _this_coders_i;
+                (_this_coders_i = this.coders[i]) === null || _this_coders_i === void 0 ? void 0 : _this_coders_i.init();
+            }
+        }
+    }
+    getDecoder(pos, prevByte) {
+        const index = ((pos & this.posMask) << this.numPrevBits) + ((prevByte & 0xff) >>> 8 - this.numPrevBits);
+        let decoder = this.coders[index];
+        if (!decoder) {
+            decoder = new LiteralDecoder2();
+            this.coders[index] = decoder;
+        }
+        return decoder;
+    }
+    constructor(){
+        this.numPosBits = 0;
+        this.numPrevBits = 0;
+        this.posMask = 0;
+        this.coders = [];
+    }
+};
+/**
+ * Output window (sliding dictionary)
+ */ let OutWindow = class OutWindow {
+    create(windowSize) {
+        if (!this.buffer || this.windowSize !== windowSize) {
+            this.buffer = allocBufferUnsafe(windowSize);
+        }
+        this.windowSize = windowSize;
+        this.pos = 0;
+        this.streamPos = 0;
+    }
+    init(solid) {
+        if (!solid) {
+            this.pos = 0;
+            this.streamPos = 0;
+        }
+    }
+    putByte(b) {
+        this.buffer[this.pos++] = b;
+        if (this.pos >= this.windowSize) {
+            if (this.sink) {
+                this.flush();
+                this.pos = 0;
+                this.streamPos = 0; // Reset streamPos after wrap to track new data from pos 0
+            } else {
+                this.pos = 0;
+            }
+        }
+    }
+    flush() {
+        const size = this.pos - this.streamPos;
+        if (size > 0 && this.sink) {
+            // Use bufferFrom to create a COPY, not a view - the buffer is reused after wrapping
+            const chunk = bufferFrom(this.buffer.slice(this.streamPos, this.streamPos + size));
+            this.sink.write(chunk);
+            this.streamPos = this.pos;
+        }
+    }
+    getByte(distance) {
+        let pos = this.pos - distance - 1;
+        if (pos < 0) {
+            pos += this.windowSize;
+        }
+        return this.buffer[pos];
+    }
+    copyBlock(distance, len) {
+        let pos = this.pos - distance - 1;
+        if (pos < 0) {
+            pos += this.windowSize;
+        }
+        for(let i = 0; i < len; i++){
+            if (pos >= this.windowSize) {
+                pos = 0;
+            }
+            this.putByte(this.buffer[pos++]);
+        }
+    }
+    /**
+   * Copy decoded data to output buffer
+   */ copyTo(output, outputOffset, count) {
+        const srcPos = this.pos - count;
+        if (srcPos < 0) {
+            // Wrap around case - data spans end and beginning of buffer
+            const firstPart = -srcPos;
+            this.buffer.copy(output, outputOffset, this.windowSize + srcPos, this.windowSize);
+            this.buffer.copy(output, outputOffset + firstPart, 0, count - firstPart);
+        } else {
+            this.buffer.copy(output, outputOffset, srcPos, srcPos + count);
+        }
+    }
+    constructor(sink){
+        this.buffer = allocBufferUnsafe(0); // Replaced by create() before use
+        this.windowSize = 0;
+        this.pos = 0;
+        this.sink = sink;
+        this.streamPos = 0;
+    }
+};
+/**
+ * Synchronous LZMA1 decoder
+ */ export class LzmaDecoder {
+    /**
+   * Set dictionary size
+   */ setDictionarySize(dictionarySize) {
+        if (dictionarySize < 0) return false;
+        if (this.dictionarySize !== dictionarySize) {
+            this.dictionarySize = dictionarySize;
+            this.dictionarySizeCheck = Math.max(dictionarySize, 1);
+            this.outWindow.create(Math.max(this.dictionarySizeCheck, 1 << 12));
+        }
+        return true;
+    }
+    /**
+   * Set lc, lp, pb properties
+   */ setLcLpPb(lc, lp, pb) {
+        if (lc > kNumLitContextBitsMax || lp > 4 || pb > kNumPosStatesBitsMax) {
+            return false;
+        }
+        const numPosStates = 1 << pb;
+        this.literalDecoder.create(lp, lc);
+        this.lenDecoder.create(numPosStates);
+        this.repLenDecoder.create(numPosStates);
+        this.posStateMask = numPosStates - 1;
+        return true;
+    }
+    /**
+   * Set decoder properties from 5-byte buffer
+   */ setDecoderProperties(properties) {
+        const props = parseProperties(properties);
+        if (!this.setLcLpPb(props.lc, props.lp, props.pb)) return false;
+        return this.setDictionarySize(props.dictionarySize);
+    }
+    /**
+   * Initialize probability tables
+   */ initProbabilities() {
+        initBitModels(this.isMatchDecoders);
+        initBitModels(this.isRepDecoders);
+        initBitModels(this.isRepG0Decoders);
+        initBitModels(this.isRepG1Decoders);
+        initBitModels(this.isRepG2Decoders);
+        initBitModels(this.isRep0LongDecoders);
+        initBitModels(this.posDecoders);
+        this.literalDecoder.init();
+        for(let i = kNumLenToPosStates - 1; i >= 0; i--){
+            this.posSlotDecoder[i].init();
+        }
+        this.lenDecoder.init();
+        this.repLenDecoder.init();
+        this.posAlignDecoder.init();
+    }
+    /**
+   * Reset probabilities only (for LZMA2 state reset)
+   */ resetProbabilities() {
+        this.initProbabilities();
+        this.state = 0;
+        this.rep0 = 0;
+        this.rep1 = 0;
+        this.rep2 = 0;
+        this.rep3 = 0;
+    }
+    /**
+   * Reset dictionary position (for LZMA2 dictionary reset)
+   */ resetDictionary() {
+        this.outWindow.init(false);
+        this.totalPos = 0;
+    }
+    /**
+   * Feed uncompressed data into the dictionary (for LZMA2 uncompressed chunks)
+   * This updates the sliding window so subsequent LZMA chunks can reference this data.
+   */ feedUncompressed(data) {
+        for(let i = 0; i < data.length; i++){
+            this.outWindow.putByte(data[i]);
+        }
+        this.totalPos += data.length;
+        if (data.length > 0) {
+            this.prevByte = data[data.length - 1];
+        }
+    }
+    /**
+   * Flush any remaining data in the OutWindow to the sink
+   */ flushOutWindow() {
+        this.outWindow.flush();
+    }
+    /**
+   * Decode LZMA data with streaming output (no buffer accumulation)
+   * @param input - Compressed input buffer
+   * @param inputOffset - Offset into input buffer
+   * @param outSize - Expected output size
+   * @param solid - If true, preserve state from previous decode
+   * @returns Number of bytes written to sink
+   */ decodeWithSink(input, inputOffset, outSize, solid = false) {
+        this.rangeDecoder.setInput(input, inputOffset);
+        if (!solid) {
+            this.outWindow.init(false);
+            this.initProbabilities();
+            this.state = 0;
+            this.rep0 = 0;
+            this.rep1 = 0;
+            this.rep2 = 0;
+            this.rep3 = 0;
+            this.prevByte = 0;
+            this.totalPos = 0;
+        } else {
+            this.outWindow.init(true);
+        }
+        let outPos = 0;
+        let cumPos = this.totalPos;
+        while(outPos < outSize){
+            const posState = cumPos & this.posStateMask;
+            if (this.rangeDecoder.decodeBit(this.isMatchDecoders, (this.state << kNumPosStatesBitsMax) + posState) === 0) {
+                // Literal
+                const decoder2 = this.literalDecoder.getDecoder(cumPos, this.prevByte);
+                if (!stateIsCharState(this.state)) {
+                    this.prevByte = decoder2.decodeWithMatchByte(this.rangeDecoder, this.outWindow.getByte(this.rep0));
+                } else {
+                    this.prevByte = decoder2.decodeNormal(this.rangeDecoder);
+                }
+                this.outWindow.putByte(this.prevByte);
+                outPos++;
+                this.state = stateUpdateChar(this.state);
+                cumPos++;
+            } else {
+                // Match or rep
+                let len;
+                if (this.rangeDecoder.decodeBit(this.isRepDecoders, this.state) === 1) {
+                    // Rep match
+                    len = 0;
+                    if (this.rangeDecoder.decodeBit(this.isRepG0Decoders, this.state) === 0) {
+                        if (this.rangeDecoder.decodeBit(this.isRep0LongDecoders, (this.state << kNumPosStatesBitsMax) + posState) === 0) {
+                            this.state = stateUpdateShortRep(this.state);
+                            len = 1;
+                        }
+                    } else {
+                        let distance;
+                        if (this.rangeDecoder.decodeBit(this.isRepG1Decoders, this.state) === 0) {
+                            distance = this.rep1;
+                        } else {
+                            if (this.rangeDecoder.decodeBit(this.isRepG2Decoders, this.state) === 0) {
+                                distance = this.rep2;
+                            } else {
+                                distance = this.rep3;
+                                this.rep3 = this.rep2;
+                            }
+                            this.rep2 = this.rep1;
+                        }
+                        this.rep1 = this.rep0;
+                        this.rep0 = distance;
+                    }
+                    if (len === 0) {
+                        len = kMatchMinLen + this.repLenDecoder.decode(this.rangeDecoder, posState);
+                        this.state = stateUpdateRep(this.state);
+                    }
+                } else {
+                    // Normal match
+                    this.rep3 = this.rep2;
+                    this.rep2 = this.rep1;
+                    this.rep1 = this.rep0;
+                    len = kMatchMinLen + this.lenDecoder.decode(this.rangeDecoder, posState);
+                    this.state = stateUpdateMatch(this.state);
+                    const posSlot = this.posSlotDecoder[getLenToPosState(len)].decode(this.rangeDecoder);
+                    if (posSlot >= kStartPosModelIndex) {
+                        const numDirectBits = (posSlot >> 1) - 1;
+                        this.rep0 = (2 | posSlot & 1) << numDirectBits;
+                        if (posSlot < kEndPosModelIndex) {
+                            this.rep0 += reverseDecodeFromArray(this.posDecoders, this.rep0 - posSlot - 1, this.rangeDecoder, numDirectBits);
+                        } else {
+                            this.rep0 += this.rangeDecoder.decodeDirectBits(numDirectBits - kNumAlignBits) << kNumAlignBits;
+                            this.rep0 += this.posAlignDecoder.reverseDecode(this.rangeDecoder);
+                            if (this.rep0 < 0) {
+                                if (this.rep0 === -1) break;
+                                throw new Error('LZMA: Invalid distance');
+                            }
+                        }
+                    } else {
+                        this.rep0 = posSlot;
+                    }
+                }
+                if (this.rep0 >= cumPos || this.rep0 >= this.dictionarySizeCheck) {
+                    throw new Error('LZMA: Invalid distance');
+                }
+                // Copy match bytes
+                for(let i = 0; i < len; i++){
+                    const b = this.outWindow.getByte(this.rep0);
+                    this.outWindow.putByte(b);
+                    outPos++;
+                }
+                cumPos += len;
+                this.prevByte = this.outWindow.getByte(0);
+            }
+        }
+        this.totalPos = cumPos;
+        return outPos;
+    }
+    /**
+   * Decode LZMA data
+   * @param input - Compressed input buffer
+   * @param inputOffset - Offset into input buffer
+   * @param outSize - Expected output size
+   * @param solid - If true, preserve state from previous decode
+   * @returns Decompressed data
+   */ decode(input, inputOffset, outSize, solid = false) {
+        this.rangeDecoder.setInput(input, inputOffset);
+        if (!solid) {
+            this.outWindow.init(false);
+            this.initProbabilities();
+            this.state = 0;
+            this.rep0 = 0;
+            this.rep1 = 0;
+            this.rep2 = 0;
+            this.rep3 = 0;
+            this.prevByte = 0;
+            this.totalPos = 0;
+        } else {
+            // Solid mode: preserve dictionary state but reinitialize range decoder
+            this.outWindow.init(true);
+        }
+        const output = allocBufferUnsafe(outSize);
+        let outPos = 0;
+        let cumPos = this.totalPos;
+        while(outPos < outSize){
+            const posState = cumPos & this.posStateMask;
+            if (this.rangeDecoder.decodeBit(this.isMatchDecoders, (this.state << kNumPosStatesBitsMax) + posState) === 0) {
+                // Literal
+                const decoder2 = this.literalDecoder.getDecoder(cumPos, this.prevByte);
+                if (!stateIsCharState(this.state)) {
+                    this.prevByte = decoder2.decodeWithMatchByte(this.rangeDecoder, this.outWindow.getByte(this.rep0));
+                } else {
+                    this.prevByte = decoder2.decodeNormal(this.rangeDecoder);
+                }
+                this.outWindow.putByte(this.prevByte);
+                output[outPos++] = this.prevByte;
+                this.state = stateUpdateChar(this.state);
+                cumPos++;
+            } else {
+                // Match or rep
+                let len;
+                if (this.rangeDecoder.decodeBit(this.isRepDecoders, this.state) === 1) {
+                    // Rep match
+                    len = 0;
+                    if (this.rangeDecoder.decodeBit(this.isRepG0Decoders, this.state) === 0) {
+                        if (this.rangeDecoder.decodeBit(this.isRep0LongDecoders, (this.state << kNumPosStatesBitsMax) + posState) === 0) {
+                            this.state = stateUpdateShortRep(this.state);
+                            len = 1;
+                        }
+                    } else {
+                        let distance;
+                        if (this.rangeDecoder.decodeBit(this.isRepG1Decoders, this.state) === 0) {
+                            distance = this.rep1;
+                        } else {
+                            if (this.rangeDecoder.decodeBit(this.isRepG2Decoders, this.state) === 0) {
+                                distance = this.rep2;
+                            } else {
+                                distance = this.rep3;
+                                this.rep3 = this.rep2;
+                            }
+                            this.rep2 = this.rep1;
+                        }
+                        this.rep1 = this.rep0;
+                        this.rep0 = distance;
+                    }
+                    if (len === 0) {
+                        len = kMatchMinLen + this.repLenDecoder.decode(this.rangeDecoder, posState);
+                        this.state = stateUpdateRep(this.state);
+                    }
+                } else {
+                    // Normal match
+                    this.rep3 = this.rep2;
+                    this.rep2 = this.rep1;
+                    this.rep1 = this.rep0;
+                    len = kMatchMinLen + this.lenDecoder.decode(this.rangeDecoder, posState);
+                    this.state = stateUpdateMatch(this.state);
+                    const posSlot = this.posSlotDecoder[getLenToPosState(len)].decode(this.rangeDecoder);
+                    if (posSlot >= kStartPosModelIndex) {
+                        const numDirectBits = (posSlot >> 1) - 1;
+                        this.rep0 = (2 | posSlot & 1) << numDirectBits;
+                        if (posSlot < kEndPosModelIndex) {
+                            this.rep0 += reverseDecodeFromArray(this.posDecoders, this.rep0 - posSlot - 1, this.rangeDecoder, numDirectBits);
+                        } else {
+                            this.rep0 += this.rangeDecoder.decodeDirectBits(numDirectBits - kNumAlignBits) << kNumAlignBits;
+                            this.rep0 += this.posAlignDecoder.reverseDecode(this.rangeDecoder);
+                            if (this.rep0 < 0) {
+                                if (this.rep0 === -1) break; // End marker
+                                throw new Error('LZMA: Invalid distance');
+                            }
+                        }
+                    } else {
+                        this.rep0 = posSlot;
+                    }
+                }
+                if (this.rep0 >= cumPos || this.rep0 >= this.dictionarySizeCheck) {
+                    throw new Error('LZMA: Invalid distance');
+                }
+                // Copy match bytes
+                for(let i = 0; i < len; i++){
+                    const b = this.outWindow.getByte(this.rep0);
+                    this.outWindow.putByte(b);
+                    output[outPos++] = b;
+                }
+                cumPos += len;
+                this.prevByte = this.outWindow.getByte(0);
+            }
+        }
+        this.totalPos = cumPos;
+        return output;
+    }
+    constructor(outputSink){
+        this.outWindow = new OutWindow(outputSink);
+        this.rangeDecoder = new RangeDecoder();
+        this.isMatchDecoders = initBitModels(null, kNumStates << kNumPosStatesBitsMax);
+        this.isRepDecoders = initBitModels(null, kNumStates);
+        this.isRepG0Decoders = initBitModels(null, kNumStates);
+        this.isRepG1Decoders = initBitModels(null, kNumStates);
+        this.isRepG2Decoders = initBitModels(null, kNumStates);
+        this.isRep0LongDecoders = initBitModels(null, kNumStates << kNumPosStatesBitsMax);
+        this.posSlotDecoder = [];
+        this.posDecoders = initBitModels(null, kNumFullDistances - kEndPosModelIndex);
+        this.posAlignDecoder = new BitTreeDecoder(kNumAlignBits);
+        this.lenDecoder = new LenDecoder();
+        this.repLenDecoder = new LenDecoder();
+        this.literalDecoder = new LiteralDecoder();
+        for(let i = 0; i < kNumLenToPosStates; i++){
+            this.posSlotDecoder[i] = new BitTreeDecoder(kNumPosSlotBits);
+        }
+        this.dictionarySize = -1;
+        this.dictionarySizeCheck = -1;
+        this.posStateMask = 0;
+        this.state = 0;
+        this.rep0 = 0;
+        this.rep1 = 0;
+        this.rep2 = 0;
+        this.rep3 = 0;
+        this.prevByte = 0;
+        this.totalPos = 0;
+    }
+}
+/**
+ * Decode LZMA1 data synchronously
+ * @param input - Compressed data (without 5-byte properties header)
+ * @param properties - 5-byte LZMA properties
+ * @param outSize - Expected output size
+ * @param outputSink - Optional output sink for zero-copy decoding (returns bytes written)
+ * @returns Decompressed data (or bytes written if outputSink provided)
+ */ export function decodeLzma(input, properties, outSize, outputSink) {
+    const decoder = new LzmaDecoder(outputSink);
+    decoder.setDecoderProperties(properties);
+    if (outputSink) {
+        // Zero-copy mode: write to sink during decode
+        const bytesWritten = decoder.decodeWithSink(input, 0, outSize, false);
+        decoder.flushOutWindow();
+        return bytesWritten;
+    }
+    // Buffering mode: pre-allocated buffer, direct writes (zero-copy)
+    return decoder.decode(input, 0, outSize, false);
+}

package/dist/esm/lzma/sync/LzmaDecoder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/lzma/sync/LzmaDecoder.ts"],"sourcesContent":["/**\n * Synchronous LZMA1 Decoder\n *\n * Decodes LZMA1 compressed data from a buffer.\n * All operations are synchronous.\n */\n\nimport { allocBufferUnsafe, bufferFrom } from 'extract-base-iterator';\nimport {\n  getLenToPosState,\n  initBitModels,\n  kEndPosModelIndex,\n  kMatchMinLen,\n  kNumAlignBits,\n  kNumFullDistances,\n  kNumLenToPosStates,\n  kNumLitContextBitsMax,\n  kNumPosSlotBits,\n  kNumPosStatesBitsMax,\n  kNumStates,\n  kStartPosModelIndex,\n  type OutputSink,\n  parseProperties,\n  stateIsCharState,\n  stateUpdateChar,\n  stateUpdateMatch,\n  stateUpdateRep,\n  stateUpdateShortRep,\n} from '../types.ts';\nimport { BitTreeDecoder, RangeDecoder, reverseDecodeFromArray } from './RangeDecoder.ts';\n\n/**\n * Length decoder for match/rep lengths\n */\nclass LenDecoder {\n  private choice: Uint16Array;\n  private lowCoder: BitTreeDecoder[];\n  private midCoder: BitTreeDecoder[];\n  private highCoder: BitTreeDecoder;\n  private numPosStates: number;\n\n  constructor() {\n    this.choice = initBitModels(null, 2);\n    this.lowCoder = [];\n    this.midCoder = [];\n    this.highCoder = new BitTreeDecoder(8);\n    this.numPosStates = 0;\n  }\n\n  create(numPosStates: number): void {\n    for (; this.numPosStates < numPosStates; this.numPosStates++) {\n      this.lowCoder[this.numPosStates] = new BitTreeDecoder(3);\n      this.midCoder[this.numPosStates] = new BitTreeDecoder(3);\n    }\n  }\n\n  init(): void {\n    initBitModels(this.choice);\n    for (let i = this.numPosStates - 1; i >= 0; i--) {\n      this.lowCoder[i].init();\n      this.midCoder[i].init();\n    }\n    this.highCoder.init();\n  }\n\n  decode(rangeDecoder: RangeDecoder, posState: number): number {\n    if (rangeDecoder.decodeBit(this.choice, 0) === 0) {\n      return this.lowCoder[posState].decode(rangeDecoder);\n    }\n    if (rangeDecoder.decodeBit(this.choice, 1) === 0) {\n      return 8 + this.midCoder[posState].decode(rangeDecoder);\n    }\n    return 16 + this.highCoder.decode(rangeDecoder);\n  }\n}\n\n/**\n * Single literal decoder (decodes one byte)\n */\nclass LiteralDecoder2 {\n  private decoders: Uint16Array;\n\n  constructor() {\n    this.decoders = initBitModels(null, 0x300);\n  }\n\n  init(): void {\n    initBitModels(this.decoders);\n  }\n\n  decodeNormal(rangeDecoder: RangeDecoder): number {\n    let symbol = 1;\n    do {\n      symbol = (symbol << 1) | rangeDecoder.decodeBit(this.decoders, symbol);\n    } while (symbol < 0x100);\n    return symbol & 0xff;\n  }\n\n  decodeWithMatchByte(rangeDecoder: RangeDecoder, matchByte: number): number {\n    let symbol = 1;\n    do {\n      const matchBit = (matchByte >> 7) & 1;\n      matchByte <<= 1;\n      const bit = rangeDecoder.decodeBit(this.decoders, ((1 + matchBit) << 8) + symbol);\n      symbol = (symbol << 1) | bit;\n      if (matchBit !== bit) {\n        while (symbol < 0x100) {\n          symbol = (symbol << 1) | rangeDecoder.decodeBit(this.decoders, symbol);\n        }\n        break;\n      }\n    } while (symbol < 0x100);\n    return symbol & 0xff;\n  }\n}\n\n/**\n * Literal decoder (array of single decoders)\n */\nclass LiteralDecoder {\n  private numPosBits: number;\n  private numPrevBits: number;\n  private posMask: number;\n  private coders: (LiteralDecoder2 | undefined)[];\n\n  constructor() {\n    this.numPosBits = 0;\n    this.numPrevBits = 0;\n    this.posMask = 0;\n    this.coders = [];\n  }\n\n  create(numPosBits: number, numPrevBits: number): void {\n    if (this.coders.length > 0 && this.numPrevBits === numPrevBits && this.numPosBits === numPosBits) {\n      return;\n    }\n    this.numPosBits = numPosBits;\n    this.posMask = (1 << numPosBits) - 1;\n    this.numPrevBits = numPrevBits;\n    this.coders = [];\n  }\n\n  init(): void {\n    for (let i = 0; i < this.coders.length; i++) {\n      if (this.coders[i]) {\n        this.coders[i]?.init();\n      }\n    }\n  }\n\n  getDecoder(pos: number, prevByte: number): LiteralDecoder2 {\n    const index = ((pos & this.posMask) << this.numPrevBits) + ((prevByte & 0xff) >>> (8 - this.numPrevBits));\n    let decoder = this.coders[index];\n    if (!decoder) {\n      decoder = new LiteralDecoder2();\n      this.coders[index] = decoder;\n    }\n    return decoder;\n  }\n}\n\n/**\n * Output window (sliding dictionary)\n */\nclass OutWindow {\n  private buffer: Buffer;\n  private windowSize: number;\n  private pos: number;\n  private sink?: {\n    write(buffer: Buffer): void;\n  };\n  private streamPos: number;\n\n  constructor(sink?: OutputSink) {\n    this.buffer = allocBufferUnsafe(0); // Replaced by create() before use\n    this.windowSize = 0;\n    this.pos = 0;\n    this.sink = sink;\n    this.streamPos = 0;\n  }\n\n  create(windowSize: number): void {\n    if (!this.buffer || this.windowSize !== windowSize) {\n      this.buffer = allocBufferUnsafe(windowSize);\n    }\n    this.windowSize = windowSize;\n    this.pos = 0;\n    this.streamPos = 0;\n  }\n\n  init(solid: boolean): void {\n    if (!solid) {\n      this.pos = 0;\n      this.streamPos = 0;\n    }\n  }\n\n  putByte(b: number): void {\n    this.buffer[this.pos++] = b;\n    if (this.pos >= this.windowSize) {\n      if (this.sink) {\n        this.flush();\n        this.pos = 0;\n        this.streamPos = 0; // Reset streamPos after wrap to track new data from pos 0\n      } else {\n        this.pos = 0;\n      }\n    }\n  }\n\n  flush(): void {\n    const size = this.pos - this.streamPos;\n    if (size > 0 && this.sink) {\n      // Use bufferFrom to create a COPY, not a view - the buffer is reused after wrapping\n      const chunk = bufferFrom(this.buffer.slice(this.streamPos, this.streamPos + size));\n      this.sink.write(chunk);\n      this.streamPos = this.pos;\n    }\n  }\n\n  getByte(distance: number): number {\n    let pos = this.pos - distance - 1;\n    if (pos < 0) {\n      pos += this.windowSize;\n    }\n    return this.buffer[pos];\n  }\n\n  copyBlock(distance: number, len: number): void {\n    let pos = this.pos - distance - 1;\n    if (pos < 0) {\n      pos += this.windowSize;\n    }\n    for (let i = 0; i < len; i++) {\n      if (pos >= this.windowSize) {\n        pos = 0;\n      }\n      this.putByte(this.buffer[pos++]);\n    }\n  }\n\n  /**\n   * Copy decoded data to output buffer\n   */\n  copyTo(output: Buffer, outputOffset: number, count: number): void {\n    const srcPos = this.pos - count;\n    if (srcPos < 0) {\n      // Wrap around case - data spans end and beginning of buffer\n      const firstPart = -srcPos;\n      this.buffer.copy(output, outputOffset, this.windowSize + srcPos, this.windowSize);\n      this.buffer.copy(output, outputOffset + firstPart, 0, count - firstPart);\n    } else {\n      this.buffer.copy(output, outputOffset, srcPos, srcPos + count);\n    }\n  }\n}\n\n/**\n * Synchronous LZMA1 decoder\n */\nexport class LzmaDecoder {\n  private outWindow: OutWindow;\n  private rangeDecoder: RangeDecoder;\n\n  // Probability models\n  private isMatchDecoders: Uint16Array;\n  private isRepDecoders: Uint16Array;\n  private isRepG0Decoders: Uint16Array;\n  private isRepG1Decoders: Uint16Array;\n  private isRepG2Decoders: Uint16Array;\n  private isRep0LongDecoders: Uint16Array;\n  private posSlotDecoder: BitTreeDecoder[];\n  private posDecoders: Uint16Array;\n  private posAlignDecoder: BitTreeDecoder;\n  private lenDecoder: LenDecoder;\n  private repLenDecoder: LenDecoder;\n  private literalDecoder: LiteralDecoder;\n\n  // Properties\n  private dictionarySize: number;\n  private dictionarySizeCheck: number;\n  private posStateMask: number;\n\n  // State (preserved across solid calls)\n  private state: number;\n  private rep0: number;\n  private rep1: number;\n  private rep2: number;\n  private rep3: number;\n  private prevByte: number;\n  private totalPos: number;\n\n  constructor(outputSink?: OutputSink) {\n    this.outWindow = new OutWindow(outputSink);\n    this.rangeDecoder = new RangeDecoder();\n\n    this.isMatchDecoders = initBitModels(null, kNumStates << kNumPosStatesBitsMax);\n    this.isRepDecoders = initBitModels(null, kNumStates);\n    this.isRepG0Decoders = initBitModels(null, kNumStates);\n    this.isRepG1Decoders = initBitModels(null, kNumStates);\n    this.isRepG2Decoders = initBitModels(null, kNumStates);\n    this.isRep0LongDecoders = initBitModels(null, kNumStates << kNumPosStatesBitsMax);\n    this.posSlotDecoder = [];\n    this.posDecoders = initBitModels(null, kNumFullDistances - kEndPosModelIndex);\n    this.posAlignDecoder = new BitTreeDecoder(kNumAlignBits);\n    this.lenDecoder = new LenDecoder();\n    this.repLenDecoder = new LenDecoder();\n    this.literalDecoder = new LiteralDecoder();\n\n    for (let i = 0; i < kNumLenToPosStates; i++) {\n      this.posSlotDecoder[i] = new BitTreeDecoder(kNumPosSlotBits);\n    }\n\n    this.dictionarySize = -1;\n    this.dictionarySizeCheck = -1;\n    this.posStateMask = 0;\n\n    this.state = 0;\n    this.rep0 = 0;\n    this.rep1 = 0;\n    this.rep2 = 0;\n    this.rep3 = 0;\n    this.prevByte = 0;\n    this.totalPos = 0;\n  }\n\n  /**\n   * Set dictionary size\n   */\n  setDictionarySize(dictionarySize: number): boolean {\n    if (dictionarySize < 0) return false;\n    if (this.dictionarySize !== dictionarySize) {\n      this.dictionarySize = dictionarySize;\n      this.dictionarySizeCheck = Math.max(dictionarySize, 1);\n      this.outWindow.create(Math.max(this.dictionarySizeCheck, 1 << 12));\n    }\n    return true;\n  }\n\n  /**\n   * Set lc, lp, pb properties\n   */\n  setLcLpPb(lc: number, lp: number, pb: number): boolean {\n    if (lc > kNumLitContextBitsMax || lp > 4 || pb > kNumPosStatesBitsMax) {\n      return false;\n    }\n    const numPosStates = 1 << pb;\n    this.literalDecoder.create(lp, lc);\n    this.lenDecoder.create(numPosStates);\n    this.repLenDecoder.create(numPosStates);\n    this.posStateMask = numPosStates - 1;\n    return true;\n  }\n\n  /**\n   * Set decoder properties from 5-byte buffer\n   */\n  setDecoderProperties(properties: Buffer | Uint8Array): boolean {\n    const props = parseProperties(properties);\n    if (!this.setLcLpPb(props.lc, props.lp, props.pb)) return false;\n    return this.setDictionarySize(props.dictionarySize);\n  }\n\n  /**\n   * Initialize probability tables\n   */\n  private initProbabilities(): void {\n    initBitModels(this.isMatchDecoders);\n    initBitModels(this.isRepDecoders);\n    initBitModels(this.isRepG0Decoders);\n    initBitModels(this.isRepG1Decoders);\n    initBitModels(this.isRepG2Decoders);\n    initBitModels(this.isRep0LongDecoders);\n    initBitModels(this.posDecoders);\n    this.literalDecoder.init();\n    for (let i = kNumLenToPosStates - 1; i >= 0; i--) {\n      this.posSlotDecoder[i].init();\n    }\n    this.lenDecoder.init();\n    this.repLenDecoder.init();\n    this.posAlignDecoder.init();\n  }\n\n  /**\n   * Reset probabilities only (for LZMA2 state reset)\n   */\n  resetProbabilities(): void {\n    this.initProbabilities();\n    this.state = 0;\n    this.rep0 = 0;\n    this.rep1 = 0;\n    this.rep2 = 0;\n    this.rep3 = 0;\n  }\n\n  /**\n   * Reset dictionary position (for LZMA2 dictionary reset)\n   */\n  resetDictionary(): void {\n    this.outWindow.init(false);\n    this.totalPos = 0;\n  }\n\n  /**\n   * Feed uncompressed data into the dictionary (for LZMA2 uncompressed chunks)\n   * This updates the sliding window so subsequent LZMA chunks can reference this data.\n   */\n  feedUncompressed(data: Buffer): void {\n    for (let i = 0; i < data.length; i++) {\n      this.outWindow.putByte(data[i]);\n    }\n    this.totalPos += data.length;\n    if (data.length > 0) {\n      this.prevByte = data[data.length - 1];\n    }\n  }\n\n  /**\n   * Flush any remaining data in the OutWindow to the sink\n   */\n  flushOutWindow(): void {\n    this.outWindow.flush();\n  }\n\n  /**\n   * Decode LZMA data with streaming output (no buffer accumulation)\n   * @param input - Compressed input buffer\n   * @param inputOffset - Offset into input buffer\n   * @param outSize - Expected output size\n   * @param solid - If true, preserve state from previous decode\n   * @returns Number of bytes written to sink\n   */\n  decodeWithSink(input: Buffer, inputOffset: number, outSize: number, solid = false): number {\n    this.rangeDecoder.setInput(input, inputOffset);\n\n    if (!solid) {\n      this.outWindow.init(false);\n      this.initProbabilities();\n      this.state = 0;\n      this.rep0 = 0;\n      this.rep1 = 0;\n      this.rep2 = 0;\n      this.rep3 = 0;\n      this.prevByte = 0;\n      this.totalPos = 0;\n    } else {\n      this.outWindow.init(true);\n    }\n\n    let outPos = 0;\n    let cumPos = this.totalPos;\n\n    while (outPos < outSize) {\n      const posState = cumPos & this.posStateMask;\n\n      if (this.rangeDecoder.decodeBit(this.isMatchDecoders, (this.state << kNumPosStatesBitsMax) + posState) === 0) {\n        // Literal\n        const decoder2 = this.literalDecoder.getDecoder(cumPos, this.prevByte);\n        if (!stateIsCharState(this.state)) {\n          this.prevByte = decoder2.decodeWithMatchByte(this.rangeDecoder, this.outWindow.getByte(this.rep0));\n        } else {\n          this.prevByte = decoder2.decodeNormal(this.rangeDecoder);\n        }\n        this.outWindow.putByte(this.prevByte);\n        outPos++;\n        this.state = stateUpdateChar(this.state);\n        cumPos++;\n      } else {\n        // Match or rep\n        let len: number;\n\n        if (this.rangeDecoder.decodeBit(this.isRepDecoders, this.state) === 1) {\n          // Rep match\n          len = 0;\n          if (this.rangeDecoder.decodeBit(this.isRepG0Decoders, this.state) === 0) {\n            if (this.rangeDecoder.decodeBit(this.isRep0LongDecoders, (this.state << kNumPosStatesBitsMax) + posState) === 0) {\n              this.state = stateUpdateShortRep(this.state);\n              len = 1;\n            }\n          } else {\n            let distance: number;\n            if (this.rangeDecoder.decodeBit(this.isRepG1Decoders, this.state) === 0) {\n              distance = this.rep1;\n            } else {\n              if (this.rangeDecoder.decodeBit(this.isRepG2Decoders, this.state) === 0) {\n                distance = this.rep2;\n              } else {\n                distance = this.rep3;\n                this.rep3 = this.rep2;\n              }\n              this.rep2 = this.rep1;\n            }\n            this.rep1 = this.rep0;\n            this.rep0 = distance;\n          }\n          if (len === 0) {\n            len = kMatchMinLen + this.repLenDecoder.decode(this.rangeDecoder, posState);\n            this.state = stateUpdateRep(this.state);\n          }\n        } else {\n          // Normal match\n          this.rep3 = this.rep2;\n          this.rep2 = this.rep1;\n          this.rep1 = this.rep0;\n          len = kMatchMinLen + this.lenDecoder.decode(this.rangeDecoder, posState);\n          this.state = stateUpdateMatch(this.state);\n\n          const posSlot = this.posSlotDecoder[getLenToPosState(len)].decode(this.rangeDecoder);\n          if (posSlot >= kStartPosModelIndex) {\n            const numDirectBits = (posSlot >> 1) - 1;\n            this.rep0 = (2 | (posSlot & 1)) << numDirectBits;\n            if (posSlot < kEndPosModelIndex) {\n              this.rep0 += reverseDecodeFromArray(this.posDecoders, this.rep0 - posSlot - 1, this.rangeDecoder, numDirectBits);\n            } else {\n              this.rep0 += this.rangeDecoder.decodeDirectBits(numDirectBits - kNumAlignBits) << kNumAlignBits;\n              this.rep0 += this.posAlignDecoder.reverseDecode(this.rangeDecoder);\n              if (this.rep0 < 0) {\n                if (this.rep0 === -1) break;\n                throw new Error('LZMA: Invalid distance');\n              }\n            }\n          } else {\n            this.rep0 = posSlot;\n          }\n        }\n\n        if (this.rep0 >= cumPos || this.rep0 >= this.dictionarySizeCheck) {\n          throw new Error('LZMA: Invalid distance');\n        }\n\n        // Copy match bytes\n        for (let i = 0; i < len; i++) {\n          const b = this.outWindow.getByte(this.rep0);\n          this.outWindow.putByte(b);\n          outPos++;\n        }\n        cumPos += len;\n        this.prevByte = this.outWindow.getByte(0);\n      }\n    }\n\n    this.totalPos = cumPos;\n    return outPos;\n  }\n\n  /**\n   * Decode LZMA data\n   * @param input - Compressed input buffer\n   * @param inputOffset - Offset into input buffer\n   * @param outSize - Expected output size\n   * @param solid - If true, preserve state from previous decode\n   * @returns Decompressed data\n   */\n  decode(input: Buffer, inputOffset: number, outSize: number, solid = false): Buffer {\n    this.rangeDecoder.setInput(input, inputOffset);\n\n    if (!solid) {\n      this.outWindow.init(false);\n      this.initProbabilities();\n      this.state = 0;\n      this.rep0 = 0;\n      this.rep1 = 0;\n      this.rep2 = 0;\n      this.rep3 = 0;\n      this.prevByte = 0;\n      this.totalPos = 0;\n    } else {\n      // Solid mode: preserve dictionary state but reinitialize range decoder\n      this.outWindow.init(true);\n    }\n\n    const output = allocBufferUnsafe(outSize);\n    let outPos = 0;\n    let cumPos = this.totalPos;\n\n    while (outPos < outSize) {\n      const posState = cumPos & this.posStateMask;\n\n      if (this.rangeDecoder.decodeBit(this.isMatchDecoders, (this.state << kNumPosStatesBitsMax) + posState) === 0) {\n        // Literal\n        const decoder2 = this.literalDecoder.getDecoder(cumPos, this.prevByte);\n        if (!stateIsCharState(this.state)) {\n          this.prevByte = decoder2.decodeWithMatchByte(this.rangeDecoder, this.outWindow.getByte(this.rep0));\n        } else {\n          this.prevByte = decoder2.decodeNormal(this.rangeDecoder);\n        }\n        this.outWindow.putByte(this.prevByte);\n        output[outPos++] = this.prevByte;\n        this.state = stateUpdateChar(this.state);\n        cumPos++;\n      } else {\n        // Match or rep\n        let len: number;\n\n        if (this.rangeDecoder.decodeBit(this.isRepDecoders, this.state) === 1) {\n          // Rep match\n          len = 0;\n          if (this.rangeDecoder.decodeBit(this.isRepG0Decoders, this.state) === 0) {\n            if (this.rangeDecoder.decodeBit(this.isRep0LongDecoders, (this.state << kNumPosStatesBitsMax) + posState) === 0) {\n              this.state = stateUpdateShortRep(this.state);\n              len = 1;\n            }\n          } else {\n            let distance: number;\n            if (this.rangeDecoder.decodeBit(this.isRepG1Decoders, this.state) === 0) {\n              distance = this.rep1;\n            } else {\n              if (this.rangeDecoder.decodeBit(this.isRepG2Decoders, this.state) === 0) {\n                distance = this.rep2;\n              } else {\n                distance = this.rep3;\n                this.rep3 = this.rep2;\n              }\n              this.rep2 = this.rep1;\n            }\n            this.rep1 = this.rep0;\n            this.rep0 = distance;\n          }\n          if (len === 0) {\n            len = kMatchMinLen + this.repLenDecoder.decode(this.rangeDecoder, posState);\n            this.state = stateUpdateRep(this.state);\n          }\n        } else {\n          // Normal match\n          this.rep3 = this.rep2;\n          this.rep2 = this.rep1;\n          this.rep1 = this.rep0;\n          len = kMatchMinLen + this.lenDecoder.decode(this.rangeDecoder, posState);\n          this.state = stateUpdateMatch(this.state);\n\n          const posSlot = this.posSlotDecoder[getLenToPosState(len)].decode(this.rangeDecoder);\n          if (posSlot >= kStartPosModelIndex) {\n            const numDirectBits = (posSlot >> 1) - 1;\n            this.rep0 = (2 | (posSlot & 1)) << numDirectBits;\n            if (posSlot < kEndPosModelIndex) {\n              this.rep0 += reverseDecodeFromArray(this.posDecoders, this.rep0 - posSlot - 1, this.rangeDecoder, numDirectBits);\n            } else {\n              this.rep0 += this.rangeDecoder.decodeDirectBits(numDirectBits - kNumAlignBits) << kNumAlignBits;\n              this.rep0 += this.posAlignDecoder.reverseDecode(this.rangeDecoder);\n              if (this.rep0 < 0) {\n                if (this.rep0 === -1) break; // End marker\n                throw new Error('LZMA: Invalid distance');\n              }\n            }\n          } else {\n            this.rep0 = posSlot;\n          }\n        }\n\n        if (this.rep0 >= cumPos || this.rep0 >= this.dictionarySizeCheck) {\n          throw new Error('LZMA: Invalid distance');\n        }\n\n        // Copy match bytes\n        for (let i = 0; i < len; i++) {\n          const b = this.outWindow.getByte(this.rep0);\n          this.outWindow.putByte(b);\n          output[outPos++] = b;\n        }\n        cumPos += len;\n        this.prevByte = this.outWindow.getByte(0);\n      }\n    }\n\n    this.totalPos = cumPos;\n    return output;\n  }\n}\n\n/**\n * Decode LZMA1 data synchronously\n * @param input - Compressed data (without 5-byte properties header)\n * @param properties - 5-byte LZMA properties\n * @param outSize - Expected output size\n * @param outputSink - Optional output sink for zero-copy decoding (returns bytes written)\n * @returns Decompressed data (or bytes written if outputSink provided)\n */\nexport function decodeLzma(input: Buffer, properties: Buffer | Uint8Array, outSize: number, outputSink?: OutputSink): Buffer | number {\n  const decoder = new LzmaDecoder(outputSink);\n  decoder.setDecoderProperties(properties);\n  if (outputSink) {\n    // Zero-copy mode: write to sink during decode\n    const bytesWritten = decoder.decodeWithSink(input, 0, outSize, false);\n    decoder.flushOutWindow();\n    return bytesWritten;\n  }\n  // Buffering mode: pre-allocated buffer, direct writes (zero-copy)\n  return decoder.decode(input, 0, outSize, false);\n}\n"],"names":["allocBufferUnsafe","bufferFrom","getLenToPosState","initBitModels","kEndPosModelIndex","kMatchMinLen","kNumAlignBits","kNumFullDistances","kNumLenToPosStates","kNumLitContextBitsMax","kNumPosSlotBits","kNumPosStatesBitsMax","kNumStates","kStartPosModelIndex","parseProperties","stateIsCharState","stateUpdateChar","stateUpdateMatch","stateUpdateRep","stateUpdateShortRep","BitTreeDecoder","RangeDecoder","reverseDecodeFromArray","LenDecoder","create","numPosStates","lowCoder","midCoder","init","choice","i","highCoder","decode","rangeDecoder","posState","decodeBit","LiteralDecoder2","decoders","decodeNormal","symbol","decodeWithMatchByte","matchByte","matchBit","bit","LiteralDecoder","numPosBits","numPrevBits","coders","length","posMask","getDecoder","pos","prevByte","index","decoder","OutWindow","windowSize","buffer","streamPos","solid","putByte","b","sink","flush","size","chunk","slice","write","getByte","distance","copyBlock","len","copyTo","output","outputOffset","count","srcPos","firstPart","copy","LzmaDecoder","setDictionarySize","dictionarySize","dictionarySizeCheck","Math","max","outWindow","setLcLpPb","lc","lp","pb","literalDecoder","lenDecoder","repLenDecoder","posStateMask","setDecoderProperties","properties","props","initProbabilities","isMatchDecoders","isRepDecoders","isRepG0Decoders","isRepG1Decoders","isRepG2Decoders","isRep0LongDecoders","posDecoders","posSlotDecoder","posAlignDecoder","resetProbabilities","state","rep0","rep1","rep2","rep3","resetDictionary","totalPos","feedUncompressed","data","flushOutWindow","decodeWithSink","input","inputOffset","outSize","setInput","outPos","cumPos","decoder2","posSlot","numDirectBits","decodeDirectBits","reverseDecode","Error","outputSink","decodeLzma","bytesWritten"],"mappings":"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"}