xz-compat 1.1.4 → 1.2.1

package/dist/cjs/sevenz.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/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 type { BufferLike } from 'extract-base-iterator';\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: BufferLike, properties: Buffer, unpackSize: number, callback: SevenZDecodeCallback): void;\nexport function decode7zLzma(data: BufferLike, properties: Buffer, unpackSize: number): Promise<Buffer>;\n/**\n * Decode LZMA-compressed data from a 7z file\n */\nexport function decode7zLzma(data: BufferLike, 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        // Native lzma-native expects Buffer, convert if needed\n        const buf = Buffer.isBuffer(data) ? data : data.toBuffer();\n        const promise = native.lzma(buf, 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: BufferLike, properties: Buffer, unpackSize: number | undefined, callback: SevenZDecodeCallback): void;\nexport function decode7zLzma2(data: BufferLike, properties: Buffer, unpackSize?: number): Promise<Buffer>;\nexport function decode7zLzma2(data: BufferLike, 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        // Native lzma-native expects Buffer, convert if needed\n        const buf = Buffer.isBuffer(data) ? data : data.toBuffer();\n        const promise = native.lzma2(buf, 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","buf","Buffer","isBuffer","toBuffer","promise","then","value","Promise","resolve","reject","decodeLzma2","lzma2"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BC;;;;;;;;;;;QAoBeA;eAAAA;;QAsCAC;eAAAA;;;8BAvDY;6BACD;wBACG;AAQ9B,IAAMC,WAAW,OAAOC,iBAAiB,aAAaA,eAAe,SAACC;WAAmBC,QAAQC,QAAQ,CAACF;;AAOnG,SAASJ,aAAaO,IAAgB,EAAEC,UAAkB,EAAEC,UAAkB,EAAEC,QAA+B;IACpH,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,uDAAuD;gBACvD,IAAMC,MAAMC,OAAOC,QAAQ,CAACd,QAAQA,OAAOA,KAAKe,QAAQ;gBACxD,IAAMC,UAAUP,OAAOE,IAAI,CAACC,KAAKX,YAAYC;gBAC7C,IAAIc,WAAW,OAAOA,QAAQC,IAAI,KAAK,YAAY;oBACjDD,QAAQC,IAAI,CAAC,SAACC;+BAAUb,GAAG,MAAMa;uBAAQZ;oBACzC;gBACF;YACF,EAAE,eAAM;YACN,2BAA2B;YAC7B;QACF;QACAA;IACF;IAEA,IAAI,OAAOH,aAAa,YAAY,OAAOC,OAAOD;IAClD,OAAO,IAAIgB,QAAQ,SAACC,SAASC;eAAWjB,OAAO,SAACI,KAAKU;mBAAWV,MAAMa,OAAOb,OAAOY,QAAQF;;;AAC9F;AAOO,SAASxB,cAAcM,IAAgB,EAAEC,UAAkB,EAAEC,UAAmB,EAAEC,QAA+B;IACtH,IAAMC,SAAS,SAACC;QACd,IAAMC,WAAW;YACfX,SAAS;gBACP,IAAI;oBACFU,GAAG,MAAMiB,IAAAA,2BAAW,EAACtB,MAAMC,YAAYC;gBACzC,EAAE,OAAOM,KAAK;oBACZH,GAAGG;gBACL;YACF;QACF;QAEA,IAAMC,SAASC,IAAAA,uBAAa;QAC5B,IAAID,mBAAAA,6BAAAA,OAAQc,KAAK,EAAE;YACjB,IAAI;gBACF,uDAAuD;gBACvD,IAAMX,MAAMC,OAAOC,QAAQ,CAACd,QAAQA,OAAOA,KAAKe,QAAQ;gBACxD,IAAMC,UAAUP,OAAOc,KAAK,CAACX,KAAKX,YAAYC;gBAC9C,IAAIc,WAAW,OAAOA,QAAQC,IAAI,KAAK,YAAY;oBACjDD,QAAQC,IAAI,CAAC,SAACC;+BAAUb,GAAG,MAAMa;uBAAQZ;oBACzC;gBACF;YACF,EAAE,eAAM;YACN,2BAA2B;YAC7B;QACF;QACAA;IACF;IAEA,IAAI,OAAOH,aAAa,YAAY,OAAOC,OAAOD;IAClD,OAAO,IAAIgB,QAAQ,SAACC,SAASC;eAAWjB,OAAO,SAACI,KAAKU;mBAAWV,MAAMa,OAAOb,OAAOY,QAAQF;;;AAC9F"}

package/dist/esm/lzma/lib/Lzma2ChunkParser.d.ts

@@ -13,6 +13,7 @@
  * 0xC0-0xDF    = LZMA chunk, reset state + new properties
  * 0xE0-0xFF    = LZMA chunk, reset dictionary + state + new properties
  */
+import type { BufferLike } from 'extract-base-iterator';
 /**
  * LZMA properties extracted from chunk header
  */
@@ -53,11 +54,11 @@ export type ParseResult = {
 /**
  * Parse an LZMA2 chunk header
  *
- * @param input - Input buffer
+ * @param input - Input buffer or BufferList
  * @param offset - Offset to start parsing
  * @returns Parsed chunk info or number of bytes needed
  */
-export declare function parseLzma2ChunkHeader(input: Buffer, offset: number): ParseResult;
+export declare function parseLzma2ChunkHeader(input: BufferLike, offset: number): ParseResult;
 /** Result type for hasCompleteChunk with totalSize included on success */
 export type CompleteChunkResult = {
     success: true;
@@ -70,4 +71,4 @@ export type CompleteChunkResult = {
 /**
  * Check if we have enough data for the complete chunk (header + data)
  */
-export declare function hasCompleteChunk(input: Buffer, offset: number): CompleteChunkResult;
+export declare function hasCompleteChunk(input: BufferLike, offset: number): CompleteChunkResult;

package/dist/esm/lzma/lib/Lzma2ChunkParser.js

@@ -13,21 +13,30 @@
  * 0xC0-0xDF    = LZMA chunk, reset state + new properties
  * 0xE0-0xFF    = LZMA chunk, reset dictionary + state + new properties
  */ /**
- * LZMA properties extracted from chunk header
- */ /**
+ * Read a byte from BufferLike at offset
+ */ function readByte(input, offset) {
+    return Buffer.isBuffer(input) ? input[offset] : input.readByte(offset);
+}
+/**
+ * Get length of BufferLike
+ */ function getLength(input) {
+    return Buffer.isBuffer(input) ? input.length : input.length;
+}
+/**
  * Parse an LZMA2 chunk header
  *
- * @param input - Input buffer
+ * @param input - Input buffer or BufferList
  * @param offset - Offset to start parsing
  * @returns Parsed chunk info or number of bytes needed
  */ export function parseLzma2ChunkHeader(input, offset) {
-    if (offset >= input.length) {
+    const len = getLength(input);
+    if (offset >= len) {
         return {
             success: false,
             needBytes: 1
         };
     }
-    const control = input[offset];
+    const control = readByte(input, offset);
     // End of stream
     if (control === 0x00) {
         return {
@@ -46,13 +55,13 @@
     // Uncompressed chunk
     if (control === 0x01 || control === 0x02) {
         // Need 3 bytes: control + 2 size bytes
-        if (offset + 3 > input.length) {
+        if (offset + 3 > len) {
             return {
                 success: false,
-                needBytes: 3 - (input.length - offset)
+                needBytes: 3 - (len - offset)
             };
         }
-        const uncompSize = (input[offset + 1] << 8 | input[offset + 2]) + 1;
+        const uncompSize = (readByte(input, offset + 1) << 8 | readByte(input, offset + 2)) + 1;
         return {
             success: true,
             chunk: {
@@ -70,20 +79,20 @@
     if (control >= 0x80) {
         const hasNewProps = control >= 0xc0;
         const minHeaderSize = hasNewProps ? 6 : 5; // control + 2 uncomp + 2 comp + (1 props)
-        if (offset + minHeaderSize > input.length) {
+        if (offset + minHeaderSize > len) {
             return {
                 success: false,
-                needBytes: minHeaderSize - (input.length - offset)
+                needBytes: minHeaderSize - (len - offset)
             };
         }
         // Parse sizes
         const uncompHigh = control & 0x1f;
-        const uncompSize = (uncompHigh << 16 | input[offset + 1] << 8 | input[offset + 2]) + 1;
-        const compSize = (input[offset + 3] << 8 | input[offset + 4]) + 1;
+        const uncompSize = (uncompHigh << 16 | readByte(input, offset + 1) << 8 | readByte(input, offset + 2)) + 1;
+        const compSize = (readByte(input, offset + 3) << 8 | readByte(input, offset + 4)) + 1;
         // Parse properties if present
         let newProps = null;
         if (hasNewProps) {
-            const propsByte = input[offset + 5];
+            const propsByte = readByte(input, offset + 5);
             const lc = propsByte % 9;
             const remainder = ~~(propsByte / 9);
             const lp = remainder % 5;
@@ -123,10 +132,11 @@
     const { chunk } = result;
     const dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;
     const totalSize = chunk.headerSize + dataSize;
-    if (offset + totalSize > input.length) {
+    const len = getLength(input);
+    if (offset + totalSize > len) {
         return {
             success: false,
-            needBytes: totalSize - (input.length - offset)
+            needBytes: totalSize - (len - offset)
         };
     }
     return {

package/dist/esm/lzma/lib/Lzma2ChunkParser.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/lzma/lib/Lzma2ChunkParser.ts"],"sourcesContent":["/**\n * LZMA2 Chunk Parser\n *\n * Shared parsing logic for LZMA2 chunk headers.\n * Used by both synchronous and streaming decoders.\n *\n * LZMA2 control byte ranges:\n * 0x00         = End of stream\n * 0x01         = Uncompressed chunk, dictionary reset\n * 0x02         = Uncompressed chunk, no dictionary reset\n * 0x80-0x9F    = LZMA chunk, no reset (solid mode)\n * 0xA0-0xBF    = LZMA chunk, reset state (probabilities)\n * 0xC0-0xDF    = LZMA chunk, reset state + new properties\n * 0xE0-0xFF    = LZMA chunk, reset dictionary + state + new properties\n */\n\n/**\n * LZMA properties extracted from chunk header\n */\nexport interface LzmaChunkProps {\n  lc: number;\n  lp: number;\n  pb: number;\n}\n\n/**\n * Parsed LZMA2 chunk information\n */\nexport interface Lzma2Chunk {\n  /** Chunk type */\n  type: 'end' | 'uncompressed' | 'lzma';\n  /** Total bytes consumed by header (including control byte) */\n  headerSize: number;\n  /** Whether to reset dictionary */\n  dictReset: boolean;\n  /** Whether to reset state/probabilities */\n  stateReset: boolean;\n  /** New LZMA properties (only for control >= 0xC0) */\n  newProps: LzmaChunkProps | null;\n  /** Uncompressed data size */\n  uncompSize: number;\n  /** Compressed data size (0 for uncompressed chunks) */\n  compSize: number;\n}\n\n/**\n * Result of parsing attempt\n */\nexport type ParseResult = { success: true; chunk: Lzma2Chunk } | { success: false; needBytes: number };\n\n/**\n * Parse an LZMA2 chunk header\n *\n * @param input - Input buffer\n * @param offset - Offset to start parsing\n * @returns Parsed chunk info or number of bytes needed\n */\nexport function parseLzma2ChunkHeader(input: Buffer, offset: number): ParseResult {\n  if (offset >= input.length) {\n    return { success: false, needBytes: 1 };\n  }\n\n  const control = input[offset];\n\n  // End of stream\n  if (control === 0x00) {\n    return {\n      success: true,\n      chunk: {\n        type: 'end',\n        headerSize: 1,\n        dictReset: false,\n        stateReset: false,\n        newProps: null,\n        uncompSize: 0,\n        compSize: 0,\n      },\n    };\n  }\n\n  // Uncompressed chunk\n  if (control === 0x01 || control === 0x02) {\n    // Need 3 bytes: control + 2 size bytes\n    if (offset + 3 > input.length) {\n      return { success: false, needBytes: 3 - (input.length - offset) };\n    }\n\n    const uncompSize = ((input[offset + 1] << 8) | input[offset + 2]) + 1;\n\n    return {\n      success: true,\n      chunk: {\n        type: 'uncompressed',\n        headerSize: 3,\n        dictReset: control === 0x01,\n        stateReset: false,\n        newProps: null,\n        uncompSize,\n        compSize: 0,\n      },\n    };\n  }\n\n  // LZMA compressed chunk\n  if (control >= 0x80) {\n    const hasNewProps = control >= 0xc0;\n    const minHeaderSize = hasNewProps ? 6 : 5; // control + 2 uncomp + 2 comp + (1 props)\n\n    if (offset + minHeaderSize > input.length) {\n      return { success: false, needBytes: minHeaderSize - (input.length - offset) };\n    }\n\n    // Parse sizes\n    const uncompHigh = control & 0x1f;\n    const uncompSize = ((uncompHigh << 16) | (input[offset + 1] << 8) | input[offset + 2]) + 1;\n    const compSize = ((input[offset + 3] << 8) | input[offset + 4]) + 1;\n\n    // Parse properties if present\n    let newProps: LzmaChunkProps | null = null;\n    if (hasNewProps) {\n      const propsByte = input[offset + 5];\n      const lc = propsByte % 9;\n      const remainder = ~~(propsByte / 9);\n      const lp = remainder % 5;\n      const pb = ~~(remainder / 5);\n      newProps = { lc, lp, pb };\n    }\n\n    return {\n      success: true,\n      chunk: {\n        type: 'lzma',\n        headerSize: minHeaderSize,\n        dictReset: control >= 0xe0,\n        stateReset: control >= 0xa0,\n        newProps,\n        uncompSize,\n        compSize,\n      },\n    };\n  }\n\n  // Invalid control byte\n  throw new Error(`Invalid LZMA2 control byte: 0x${control.toString(16)}`);\n}\n\n/** Result type for hasCompleteChunk with totalSize included on success */\nexport type CompleteChunkResult = { success: true; chunk: Lzma2Chunk; totalSize: number } | { success: false; needBytes: number };\n\n/**\n * Check if we have enough data for the complete chunk (header + data)\n */\nexport function hasCompleteChunk(input: Buffer, offset: number): CompleteChunkResult {\n  const result = parseLzma2ChunkHeader(input, offset);\n\n  if (result.success === false) {\n    return { success: false, needBytes: result.needBytes };\n  }\n\n  const { chunk } = result;\n  const dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;\n  const totalSize = chunk.headerSize + dataSize;\n\n  if (offset + totalSize > input.length) {\n    return { success: false, needBytes: totalSize - (input.length - offset) };\n  }\n\n  return { success: true, chunk, totalSize };\n}\n"],"names":["parseLzma2ChunkHeader","input","offset","length","success","needBytes","control","chunk","type","headerSize","dictReset","stateReset","newProps","uncompSize","compSize","hasNewProps","minHeaderSize","uncompHigh","propsByte","lc","remainder","lp","pb","Error","toString","hasCompleteChunk","result","dataSize","totalSize"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/xz-compat/src/lzma/lib/Lzma2ChunkParser.ts"],"sourcesContent":["/**\n * LZMA2 Chunk Parser\n *\n * Shared parsing logic for LZMA2 chunk headers.\n * Used by both synchronous and streaming decoders.\n *\n * LZMA2 control byte ranges:\n * 0x00         = End of stream\n * 0x01         = Uncompressed chunk, dictionary reset\n * 0x02         = Uncompressed chunk, no dictionary reset\n * 0x80-0x9F    = LZMA chunk, no reset (solid mode)\n * 0xA0-0xBF    = LZMA chunk, reset state (probabilities)\n * 0xC0-0xDF    = LZMA chunk, reset state + new properties\n * 0xE0-0xFF    = LZMA chunk, reset dictionary + state + new properties\n */\n\nimport type { BufferLike } from 'extract-base-iterator';\n\n/**\n * LZMA properties extracted from chunk header\n */\nexport interface LzmaChunkProps {\n  lc: number;\n  lp: number;\n  pb: number;\n}\n\n/**\n * Parsed LZMA2 chunk information\n */\nexport interface Lzma2Chunk {\n  /** Chunk type */\n  type: 'end' | 'uncompressed' | 'lzma';\n  /** Total bytes consumed by header (including control byte) */\n  headerSize: number;\n  /** Whether to reset dictionary */\n  dictReset: boolean;\n  /** Whether to reset state/probabilities */\n  stateReset: boolean;\n  /** New LZMA properties (only for control >= 0xC0) */\n  newProps: LzmaChunkProps | null;\n  /** Uncompressed data size */\n  uncompSize: number;\n  /** Compressed data size (0 for uncompressed chunks) */\n  compSize: number;\n}\n\n/**\n * Result of parsing attempt\n */\nexport type ParseResult = { success: true; chunk: Lzma2Chunk } | { success: false; needBytes: number };\n\n/**\n * Read a byte from BufferLike at offset\n */\nfunction readByte(input: BufferLike, offset: number): number {\n  return Buffer.isBuffer(input) ? input[offset] : input.readByte(offset);\n}\n\n/**\n * Get length of BufferLike\n */\nfunction getLength(input: BufferLike): number {\n  return Buffer.isBuffer(input) ? input.length : input.length;\n}\n\n/**\n * Parse an LZMA2 chunk header\n *\n * @param input - Input buffer or BufferList\n * @param offset - Offset to start parsing\n * @returns Parsed chunk info or number of bytes needed\n */\nexport function parseLzma2ChunkHeader(input: BufferLike, offset: number): ParseResult {\n  const len = getLength(input);\n  if (offset >= len) {\n    return { success: false, needBytes: 1 };\n  }\n\n  const control = readByte(input, offset);\n\n  // End of stream\n  if (control === 0x00) {\n    return {\n      success: true,\n      chunk: {\n        type: 'end',\n        headerSize: 1,\n        dictReset: false,\n        stateReset: false,\n        newProps: null,\n        uncompSize: 0,\n        compSize: 0,\n      },\n    };\n  }\n\n  // Uncompressed chunk\n  if (control === 0x01 || control === 0x02) {\n    // Need 3 bytes: control + 2 size bytes\n    if (offset + 3 > len) {\n      return { success: false, needBytes: 3 - (len - offset) };\n    }\n\n    const uncompSize = ((readByte(input, offset + 1) << 8) | readByte(input, offset + 2)) + 1;\n\n    return {\n      success: true,\n      chunk: {\n        type: 'uncompressed',\n        headerSize: 3,\n        dictReset: control === 0x01,\n        stateReset: false,\n        newProps: null,\n        uncompSize,\n        compSize: 0,\n      },\n    };\n  }\n\n  // LZMA compressed chunk\n  if (control >= 0x80) {\n    const hasNewProps = control >= 0xc0;\n    const minHeaderSize = hasNewProps ? 6 : 5; // control + 2 uncomp + 2 comp + (1 props)\n\n    if (offset + minHeaderSize > len) {\n      return { success: false, needBytes: minHeaderSize - (len - offset) };\n    }\n\n    // Parse sizes\n    const uncompHigh = control & 0x1f;\n    const uncompSize = ((uncompHigh << 16) | (readByte(input, offset + 1) << 8) | readByte(input, offset + 2)) + 1;\n    const compSize = ((readByte(input, offset + 3) << 8) | readByte(input, offset + 4)) + 1;\n\n    // Parse properties if present\n    let newProps: LzmaChunkProps | null = null;\n    if (hasNewProps) {\n      const propsByte = readByte(input, offset + 5);\n      const lc = propsByte % 9;\n      const remainder = ~~(propsByte / 9);\n      const lp = remainder % 5;\n      const pb = ~~(remainder / 5);\n      newProps = { lc, lp, pb };\n    }\n\n    return {\n      success: true,\n      chunk: {\n        type: 'lzma',\n        headerSize: minHeaderSize,\n        dictReset: control >= 0xe0,\n        stateReset: control >= 0xa0,\n        newProps,\n        uncompSize,\n        compSize,\n      },\n    };\n  }\n\n  // Invalid control byte\n  throw new Error(`Invalid LZMA2 control byte: 0x${control.toString(16)}`);\n}\n\n/** Result type for hasCompleteChunk with totalSize included on success */\nexport type CompleteChunkResult = { success: true; chunk: Lzma2Chunk; totalSize: number } | { success: false; needBytes: number };\n\n/**\n * Check if we have enough data for the complete chunk (header + data)\n */\nexport function hasCompleteChunk(input: BufferLike, offset: number): CompleteChunkResult {\n  const result = parseLzma2ChunkHeader(input, offset);\n\n  if (result.success === false) {\n    return { success: false, needBytes: result.needBytes };\n  }\n\n  const { chunk } = result;\n  const dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;\n  const totalSize = chunk.headerSize + dataSize;\n  const len = getLength(input);\n\n  if (offset + totalSize > len) {\n    return { success: false, needBytes: totalSize - (len - offset) };\n  }\n\n  return { success: true, chunk, totalSize };\n}\n"],"names":["readByte","input","offset","Buffer","isBuffer","getLength","length","parseLzma2ChunkHeader","len","success","needBytes","control","chunk","type","headerSize","dictReset","stateReset","newProps","uncompSize","compSize","hasNewProps","minHeaderSize","uncompHigh","propsByte","lc","remainder","lp","pb","Error","toString","hasCompleteChunk","result","dataSize","totalSize"],"mappings":"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"}

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

@@ -2,7 +2,7 @@
  * Synchronous LZMA2 Decoder
  *
  * LZMA2 is a container format that wraps LZMA chunks with framing.
- * Decodes LZMA2 data from a buffer.
+ * Decodes LZMA2 data from a buffer or BufferList.
  */
 import { type BufferLike } from 'extract-base-iterator';
 import { type OutputSink } from '../types.js';
@@ -12,7 +12,6 @@ import { type OutputSink } from '../types.js';
 export declare class Lzma2Decoder {
     private lzmaDecoder;
     private dictionarySize;
-    private propsSet;
     constructor(properties: Buffer | Uint8Array, outputSink?: OutputSink);
     /**
      * Reset the dictionary (for stream boundaries)

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

@@ -2,11 +2,24 @@
  * 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';
+ * Decodes LZMA2 data from a buffer or BufferList.
+ */ import { allocBufferUnsafe, bufferConcat, bufferFrom, canAllocateBufferSize } from 'extract-base-iterator';
 import { parseLzma2ChunkHeader } from '../lib/Lzma2ChunkParser.js';
 import { parseLzma2DictionarySize } from '../types.js';
 import { LzmaDecoder } from './LzmaDecoder.js';
+/**
+ * Read multiple bytes from BufferLike into a Buffer
+ */ function readBytes(input, offset, length) {
+    if (Buffer.isBuffer(input)) {
+        return input.slice(offset, offset + length);
+    }
+    // For BufferList, create a new Buffer with the data
+    const buf = bufferFrom(new Array(length));
+    for(let i = 0; i < length; i++){
+        buf[i] = input.readByte(offset + i);
+    }
+    return buf;
+}
 /**
  * Synchronous LZMA2 decoder
  */ export class Lzma2Decoder {
@@ -45,12 +58,10 @@ import { LzmaDecoder } from './LzmaDecoder.js';
    * @param input - LZMA2 compressed data (Buffer or BufferList)
    * @returns Total number of bytes written to sink
    */ decodeWithSink(input) {
-        // Convert BufferList to Buffer for low-level parsing
-        const buf = Buffer.isBuffer(input) ? input : input.toBuffer();
         let totalBytes = 0;
         let offset = 0;
-        while(offset < buf.length){
-            const result = parseLzma2ChunkHeader(buf, offset);
+        while(true){
+            const result = parseLzma2ChunkHeader(input, offset);
             if (!result.success) {
                 throw new Error('Truncated LZMA2 chunk header');
             }
@@ -58,45 +69,31 @@ import { LzmaDecoder } from './LzmaDecoder.js';
             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 > buf.length) {
-                throw new Error(`Truncated LZMA2 ${chunk.type} data`);
-            }
             // Handle dictionary reset
             if (chunk.dictReset) {
                 this.lzmaDecoder.resetDictionary();
             }
+            // Handle state reset
+            if (chunk.stateReset) {
+                this.lzmaDecoder.resetProbabilities();
+            }
+            // Apply new properties if present
+            if (chunk.newProps) {
+                const { lc, lp, pb } = chunk.newProps;
+                this.lzmaDecoder.setLcLpPb(lc, lp, pb);
+            }
             const dataOffset = offset + chunk.headerSize;
+            const useSolid = !chunk.stateReset || chunk.stateReset && !chunk.dictReset;
             if (chunk.type === 'uncompressed') {
-                const uncompData = buf.slice(dataOffset, dataOffset + chunk.uncompSize);
+                // Read uncompressed data directly
+                const uncompData = readBytes(input, 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;
-                } else {
-                    // No new properties, check if we already have them
-                    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(buf, dataOffset, chunk.uncompSize, useSolid);
+                // LZMA compressed chunk - decode directly from BufferLike
+                totalBytes += this.lzmaDecoder.decodeWithSink(input, dataOffset, chunk.uncompSize, useSolid);
                 offset = dataOffset + chunk.compSize;
             }
         }
@@ -110,18 +107,19 @@ import { LzmaDecoder } from './LzmaDecoder.js';
    * @param unpackSize - Expected output size (optional, for pre-allocation)
    * @returns Decompressed data
    */ decode(input, unpackSize) {
-        // Convert BufferList to Buffer for low-level parsing
-        const buf = Buffer.isBuffer(input) ? input : input.toBuffer();
-        // Pre-allocate output buffer if size is known
+        // Pre-allocate output buffer if size is known and safe for this Node version
         let outputBuffer = null;
         let outputPos = 0;
         const outputChunks = [];
-        if (unpackSize && unpackSize > 0) {
+        // Use canAllocateBufferSize to dynamically check if pre-allocation is safe
+        const canPreAllocate = unpackSize && unpackSize > 0 && canAllocateBufferSize(unpackSize);
+        if (canPreAllocate) {
             outputBuffer = allocBufferUnsafe(unpackSize);
         }
         let offset = 0;
-        while(offset < buf.length){
-            const result = parseLzma2ChunkHeader(buf, offset);
+        // Parse and decode LZMA2 chunks one at a time
+        while(true){
+            const result = parseLzma2ChunkHeader(input, offset);
             if (!result.success) {
                 throw new Error('Truncated LZMA2 chunk header');
             }
@@ -129,18 +127,25 @@ import { LzmaDecoder } from './LzmaDecoder.js';
             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 > buf.length) {
-                throw new Error(`Truncated LZMA2 ${chunk.type} data`);
-            }
+            const dataOffset = offset + chunk.headerSize;
             // Handle dictionary reset
             if (chunk.dictReset) {
                 this.lzmaDecoder.resetDictionary();
             }
-            const dataOffset = offset + chunk.headerSize;
+            // Handle state reset
+            if (chunk.stateReset) {
+                this.lzmaDecoder.resetProbabilities();
+            }
+            // Apply new properties if present
+            if (chunk.newProps) {
+                const { lc, lp, pb } = chunk.newProps;
+                this.lzmaDecoder.setLcLpPb(lc, lp, pb);
+            }
+            // Determine solid mode
+            const useSolid = !chunk.stateReset || chunk.stateReset && !chunk.dictReset;
             if (chunk.type === 'uncompressed') {
-                const uncompData = buf.slice(dataOffset, dataOffset + chunk.uncompSize);
+                // Read uncompressed data
+                const uncompData = readBytes(input, dataOffset, chunk.uncompSize);
                 // Copy to output
                 if (outputBuffer) {
                     uncompData.copy(outputBuffer, outputPos);
@@ -152,34 +157,14 @@ import { LzmaDecoder } from './LzmaDecoder.js';
                 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;
-                } else {
-                    // No new properties, check if we already have them
-                    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 - use zero-copy when we have pre-allocated buffer
+                // LZMA compressed chunk - decode directly from BufferLike
                 if (outputBuffer) {
                     // Zero-copy: decode directly into caller's buffer
-                    const bytesWritten = this.lzmaDecoder.decodeToBuffer(buf, dataOffset, chunk.uncompSize, outputBuffer, outputPos, useSolid);
+                    const bytesWritten = this.lzmaDecoder.decodeToBuffer(input, dataOffset, chunk.uncompSize, outputBuffer, outputPos, useSolid);
                     outputPos += bytesWritten;
                 } else {
                     // No pre-allocation: decode to new buffer and collect chunks
-                    const chunkData = buf.slice(dataOffset, dataOffset + chunk.compSize);
+                    const chunkData = readBytes(input, dataOffset, chunk.compSize);
                     const decoded = this.lzmaDecoder.decode(chunkData, 0, chunk.uncompSize, useSolid);
                     outputChunks.push(decoded);
                 }
@@ -190,7 +175,8 @@ import { LzmaDecoder } from './LzmaDecoder.js';
         if (outputBuffer) {
             return outputPos < outputBuffer.length ? outputBuffer.slice(0, outputPos) : outputBuffer;
         }
-        return Buffer.concat(outputChunks);
+        // Use bufferConcat which handles large buffers safely via pairwise combination
+        return bufferConcat(outputChunks);
     }
     constructor(properties, outputSink){
         if (!properties || properties.length < 1) {
@@ -199,7 +185,6 @@ import { LzmaDecoder } from './LzmaDecoder.js';
         this.dictionarySize = parseLzma2DictionarySize(properties[0]);
         this.lzmaDecoder = new LzmaDecoder(outputSink);
         this.lzmaDecoder.setDictionarySize(this.dictionarySize);
-        this.propsSet = false;
     }
 }
 /**
@@ -210,6 +195,21 @@ import { LzmaDecoder } from './LzmaDecoder.js';
  * @param outputSink - Optional output sink with write callback for streaming (returns bytes written)
  * @returns Decompressed data (or bytes written if outputSink provided)
  */ export function decodeLzma2(input, properties, unpackSize, outputSink) {
+    // For very large outputs on old Node versions, we cannot return a single Buffer
+    // Use streaming mode internally to handle large outputs on modern Node
+    if (!outputSink && unpackSize && unpackSize > 0 && !canAllocateBufferSize(unpackSize)) {
+        // Large output - use streaming mode with internal chunking
+        const chunks = [];
+        const sink = {
+            write (buffer) {
+                chunks.push(buffer);
+            }
+        };
+        const decoder = new Lzma2Decoder(properties, sink);
+        decoder.decodeWithSink(input);
+        // Combine chunks at the end - use bufferConcat for safe combination
+        return bufferConcat(chunks);
+    }
     const decoder = new Lzma2Decoder(properties, outputSink);
     if (outputSink) {
         // Zero-copy mode: write to sink during decode

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

@@ -1 +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, 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":["allocBufferUnsafe","parseLzma2ChunkHeader","parseLzma2DictionarySize","LzmaDecoder","Lzma2Decoder","resetDictionary","lzmaDecoder","resetProbabilities","setLcLpPb","lc","lp","pb","feedUncompressed","data","decodeLzmaData","input","offset","outSize","solid","decode","decodeWithSink","buf","Buffer","isBuffer","toBuffer","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","bytesWritten","decodeToBuffer","chunkData","decoded","concat","properties","outputSink","dictionarySize","setDictionarySize","decodeLzma2","decoder"],"mappings":"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"}
+{"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 or BufferList.\n */\n\nimport { allocBufferUnsafe, type BufferLike, bufferConcat, bufferFrom, canAllocateBufferSize } 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 * Read multiple bytes from BufferLike into a Buffer\n */\nfunction readBytes(input: BufferLike, offset: number, length: number): Buffer {\n  if (Buffer.isBuffer(input)) {\n    return input.slice(offset, offset + length);\n  }\n  // For BufferList, create a new Buffer with the data\n  const buf = bufferFrom(new Array(length));\n  for (let i = 0; i < length; i++) {\n    buf[i] = input.readByte(offset + i);\n  }\n  return buf;\n}\n\n/**\n * Synchronous LZMA2 decoder\n */\nexport class Lzma2Decoder {\n  private lzmaDecoder: LzmaDecoder;\n  private dictionarySize: number;\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  }\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    let totalBytes = 0;\n    let offset = 0;\n\n    while (true) {\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      // Handle dictionary reset\n      if (chunk.dictReset) {\n        this.lzmaDecoder.resetDictionary();\n      }\n\n      // Handle state reset\n      if (chunk.stateReset) {\n        this.lzmaDecoder.resetProbabilities();\n      }\n\n      // Apply new properties if present\n      if (chunk.newProps) {\n        const { lc, lp, pb } = chunk.newProps;\n        this.lzmaDecoder.setLcLpPb(lc, lp, pb);\n      }\n\n      const dataOffset = offset + chunk.headerSize;\n      const useSolid = !chunk.stateReset || (chunk.stateReset && !chunk.dictReset);\n\n      if (chunk.type === 'uncompressed') {\n        // Read uncompressed data directly\n        const uncompData = readBytes(input, 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 - decode directly from BufferLike\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 (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    // Pre-allocate output buffer if size is known and safe for this Node version\n    let outputBuffer: Buffer | null = null;\n    let outputPos = 0;\n    const outputChunks: Buffer[] = [];\n\n    // Use canAllocateBufferSize to dynamically check if pre-allocation is safe\n    const canPreAllocate = unpackSize && unpackSize > 0 && canAllocateBufferSize(unpackSize);\n    if (canPreAllocate) {\n      outputBuffer = allocBufferUnsafe(unpackSize);\n    }\n\n    let offset = 0;\n\n    // Parse and decode LZMA2 chunks one at a time\n    while (true) {\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      const dataOffset = offset + chunk.headerSize;\n\n      // Handle dictionary reset\n      if (chunk.dictReset) {\n        this.lzmaDecoder.resetDictionary();\n      }\n\n      // Handle state reset\n      if (chunk.stateReset) {\n        this.lzmaDecoder.resetProbabilities();\n      }\n\n      // Apply new properties if present\n      if (chunk.newProps) {\n        const { lc, lp, pb } = chunk.newProps;\n        this.lzmaDecoder.setLcLpPb(lc, lp, pb);\n      }\n\n      // Determine solid mode\n      const useSolid = !chunk.stateReset || (chunk.stateReset && !chunk.dictReset);\n\n      if (chunk.type === 'uncompressed') {\n        // Read uncompressed data\n        const uncompData = readBytes(input, 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 - decode directly from BufferLike\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 = readBytes(input, 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    // Use bufferConcat which handles large buffers safely via pairwise combination\n    return bufferConcat(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  // For very large outputs on old Node versions, we cannot return a single Buffer\n  // Use streaming mode internally to handle large outputs on modern Node\n  if (!outputSink && unpackSize && unpackSize > 0 && !canAllocateBufferSize(unpackSize)) {\n    // Large output - use streaming mode with internal chunking\n    const chunks: Buffer[] = [];\n    const sink: OutputSink = {\n      write(buffer: Buffer): void {\n        chunks.push(buffer);\n      },\n    };\n\n    const decoder = new Lzma2Decoder(properties, sink);\n    decoder.decodeWithSink(input);\n\n    // Combine chunks at the end - use bufferConcat for safe combination\n    return bufferConcat(chunks);\n  }\n\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":["allocBufferUnsafe","bufferConcat","bufferFrom","canAllocateBufferSize","parseLzma2ChunkHeader","parseLzma2DictionarySize","LzmaDecoder","readBytes","input","offset","length","Buffer","isBuffer","slice","buf","Array","i","readByte","Lzma2Decoder","resetDictionary","lzmaDecoder","resetProbabilities","setLcLpPb","lc","lp","pb","feedUncompressed","data","decodeLzmaData","outSize","solid","decode","decodeWithSink","totalBytes","result","success","Error","chunk","type","dictReset","stateReset","newProps","dataOffset","headerSize","useSolid","uncompData","uncompSize","compSize","flushOutWindow","unpackSize","outputBuffer","outputPos","outputChunks","canPreAllocate","copy","push","bytesWritten","decodeToBuffer","chunkData","decoded","properties","outputSink","dictionarySize","setDictionarySize","decodeLzma2","chunks","sink","write","buffer","decoder"],"mappings":"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"}

package/dist/esm/sevenz.d.ts

@@ -27,14 +27,15 @@
  * and writes directly to it. Wrapping with an OutputSink that buffers to an
  * array defeats this optimization by creating unnecessary intermediate copies.
  */
+import type { BufferLike } from 'extract-base-iterator';
 /** 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;
-export declare function decode7zLzma(data: Buffer, properties: Buffer, unpackSize: number): Promise<Buffer>;
+export declare function decode7zLzma(data: BufferLike, properties: Buffer, unpackSize: number, callback: SevenZDecodeCallback): void;
+export declare function decode7zLzma(data: BufferLike, properties: Buffer, unpackSize: number): Promise<Buffer>;
 /**
  * Decode LZMA2-compressed data from a 7z file
  */
-export declare function decode7zLzma2(data: Buffer, properties: Buffer, unpackSize: number | undefined, callback: SevenZDecodeCallback): void;
-export declare function decode7zLzma2(data: Buffer, properties: Buffer, unpackSize?: number): Promise<Buffer>;
+export declare function decode7zLzma2(data: BufferLike, properties: Buffer, unpackSize: number | undefined, callback: SevenZDecodeCallback): void;
+export declare function decode7zLzma2(data: BufferLike, properties: Buffer, unpackSize?: number): Promise<Buffer>;

package/dist/esm/sevenz.js

@@ -46,7 +46,9 @@ const schedule = typeof setImmediate === 'function' ? setImmediate : (fn)=>proce
         const native = tryLoadNative();
         if (native === null || native === void 0 ? void 0 : native.lzma) {
             try {
-                const promise = native.lzma(data, properties, unpackSize);
+                // Native lzma-native expects Buffer, convert if needed
+                const buf = Buffer.isBuffer(data) ? data : data.toBuffer();
+                const promise = native.lzma(buf, properties, unpackSize);
                 if (promise && typeof promise.then === 'function') {
                     promise.then((value)=>cb(null, value), fallback);
                     return;
@@ -74,7 +76,9 @@ export function decode7zLzma2(data, properties, unpackSize, callback) {
         const native = tryLoadNative();
         if (native === null || native === void 0 ? void 0 : native.lzma2) {
             try {
-                const promise = native.lzma2(data, properties, unpackSize);
+                // Native lzma-native expects Buffer, convert if needed
+                const buf = Buffer.isBuffer(data) ? data : data.toBuffer();
+                const promise = native.lzma2(buf, properties, unpackSize);
                 if (promise && typeof promise.then === 'function') {
                     promise.then((value)=>cb(null, value), fallback);
                     return;

package/dist/esm/sevenz.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/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":["decodeLzma2","decodeLzma","tryLoadNative","schedule","setImmediate","fn","process","nextTick","decode7zLzma","data","properties","unpackSize","callback","worker","cb","fallback","err","native","lzma","promise","then","value","Promise","resolve","reject","decode7zLzma2","lzma2"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BC,GAED,SAASA,WAAW,QAAQ,8BAA8B;AAC1D,SAASC,UAAU,QAAQ,6BAA6B;AACxD,SAASC,aAAa,QAAQ,cAAc;AAQ5C,MAAMC,WAAW,OAAOC,iBAAiB,aAAaA,eAAe,CAACC,KAAmBC,QAAQC,QAAQ,CAACF;AAI1G;;CAEC,GACD,OAAO,SAASG,aAAaC,IAAY,EAAEC,UAAkB,EAAEC,UAAkB,EAAEC,QAA+B;IAChH,MAAMC,SAAS,CAACC;QACd,MAAMC,WAAW;YACfZ,SAAS;gBACP,IAAI;oBACFW,GAAG,MAAMb,WAAWQ,MAAMC,YAAYC;gBACxC,EAAE,OAAOK,KAAK;oBACZF,GAAGE;gBACL;YACF;QACF;QAEA,MAAMC,SAASf;QACf,IAAIe,mBAAAA,6BAAAA,OAAQC,IAAI,EAAE;YAChB,IAAI;gBACF,MAAMC,UAAUF,OAAOC,IAAI,CAACT,MAAMC,YAAYC;gBAC9C,IAAIQ,WAAW,OAAOA,QAAQC,IAAI,KAAK,YAAY;oBACjDD,QAAQC,IAAI,CAAC,CAACC,QAAUP,GAAG,MAAMO,QAAQN;oBACzC;gBACF;YACF,EAAE,OAAM;YACN,2BAA2B;YAC7B;QACF;QACAA;IACF;IAEA,IAAI,OAAOH,aAAa,YAAY,OAAOC,OAAOD;IAClD,OAAO,IAAIU,QAAQ,CAACC,SAASC,SAAWX,OAAO,CAACG,KAAKK,QAAWL,MAAMQ,OAAOR,OAAOO,QAAQF;AAC9F;AAOA,OAAO,SAASI,cAAchB,IAAY,EAAEC,UAAkB,EAAEC,UAAmB,EAAEC,QAA+B;IAClH,MAAMC,SAAS,CAACC;QACd,MAAMC,WAAW;YACfZ,SAAS;gBACP,IAAI;oBACFW,GAAG,MAAMd,YAAYS,MAAMC,YAAYC;gBACzC,EAAE,OAAOK,KAAK;oBACZF,GAAGE;gBACL;YACF;QACF;QAEA,MAAMC,SAASf;QACf,IAAIe,mBAAAA,6BAAAA,OAAQS,KAAK,EAAE;YACjB,IAAI;gBACF,MAAMP,UAAUF,OAAOS,KAAK,CAACjB,MAAMC,YAAYC;gBAC/C,IAAIQ,WAAW,OAAOA,QAAQC,IAAI,KAAK,YAAY;oBACjDD,QAAQC,IAAI,CAAC,CAACC,QAAUP,GAAG,MAAMO,QAAQN;oBACzC;gBACF;YACF,EAAE,OAAM;YACN,2BAA2B;YAC7B;QACF;QACAA;IACF;IAEA,IAAI,OAAOH,aAAa,YAAY,OAAOC,OAAOD;IAClD,OAAO,IAAIU,QAAQ,CAACC,SAASC,SAAWX,OAAO,CAACG,KAAKK,QAAWL,MAAMQ,OAAOR,OAAOO,QAAQF;AAC9F"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/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 type { BufferLike } from 'extract-base-iterator';\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: BufferLike, properties: Buffer, unpackSize: number, callback: SevenZDecodeCallback): void;\nexport function decode7zLzma(data: BufferLike, properties: Buffer, unpackSize: number): Promise<Buffer>;\n/**\n * Decode LZMA-compressed data from a 7z file\n */\nexport function decode7zLzma(data: BufferLike, 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        // Native lzma-native expects Buffer, convert if needed\n        const buf = Buffer.isBuffer(data) ? data : data.toBuffer();\n        const promise = native.lzma(buf, 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: BufferLike, properties: Buffer, unpackSize: number | undefined, callback: SevenZDecodeCallback): void;\nexport function decode7zLzma2(data: BufferLike, properties: Buffer, unpackSize?: number): Promise<Buffer>;\nexport function decode7zLzma2(data: BufferLike, 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        // Native lzma-native expects Buffer, convert if needed\n        const buf = Buffer.isBuffer(data) ? data : data.toBuffer();\n        const promise = native.lzma2(buf, 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":["decodeLzma2","decodeLzma","tryLoadNative","schedule","setImmediate","fn","process","nextTick","decode7zLzma","data","properties","unpackSize","callback","worker","cb","fallback","err","native","lzma","buf","Buffer","isBuffer","toBuffer","promise","then","value","Promise","resolve","reject","decode7zLzma2","lzma2"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BC,GAGD,SAASA,WAAW,QAAQ,8BAA8B;AAC1D,SAASC,UAAU,QAAQ,6BAA6B;AACxD,SAASC,aAAa,QAAQ,cAAc;AAQ5C,MAAMC,WAAW,OAAOC,iBAAiB,aAAaA,eAAe,CAACC,KAAmBC,QAAQC,QAAQ,CAACF;AAI1G;;CAEC,GACD,OAAO,SAASG,aAAaC,IAAgB,EAAEC,UAAkB,EAAEC,UAAkB,EAAEC,QAA+B;IACpH,MAAMC,SAAS,CAACC;QACd,MAAMC,WAAW;YACfZ,SAAS;gBACP,IAAI;oBACFW,GAAG,MAAMb,WAAWQ,MAAMC,YAAYC;gBACxC,EAAE,OAAOK,KAAK;oBACZF,GAAGE;gBACL;YACF;QACF;QAEA,MAAMC,SAASf;QACf,IAAIe,mBAAAA,6BAAAA,OAAQC,IAAI,EAAE;YAChB,IAAI;gBACF,uDAAuD;gBACvD,MAAMC,MAAMC,OAAOC,QAAQ,CAACZ,QAAQA,OAAOA,KAAKa,QAAQ;gBACxD,MAAMC,UAAUN,OAAOC,IAAI,CAACC,KAAKT,YAAYC;gBAC7C,IAAIY,WAAW,OAAOA,QAAQC,IAAI,KAAK,YAAY;oBACjDD,QAAQC,IAAI,CAAC,CAACC,QAAUX,GAAG,MAAMW,QAAQV;oBACzC;gBACF;YACF,EAAE,OAAM;YACN,2BAA2B;YAC7B;QACF;QACAA;IACF;IAEA,IAAI,OAAOH,aAAa,YAAY,OAAOC,OAAOD;IAClD,OAAO,IAAIc,QAAQ,CAACC,SAASC,SAAWf,OAAO,CAACG,KAAKS,QAAWT,MAAMY,OAAOZ,OAAOW,QAAQF;AAC9F;AAOA,OAAO,SAASI,cAAcpB,IAAgB,EAAEC,UAAkB,EAAEC,UAAmB,EAAEC,QAA+B;IACtH,MAAMC,SAAS,CAACC;QACd,MAAMC,WAAW;YACfZ,SAAS;gBACP,IAAI;oBACFW,GAAG,MAAMd,YAAYS,MAAMC,YAAYC;gBACzC,EAAE,OAAOK,KAAK;oBACZF,GAAGE;gBACL;YACF;QACF;QAEA,MAAMC,SAASf;QACf,IAAIe,mBAAAA,6BAAAA,OAAQa,KAAK,EAAE;YACjB,IAAI;gBACF,uDAAuD;gBACvD,MAAMX,MAAMC,OAAOC,QAAQ,CAACZ,QAAQA,OAAOA,KAAKa,QAAQ;gBACxD,MAAMC,UAAUN,OAAOa,KAAK,CAACX,KAAKT,YAAYC;gBAC9C,IAAIY,WAAW,OAAOA,QAAQC,IAAI,KAAK,YAAY;oBACjDD,QAAQC,IAAI,CAAC,CAACC,QAAUX,GAAG,MAAMW,QAAQV;oBACzC;gBACF;YACF,EAAE,OAAM;YACN,2BAA2B;YAC7B;QACF;QACAA;IACF;IAEA,IAAI,OAAOH,aAAa,YAAY,OAAOC,OAAOD;IAClD,OAAO,IAAIc,QAAQ,CAACC,SAASC,SAAWf,OAAO,CAACG,KAAKS,QAAWT,MAAMY,OAAOZ,OAAOW,QAAQF;AAC9F"}