7z-iterator 1.3.1 → 2.0.0

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

@@ -1,115 +0,0 @@
-/**
- * Synchronous LZMA2 Decoder
- *
- * LZMA2 is a container format that wraps LZMA chunks with framing.
- * Decodes LZMA2 data from a buffer.
- */ import { allocBufferUnsafe } from 'extract-base-iterator';
-import { parseLzma2ChunkHeader } from '../Lzma2ChunkParser.js';
-import { parseLzma2DictionarySize } from '../types.js';
-import { LzmaDecoder } from './LzmaDecoder.js';
-/**
- * Synchronous LZMA2 decoder
- */ export class Lzma2Decoder {
-    /**
-   * Decode LZMA2 data
-   * @param input - LZMA2 compressed data
-   * @param unpackSize - Expected output size (optional, for pre-allocation)
-   * @returns Decompressed data
-   */ decode(input, unpackSize) {
-        // Pre-allocate output buffer if size is known
-        let outputBuffer = null;
-        let outputPos = 0;
-        const outputChunks = [];
-        if (unpackSize && unpackSize > 0) {
-            outputBuffer = allocBufferUnsafe(unpackSize);
-        }
-        let offset = 0;
-        while(offset < input.length){
-            const result = parseLzma2ChunkHeader(input, offset);
-            if (!result.success) {
-                throw new Error('Truncated LZMA2 chunk header');
-            }
-            const chunk = result.chunk;
-            if (chunk.type === 'end') {
-                break;
-            }
-            // Validate we have enough data for the chunk
-            const dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;
-            if (offset + chunk.headerSize + dataSize > input.length) {
-                throw new Error(`Truncated LZMA2 ${chunk.type} data`);
-            }
-            // Handle dictionary reset
-            if (chunk.dictReset) {
-                this.lzmaDecoder.resetDictionary();
-            }
-            const dataOffset = offset + chunk.headerSize;
-            if (chunk.type === 'uncompressed') {
-                const uncompData = input.slice(dataOffset, dataOffset + chunk.uncompSize);
-                // Copy to output
-                if (outputBuffer) {
-                    uncompData.copy(outputBuffer, outputPos);
-                    outputPos += uncompData.length;
-                } else {
-                    outputChunks.push(uncompData);
-                }
-                // Feed uncompressed data to dictionary so subsequent LZMA chunks can reference it
-                this.lzmaDecoder.feedUncompressed(uncompData);
-                offset = dataOffset + chunk.uncompSize;
-            } else {
-                // LZMA compressed chunk
-                // Apply new properties if present
-                if (chunk.newProps) {
-                    const { lc, lp, pb } = chunk.newProps;
-                    if (!this.lzmaDecoder.setLcLpPb(lc, lp, pb)) {
-                        throw new Error(`Invalid LZMA properties: lc=${lc} lp=${lp} pb=${pb}`);
-                    }
-                    this.propsSet = true;
-                }
-                if (!this.propsSet) {
-                    throw new Error('LZMA chunk without properties');
-                }
-                // Reset probabilities if state reset
-                if (chunk.stateReset) {
-                    this.lzmaDecoder.resetProbabilities();
-                }
-                // Determine solid mode - preserve dictionary if not resetting state or if only resetting state (not dict)
-                const useSolid = !chunk.stateReset || chunk.stateReset && !chunk.dictReset;
-                // Decode LZMA chunk
-                const chunkData = input.slice(dataOffset, dataOffset + chunk.compSize);
-                const decoded = this.lzmaDecoder.decode(chunkData, 0, chunk.uncompSize, useSolid);
-                // Copy to output
-                if (outputBuffer) {
-                    decoded.copy(outputBuffer, outputPos);
-                    outputPos += decoded.length;
-                } else {
-                    outputChunks.push(decoded);
-                }
-                offset = dataOffset + chunk.compSize;
-            }
-        }
-        // Return pre-allocated buffer or concatenated chunks
-        if (outputBuffer) {
-            return outputPos < outputBuffer.length ? outputBuffer.slice(0, outputPos) : outputBuffer;
-        }
-        return Buffer.concat(outputChunks);
-    }
-    constructor(properties){
-        if (!properties || properties.length < 1) {
-            throw new Error('LZMA2 requires properties byte');
-        }
-        this.dictionarySize = parseLzma2DictionarySize(properties[0]);
-        this.lzmaDecoder = new LzmaDecoder();
-        this.lzmaDecoder.setDictionarySize(this.dictionarySize);
-        this.propsSet = false;
-    }
-}
-/**
- * Decode LZMA2 data synchronously
- * @param input - LZMA2 compressed data
- * @param properties - 1-byte properties (dictionary size)
- * @param unpackSize - Expected output size (optional)
- * @returns Decompressed data
- */ export function decodeLzma2(input, properties, unpackSize) {
-    const decoder = new Lzma2Decoder(properties);
-    return decoder.decode(input, unpackSize);
-}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/lzma/sync/Lzma2Decoder.ts"],"sourcesContent":["/**\n * Synchronous LZMA2 Decoder\n *\n * LZMA2 is a container format that wraps LZMA chunks with framing.\n * Decodes LZMA2 data from a buffer.\n */\n\nimport { allocBufferUnsafe } from 'extract-base-iterator';\nimport { parseLzma2ChunkHeader } from '../Lzma2ChunkParser.ts';\nimport { parseLzma2DictionarySize } from '../types.ts';\nimport { LzmaDecoder } from './LzmaDecoder.ts';\n\n/**\n * Synchronous LZMA2 decoder\n */\nexport class Lzma2Decoder {\n  private lzmaDecoder: LzmaDecoder;\n  private dictionarySize: number;\n  private propsSet: boolean;\n\n  constructor(properties: Buffer | Uint8Array) {\n    if (!properties || properties.length < 1) {\n      throw new Error('LZMA2 requires properties byte');\n    }\n\n    this.dictionarySize = parseLzma2DictionarySize(properties[0]);\n    this.lzmaDecoder = new LzmaDecoder();\n    this.lzmaDecoder.setDictionarySize(this.dictionarySize);\n    this.propsSet = false;\n  }\n\n  /**\n   * Decode LZMA2 data\n   * @param input - LZMA2 compressed data\n   * @param unpackSize - Expected output size (optional, for pre-allocation)\n   * @returns Decompressed data\n   */\n  decode(input: Buffer, unpackSize?: number): Buffer {\n    // Pre-allocate output buffer if size is known\n    let outputBuffer: Buffer | null = null;\n    let outputPos = 0;\n    const outputChunks: Buffer[] = [];\n\n    if (unpackSize && unpackSize > 0) {\n      outputBuffer = allocBufferUnsafe(unpackSize);\n    }\n\n    let offset = 0;\n\n    while (offset < input.length) {\n      const result = parseLzma2ChunkHeader(input, offset);\n\n      if (!result.success) {\n        throw new Error('Truncated LZMA2 chunk header');\n      }\n\n      const chunk = result.chunk;\n\n      if (chunk.type === 'end') {\n        break;\n      }\n\n      // Validate we have enough data for the chunk\n      const dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;\n      if (offset + chunk.headerSize + dataSize > input.length) {\n        throw new Error(`Truncated LZMA2 ${chunk.type} data`);\n      }\n\n      // Handle dictionary reset\n      if (chunk.dictReset) {\n        this.lzmaDecoder.resetDictionary();\n      }\n\n      const dataOffset = offset + chunk.headerSize;\n\n      if (chunk.type === 'uncompressed') {\n        const uncompData = input.slice(dataOffset, dataOffset + chunk.uncompSize);\n\n        // Copy to output\n        if (outputBuffer) {\n          uncompData.copy(outputBuffer, outputPos);\n          outputPos += uncompData.length;\n        } else {\n          outputChunks.push(uncompData);\n        }\n\n        // Feed uncompressed data to dictionary so subsequent LZMA chunks can reference it\n        this.lzmaDecoder.feedUncompressed(uncompData);\n\n        offset = dataOffset + chunk.uncompSize;\n      } else {\n        // LZMA compressed chunk\n\n        // Apply new properties if present\n        if (chunk.newProps) {\n          const { lc, lp, pb } = chunk.newProps;\n          if (!this.lzmaDecoder.setLcLpPb(lc, lp, pb)) {\n            throw new Error(`Invalid LZMA properties: lc=${lc} lp=${lp} pb=${pb}`);\n          }\n          this.propsSet = true;\n        }\n\n        if (!this.propsSet) {\n          throw new Error('LZMA chunk without properties');\n        }\n\n        // Reset probabilities if state reset\n        if (chunk.stateReset) {\n          this.lzmaDecoder.resetProbabilities();\n        }\n\n        // Determine solid mode - preserve dictionary if not resetting state or if only resetting state (not dict)\n        const useSolid = !chunk.stateReset || (chunk.stateReset && !chunk.dictReset);\n\n        // Decode LZMA chunk\n        const chunkData = input.slice(dataOffset, dataOffset + chunk.compSize);\n        const decoded = this.lzmaDecoder.decode(chunkData, 0, chunk.uncompSize, useSolid);\n\n        // Copy to output\n        if (outputBuffer) {\n          decoded.copy(outputBuffer, outputPos);\n          outputPos += decoded.length;\n        } else {\n          outputChunks.push(decoded);\n        }\n\n        offset = dataOffset + chunk.compSize;\n      }\n    }\n\n    // Return pre-allocated buffer or concatenated chunks\n    if (outputBuffer) {\n      return outputPos < outputBuffer.length ? outputBuffer.slice(0, outputPos) : outputBuffer;\n    }\n    return Buffer.concat(outputChunks);\n  }\n}\n\n/**\n * Decode LZMA2 data synchronously\n * @param input - LZMA2 compressed data\n * @param properties - 1-byte properties (dictionary size)\n * @param unpackSize - Expected output size (optional)\n * @returns Decompressed data\n */\nexport function decodeLzma2(input: Buffer, properties: Buffer | Uint8Array, unpackSize?: number): Buffer {\n  const decoder = new Lzma2Decoder(properties);\n  return decoder.decode(input, unpackSize);\n}\n"],"names":["allocBufferUnsafe","parseLzma2ChunkHeader","parseLzma2DictionarySize","LzmaDecoder","Lzma2Decoder","decode","input","unpackSize","outputBuffer","outputPos","outputChunks","offset","length","result","success","Error","chunk","type","dataSize","uncompSize","compSize","headerSize","dictReset","lzmaDecoder","resetDictionary","dataOffset","uncompData","slice","copy","push","feedUncompressed","newProps","lc","lp","pb","setLcLpPb","propsSet","stateReset","resetProbabilities","useSolid","chunkData","decoded","Buffer","concat","properties","dictionarySize","setDictionarySize","decodeLzma2","decoder"],"mappings":"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"}

package/dist/esm/lzma/sync/LzmaDecoder.d.ts

@@ -1,82 +0,0 @@
-/**
- * Synchronous LZMA1 Decoder
- *
- * Decodes LZMA1 compressed data from a buffer.
- * All operations are synchronous.
- */
-/**
- * Synchronous LZMA1 decoder
- */
-export declare class LzmaDecoder {
-    private outWindow;
-    private rangeDecoder;
-    private isMatchDecoders;
-    private isRepDecoders;
-    private isRepG0Decoders;
-    private isRepG1Decoders;
-    private isRepG2Decoders;
-    private isRep0LongDecoders;
-    private posSlotDecoder;
-    private posDecoders;
-    private posAlignDecoder;
-    private lenDecoder;
-    private repLenDecoder;
-    private literalDecoder;
-    private dictionarySize;
-    private dictionarySizeCheck;
-    private posStateMask;
-    private state;
-    private rep0;
-    private rep1;
-    private rep2;
-    private rep3;
-    private prevByte;
-    private totalPos;
-    constructor();
-    /**
-     * Set dictionary size
-     */
-    setDictionarySize(dictionarySize: number): boolean;
-    /**
-     * Set lc, lp, pb properties
-     */
-    setLcLpPb(lc: number, lp: number, pb: number): boolean;
-    /**
-     * Set decoder properties from 5-byte buffer
-     */
-    setDecoderProperties(properties: Buffer | Uint8Array): boolean;
-    /**
-     * Initialize probability tables
-     */
-    private initProbabilities;
-    /**
-     * Reset probabilities only (for LZMA2 state reset)
-     */
-    resetProbabilities(): void;
-    /**
-     * Reset dictionary position (for LZMA2 dictionary reset)
-     */
-    resetDictionary(): void;
-    /**
-     * 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: Buffer): void;
-    /**
-     * 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: Buffer, inputOffset: number, outSize: number, solid?: boolean): Buffer;
-}
-/**
- * Decode LZMA1 data synchronously
- * @param input - Compressed data (without 5-byte properties header)
- * @param properties - 5-byte LZMA properties
- * @param outSize - Expected output size
- * @returns Decompressed data
- */
-export declare function decodeLzma(input: Buffer, properties: Buffer | Uint8Array, outSize: number): Buffer;

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

@@ -1,403 +0,0 @@
-/**
- * Synchronous LZMA1 Decoder
- *
- * Decodes LZMA1 compressed data from a buffer.
- * All operations are synchronous.
- */ import { allocBufferUnsafe } 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;
-    }
-    init(solid) {
-        if (!solid) {
-            this.pos = 0;
-        }
-    }
-    putByte(b) {
-        this.buffer[this.pos++] = b;
-        if (this.pos >= this.windowSize) {
-            this.pos = 0;
-        }
-    }
-    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(){
-        this.buffer = allocBufferUnsafe(0); // Replaced by create() before use
-        this.windowSize = 0;
-        this.pos = 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];
-        }
-    }
-    /**
-   * 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(){
-        this.outWindow = new OutWindow();
-        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
- * @returns Decompressed data
- */ export function decodeLzma(input, properties, outSize) {
-    const decoder = new LzmaDecoder();
-    decoder.setDecoderProperties(properties);
-    return decoder.decode(input, 0, outSize, false);
-}