xz-compat 1.0.0 → 1.1.0

package/dist/cjs/index.d.cts

@@ -8,8 +8,8 @@
  * when native bindings are available.
  */
 export { decode7zLzma, decode7zLzma2, type SevenZDecodeCallback } from './sevenz.js';
-export { createXZDecoder, decodeXZ, type XzDecodeCallback } from './xz/Decoder.js';
+export { type BufferLike, createXZDecoder, decodeXZ, type XzDecodeCallback } from './xz/Decoder.js';
 export { createLzma2Decoder, createLzmaDecoder, decodeLzma, decodeLzma2 } from './lzma/index.js';
 export * from './filters/index.js';
 export { isNativeAvailable } from './native.js';
-export type { DecodeCallback } from './utils/runDecode.js';
+export type { DecodeCallback } from './sevenz.js';

package/dist/cjs/index.d.ts

@@ -8,8 +8,8 @@
  * when native bindings are available.
  */
 export { decode7zLzma, decode7zLzma2, type SevenZDecodeCallback } from './sevenz.js';
-export { createXZDecoder, decodeXZ, type XzDecodeCallback } from './xz/Decoder.js';
+export { type BufferLike, createXZDecoder, decodeXZ, type XzDecodeCallback } from './xz/Decoder.js';
 export { createLzma2Decoder, createLzmaDecoder, decodeLzma, decodeLzma2 } from './lzma/index.js';
 export * from './filters/index.js';
 export { isNativeAvailable } from './native.js';
-export type { DecodeCallback } from './utils/runDecode.js';
+export type { DecodeCallback } from './sevenz.js';

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/xz-compat/src/index.ts"],"sourcesContent":["/**\n * XZ-Compat: XZ/LZMA Decompression Library\n *\n * Pure JavaScript implementation with optional native acceleration\n * via lzma-native on Node.js 10+.\n *\n * Works on Node.js 0.8+ with automatic performance optimization\n * when native bindings are available.\n */\n\n// ============================================================================\n// High-Level APIs (Recommended)\n// ============================================================================\n\n// 7z-specific decoders - accept properties separately, try native automatically\nexport { decode7zLzma, decode7zLzma2, type SevenZDecodeCallback } from './sevenz.ts';\n// XZ container format - self-describing, works great with native acceleration\nexport { createXZDecoder, decodeXZ, type XzDecodeCallback } from './xz/Decoder.ts';\n\n// ============================================================================\n// Low-Level APIs (Backward Compatibility)\n// ============================================================================\n\n// Raw LZMA decoders (for specialized use cases)\nexport { createLzma2Decoder, createLzmaDecoder, decodeLzma, decodeLzma2 } from './lzma/index.ts';\n\n// ============================================================================\n// Supporting APIs\n// ============================================================================\n\n// Preprocessing filters (BCJ/Delta - used by 7z-iterator)\nexport * from './filters/index.ts';\n\n// Native acceleration utilities\nexport { isNativeAvailable } from './native.ts';\n\n// Callback type used by async decoders\nexport type { DecodeCallback } from './utils/runDecode.ts';\n"],"names":["createLzma2Decoder","createLzmaDecoder","createXZDecoder","decode7zLzma","decode7zLzma2","decodeLzma","decodeLzma2","decodeXZ","isNativeAvailable"],"mappings":"AAAA;;;;;;;;CAQC,GAED,+EAA+E;AAC/E,gCAAgC;AAChC,+EAA+E;AAE/E,gFAAgF;;;;;;;;;;;;QAUvEA;eAAAA,2BAAkB;;QAAEC;eAAAA,0BAAiB;;QAPrCC;eAAAA,0BAAe;;QAFfC;eAAAA,sBAAY;;QAAEC;eAAAA,uBAAa;;QASYC;eAAAA,mBAAU;;QAAEC;eAAAA,oBAAW;;QAP7CC;eAAAA,mBAAQ;;QAiBzBC;eAAAA,2BAAiB;;;wBAnB6C;yBAEN;uBAOc;qBAOjE;wBAGoB"}
+{"version":3,"sources":["/Users/kevin/Dev/iterators/xz-compat/src/index.ts"],"sourcesContent":["/**\n * XZ-Compat: XZ/LZMA Decompression Library\n *\n * Pure JavaScript implementation with optional native acceleration\n * via lzma-native on Node.js 10+.\n *\n * Works on Node.js 0.8+ with automatic performance optimization\n * when native bindings are available.\n */\n\n// ============================================================================\n// High-Level APIs (Recommended)\n// ============================================================================\n\n// 7z-specific decoders - accept properties separately, try native automatically\nexport { decode7zLzma, decode7zLzma2, type SevenZDecodeCallback } from './sevenz.ts';\n// XZ container format - self-describing, works great with native acceleration\nexport { type BufferLike, createXZDecoder, decodeXZ, type XzDecodeCallback } from './xz/Decoder.ts';\n\n// ============================================================================\n// Low-Level APIs (Backward Compatibility)\n// ============================================================================\n\n// Raw LZMA decoders (for specialized use cases)\nexport { createLzma2Decoder, createLzmaDecoder, decodeLzma, decodeLzma2 } from './lzma/index.ts';\n\n// ============================================================================\n// Supporting APIs\n// ============================================================================\n\n// Preprocessing filters (BCJ/Delta - used by 7z-iterator)\nexport * from './filters/index.ts';\n\n// Native acceleration utilities\nexport { isNativeAvailable } from './native.ts';\n\n// Callback type used by async decoders\nexport type { DecodeCallback } from './sevenz.ts';\n"],"names":["createLzma2Decoder","createLzmaDecoder","createXZDecoder","decode7zLzma","decode7zLzma2","decodeLzma","decodeLzma2","decodeXZ","isNativeAvailable"],"mappings":"AAAA;;;;;;;;CAQC,GAED,+EAA+E;AAC/E,gCAAgC;AAChC,+EAA+E;AAE/E,gFAAgF;;;;;;;;;;;;QAUvEA;eAAAA,2BAAkB;;QAAEC;eAAAA,0BAAiB;;QAPpBC;eAAAA,0BAAe;;QAFhCC;eAAAA,sBAAY;;QAAEC;eAAAA,uBAAa;;QASYC;eAAAA,mBAAU;;QAAEC;eAAAA,oBAAW;;QAP5BC;eAAAA,mBAAQ;;QAiB1CC;eAAAA,2BAAiB;;;wBAnB6C;yBAEW;uBAOH;qBAOjE;wBAGoB"}

package/dist/cjs/lzma/sync/Lzma2Decoder.d.cts

@@ -4,6 +4,7 @@
  * LZMA2 is a container format that wraps LZMA chunks with framing.
  * Decodes LZMA2 data from a buffer.
  */
+import { type BufferLike } from 'extract-base-iterator';
 import { type OutputSink } from '../types.js';
 /**
  * Synchronous LZMA2 decoder
@@ -40,26 +41,26 @@ export declare class Lzma2Decoder {
     decodeLzmaData(input: Buffer, offset: number, outSize: number, solid?: boolean): Buffer;
     /**
      * Decode LZMA2 data with streaming output
-     * @param input - LZMA2 compressed data
+     * @param input - LZMA2 compressed data (Buffer or BufferList)
      * @returns Total number of bytes written to sink
      */
