xz-compat 0.1.0

package/dist/esm/lzma/stream/transforms.js

@@ -0,0 +1,190 @@
+/**
+ * LZMA Transform Stream Wrappers
+ *
+ * Provides Transform streams for LZMA1 and LZMA2 decompression.
+ *
+ * LZMA2 streaming works by buffering until a complete chunk is available,
+ * then decoding synchronously. LZMA2 chunks are bounded in size (~2MB max
+ * uncompressed), so memory usage is predictable and bounded.
+ *
+ * Performance Optimization:
+ * - Uses OutputSink pattern for zero-copy output during decode
+ * - Each decoded byte written directly to stream (not buffered then copied)
+ * - ~4x faster than previous buffering approach
+ *
+ * True byte-by-byte async LZMA streaming would require rewriting the entire
+ * decoder with continuation-passing style, which is complex and not worth
+ * the effort given LZMA2's chunked format.
+ */ import { allocBufferUnsafe, Transform } from 'extract-base-iterator';
+import { hasCompleteChunk } from '../Lzma2ChunkParser.js';
+import { LzmaDecoder } from '../sync/LzmaDecoder.js';
+import { parseLzma2DictionarySize } from '../types.js';
+/**
+ * Create an LZMA2 decoder Transform stream
+ *
+ * This is a streaming decoder that processes LZMA2 chunks incrementally.
+ * Memory usage is O(dictionary_size + max_chunk_size) instead of O(folder_size).
+ *
+ * @param properties - 1-byte LZMA2 properties (dictionary size)
+ * @returns Transform stream that decompresses LZMA2 data
+ */ export function createLzma2Decoder(properties) {
+    if (!properties || properties.length < 1) {
+        throw new Error('LZMA2 requires properties byte');
+    }
+    const dictSize = parseLzma2DictionarySize(properties[0]);
+    // LZMA decoder instance - reused across chunks for solid mode
+    const decoder = new LzmaDecoder();
+    decoder.setDictionarySize(dictSize);
+    // Track current LZMA properties
+    let propsSet = false;
+    // Buffer for incomplete chunk data
+    let pending = null;
+    let finished = false;
+    return new Transform({
+        transform: function(chunk, _encoding, callback) {
+            if (finished) {
+                callback(null);
+                return;
+            }
+            // Combine with pending data
+            let input;
+            if (pending && pending.length > 0) {
+                input = Buffer.concat([
+                    pending,
+                    chunk
+                ]);
+                pending = null;
+            } else {
+                input = chunk;
+            }
+            let offset = 0;
+            try {
+                while(offset < input.length && !finished){
+                    const result = hasCompleteChunk(input, offset);
+                    if (!result.success) {
+                        // Need more data
+                        pending = input.slice(offset);
+                        break;
+                    }
+                    const { chunk: chunkInfo, totalSize } = result;
+                    if (chunkInfo.type === 'end') {
+                        finished = true;
+                        break;
+                    }
+                    // Handle dictionary reset
+                    if (chunkInfo.dictReset) {
+                        decoder.resetDictionary();
+                    }
+                    const dataOffset = offset + chunkInfo.headerSize;
+                    if (chunkInfo.type === 'uncompressed') {
+                        const uncompData = input.slice(dataOffset, dataOffset + chunkInfo.uncompSize);
+                        this.push(uncompData);
+                        // Feed uncompressed data to dictionary for subsequent LZMA chunks
+                        decoder.feedUncompressed(uncompData);
+                    } else {
+                        // LZMA compressed chunk
+                        // Variables to store properties (used for both decoders)
+                        let lc;
+                        let lp;
+                        let pb;
+                        // Apply new properties if present
+                        if (chunkInfo.newProps) {
+                            ({ lc, lp, pb } = chunkInfo.newProps);
+                            if (!decoder.setLcLpPb(lc, lp, pb)) {
+                                throw new Error(`Invalid LZMA properties: lc=${lc} lp=${lp} pb=${pb}`);
+                            }
+                            propsSet = true;
+                        }
+                        if (!propsSet) {
+                            throw new Error('LZMA chunk without properties');
+                        }
+                        // Reset probabilities if state reset
+                        if (chunkInfo.stateReset) {
+                            decoder.resetProbabilities();
+                        }
+                        // Determine solid mode - preserve dictionary if not resetting state or if only resetting state (not dict)
+                        const useSolid = !chunkInfo.stateReset || chunkInfo.stateReset && !chunkInfo.dictReset;
+                        const compData = input.slice(dataOffset, dataOffset + chunkInfo.compSize);
+                        // Enhanced: Use OutputSink for direct emission (zero-copy)
+                        // Create a decoder with direct stream emission
+                        const streamDecoder = new LzmaDecoder({
+                            write: (chunk)=>this.push(chunk)
+                        });
+                        streamDecoder.setDictionarySize(dictSize);
+                        // Preserve properties from main decoder
+                        streamDecoder.setLcLpPb(lc, lp, pb);
+                        // Use solid mode based on chunk properties
+                        streamDecoder.decodeWithSink(compData, 0, chunkInfo.uncompSize, useSolid);
+                        // Flush any remaining data in the OutWindow
+                        streamDecoder.flushOutWindow();
+                    }
+                    offset += totalSize;
+                }
+                callback(null);
+            } catch (err) {
+                callback(err);
+            }
+        },
+        flush: function(callback) {
+            if (pending && pending.length > 0 && !finished) {
+                callback(new Error('Truncated LZMA2 stream'));
+            } else {
+                callback(null);
+            }
+        }
+    });
+}
+/**
+ * Create an LZMA1 decoder Transform stream
+ *
+ * Note: LZMA1 has no chunk boundaries, so this requires knowing the
+ * uncompressed size upfront. The stream buffers all input, then
+ * decompresses when complete.
+ *
+ * For true streaming, use LZMA2 which has built-in chunking.
+ *
+ * Optimization: Pre-allocates input buffer and copies chunks once,
+ * avoiding the double-buffering of Buffer.concat().
+ *
+ * @param properties - 5-byte LZMA properties
+ * @param unpackSize - Expected uncompressed size
+ * @returns Transform stream that decompresses LZMA1 data
+ */ export function createLzmaDecoder(properties, unpackSize) {
+    const decoder = new LzmaDecoder();
+    decoder.setDecoderProperties(properties);
+    const chunks = [];
+    let totalSize = 0;
+    return new Transform({
+        transform: function(chunk, _encoding, callback) {
+            chunks.push(chunk);
+            totalSize += chunk.length;
+            callback(null);
+        },
+        flush: function(callback) {
+            try {
+                // Optimization: Pre-allocate single buffer instead of Buffer.concat()
+                // This reduces peak memory usage by ~50% during concatenation
+                const input = allocBufferUnsafe(totalSize);
+                let offset = 0;
+                // Copy each chunk into the pre-allocated buffer
+                for(let i = 0; i < chunks.length; i++){
+                    const chunk = chunks[i];
+                    chunk.copy(input, offset);
+                    offset += chunk.length;
+                }
+                // Enhanced: Use OutputSink for direct emission (zero-copy)
+                // Create a decoder with direct stream emission
+                const streamDecoder = new LzmaDecoder({
+                    write: (chunk)=>this.push(chunk)
+                });
+                streamDecoder.setDecoderProperties(properties);
+                streamDecoder.decodeWithSink(input, 0, unpackSize, false);
+                // Flush any remaining data in the OutWindow
+                streamDecoder.flushOutWindow();
+                callback(null);
+            } catch (err) {
+                callback(err);
+            }
+        }
+    });
+}

package/dist/esm/lzma/stream/transforms.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/lzma/stream/transforms.ts"],"sourcesContent":["/**\n * LZMA Transform Stream Wrappers\n *\n * Provides Transform streams for LZMA1 and LZMA2 decompression.\n *\n * LZMA2 streaming works by buffering until a complete chunk is available,\n * then decoding synchronously. LZMA2 chunks are bounded in size (~2MB max\n * uncompressed), so memory usage is predictable and bounded.\n *\n * Performance Optimization:\n * - Uses OutputSink pattern for zero-copy output during decode\n * - Each decoded byte written directly to stream (not buffered then copied)\n * - ~4x faster than previous buffering approach\n *\n * True byte-by-byte async LZMA streaming would require rewriting the entire\n * decoder with continuation-passing style, which is complex and not worth\n * the effort given LZMA2's chunked format.\n */\n\nimport { allocBufferUnsafe, Transform } from 'extract-base-iterator';\nimport { hasCompleteChunk } from '../Lzma2ChunkParser.ts';\nimport { LzmaDecoder } from '../sync/LzmaDecoder.ts';\nimport { parseLzma2DictionarySize } from '../types.ts';\n\n/**\n * Create an LZMA2 decoder Transform stream\n *\n * This is a streaming decoder that processes LZMA2 chunks incrementally.\n * Memory usage is O(dictionary_size + max_chunk_size) instead of O(folder_size).\n *\n * @param properties - 1-byte LZMA2 properties (dictionary size)\n * @returns Transform stream that decompresses LZMA2 data\n */\nexport function createLzma2Decoder(properties: Buffer | Uint8Array): InstanceType<typeof Transform> {\n  if (!properties || properties.length < 1) {\n    throw new Error('LZMA2 requires properties byte');\n  }\n\n  const dictSize = parseLzma2DictionarySize(properties[0]);\n\n  // LZMA decoder instance - reused across chunks for solid mode\n  const decoder = new LzmaDecoder();\n  decoder.setDictionarySize(dictSize);\n\n  // Track current LZMA properties\n  let propsSet = false;\n\n  // Buffer for incomplete chunk data\n  let pending: Buffer | null = null;\n  let finished = false;\n\n  return new Transform({\n    transform: function (this: InstanceType<typeof Transform>, chunk: Buffer, _encoding: string, callback: (err?: Error | null) => void) {\n      if (finished) {\n        callback(null);\n        return;\n      }\n\n      // Combine with pending data\n      let input: Buffer;\n      if (pending && pending.length > 0) {\n        input = Buffer.concat([pending, chunk]);\n        pending = null;\n      } else {\n        input = chunk;\n      }\n\n      let offset = 0;\n\n      try {\n        while (offset < input.length && !finished) {\n          const result = hasCompleteChunk(input, offset);\n\n          if (!result.success) {\n            // Need more data\n            pending = input.slice(offset);\n            break;\n          }\n\n          const { chunk: chunkInfo, totalSize } = result;\n\n          if (chunkInfo.type === 'end') {\n            finished = true;\n            break;\n          }\n\n          // Handle dictionary reset\n          if (chunkInfo.dictReset) {\n            decoder.resetDictionary();\n          }\n\n          const dataOffset = offset + chunkInfo.headerSize;\n\n          if (chunkInfo.type === 'uncompressed') {\n            const uncompData = input.slice(dataOffset, dataOffset + chunkInfo.uncompSize);\n            this.push(uncompData);\n\n            // Feed uncompressed data to dictionary for subsequent LZMA chunks\n            decoder.feedUncompressed(uncompData);\n          } else {\n            // LZMA compressed chunk\n\n            // Variables to store properties (used for both decoders)\n            let lc: number;\n            let lp: number;\n            let pb: number;\n\n            // Apply new properties if present\n            if (chunkInfo.newProps) {\n              ({ lc, lp, pb } = chunkInfo.newProps);\n              if (!decoder.setLcLpPb(lc, lp, pb)) {\n                throw new Error(`Invalid LZMA properties: lc=${lc} lp=${lp} pb=${pb}`);\n              }\n              propsSet = true;\n            }\n\n            if (!propsSet) {\n              throw new Error('LZMA chunk without properties');\n            }\n\n            // Reset probabilities if state reset\n            if (chunkInfo.stateReset) {\n              decoder.resetProbabilities();\n            }\n\n            // Determine solid mode - preserve dictionary if not resetting state or if only resetting state (not dict)\n            const useSolid = !chunkInfo.stateReset || (chunkInfo.stateReset && !chunkInfo.dictReset);\n\n            const compData = input.slice(dataOffset, dataOffset + chunkInfo.compSize);\n\n            // Enhanced: Use OutputSink for direct emission (zero-copy)\n            // Create a decoder with direct stream emission\n            const streamDecoder = new LzmaDecoder({\n              write: (chunk: Buffer) => this.push(chunk),\n            });\n            streamDecoder.setDictionarySize(dictSize);\n            // Preserve properties from main decoder\n            streamDecoder.setLcLpPb(lc, lp, pb);\n\n            // Use solid mode based on chunk properties\n            streamDecoder.decodeWithSink(compData, 0, chunkInfo.uncompSize, useSolid);\n\n            // Flush any remaining data in the OutWindow\n            streamDecoder.flushOutWindow();\n          }\n\n          offset += totalSize;\n        }\n\n        callback(null);\n      } catch (err) {\n        callback(err as Error);\n      }\n    },\n\n    flush: function (this: InstanceType<typeof Transform>, callback: (err?: Error | null) => void) {\n      if (pending && pending.length > 0 && !finished) {\n        callback(new Error('Truncated LZMA2 stream'));\n      } else {\n        callback(null);\n      }\n    },\n  });\n}\n\n/**\n * Create an LZMA1 decoder Transform stream\n *\n * Note: LZMA1 has no chunk boundaries, so this requires knowing the\n * uncompressed size upfront. The stream buffers all input, then\n * decompresses when complete.\n *\n * For true streaming, use LZMA2 which has built-in chunking.\n *\n * Optimization: Pre-allocates input buffer and copies chunks once,\n * avoiding the double-buffering of Buffer.concat().\n *\n * @param properties - 5-byte LZMA properties\n * @param unpackSize - Expected uncompressed size\n * @returns Transform stream that decompresses LZMA1 data\n */\nexport function createLzmaDecoder(properties: Buffer | Uint8Array, unpackSize: number): InstanceType<typeof Transform> {\n  const decoder = new LzmaDecoder();\n  decoder.setDecoderProperties(properties);\n\n  const chunks: Buffer[] = [];\n  let totalSize = 0;\n\n  return new Transform({\n    transform: function (this: InstanceType<typeof Transform>, chunk: Buffer, _encoding: string, callback: (err?: Error | null) => void) {\n      chunks.push(chunk);\n      totalSize += chunk.length;\n      callback(null);\n    },\n\n    flush: function (this: InstanceType<typeof Transform>, callback: (err?: Error | null) => void) {\n      try {\n        // Optimization: Pre-allocate single buffer instead of Buffer.concat()\n        // This reduces peak memory usage by ~50% during concatenation\n        const input = allocBufferUnsafe(totalSize);\n        let offset = 0;\n\n        // Copy each chunk into the pre-allocated buffer\n        for (let i = 0; i < chunks.length; i++) {\n          const chunk = chunks[i];\n          chunk.copy(input, offset);\n          offset += chunk.length;\n        }\n\n        // Enhanced: Use OutputSink for direct emission (zero-copy)\n        // Create a decoder with direct stream emission\n        const streamDecoder = new LzmaDecoder({\n          write: (chunk: Buffer) => this.push(chunk),\n        });\n        streamDecoder.setDecoderProperties(properties);\n        streamDecoder.decodeWithSink(input, 0, unpackSize, false);\n\n        // Flush any remaining data in the OutWindow\n        streamDecoder.flushOutWindow();\n\n        callback(null);\n      } catch (err) {\n        callback(err as Error);\n      }\n    },\n  });\n}\n"],"names":["allocBufferUnsafe","Transform","hasCompleteChunk","LzmaDecoder","parseLzma2DictionarySize","createLzma2Decoder","properties","length","Error","dictSize","decoder","setDictionarySize","propsSet","pending","finished","transform","chunk","_encoding","callback","input","Buffer","concat","offset","result","success","slice","chunkInfo","totalSize","type","dictReset","resetDictionary","dataOffset","headerSize","uncompData","uncompSize","push","feedUncompressed","lc","lp","pb","newProps","setLcLpPb","stateReset","resetProbabilities","useSolid","compData","compSize","streamDecoder","write","decodeWithSink","flushOutWindow","err","flush","createLzmaDecoder","unpackSize","setDecoderProperties","chunks","i","copy"],"mappings":"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"}

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

@@ -0,0 +1,63 @@
+/**
+ * Synchronous LZMA2 Decoder
+ *
+ * LZMA2 is a container format that wraps LZMA chunks with framing.
+ * Decodes LZMA2 data from a buffer.
+ */
+import { type OutputSink } from '../types.js';
+/**
+ * Synchronous LZMA2 decoder
+ */
+export declare class Lzma2Decoder {
+    private lzmaDecoder;
+    private dictionarySize;
+    private propsSet;
+    constructor(properties: Buffer | Uint8Array, outputSink?: OutputSink);
+    /**
+     * Reset the dictionary (for stream boundaries)
+     */
+    resetDictionary(): void;
+    /**
+     * Reset all probability models (for stream boundaries)
+     */
+    resetProbabilities(): void;
+    /**
+     * Set LZMA properties
+     */
+    setLcLpPb(lc: number, lp: number, pb: number): boolean;
+    /**
+     * Feed uncompressed data to the dictionary (for subsequent LZMA chunks)
+     */
+    feedUncompressed(data: Buffer): void;
+    /**
+     * Decode raw LZMA data (used internally for LZMA2 chunks)
+     * @param input - LZMA compressed data
+     * @param offset - Input offset
+     * @param outSize - Expected output size
+     * @param solid - Use solid mode
+     * @returns Decompressed data
+     */
+    decodeLzmaData(input: Buffer, offset: number, outSize: number, solid?: boolean): Buffer;
+    /**
+     * Decode LZMA2 data with streaming output
+     * @param input - LZMA2 compressed data
+     * @returns Total number of bytes written to sink
+     */
+    decodeWithSink(input: Buffer): number;
+    /**
+     * Decode LZMA2 data
+     * @param input - LZMA2 compressed data
+     * @param unpackSize - Expected output size (optional, for pre-allocation)
+     * @returns Decompressed data
+     */
+    decode(input: Buffer, unpackSize?: number): Buffer;
+}
+/**
+ * Decode LZMA2 data synchronously
+ * @param input - LZMA2 compressed data
+ * @param properties - 1-byte properties (dictionary size)
+ * @param unpackSize - Expected output size (optional, autodetects if not provided)
+ * @param outputSink - Optional output sink for zero-copy decoding (returns bytes written)
+ * @returns Decompressed data (or bytes written if outputSink provided)
+ */
+export declare function decodeLzma2(input: Buffer, properties: Buffer | Uint8Array, unpackSize?: number, outputSink?: OutputSink): Buffer | number;

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

@@ -0,0 +1,211 @@
+/**
+ * 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 {
+    /**
+   * Reset the dictionary (for stream boundaries)
+   */ resetDictionary() {
+        this.lzmaDecoder.resetDictionary();
+    }
+    /**
+   * Reset all probability models (for stream boundaries)
+   */ resetProbabilities() {
+        this.lzmaDecoder.resetProbabilities();
+    }
+    /**
+   * Set LZMA properties
+   */ setLcLpPb(lc, lp, pb) {
+        return this.lzmaDecoder.setLcLpPb(lc, lp, pb);
+    }
+    /**
+   * Feed uncompressed data to the dictionary (for subsequent LZMA chunks)
+   */ feedUncompressed(data) {
+        this.lzmaDecoder.feedUncompressed(data);
+    }
+    /**
+   * Decode raw LZMA data (used internally for LZMA2 chunks)
+   * @param input - LZMA compressed data
+   * @param offset - Input offset
+   * @param outSize - Expected output size
+   * @param solid - Use solid mode
+   * @returns Decompressed data
+   */ decodeLzmaData(input, offset, outSize, solid = false) {
+        return this.lzmaDecoder.decode(input, offset, outSize, solid);
+    }
+    /**
+   * Decode LZMA2 data with streaming output
+   * @param input - LZMA2 compressed data
+   * @returns Total number of bytes written to sink
+   */ decodeWithSink(input) {
+        let totalBytes = 0;
+        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);
+                // Feed uncompressed data to dictionary so subsequent LZMA chunks can reference it
+                this.lzmaDecoder.feedUncompressed(uncompData);
+                totalBytes += uncompData.length;
+                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
+                const useSolid = !chunk.stateReset || chunk.stateReset && !chunk.dictReset;
+                // Decode LZMA chunk directly to sink
+                totalBytes += this.lzmaDecoder.decodeWithSink(input, dataOffset, chunk.uncompSize, useSolid);
+                offset = dataOffset + chunk.compSize;
+            }
+        }
+        // Flush any remaining data in the OutWindow
+        this.lzmaDecoder.flushOutWindow();
+        return totalBytes;
+    }
+    /**
+   * 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, outputSink){
+        if (!properties || properties.length < 1) {
+            throw new Error('LZMA2 requires properties byte');
+        }
+        this.dictionarySize = parseLzma2DictionarySize(properties[0]);
+        this.lzmaDecoder = new LzmaDecoder(outputSink);
+        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, autodetects if not provided)
+ * @param outputSink - Optional output sink for zero-copy decoding (returns bytes written)
+ * @returns Decompressed data (or bytes written if outputSink provided)
+ */ export function decodeLzma2(input, properties, unpackSize, outputSink) {
+    const decoder = new Lzma2Decoder(properties, outputSink);
+    if (outputSink) {
+        // Zero-copy mode: write to sink during decode
+        return decoder.decodeWithSink(input);
+    }
+    // Buffering mode: returns Buffer (zero-copy)
+    return decoder.decode(input, unpackSize);
+}

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/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 { type OutputSink, 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, outputSink?: OutputSink) {\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(outputSink);\n    this.lzmaDecoder.setDictionarySize(this.dictionarySize);\n    this.propsSet = false;\n  }\n\n  /**\n   * Reset the dictionary (for stream boundaries)\n   */\n  resetDictionary(): void {\n    this.lzmaDecoder.resetDictionary();\n  }\n\n  /**\n   * Reset all probability models (for stream boundaries)\n   */\n  resetProbabilities(): void {\n    this.lzmaDecoder.resetProbabilities();\n  }\n\n  /**\n   * Set LZMA properties\n   */\n  setLcLpPb(lc: number, lp: number, pb: number): boolean {\n    return this.lzmaDecoder.setLcLpPb(lc, lp, pb);\n  }\n\n  /**\n   * Feed uncompressed data to the dictionary (for subsequent LZMA chunks)\n   */\n  feedUncompressed(data: Buffer): void {\n    this.lzmaDecoder.feedUncompressed(data);\n  }\n\n  /**\n   * Decode raw LZMA data (used internally for LZMA2 chunks)\n   * @param input - LZMA compressed data\n   * @param offset - Input offset\n   * @param outSize - Expected output size\n   * @param solid - Use solid mode\n   * @returns Decompressed data\n   */\n  decodeLzmaData(input: Buffer, offset: number, outSize: number, solid = false): Buffer {\n    return this.lzmaDecoder.decode(input, offset, outSize, solid);\n  }\n\n  /**\n   * Decode LZMA2 data with streaming output\n   * @param input - LZMA2 compressed data\n   * @returns Total number of bytes written to sink\n   */\n  decodeWithSink(input: Buffer): number {\n    let totalBytes = 0;\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        // Feed uncompressed data to dictionary so subsequent LZMA chunks can reference it\n        this.lzmaDecoder.feedUncompressed(uncompData);\n\n        totalBytes += uncompData.length;\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\n        const useSolid = !chunk.stateReset || (chunk.stateReset && !chunk.dictReset);\n\n        // Decode LZMA chunk directly to sink\n        totalBytes += this.lzmaDecoder.decodeWithSink(input, dataOffset, chunk.uncompSize, useSolid);\n\n        offset = dataOffset + chunk.compSize;\n      }\n    }\n\n    // Flush any remaining data in the OutWindow\n    this.lzmaDecoder.flushOutWindow();\n\n    return totalBytes;\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, autodetects if not provided)\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 decodeLzma2(input: Buffer, properties: Buffer | Uint8Array, unpackSize?: number, outputSink?: OutputSink): Buffer | number {\n  const decoder = new Lzma2Decoder(properties, outputSink);\n  if (outputSink) {\n    // Zero-copy mode: write to sink during decode\n    return decoder.decodeWithSink(input);\n  }\n  // Buffering mode: returns Buffer (zero-copy)\n  return decoder.decode(input, unpackSize);\n}\n"],"names":["allocBufferUnsafe","parseLzma2ChunkHeader","parseLzma2DictionarySize","LzmaDecoder","Lzma2Decoder","resetDictionary","lzmaDecoder","resetProbabilities","setLcLpPb","lc","lp","pb","feedUncompressed","data","decodeLzmaData","input","offset","outSize","solid","decode","decodeWithSink","totalBytes","length","result","success","Error","chunk","type","dataSize","uncompSize","compSize","headerSize","dictReset","dataOffset","uncompData","slice","newProps","propsSet","stateReset","useSolid","flushOutWindow","unpackSize","outputBuffer","outputPos","outputChunks","copy","push","chunkData","decoded","Buffer","concat","properties","outputSink","dictionarySize","setDictionarySize","decodeLzma2","decoder"],"mappings":"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"}

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

@@ -0,0 +1,97 @@
+/**
+ * Synchronous LZMA1 Decoder
+ *
+ * Decodes LZMA1 compressed data from a buffer.
+ * All operations are synchronous.
+ */
+import { type OutputSink } from '../types.js';
+/**
+ * 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(outputSink?: OutputSink);
+    /**
+     * 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;
+    /**
+     * Flush any remaining data in the OutWindow to the sink
+     */
+    flushOutWindow(): void;
+    /**
+     * 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: Buffer, inputOffset: number, outSize: number, solid?: boolean): number;
+    /**
+     * 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
+ * @param outputSink - Optional output sink for zero-copy decoding (returns bytes written)
+ * @returns Decompressed data (or bytes written if outputSink provided)
+ */
+export declare function decodeLzma(input: Buffer, properties: Buffer | Uint8Array, outSize: number, outputSink?: OutputSink): Buffer | number;