-    decodeWithSink(input: Buffer): number;
+    decodeWithSink(input: BufferLike): number;
     /**
      * Decode LZMA2 data
-     * @param input - LZMA2 compressed data
+     * @param input - LZMA2 compressed data (Buffer or BufferList)
      * @param unpackSize - Expected output size (optional, for pre-allocation)
      * @returns Decompressed data
      */
-    decode(input: Buffer, unpackSize?: number): Buffer;
+    decode(input: BufferLike, unpackSize?: number): Buffer;
 }
 /**
  * Decode LZMA2 data synchronously
- * @param input - LZMA2 compressed data
+ * @param input - LZMA2 compressed data (Buffer or BufferList)
  * @param properties - 1-byte properties (dictionary size)
  * @param unpackSize - Expected output size (optional, autodetects if not provided)
  * @param outputSink - Optional output sink with write callback for streaming (returns bytes written)
  * @returns Decompressed data (or bytes written if outputSink provided)
  */
-export declare function decodeLzma2(input: Buffer, properties: Buffer | Uint8Array, unpackSize?: number, outputSink?: {
+export declare function decodeLzma2(input: BufferLike, properties: Buffer | Uint8Array, unpackSize?: number, outputSink?: {
     write(buffer: Buffer): void;
 }): Buffer | number;

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

@@ -4,6 +4,7 @@
  * LZMA2 is a container format that wraps LZMA chunks with framing.
  * Decodes LZMA2 data from a buffer.
  */
+import { type BufferLike } from 'extract-base-iterator';
 import { type OutputSink } from '../types.js';
 /**
  * Synchronous LZMA2 decoder
@@ -40,26 +41,26 @@ export declare class Lzma2Decoder {
     decodeLzmaData(input: Buffer, offset: number, outSize: number, solid?: boolean): Buffer;
     /**
      * Decode LZMA2 data with streaming output
-     * @param input - LZMA2 compressed data
+     * @param input - LZMA2 compressed data (Buffer or BufferList)
      * @returns Total number of bytes written to sink
      */
-    decodeWithSink(input: Buffer): number;
+    decodeWithSink(input: BufferLike): number;
     /**
      * Decode LZMA2 data
-     * @param input - LZMA2 compressed data
+     * @param input - LZMA2 compressed data (Buffer or BufferList)
      * @param unpackSize - Expected output size (optional, for pre-allocation)
      * @returns Decompressed data
      */
-    decode(input: Buffer, unpackSize?: number): Buffer;
+    decode(input: BufferLike, unpackSize?: number): Buffer;
 }
 /**
  * Decode LZMA2 data synchronously
- * @param input - LZMA2 compressed data
+ * @param input - LZMA2 compressed data (Buffer or BufferList)
  * @param properties - 1-byte properties (dictionary size)
  * @param unpackSize - Expected output size (optional, autodetects if not provided)
  * @param outputSink - Optional output sink with write callback for streaming (returns bytes written)
  * @returns Decompressed data (or bytes written if outputSink provided)
  */
-export declare function decodeLzma2(input: Buffer, properties: Buffer | Uint8Array, unpackSize?: number, outputSink?: {
+export declare function decodeLzma2(input: BufferLike, properties: Buffer | Uint8Array, unpackSize?: number, outputSink?: {
     write(buffer: Buffer): void;
 }): Buffer | number;

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

@@ -76,13 +76,15 @@ var Lzma2Decoder = /*#__PURE__*/ function() {
     };
     /**
    * Decode LZMA2 data with streaming output
-   * @param input - LZMA2 compressed data
+   * @param input - LZMA2 compressed data (Buffer or BufferList)
    * @returns Total number of bytes written to sink
    */ _proto.decodeWithSink = function decodeWithSink(input) {
+        // Convert BufferList to Buffer for low-level parsing
+        var buf = Buffer.isBuffer(input) ? input : input.toBuffer();
         var totalBytes = 0;
         var offset = 0;
-        while(offset < input.length){
-            var result = (0, _Lzma2ChunkParserts.parseLzma2ChunkHeader)(input, offset);
+        while(offset < buf.length){
+            var result = (0, _Lzma2ChunkParserts.parseLzma2ChunkHeader)(buf, offset);
             if (!result.success) {
                 throw new Error('Truncated LZMA2 chunk header');
             }
@@ -92,7 +94,7 @@ var Lzma2Decoder = /*#__PURE__*/ function() {
             }
             // Validate we have enough data for the chunk
             var dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;
-            if (offset + chunk.headerSize + dataSize > input.length) {
+            if (offset + chunk.headerSize + dataSize > buf.length) {
                 throw new Error("Truncated LZMA2 ".concat(chunk.type, " data"));
             }
             // Handle dictionary reset
@@ -101,7 +103,7 @@ var Lzma2Decoder = /*#__PURE__*/ function() {
             }
             var dataOffset = offset + chunk.headerSize;
             if (chunk.type === 'uncompressed') {
-                var uncompData = input.slice(dataOffset, dataOffset + chunk.uncompSize);
+                var uncompData = buf.slice(dataOffset, dataOffset + chunk.uncompSize);
                 // Feed uncompressed data to dictionary so subsequent LZMA chunks can reference it
                 this.lzmaDecoder.feedUncompressed(uncompData);
                 totalBytes += uncompData.length;
@@ -128,7 +130,7 @@ var Lzma2Decoder = /*#__PURE__*/ function() {
                 // Determine solid mode
                 var useSolid = !chunk.stateReset || chunk.stateReset && !chunk.dictReset;
                 // Decode LZMA chunk directly to sink
-                totalBytes += this.lzmaDecoder.decodeWithSink(input, dataOffset, chunk.uncompSize, useSolid);
+                totalBytes += this.lzmaDecoder.decodeWithSink(buf, dataOffset, chunk.uncompSize, useSolid);
                 offset = dataOffset + chunk.compSize;
             }
         }
@@ -138,10 +140,12 @@ var Lzma2Decoder = /*#__PURE__*/ function() {
     };
     /**
    * Decode LZMA2 data
-   * @param input - LZMA2 compressed data
+   * @param input - LZMA2 compressed data (Buffer or BufferList)
    * @param unpackSize - Expected output size (optional, for pre-allocation)
    * @returns Decompressed data
    */ _proto.decode = function decode(input, unpackSize) {
+        // Convert BufferList to Buffer for low-level parsing
+        var buf = Buffer.isBuffer(input) ? input : input.toBuffer();
         // Pre-allocate output buffer if size is known
         var outputBuffer = null;
         var outputPos = 0;
@@ -150,8 +154,8 @@ var Lzma2Decoder = /*#__PURE__*/ function() {
             outputBuffer = (0, _extractbaseiterator.allocBufferUnsafe)(unpackSize);
         }
         var offset = 0;
-        while(offset < input.length){
-            var result = (0, _Lzma2ChunkParserts.parseLzma2ChunkHeader)(input, offset);
+        while(offset < buf.length){
+            var result = (0, _Lzma2ChunkParserts.parseLzma2ChunkHeader)(buf, offset);
             if (!result.success) {
                 throw new Error('Truncated LZMA2 chunk header');
             }
@@ -161,7 +165,7 @@ var Lzma2Decoder = /*#__PURE__*/ function() {
             }
             // Validate we have enough data for the chunk
             var dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;
-            if (offset + chunk.headerSize + dataSize > input.length) {
+            if (offset + chunk.headerSize + dataSize > buf.length) {
                 throw new Error("Truncated LZMA2 ".concat(chunk.type, " data"));
             }
             // Handle dictionary reset
@@ -170,7 +174,7 @@ var Lzma2Decoder = /*#__PURE__*/ function() {
             }
             var dataOffset = offset + chunk.headerSize;
             if (chunk.type === 'uncompressed') {
-                var uncompData = input.slice(dataOffset, dataOffset + chunk.uncompSize);
+                var uncompData = buf.slice(dataOffset, dataOffset + chunk.uncompSize);
                 // Copy to output
                 if (outputBuffer) {
                     uncompData.copy(outputBuffer, outputPos);
@@ -205,11 +209,11 @@ var Lzma2Decoder = /*#__PURE__*/ function() {
                 // Decode LZMA chunk - use zero-copy when we have pre-allocated buffer
                 if (outputBuffer) {
                     // Zero-copy: decode directly into caller's buffer
-                    var bytesWritten = this.lzmaDecoder.decodeToBuffer(input, dataOffset, chunk.uncompSize, outputBuffer, outputPos, useSolid);
+                    var bytesWritten = this.lzmaDecoder.decodeToBuffer(buf, dataOffset, chunk.uncompSize, outputBuffer, outputPos, useSolid);
                     outputPos += bytesWritten;
                 } else {
                     // No pre-allocation: decode to new buffer and collect chunks
-                    var chunkData = input.slice(dataOffset, dataOffset + chunk.compSize);
+                    var chunkData = buf.slice(dataOffset, dataOffset + chunk.compSize);
                     var decoded = this.lzmaDecoder.decode(chunkData, 0, chunk.uncompSize, useSolid);
                     outputChunks.push(decoded);
                 }

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/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 '../lib/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        } else {\n          // No new properties, check if we already have them\n          if (!this.propsSet) {\n            throw new Error('LZMA chunk without properties');\n          }\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        } else {\n          // No new properties, check if we already have them\n          if (!this.propsSet) {\n            throw new Error('LZMA chunk without properties');\n          }\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 - use zero-copy when we have pre-allocated buffer\n        if (outputBuffer) {\n          // Zero-copy: decode directly into caller's buffer\n          const bytesWritten = this.lzmaDecoder.decodeToBuffer(input, dataOffset, chunk.uncompSize, outputBuffer, outputPos, useSolid);\n          outputPos += bytesWritten;\n        } else {\n          // No pre-allocation: decode to new buffer and collect chunks\n          const chunkData = input.slice(dataOffset, dataOffset + chunk.compSize);\n          const decoded = this.lzmaDecoder.decode(chunkData, 0, chunk.uncompSize, useSolid);\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 with write callback for streaming (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?: { write(buffer: Buffer): void }): Buffer | number {\n  const decoder = new Lzma2Decoder(properties, outputSink as 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":["Lzma2Decoder","decodeLzma2","properties","outputSink","length","Error","dictionarySize","parseLzma2DictionarySize","lzmaDecoder","LzmaDecoder","setDictionarySize","propsSet","resetDictionary","resetProbabilities","setLcLpPb","lc","lp","pb","feedUncompressed","data","decodeLzmaData","input","offset","outSize","solid","decode","decodeWithSink","totalBytes","result","parseLzma2ChunkHeader","success","chunk","type","dataSize","uncompSize","compSize","headerSize","dictReset","dataOffset","uncompData","slice","newProps","stateReset","useSolid","flushOutWindow","unpackSize","outputBuffer","outputPos","outputChunks","allocBufferUnsafe","copy","push","bytesWritten","decodeToBuffer","chunkData","decoded","Buffer","concat","decoder"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/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, type BufferLike } from 'extract-base-iterator';\nimport { parseLzma2ChunkHeader } from '../lib/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 (Buffer or BufferList)\n   * @returns Total number of bytes written to sink\n   */\n  decodeWithSink(input: BufferLike): number {\n    // Convert BufferList to Buffer for low-level parsing\n    const buf = Buffer.isBuffer(input) ? input : input.toBuffer();\n    let totalBytes = 0;\n    let offset = 0;\n\n    while (offset < buf.length) {\n      const result = parseLzma2ChunkHeader(buf, 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 > buf.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 = buf.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        } else {\n          // No new properties, check if we already have them\n          if (!this.propsSet) {\n            throw new Error('LZMA chunk without properties');\n          }\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(buf, 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 (Buffer or BufferList)\n   * @param unpackSize - Expected output size (optional, for pre-allocation)\n   * @returns Decompressed data\n   */\n  decode(input: BufferLike, unpackSize?: number): Buffer {\n    // Convert BufferList to Buffer for low-level parsing\n    const buf = Buffer.isBuffer(input) ? input : input.toBuffer();\n\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 < buf.length) {\n      const result = parseLzma2ChunkHeader(buf, 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 > buf.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 = buf.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        } else {\n          // No new properties, check if we already have them\n          if (!this.propsSet) {\n            throw new Error('LZMA chunk without properties');\n          }\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 - use zero-copy when we have pre-allocated buffer\n        if (outputBuffer) {\n          // Zero-copy: decode directly into caller's buffer\n          const bytesWritten = this.lzmaDecoder.decodeToBuffer(buf, dataOffset, chunk.uncompSize, outputBuffer, outputPos, useSolid);\n          outputPos += bytesWritten;\n        } else {\n          // No pre-allocation: decode to new buffer and collect chunks\n          const chunkData = buf.slice(dataOffset, dataOffset + chunk.compSize);\n          const decoded = this.lzmaDecoder.decode(chunkData, 0, chunk.uncompSize, useSolid);\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 (Buffer or BufferList)\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 with write callback for streaming (returns bytes written)\n * @returns Decompressed data (or bytes written if outputSink provided)\n */\nexport function decodeLzma2(input: BufferLike, properties: Buffer | Uint8Array, unpackSize?: number, outputSink?: { write(buffer: Buffer): void }): Buffer | number {\n  const decoder = new Lzma2Decoder(properties, outputSink as 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":["Lzma2Decoder","decodeLzma2","properties","outputSink","length","Error","dictionarySize","parseLzma2DictionarySize","lzmaDecoder","LzmaDecoder","setDictionarySize","propsSet","resetDictionary","resetProbabilities","setLcLpPb","lc","lp","pb","feedUncompressed","data","decodeLzmaData","input","offset","outSize","solid","decode","decodeWithSink","buf","Buffer","isBuffer","toBuffer","totalBytes","result","parseLzma2ChunkHeader","success","chunk","type","dataSize","uncompSize","compSize","headerSize","dictReset","dataOffset","uncompData","slice","newProps","stateReset","useSolid","flushOutWindow","unpackSize","outputBuffer","outputPos","outputChunks","allocBufferUnsafe","copy","push","bytesWritten","decodeToBuffer","chunkData","decoded","concat","decoder"],"mappings":"AAAA;;;;;CAKC;;;;;;;;;;;QAUYA;eAAAA;;QAkQGC;eAAAA;;;mCA1QmC;kCACb;uBACoB;6BAC9B;;;;;;AAKrB,IAAA,AAAMD,6BAAN;;aAAMA,aAKCE,UAA+B,EAAEC,UAAuB;gCALzDH;QAMT,IAAI,CAACE,cAAcA,WAAWE,MAAM,GAAG,GAAG;YACxC,MAAM,IAAIC,MAAM;QAClB;QAEA,IAAI,CAACC,cAAc,GAAGC,IAAAA,iCAAwB,EAACL,UAAU,CAAC,EAAE;QAC5D,IAAI,CAACM,WAAW,GAAG,IAAIC,0BAAW,CAACN;QACnC,IAAI,CAACK,WAAW,CAACE,iBAAiB,CAAC,IAAI,CAACJ,cAAc;QACtD,IAAI,CAACK,QAAQ,GAAG;;iBAbPX;IAgBX;;GAEC,GACDY,OAAAA,eAEC,GAFDA,SAAAA;QACE,IAAI,CAACJ,WAAW,CAACI,eAAe;IAClC;IAEA;;GAEC,GACDC,OAAAA,kBAEC,GAFDA,SAAAA;QACE,IAAI,CAACL,WAAW,CAACK,kBAAkB;IACrC;IAEA;;GAEC,GACDC,OAAAA,SAEC,GAFDA,SAAAA,UAAUC,EAAU,EAAEC,EAAU,EAAEC,EAAU;QAC1C,OAAO,IAAI,CAACT,WAAW,CAACM,SAAS,CAACC,IAAIC,IAAIC;IAC5C;IAEA;;GAEC,GACDC,OAAAA,gBAEC,GAFDA,SAAAA,iBAAiBC,IAAY;QAC3B,IAAI,CAACX,WAAW,CAACU,gBAAgB,CAACC;IACpC;IAEA;;;;;;;GAOC,GACDC,OAAAA,cAEC,GAFDA,SAAAA,eAAeC,KAAa,EAAEC,MAAc,EAAEC,OAAe;YAAEC,QAAAA,iEAAQ;QACrE,OAAO,IAAI,CAAChB,WAAW,CAACiB,MAAM,CAACJ,OAAOC,QAAQC,SAASC;IACzD;IAEA;;;;GAIC,GACDE,OAAAA,cA4EC,GA5EDA,SAAAA,eAAeL,KAAiB;QAC9B,qDAAqD;QACrD,IAAMM,MAAMC,OAAOC,QAAQ,CAACR,SAASA,QAAQA,MAAMS,QAAQ;QAC3D,IAAIC,aAAa;QACjB,IAAIT,SAAS;QAEb,MAAOA,SAASK,IAAIvB,MAAM,CAAE;YAC1B,IAAM4B,SAASC,IAAAA,yCAAqB,EAACN,KAAKL;YAE1C,IAAI,CAACU,OAAOE,OAAO,EAAE;gBACnB,MAAM,IAAI7B,MAAM;YAClB;YAEA,IAAM8B,QAAQH,OAAOG,KAAK;YAE1B,IAAIA,MAAMC,IAAI,KAAK,OAAO;gBACxB;YACF;YAEA,6CAA6C;YAC7C,IAAMC,WAAWF,MAAMC,IAAI,KAAK,iBAAiBD,MAAMG,UAAU,GAAGH,MAAMI,QAAQ;YAClF,IAAIjB,SAASa,MAAMK,UAAU,GAAGH,WAAWV,IAAIvB,MAAM,EAAE;gBACrD,MAAM,IAAIC,MAAM,AAAC,mBAA6B,OAAX8B,MAAMC,IAAI,EAAC;YAChD;YAEA,0BAA0B;YAC1B,IAAID,MAAMM,SAAS,EAAE;gBACnB,IAAI,CAACjC,WAAW,CAACI,eAAe;YAClC;YAEA,IAAM8B,aAAapB,SAASa,MAAMK,UAAU;YAE5C,IAAIL,MAAMC,IAAI,KAAK,gBAAgB;gBACjC,IAAMO,aAAahB,IAAIiB,KAAK,CAACF,YAAYA,aAAaP,MAAMG,UAAU;gBAEtE,kFAAkF;gBAClF,IAAI,CAAC9B,WAAW,CAACU,gBAAgB,CAACyB;gBAElCZ,cAAcY,WAAWvC,MAAM;gBAC/BkB,SAASoB,aAAaP,MAAMG,UAAU;YACxC,OAAO;gBACL,wBAAwB;gBAExB,kCAAkC;gBAClC,IAAIH,MAAMU,QAAQ,EAAE;oBAClB,IAAuBV,kBAAAA,MAAMU,QAAQ,EAA7B9B,KAAeoB,gBAAfpB,IAAIC,KAAWmB,gBAAXnB,IAAIC,KAAOkB,gBAAPlB;oBAChB,IAAI,CAAC,IAAI,CAACT,WAAW,CAACM,SAAS,CAACC,IAAIC,IAAIC,KAAK;wBAC3C,MAAM,IAAIZ,MAAM,AAAC,+BAAuCW,OAATD,IAAG,QAAeE,OAATD,IAAG,QAAS,OAAHC;oBACnE;oBACA,IAAI,CAACN,QAAQ,GAAG;gBAClB,OAAO;oBACL,mDAAmD;oBACnD,IAAI,CAAC,IAAI,CAACA,QAAQ,EAAE;wBAClB,MAAM,IAAIN,MAAM;oBAClB;gBACF;gBAEA,qCAAqC;gBACrC,IAAI8B,MAAMW,UAAU,EAAE;oBACpB,IAAI,CAACtC,WAAW,CAACK,kBAAkB;gBACrC;gBAEA,uBAAuB;gBACvB,IAAMkC,WAAW,CAACZ,MAAMW,UAAU,IAAKX,MAAMW,UAAU,IAAI,CAACX,MAAMM,SAAS;gBAE3E,qCAAqC;gBACrCV,cAAc,IAAI,CAACvB,WAAW,CAACkB,cAAc,CAACC,KAAKe,YAAYP,MAAMG,UAAU,EAAES;gBAEjFzB,SAASoB,aAAaP,MAAMI,QAAQ;YACtC;QACF;QAEA,4CAA4C;QAC5C,IAAI,CAAC/B,WAAW,CAACwC,cAAc;QAE/B,OAAOjB;IACT;IAEA;;;;;GAKC,GACDN,OAAAA,MAsGC,GAtGDA,SAAAA,OAAOJ,KAAiB,EAAE4B,UAAmB;QAC3C,qDAAqD;QACrD,IAAMtB,MAAMC,OAAOC,QAAQ,CAACR,SAASA,QAAQA,MAAMS,QAAQ;QAE3D,8CAA8C;QAC9C,IAAIoB,eAA8B;QAClC,IAAIC,YAAY;QAChB,IAAMC,eAAyB,EAAE;QAEjC,IAAIH,cAAcA,aAAa,GAAG;YAChCC,eAAeG,IAAAA,sCAAiB,EAACJ;QACnC;QAEA,IAAI3B,SAAS;QAEb,MAAOA,SAASK,IAAIvB,MAAM,CAAE;YAC1B,IAAM4B,SAASC,IAAAA,yCAAqB,EAACN,KAAKL;YAE1C,IAAI,CAACU,OAAOE,OAAO,EAAE;gBACnB,MAAM,IAAI7B,MAAM;YAClB;YAEA,IAAM8B,QAAQH,OAAOG,KAAK;YAE1B,IAAIA,MAAMC,IAAI,KAAK,OAAO;gBACxB;YACF;YAEA,6CAA6C;YAC7C,IAAMC,WAAWF,MAAMC,IAAI,KAAK,iBAAiBD,MAAMG,UAAU,GAAGH,MAAMI,QAAQ;YAClF,IAAIjB,SAASa,MAAMK,UAAU,GAAGH,WAAWV,IAAIvB,MAAM,EAAE;gBACrD,MAAM,IAAIC,MAAM,AAAC,mBAA6B,OAAX8B,MAAMC,IAAI,EAAC;YAChD;YAEA,0BAA0B;YAC1B,IAAID,MAAMM,SAAS,EAAE;gBACnB,IAAI,CAACjC,WAAW,CAACI,eAAe;YAClC;YAEA,IAAM8B,aAAapB,SAASa,MAAMK,UAAU;YAE5C,IAAIL,MAAMC,IAAI,KAAK,gBAAgB;gBACjC,IAAMO,aAAahB,IAAIiB,KAAK,CAACF,YAAYA,aAAaP,MAAMG,UAAU;gBAEtE,iBAAiB;gBACjB,IAAIY,cAAc;oBAChBP,WAAWW,IAAI,CAACJ,cAAcC;oBAC9BA,aAAaR,WAAWvC,MAAM;gBAChC,OAAO;oBACLgD,aAAaG,IAAI,CAACZ;gBACpB;gBAEA,kFAAkF;gBAClF,IAAI,CAACnC,WAAW,CAACU,gBAAgB,CAACyB;gBAElCrB,SAASoB,aAAaP,MAAMG,UAAU;YACxC,OAAO;gBACL,wBAAwB;gBAExB,kCAAkC;gBAClC,IAAIH,MAAMU,QAAQ,EAAE;oBAClB,IAAuBV,kBAAAA,MAAMU,QAAQ,EAA7B9B,KAAeoB,gBAAfpB,IAAIC,KAAWmB,gBAAXnB,IAAIC,KAAOkB,gBAAPlB;oBAChB,IAAI,CAAC,IAAI,CAACT,WAAW,CAACM,SAAS,CAACC,IAAIC,IAAIC,KAAK;wBAC3C,MAAM,IAAIZ,MAAM,AAAC,+BAAuCW,OAATD,IAAG,QAAeE,OAATD,IAAG,QAAS,OAAHC;oBACnE;oBACA,IAAI,CAACN,QAAQ,GAAG;gBAClB,OAAO;oBACL,mDAAmD;oBACnD,IAAI,CAAC,IAAI,CAACA,QAAQ,EAAE;wBAClB,MAAM,IAAIN,MAAM;oBAClB;gBACF;gBAEA,qCAAqC;gBACrC,IAAI8B,MAAMW,UAAU,EAAE;oBACpB,IAAI,CAACtC,WAAW,CAACK,kBAAkB;gBACrC;gBAEA,0GAA0G;gBAC1G,IAAMkC,WAAW,CAACZ,MAAMW,UAAU,IAAKX,MAAMW,UAAU,IAAI,CAACX,MAAMM,SAAS;gBAE3E,sEAAsE;gBACtE,IAAIS,cAAc;oBAChB,kDAAkD;oBAClD,IAAMM,eAAe,IAAI,CAAChD,WAAW,CAACiD,cAAc,CAAC9B,KAAKe,YAAYP,MAAMG,UAAU,EAAEY,cAAcC,WAAWJ;oBACjHI,aAAaK;gBACf,OAAO;oBACL,6DAA6D;oBAC7D,IAAME,YAAY/B,IAAIiB,KAAK,CAACF,YAAYA,aAAaP,MAAMI,QAAQ;oBACnE,IAAMoB,UAAU,IAAI,CAACnD,WAAW,CAACiB,MAAM,CAACiC,WAAW,GAAGvB,MAAMG,UAAU,EAAES;oBACxEK,aAAaG,IAAI,CAACI;gBACpB;gBAEArC,SAASoB,aAAaP,MAAMI,QAAQ;YACtC;QACF;QAEA,qDAAqD;QACrD,IAAIW,cAAc;YAChB,OAAOC,YAAYD,aAAa9C,MAAM,GAAG8C,aAAaN,KAAK,CAAC,GAAGO,aAAaD;QAC9E;QACA,OAAOtB,OAAOgC,MAAM,CAACR;IACvB;WAvPWpD;;AAkQN,SAASC,YAAYoB,KAAiB,EAAEnB,UAA+B,EAAE+C,UAAmB,EAAE9C,UAA4C;IAC/I,IAAM0D,UAAU,IAAI7D,aAAaE,YAAYC;IAC7C,IAAIA,YAAY;QACd,8CAA8C;QAC9C,OAAO0D,QAAQnC,cAAc,CAACL;IAChC;IACA,6CAA6C;IAC7C,OAAOwC,QAAQpC,MAAM,CAACJ,OAAO4B;AAC/B"}

package/dist/cjs/sevenz.d.cts

@@ -27,7 +27,8 @@
  * and writes directly to it. Wrapping with an OutputSink that buffers to an
  * array defeats this optimization by creating unnecessary intermediate copies.
  */
-import { type DecodeCallback } from './utils/runDecode.js';
+/** Callback for async decode operations: (error, result) => void */
+export type DecodeCallback<T = Buffer> = (error: Error | null, result?: T) => void;
 /** Callback invoked when an async 7z decode completes */
 export type SevenZDecodeCallback = DecodeCallback<Buffer>;
 export declare function decode7zLzma(data: Buffer, properties: Buffer, unpackSize: number, callback: SevenZDecodeCallback): void;

package/dist/cjs/sevenz.d.ts

@@ -27,7 +27,8 @@
  * and writes directly to it. Wrapping with an OutputSink that buffers to an
  * array defeats this optimization by creating unnecessary intermediate copies.
  */
-import { type DecodeCallback } from './utils/runDecode.js';
+/** Callback for async decode operations: (error, result) => void */
+export type DecodeCallback<T = Buffer> = (error: Error | null, result?: T) => void;
 /** Callback invoked when an async 7z decode completes */
 export type SevenZDecodeCallback = DecodeCallback<Buffer>;
 export declare function decode7zLzma(data: Buffer, properties: Buffer, unpackSize: number, callback: SevenZDecodeCallback): void;

package/dist/cjs/sevenz.js

@@ -47,24 +47,28 @@ _export(exports, {
 var _Lzma2Decoderts = require("./lzma/sync/Lzma2Decoder.js");
 var _LzmaDecoderts = require("./lzma/sync/LzmaDecoder.js");
 var _nativets = require("./native.js");
-var _runDecodets = require("./utils/runDecode.js");
+var schedule = typeof setImmediate === 'function' ? setImmediate : function(fn) {
+    return process.nextTick(fn);
+};
 function decode7zLzma(data, properties, unpackSize, callback) {
-    return (0, _runDecodets.runDecode)(function(done) {
+    var worker = function(cb) {
         var fallback = function() {
-            return (0, _runDecodets.runSync)(function() {
-                return (0, _LzmaDecoderts.decodeLzma)(data, properties, unpackSize);
-            }, done);
+            schedule(function() {
+                try {
+                    cb(null, (0, _LzmaDecoderts.decodeLzma)(data, properties, unpackSize));
+                } catch (err) {
+                    cb(err);
+                }
+            });
         };
         var native = (0, _nativets.tryLoadNative)();
-        if (native && native.lzma) {
+        if (native === null || native === void 0 ? void 0 : native.lzma) {
             try {
                 var promise = native.lzma(data, properties, unpackSize);
                 if (promise && typeof promise.then === 'function') {
                     promise.then(function(value) {
-                        return done(null, value);
-                    }, function() {
-                        return fallback();
-                    });
+                        return cb(null, value);
+                    }, fallback);
                     return;
                 }
             } catch (unused) {
@@ -72,25 +76,33 @@ function decode7zLzma(data, properties, unpackSize, callback) {
             }
         }
         fallback();
-    }, callback);
+    };
+    if (typeof callback === 'function') return worker(callback);
+    return new Promise(function(resolve, reject) {
+        return worker(function(err, value) {
+            return err ? reject(err) : resolve(value);
+        });
+    });
 }
 function decode7zLzma2(data, properties, unpackSize, callback) {
-    return (0, _runDecodets.runDecode)(function(done) {
+    var worker = function(cb) {
         var fallback = function() {
-            return (0, _runDecodets.runSync)(function() {
-                return (0, _Lzma2Decoderts.decodeLzma2)(data, properties, unpackSize);
-            }, done);
+            schedule(function() {
+                try {
+                    cb(null, (0, _Lzma2Decoderts.decodeLzma2)(data, properties, unpackSize));
+                } catch (err) {
+                    cb(err);
+                }
+            });
         };
         var native = (0, _nativets.tryLoadNative)();
-        if (native && native.lzma2) {
+        if (native === null || native === void 0 ? void 0 : native.lzma2) {
             try {
                 var promise = native.lzma2(data, properties, unpackSize);
                 if (promise && typeof promise.then === 'function') {
                     promise.then(function(value) {
-                        return done(null, value);
-                    }, function() {
-                        return fallback();
-                    });
+                        return cb(null, value);
+                    }, fallback);
                     return;
                 }
             } catch (unused) {
@@ -98,6 +110,12 @@ function decode7zLzma2(data, properties, unpackSize, callback) {
             }
         }
         fallback();
-    }, callback);
+    };
+    if (typeof callback === 'function') return worker(callback);
+    return new Promise(function(resolve, reject) {
+        return worker(function(err, value) {
+            return err ? reject(err) : resolve(value);
+        });
+    });
 }
 /* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/sevenz.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/xz-compat/src/sevenz.ts"],"sourcesContent":["/**\n * High-Level 7z-Specific Decoders\n *\n * These functions accept properties separately (matching 7z format structure)\n * and execute either the native lzma-native path or the pure JS fallback.\n *\n * This provides automatic native acceleration for 7z files while maintaining\n * the API that 7z-iterator expects.\n *\n * IMPORTANT: Buffer Management Pattern\n *\n * ❌ SLOW - DO NOT use OutputSink with buffering:\n *   const chunks: Buffer[] = [];\n *   decodeLzma2(data, props, size, { write: c => chunks.push(c) });\n *   return Buffer.concat(chunks);  // ← 3 copies: push + concat + return\n *\n *   OutWindow → chunks.push(chunk) → Buffer.concat(chunks) → result\n *              COPY TO ARRAY              COPY ALL            FINAL BUFFER\n *\n * ✅ FAST - Direct return (let decoder manage buffer):\n *   return decodeLzma2(data, props, size) as Buffer;  // ← 1 copy\n *\n *   OutWindow → pre-allocated buffer → result\n *               DIRECT WRITE\n *\n * The decodeLzma2() function internally pre-allocates the exact output size\n * and writes directly to it. Wrapping with an OutputSink that buffers to an\n * array defeats this optimization by creating unnecessary intermediate copies.\n */\n\nimport { decodeLzma2 } from './lzma/sync/Lzma2Decoder.ts';\nimport { decodeLzma } from './lzma/sync/LzmaDecoder.ts';\nimport { tryLoadNative } from './native.ts';\nimport { type DecodeCallback, runDecode, runSync } from './utils/runDecode.ts';\n\n/** Callback invoked when an async 7z decode completes */\nexport type SevenZDecodeCallback = DecodeCallback<Buffer>;\n\nexport function decode7zLzma(data: Buffer, properties: Buffer, unpackSize: number, callback: SevenZDecodeCallback): void;\nexport function decode7zLzma(data: Buffer, properties: Buffer, unpackSize: number): Promise<Buffer>;\n/**\n * Decode LZMA-compressed data from a 7z file\n */\nexport function decode7zLzma(data: Buffer, properties: Buffer, unpackSize: number, callback?: SevenZDecodeCallback): Promise<Buffer> | void {\n  return runDecode((done) => {\n    const fallback = () => runSync(() => decodeLzma(data, properties, unpackSize) as Buffer, done);\n    const native = tryLoadNative();\n\n    if (native && native.lzma) {\n      try {\n        const promise = native.lzma(data, properties, unpackSize);\n        if (promise && typeof promise.then === 'function') {\n          promise.then(\n            (value) => done(null, value),\n            () => fallback()\n          );\n          return;\n        }\n      } catch {\n        // fall through to fallback\n      }\n    }\n\n    fallback();\n  }, callback);\n}\n\n/**\n * Decode LZMA2-compressed data from a 7z file\n */\nexport function decode7zLzma2(data: Buffer, properties: Buffer, unpackSize: number | undefined, callback: SevenZDecodeCallback): void;\nexport function decode7zLzma2(data: Buffer, properties: Buffer, unpackSize?: number): Promise<Buffer>;\nexport function decode7zLzma2(data: Buffer, properties: Buffer, unpackSize?: number, callback?: SevenZDecodeCallback): Promise<Buffer> | void {\n  return runDecode((done) => {\n    const fallback = () => runSync(() => decodeLzma2(data, properties, unpackSize) as Buffer, done);\n    const native = tryLoadNative();\n\n    if (native && native.lzma2) {\n      try {\n        const promise = native.lzma2(data, properties, unpackSize);\n        if (promise && typeof promise.then === 'function') {\n          promise.then(\n            (value) => done(null, value),\n            () => fallback()\n          );\n          return;\n        }\n      } catch {\n        // fall through to fallback\n      }\n    }\n\n    fallback();\n  }, callback);\n}\n"],"names":["decode7zLzma","decode7zLzma2","data","properties","unpackSize","callback","runDecode","done","fallback","runSync","decodeLzma","native","tryLoadNative","lzma","promise","then","value","decodeLzma2","lzma2"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BC;;;;;;;;;;;QAeeA;eAAAA;;QA6BAC;eAAAA;;;8BA1CY;6BACD;wBACG;2BAC0B;AAUjD,SAASD,aAAaE,IAAY,EAAEC,UAAkB,EAAEC,UAAkB,EAAEC,QAA+B;IAChH,OAAOC,IAAAA,sBAAS,EAAC,SAACC;QAChB,IAAMC,WAAW;mBAAMC,IAAAA,oBAAO,EAAC;uBAAMC,IAAAA,yBAAU,EAACR,MAAMC,YAAYC;eAAuBG;;QACzF,IAAMI,SAASC,IAAAA,uBAAa;QAE5B,IAAID,UAAUA,OAAOE,IAAI,EAAE;YACzB,IAAI;gBACF,IAAMC,UAAUH,OAAOE,IAAI,CAACX,MAAMC,YAAYC;gBAC9C,IAAIU,WAAW,OAAOA,QAAQC,IAAI,KAAK,YAAY;oBACjDD,QAAQC,IAAI,CACV,SAACC;+BAAUT,KAAK,MAAMS;uBACtB;+BAAMR;;oBAER;gBACF;YACF,EAAE,eAAM;YACN,2BAA2B;YAC7B;QACF;QAEAA;IACF,GAAGH;AACL;AAOO,SAASJ,cAAcC,IAAY,EAAEC,UAAkB,EAAEC,UAAmB,EAAEC,QAA+B;IAClH,OAAOC,IAAAA,sBAAS,EAAC,SAACC;QAChB,IAAMC,WAAW;mBAAMC,IAAAA,oBAAO,EAAC;uBAAMQ,IAAAA,2BAAW,EAACf,MAAMC,YAAYC;eAAuBG;;QAC1F,IAAMI,SAASC,IAAAA,uBAAa;QAE5B,IAAID,UAAUA,OAAOO,KAAK,EAAE;YAC1B,IAAI;gBACF,IAAMJ,UAAUH,OAAOO,KAAK,CAAChB,MAAMC,YAAYC;gBAC/C,IAAIU,WAAW,OAAOA,QAAQC,IAAI,KAAK,YAAY;oBACjDD,QAAQC,IAAI,CACV,SAACC;+BAAUT,KAAK,MAAMS;uBACtB;+BAAMR;;oBAER;gBACF;YACF,EAAE,eAAM;YACN,2BAA2B;YAC7B;QACF;QAEAA;IACF,GAAGH;AACL"}
+{"version":3,"sources":["/Users/kevin/Dev/iterators/xz-compat/src/sevenz.ts"],"sourcesContent":["/**\n * High-Level 7z-Specific Decoders\n *\n * These functions accept properties separately (matching 7z format structure)\n * and execute either the native lzma-native path or the pure JS fallback.\n *\n * This provides automatic native acceleration for 7z files while maintaining\n * the API that 7z-iterator expects.\n *\n * IMPORTANT: Buffer Management Pattern\n *\n * ❌ SLOW - DO NOT use OutputSink with buffering:\n *   const chunks: Buffer[] = [];\n *   decodeLzma2(data, props, size, { write: c => chunks.push(c) });\n *   return Buffer.concat(chunks);  // ← 3 copies: push + concat + return\n *\n *   OutWindow → chunks.push(chunk) → Buffer.concat(chunks) → result\n *              COPY TO ARRAY              COPY ALL            FINAL BUFFER\n *\n * ✅ FAST - Direct return (let decoder manage buffer):\n *   return decodeLzma2(data, props, size) as Buffer;  // ← 1 copy\n *\n *   OutWindow → pre-allocated buffer → result\n *               DIRECT WRITE\n *\n * The decodeLzma2() function internally pre-allocates the exact output size\n * and writes directly to it. Wrapping with an OutputSink that buffers to an\n * array defeats this optimization by creating unnecessary intermediate copies.\n */\n\nimport { decodeLzma2 } from './lzma/sync/Lzma2Decoder.ts';\nimport { decodeLzma } from './lzma/sync/LzmaDecoder.ts';\nimport { tryLoadNative } from './native.ts';\n\n/** Callback for async decode operations: (error, result) => void */\nexport type DecodeCallback<T = Buffer> = (error: Error | null, result?: T) => void;\n\n/** Callback invoked when an async 7z decode completes */\nexport type SevenZDecodeCallback = DecodeCallback<Buffer>;\n\nconst schedule = typeof setImmediate === 'function' ? setImmediate : (fn: () => void) => process.nextTick(fn);\n\nexport function decode7zLzma(data: Buffer, properties: Buffer, unpackSize: number, callback: SevenZDecodeCallback): void;\nexport function decode7zLzma(data: Buffer, properties: Buffer, unpackSize: number): Promise<Buffer>;\n/**\n * Decode LZMA-compressed data from a 7z file\n */\nexport function decode7zLzma(data: Buffer, properties: Buffer, unpackSize: number, callback?: SevenZDecodeCallback): Promise<Buffer> | void {\n  const worker = (cb: SevenZDecodeCallback) => {\n    const fallback = () => {\n      schedule(() => {\n        try {\n          cb(null, decodeLzma(data, properties, unpackSize) as Buffer);\n        } catch (err) {\n          cb(err as Error);\n        }\n      });\n    };\n\n    const native = tryLoadNative();\n    if (native?.lzma) {\n      try {\n        const promise = native.lzma(data, properties, unpackSize);\n        if (promise && typeof promise.then === 'function') {\n          promise.then((value) => cb(null, value), fallback);\n          return;\n        }\n      } catch {\n        // fall through to fallback\n      }\n    }\n    fallback();\n  };\n\n  if (typeof callback === 'function') return worker(callback);\n  return new Promise((resolve, reject) => worker((err, value) => (err ? reject(err) : resolve(value as Buffer))));\n}\n\n/**\n * Decode LZMA2-compressed data from a 7z file\n */\nexport function decode7zLzma2(data: Buffer, properties: Buffer, unpackSize: number | undefined, callback: SevenZDecodeCallback): void;\nexport function decode7zLzma2(data: Buffer, properties: Buffer, unpackSize?: number): Promise<Buffer>;\nexport function decode7zLzma2(data: Buffer, properties: Buffer, unpackSize?: number, callback?: SevenZDecodeCallback): Promise<Buffer> | void {\n  const worker = (cb: SevenZDecodeCallback) => {\n    const fallback = () => {\n      schedule(() => {\n        try {\n          cb(null, decodeLzma2(data, properties, unpackSize) as Buffer);\n        } catch (err) {\n          cb(err as Error);\n        }\n      });\n    };\n\n    const native = tryLoadNative();\n    if (native?.lzma2) {\n      try {\n        const promise = native.lzma2(data, properties, unpackSize);\n        if (promise && typeof promise.then === 'function') {\n          promise.then((value) => cb(null, value), fallback);\n          return;\n        }\n      } catch {\n        // fall through to fallback\n      }\n    }\n    fallback();\n  };\n\n  if (typeof callback === 'function') return worker(callback);\n  return new Promise((resolve, reject) => worker((err, value) => (err ? reject(err) : resolve(value as Buffer))));\n}\n"],"names":["decode7zLzma","decode7zLzma2","schedule","setImmediate","fn","process","nextTick","data","properties","unpackSize","callback","worker","cb","fallback","decodeLzma","err","native","tryLoadNative","lzma","promise","then","value","Promise","resolve","reject","decodeLzma2","lzma2"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BC;;;;;;;;;;;QAmBeA;eAAAA;;QAoCAC;eAAAA;;;8BArDY;6BACD;wBACG;AAQ9B,IAAMC,WAAW,OAAOC,iBAAiB,aAAaA,eAAe,SAACC;WAAmBC,QAAQC,QAAQ,CAACF;;AAOnG,SAASJ,aAAaO,IAAY,EAAEC,UAAkB,EAAEC,UAAkB,EAAEC,QAA+B;IAChH,IAAMC,SAAS,SAACC;QACd,IAAMC,WAAW;YACfX,SAAS;gBACP,IAAI;oBACFU,GAAG,MAAME,IAAAA,yBAAU,EAACP,MAAMC,YAAYC;gBACxC,EAAE,OAAOM,KAAK;oBACZH,GAAGG;gBACL;YACF;QACF;QAEA,IAAMC,SAASC,IAAAA,uBAAa;QAC5B,IAAID,mBAAAA,6BAAAA,OAAQE,IAAI,EAAE;YAChB,IAAI;gBACF,IAAMC,UAAUH,OAAOE,IAAI,CAACX,MAAMC,YAAYC;gBAC9C,IAAIU,WAAW,OAAOA,QAAQC,IAAI,KAAK,YAAY;oBACjDD,QAAQC,IAAI,CAAC,SAACC;+BAAUT,GAAG,MAAMS;uBAAQR;oBACzC;gBACF;YACF,EAAE,eAAM;YACN,2BAA2B;YAC7B;QACF;QACAA;IACF;IAEA,IAAI,OAAOH,aAAa,YAAY,OAAOC,OAAOD;IAClD,OAAO,IAAIY,QAAQ,SAACC,SAASC;eAAWb,OAAO,SAACI,KAAKM;mBAAWN,MAAMS,OAAOT,OAAOQ,QAAQF;;;AAC9F;AAOO,SAASpB,cAAcM,IAAY,EAAEC,UAAkB,EAAEC,UAAmB,EAAEC,QAA+B;IAClH,IAAMC,SAAS,SAACC;QACd,IAAMC,WAAW;YACfX,SAAS;gBACP,IAAI;oBACFU,GAAG,MAAMa,IAAAA,2BAAW,EAAClB,MAAMC,YAAYC;gBACzC,EAAE,OAAOM,KAAK;oBACZH,GAAGG;gBACL;YACF;QACF;QAEA,IAAMC,SAASC,IAAAA,uBAAa;QAC5B,IAAID,mBAAAA,6BAAAA,OAAQU,KAAK,EAAE;YACjB,IAAI;gBACF,IAAMP,UAAUH,OAAOU,KAAK,CAACnB,MAAMC,YAAYC;gBAC/C,IAAIU,WAAW,OAAOA,QAAQC,IAAI,KAAK,YAAY;oBACjDD,QAAQC,IAAI,CAAC,SAACC;+BAAUT,GAAG,MAAMS;uBAAQR;oBACzC;gBACF;YACF,EAAE,eAAM;YACN,2BAA2B;YAC7B;QACF;QACAA;IACF;IAEA,IAAI,OAAOH,aAAa,YAAY,OAAOC,OAAOD;IAClD,OAAO,IAAIY,QAAQ,SAACC,SAASC;eAAWb,OAAO,SAACI,KAAKM;mBAAWN,MAAMS,OAAOT,OAAOQ,QAAQF;;;AAC9F"}

package/dist/cjs/xz/Decoder.d.cts

@@ -18,14 +18,26 @@
  *   decodeLzma2(data, props, size, { write: c => chunks.push(c) });
  *   return Buffer.concat(chunks);  // ← Unnecessary copies!
  */
+import { type BufferLike } from 'extract-base-iterator';
 import type { Transform as TransformType } from 'stream';
-import { type DecodeCallback } from '../utils/runDecode.js';
+import type { DecodeCallback } from '../sevenz.js';
+export type { BufferLike } from 'extract-base-iterator';
 /** Callback invoked when an async decode completes */
-export type XzDecodeCallback = DecodeCallback<Buffer>;
+export type XzDecodeCallback = DecodeCallback<BufferLike>;
+/**
+ * Decompress XZ data. With a callback the result is provided asynchronously;
+ * otherwise a Promise resolves with the decoded data.
+ *
+ * Returns Buffer for single-block files (most small files).
+ * Returns BufferList for multi-block files (avoids large contiguous allocation).
+ */
 export declare function decodeXZ(input: Buffer, callback: XzDecodeCallback): void;
-export declare function decodeXZ(input: Buffer): Promise<Buffer>;
+export declare function decodeXZ(input: Buffer): Promise<BufferLike>;
 /**
  * Create an XZ decompression Transform stream
  * @returns Transform stream that decompresses XZ data
+ *
+ * Uses BufferList to avoid large contiguous buffer allocations.
+ * Decompresses and pushes blocks one at a time for streaming output.
  */
 export declare function createXZDecoder(): TransformType;

package/dist/cjs/xz/Decoder.d.ts

@@ -18,14 +18,26 @@
  *   decodeLzma2(data, props, size, { write: c => chunks.push(c) });
  *   return Buffer.concat(chunks);  // ← Unnecessary copies!
  */
+import { type BufferLike } from 'extract-base-iterator';
 import type { Transform as TransformType } from 'stream';
-import { type DecodeCallback } from '../utils/runDecode.js';
+import type { DecodeCallback } from '../sevenz.js';
+export type { BufferLike } from 'extract-base-iterator';
 /** Callback invoked when an async decode completes */
-export type XzDecodeCallback = DecodeCallback<Buffer>;
+export type XzDecodeCallback = DecodeCallback<BufferLike>;
+/**
+ * Decompress XZ data. With a callback the result is provided asynchronously;
+ * otherwise a Promise resolves with the decoded data.
+ *
+ * Returns Buffer for single-block files (most small files).
+ * Returns BufferList for multi-block files (avoids large contiguous allocation).
+ */
 export declare function decodeXZ(input: Buffer, callback: XzDecodeCallback): void;
-export declare function decodeXZ(input: Buffer): Promise<Buffer>;
+export declare function decodeXZ(input: Buffer): Promise<BufferLike>;
 /**
  * Create an XZ decompression Transform stream
  * @returns Transform stream that decompresses XZ data
+ *
+ * Uses BufferList to avoid large contiguous buffer allocations.
+ * Decompresses and pushes blocks one at a time for streaming output.
  */
 export declare function createXZDecoder(): TransformType;