7z-iterator 1.1.2 → 1.2.0

package/dist/esm/sevenz/codecs/BcjArm.js

@@ -5,10 +5,11 @@
 // these to absolute addresses during compression, and back during decompression.
 //
 // Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c
-import { bufferFrom } from 'extract-base-iterator';
-import createBufferingDecoder from './createBufferingDecoder.js';
+//
+// This implementation uses true streaming - processes data chunk by chunk.
+import { allocBuffer, bufferFrom, Transform } from 'extract-base-iterator';
 /**
- * Decode ARM BCJ filtered data
+ * Decode ARM BCJ filtered data (synchronous, for buffered use)
  * Reverses the BCJ transformation by converting absolute addresses back to relative
  *
  * ARM BL instruction format:
@@ -35,7 +36,6 @@ import createBufferingDecoder from './createBufferingDecoder.js';
             }
             // Convert absolute to relative:
             // Subtract current position (in words, so divide by 4)
-            // ARM PC is 2 words (8 bytes) ahead during execution
             const relAddr = addr - (pos >>> 2);
             // Write back lower 24 bits
             output[pos] = relAddr & 0xff;
@@ -47,7 +47,55 @@ import createBufferingDecoder from './createBufferingDecoder.js';
     return output;
 }
 /**
- * Create an ARM BCJ decoder Transform stream
- */ export function createBcjArmDecoder(properties, unpackSize) {
-    return createBufferingDecoder(decodeBcjArm, properties, unpackSize);
+ * Create a streaming ARM BCJ decoder Transform.
+ * Processes data in 4-byte aligned chunks.
+ */ export function createBcjArmDecoder(_properties, _unpackSize) {
+    let globalPos = 0; // Position in the overall stream (in bytes)
+    let pending = null; // Incomplete 4-byte group
+    const transform = new Transform({
+        transform: (chunk, _encoding, callback)=>{
+            // Combine pending bytes with new chunk
+            let data;
+            if (pending && pending.length > 0) {
+                data = Buffer.concat([
+                    pending,
+                    chunk
+                ]);
+            } else {
+                data = chunk;
+            }
+            // Process only complete 4-byte groups
+            const completeBytes = data.length - data.length % 4;
+            if (completeBytes === 0) {
+                pending = data;
+                callback(null, allocBuffer(0));
+                return;
+            }
+            const output = bufferFrom(data.slice(0, completeBytes));
+            pending = data.length > completeBytes ? data.slice(completeBytes) : null;
+            let pos = 0;
+            while(pos + 4 <= output.length){
+                if (output[pos + 3] === 0xeb) {
+                    let addr = output[pos] | output[pos + 1] << 8 | output[pos + 2] << 16;
+                    if (addr & 0x800000) {
+                        addr |= 0xff000000;
+                    }
+                    const relAddr = addr - (globalPos >>> 2);
+                    output[pos] = relAddr & 0xff;
+                    output[pos + 1] = relAddr >>> 8 & 0xff;
+                    output[pos + 2] = relAddr >>> 16 & 0xff;
+                }
+                pos += 4;
+                globalPos += 4;
+            }
+            callback(null, output);
+        },
+        flush: function(callback) {
+            if (pending && pending.length > 0) {
+                this.push(pending);
+            }
+            callback(null);
+        }
+    });
+    return transform;
 }

package/dist/esm/sevenz/codecs/BcjArm.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/BcjArm.ts"],"sourcesContent":["// BCJ (ARM 32-bit) filter codec - converts ARM branch instruction addresses\n// This filter makes ARM executables more compressible by LZMA\n//\n// ARM branch instructions (BL) use relative addressing. The filter converts\n// these to absolute addresses during compression, and back during decompression.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode ARM BCJ filtered data\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * ARM BL instruction format:\n * - 4 bytes aligned\n * - Byte pattern: XX XX XX EB (where EB = 0xEB opcode for BL)\n * - Lower 24 bits are signed offset (in words, not bytes)\n *\n * @param input - ARM BCJ filtered data\n * @param _properties - Unused for ARM BCJ\n * @param _unpackSize - Unused for ARM BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjArm(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    // Check for BL instruction: byte 3 is 0xEB\n    if (output[pos + 3] === 0xeb) {\n      // Read 24-bit address (little-endian in bytes 0-2)\n      let addr = output[pos] | (output[pos + 1] << 8) | (output[pos + 2] << 16);\n\n      // Sign-extend 24-bit to 32-bit\n      if (addr & 0x800000) {\n        addr |= 0xff000000;\n      }\n\n      // Convert absolute to relative:\n      // Subtract current position (in words, so divide by 4)\n      // ARM PC is 2 words (8 bytes) ahead during execution\n      const relAddr = addr - (pos >>> 2);\n\n      // Write back lower 24 bits\n      output[pos] = relAddr & 0xff;\n      output[pos + 1] = (relAddr >>> 8) & 0xff;\n      output[pos + 2] = (relAddr >>> 16) & 0xff;\n    }\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create an ARM BCJ decoder Transform stream\n */\nexport function createBcjArmDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeBcjArm, properties, unpackSize);\n}\n"],"names":["bufferFrom","createBufferingDecoder","decodeBcjArm","input","_properties","_unpackSize","output","pos","length","addr","relAddr","createBcjArmDecoder","properties","unpackSize"],"mappings":"AAAA,4EAA4E;AAC5E,8DAA8D;AAC9D,EAAE;AACF,4EAA4E;AAC5E,iFAAiF;AACjF,EAAE;AACF,+DAA+D;AAE/D,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,8BAA8B;AAEjE;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASC,aAAaC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACpF,MAAMC,SAASN,WAAWG,QAAQ,gCAAgC;IAClE,IAAII,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKD,OAAOE,MAAM,CAAE;QAC/B,2CAA2C;QAC3C,IAAIF,MAAM,CAACC,MAAM,EAAE,KAAK,MAAM;YAC5B,mDAAmD;YACnD,IAAIE,OAAOH,MAAM,CAACC,IAAI,GAAID,MAAM,CAACC,MAAM,EAAE,IAAI,IAAMD,MAAM,CAACC,MAAM,EAAE,IAAI;YAEtE,+BAA+B;YAC/B,IAAIE,OAAO,UAAU;gBACnBA,QAAQ;YACV;YAEA,gCAAgC;YAChC,uDAAuD;YACvD,qDAAqD;YACrD,MAAMC,UAAUD,OAAQF,CAAAA,QAAQ,CAAA;YAEhC,2BAA2B;YAC3BD,MAAM,CAACC,IAAI,GAAGG,UAAU;YACxBJ,MAAM,CAACC,MAAM,EAAE,GAAG,AAACG,YAAY,IAAK;YACpCJ,MAAM,CAACC,MAAM,EAAE,GAAG,AAACG,YAAY,KAAM;QACvC;QACAH,OAAO;IACT;IAEA,OAAOD;AACT;AAEA;;CAEC,GACD,OAAO,SAASK,oBAAoBC,UAAmB,EAAEC,UAAmB;IAC1E,OAAOZ,uBAAuBC,cAAcU,YAAYC;AAC1D"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/BcjArm.ts"],"sourcesContent":["// BCJ (ARM 32-bit) filter codec - converts ARM branch instruction addresses\n// This filter makes ARM executables more compressible by LZMA\n//\n// ARM branch instructions (BL) use relative addressing. The filter converts\n// these to absolute addresses during compression, and back during decompression.\n//\n// Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c\n//\n// This implementation uses true streaming - processes data chunk by chunk.\n\nimport { allocBuffer, bufferFrom, Transform } from 'extract-base-iterator';\n\n/**\n * Decode ARM BCJ filtered data (synchronous, for buffered use)\n * Reverses the BCJ transformation by converting absolute addresses back to relative\n *\n * ARM BL instruction format:\n * - 4 bytes aligned\n * - Byte pattern: XX XX XX EB (where EB = 0xEB opcode for BL)\n * - Lower 24 bits are signed offset (in words, not bytes)\n *\n * @param input - ARM BCJ filtered data\n * @param _properties - Unused for ARM BCJ\n * @param _unpackSize - Unused for ARM BCJ\n * @returns Unfiltered data\n */\nexport function decodeBcjArm(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  const output = bufferFrom(input); // Copy since we modify in place\n  let pos = 0;\n\n  // Process 4-byte aligned positions\n  while (pos + 4 <= output.length) {\n    // Check for BL instruction: byte 3 is 0xEB\n    if (output[pos + 3] === 0xeb) {\n      // Read 24-bit address (little-endian in bytes 0-2)\n      let addr = output[pos] | (output[pos + 1] << 8) | (output[pos + 2] << 16);\n\n      // Sign-extend 24-bit to 32-bit\n      if (addr & 0x800000) {\n        addr |= 0xff000000;\n      }\n\n      // Convert absolute to relative:\n      // Subtract current position (in words, so divide by 4)\n      const relAddr = addr - (pos >>> 2);\n\n      // Write back lower 24 bits\n      output[pos] = relAddr & 0xff;\n      output[pos + 1] = (relAddr >>> 8) & 0xff;\n      output[pos + 2] = (relAddr >>> 16) & 0xff;\n    }\n    pos += 4;\n  }\n\n  return output;\n}\n\n/**\n * Create a streaming ARM BCJ decoder Transform.\n * Processes data in 4-byte aligned chunks.\n */\nexport function createBcjArmDecoder(_properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform> {\n  let globalPos = 0; // Position in the overall stream (in bytes)\n  let pending: Buffer | null = null; // Incomplete 4-byte group\n\n  const transform = new Transform({\n    transform: (chunk: Buffer, _encoding: string, callback: (err?: Error | null, data?: Buffer) => void) => {\n      // Combine pending bytes with new chunk\n      let data: Buffer;\n      if (pending && pending.length > 0) {\n        data = Buffer.concat([pending, chunk]);\n      } else {\n        data = chunk;\n      }\n\n      // Process only complete 4-byte groups\n      const completeBytes = data.length - (data.length % 4);\n      if (completeBytes === 0) {\n        pending = data;\n        callback(null, allocBuffer(0));\n        return;\n      }\n\n      const output = bufferFrom(data.slice(0, completeBytes));\n      pending = data.length > completeBytes ? data.slice(completeBytes) : null;\n\n      let pos = 0;\n      while (pos + 4 <= output.length) {\n        if (output[pos + 3] === 0xeb) {\n          let addr = output[pos] | (output[pos + 1] << 8) | (output[pos + 2] << 16);\n          if (addr & 0x800000) {\n            addr |= 0xff000000;\n          }\n          const relAddr = addr - (globalPos >>> 2);\n          output[pos] = relAddr & 0xff;\n          output[pos + 1] = (relAddr >>> 8) & 0xff;\n          output[pos + 2] = (relAddr >>> 16) & 0xff;\n        }\n        pos += 4;\n        globalPos += 4;\n      }\n\n      callback(null, output);\n    },\n    flush: function (this: InstanceType<typeof Transform>, callback: (err?: Error | null) => void) {\n      if (pending && pending.length > 0) {\n        this.push(pending);\n      }\n      callback(null);\n    },\n  });\n\n  return transform;\n}\n"],"names":["allocBuffer","bufferFrom","Transform","decodeBcjArm","input","_properties","_unpackSize","output","pos","length","addr","relAddr","createBcjArmDecoder","globalPos","pending","transform","chunk","_encoding","callback","data","Buffer","concat","completeBytes","slice","flush","push"],"mappings":"AAAA,4EAA4E;AAC5E,8DAA8D;AAC9D,EAAE;AACF,4EAA4E;AAC5E,iFAAiF;AACjF,EAAE;AACF,+DAA+D;AAC/D,EAAE;AACF,2EAA2E;AAE3E,SAASA,WAAW,EAAEC,UAAU,EAAEC,SAAS,QAAQ,wBAAwB;AAE3E;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASC,aAAaC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACpF,MAAMC,SAASN,WAAWG,QAAQ,gCAAgC;IAClE,IAAII,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKD,OAAOE,MAAM,CAAE;QAC/B,2CAA2C;QAC3C,IAAIF,MAAM,CAACC,MAAM,EAAE,KAAK,MAAM;YAC5B,mDAAmD;YACnD,IAAIE,OAAOH,MAAM,CAACC,IAAI,GAAID,MAAM,CAACC,MAAM,EAAE,IAAI,IAAMD,MAAM,CAACC,MAAM,EAAE,IAAI;YAEtE,+BAA+B;YAC/B,IAAIE,OAAO,UAAU;gBACnBA,QAAQ;YACV;YAEA,gCAAgC;YAChC,uDAAuD;YACvD,MAAMC,UAAUD,OAAQF,CAAAA,QAAQ,CAAA;YAEhC,2BAA2B;YAC3BD,MAAM,CAACC,IAAI,GAAGG,UAAU;YACxBJ,MAAM,CAACC,MAAM,EAAE,GAAG,AAACG,YAAY,IAAK;YACpCJ,MAAM,CAACC,MAAM,EAAE,GAAG,AAACG,YAAY,KAAM;QACvC;QACAH,OAAO;IACT;IAEA,OAAOD;AACT;AAEA;;;CAGC,GACD,OAAO,SAASK,oBAAoBP,WAAoB,EAAEC,WAAoB;IAC5E,IAAIO,YAAY,GAAG,4CAA4C;IAC/D,IAAIC,UAAyB,MAAM,0BAA0B;IAE7D,MAAMC,YAAY,IAAIb,UAAU;QAC9Ba,WAAW,CAACC,OAAeC,WAAmBC;YAC5C,uCAAuC;YACvC,IAAIC;YACJ,IAAIL,WAAWA,QAAQL,MAAM,GAAG,GAAG;gBACjCU,OAAOC,OAAOC,MAAM,CAAC;oBAACP;oBAASE;iBAAM;YACvC,OAAO;gBACLG,OAAOH;YACT;YAEA,sCAAsC;YACtC,MAAMM,gBAAgBH,KAAKV,MAAM,GAAIU,KAAKV,MAAM,GAAG;YACnD,IAAIa,kBAAkB,GAAG;gBACvBR,UAAUK;gBACVD,SAAS,MAAMlB,YAAY;gBAC3B;YACF;YAEA,MAAMO,SAASN,WAAWkB,KAAKI,KAAK,CAAC,GAAGD;YACxCR,UAAUK,KAAKV,MAAM,GAAGa,gBAAgBH,KAAKI,KAAK,CAACD,iBAAiB;YAEpE,IAAId,MAAM;YACV,MAAOA,MAAM,KAAKD,OAAOE,MAAM,CAAE;gBAC/B,IAAIF,MAAM,CAACC,MAAM,EAAE,KAAK,MAAM;oBAC5B,IAAIE,OAAOH,MAAM,CAACC,IAAI,GAAID,MAAM,CAACC,MAAM,EAAE,IAAI,IAAMD,MAAM,CAACC,MAAM,EAAE,IAAI;oBACtE,IAAIE,OAAO,UAAU;wBACnBA,QAAQ;oBACV;oBACA,MAAMC,UAAUD,OAAQG,CAAAA,cAAc,CAAA;oBACtCN,MAAM,CAACC,IAAI,GAAGG,UAAU;oBACxBJ,MAAM,CAACC,MAAM,EAAE,GAAG,AAACG,YAAY,IAAK;oBACpCJ,MAAM,CAACC,MAAM,EAAE,GAAG,AAACG,YAAY,KAAM;gBACvC;gBACAH,OAAO;gBACPK,aAAa;YACf;YAEAK,SAAS,MAAMX;QACjB;QACAiB,OAAO,SAAgDN,QAAsC;YAC3F,IAAIJ,WAAWA,QAAQL,MAAM,GAAG,GAAG;gBACjC,IAAI,CAACgB,IAAI,CAACX;YACZ;YACAI,SAAS;QACX;IACF;IAEA,OAAOH;AACT"}

package/dist/esm/sevenz/codecs/Copy.d.ts

@@ -1,10 +1,9 @@
-import Stream from 'stream';
-type Transform = Stream.Transform;
+import { type Transform } from 'extract-base-iterator';
 /**
  * Create a Copy decoder stream
  * Simply passes through data unchanged
  */
-export declare function createCopyDecoder(): Transform;
+export declare function createCopyDecoder(): InstanceType<typeof Transform>;
 /**
  * Decode a buffer using Copy codec (no-op)
  * @param input - Input buffer
@@ -13,4 +12,3 @@ export declare function createCopyDecoder(): Transform;
  * @returns Same buffer (no transformation)
  */
 export declare function decodeCopy(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
-export {};

package/dist/esm/sevenz/codecs/Copy.js

@@ -1,14 +1,6 @@
 // Copy codec - passthrough (no compression)
 // This is the simplest codec, just passes data through unchanged
-import Stream from 'stream';
-// Use native streams when available, readable-stream only for Node 0.x
-const major = +process.versions.node.split('.')[0];
-let PassThrough;
-if (major > 0) {
-    PassThrough = Stream.PassThrough;
-} else {
-    PassThrough = require('readable-stream').PassThrough;
-}
+import { PassThrough } from 'extract-base-iterator';
 /**
  * Create a Copy decoder stream
  * Simply passes through data unchanged

package/dist/esm/sevenz/codecs/Copy.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Copy.ts"],"sourcesContent":["// Copy codec - passthrough (no compression)\n// This is the simplest codec, just passes data through unchanged\n\nimport Stream from 'stream';\n\n// Use native streams when available, readable-stream only for Node 0.x\nconst major = +process.versions.node.split('.')[0];\nlet PassThrough: typeof Stream.PassThrough;\nif (major > 0) {\n  PassThrough = Stream.PassThrough;\n} else {\n  PassThrough = require('readable-stream').PassThrough;\n}\ntype Transform = Stream.Transform;\n\n/**\n * Create a Copy decoder stream\n * Simply passes through data unchanged\n */\nexport function createCopyDecoder(): Transform {\n  return new PassThrough();\n}\n\n/**\n * Decode a buffer using Copy codec (no-op)\n * @param input - Input buffer\n * @param _properties - Unused\n * @param _unpackSize - Unused\n * @returns Same buffer (no transformation)\n */\nexport function decodeCopy(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  return input;\n}\n"],"names":["Stream","major","process","versions","node","split","PassThrough","require","createCopyDecoder","decodeCopy","input","_properties","_unpackSize"],"mappings":"AAAA,4CAA4C;AAC5C,iEAAiE;AAEjE,OAAOA,YAAY,SAAS;AAE5B,uEAAuE;AACvE,MAAMC,QAAQ,CAACC,QAAQC,QAAQ,CAACC,IAAI,CAACC,KAAK,CAAC,IAAI,CAAC,EAAE;AAClD,IAAIC;AACJ,IAAIL,QAAQ,GAAG;IACbK,cAAcN,OAAOM,WAAW;AAClC,OAAO;IACLA,cAAcC,QAAQ,mBAAmBD,WAAW;AACtD;AAGA;;;CAGC,GACD,OAAO,SAASE;IACd,OAAO,IAAIF;AACb;AAEA;;;;;;CAMC,GACD,OAAO,SAASG,WAAWC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IAClF,OAAOF;AACT"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Copy.ts"],"sourcesContent":["// Copy codec - passthrough (no compression)\n// This is the simplest codec, just passes data through unchanged\n\nimport { PassThrough, type Transform } from 'extract-base-iterator';\n\n/**\n * Create a Copy decoder stream\n * Simply passes through data unchanged\n */\nexport function createCopyDecoder(): InstanceType<typeof Transform> {\n  return new PassThrough();\n}\n\n/**\n * Decode a buffer using Copy codec (no-op)\n * @param input - Input buffer\n * @param _properties - Unused\n * @param _unpackSize - Unused\n * @returns Same buffer (no transformation)\n */\nexport function decodeCopy(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  return input;\n}\n"],"names":["PassThrough","createCopyDecoder","decodeCopy","input","_properties","_unpackSize"],"mappings":"AAAA,4CAA4C;AAC5C,iEAAiE;AAEjE,SAASA,WAAW,QAAwB,wBAAwB;AAEpE;;;CAGC,GACD,OAAO,SAASC;IACd,OAAO,IAAID;AACb;AAEA;;;;;;CAMC,GACD,OAAO,SAASE,WAAWC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IAClF,OAAOF;AACT"}

package/dist/esm/sevenz/codecs/Deflate.d.ts

@@ -1,6 +1,6 @@
-import type { Transform } from 'readable-stream';
+import type { Transform } from 'stream';
 /**
- * Decode Deflate compressed data
+ * Decode Deflate compressed data synchronously
  *
  * @param input - Deflate compressed data
  * @param _properties - Unused for Deflate
@@ -9,6 +9,8 @@ import type { Transform } from 'readable-stream';
  */
 export declare function decodeDeflate(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
 /**
- * Create a Deflate decoder Transform stream
+ * Create a Deflate decoder Transform stream.
+ * Uses zlib's streaming createInflateRaw() for true streaming decompression.
+ * Data is decompressed incrementally as it flows through, not buffered.
  */
-export declare function createDeflateDecoder(properties?: Buffer, unpackSize?: number): Transform;
+export declare function createDeflateDecoder(_properties?: Buffer, _unpackSize?: number): Transform;

package/dist/esm/sevenz/codecs/Deflate.js

@@ -1,11 +1,11 @@
 // Deflate codec - standard zlib/zip compression
 // 7z uses raw deflate without zlib or gzip headers
 //
-// Uses native zlib on Node 0.11.12+, falls back to pako for older versions
-import { inflateRaw } from 'extract-base-iterator';
-import createBufferingDecoder from './createBufferingDecoder.js';
+// Uses native zlib.createInflateRaw() for true streaming decompression
+// Falls back to pako for older Node versions via extract-base-iterator
+import { createInflateRawStream, inflateRaw } from 'extract-base-iterator';
 /**
- * Decode Deflate compressed data
+ * Decode Deflate compressed data synchronously
  *
  * @param input - Deflate compressed data
  * @param _properties - Unused for Deflate
@@ -15,7 +15,9 @@ import createBufferingDecoder from './createBufferingDecoder.js';
     return inflateRaw(input);
 }
 /**
- * Create a Deflate decoder Transform stream
- */ export function createDeflateDecoder(properties, unpackSize) {
-    return createBufferingDecoder(decodeDeflate, properties, unpackSize);
+ * Create a Deflate decoder Transform stream.
+ * Uses zlib's streaming createInflateRaw() for true streaming decompression.
+ * Data is decompressed incrementally as it flows through, not buffered.
+ */ export function createDeflateDecoder(_properties, _unpackSize) {
+    return createInflateRawStream();
 }

package/dist/esm/sevenz/codecs/Deflate.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Deflate.ts"],"sourcesContent":["// Deflate codec - standard zlib/zip compression\n// 7z uses raw deflate without zlib or gzip headers\n//\n// Uses native zlib on Node 0.11.12+, falls back to pako for older versions\n\nimport { inflateRaw } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode Deflate compressed data\n *\n * @param input - Deflate compressed data\n * @param _properties - Unused for Deflate\n * @param _unpackSize - Unused for Deflate\n * @returns Decompressed data\n */\nexport function decodeDeflate(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  return inflateRaw(input);\n}\n\n/**\n * Create a Deflate decoder Transform stream\n */\nexport function createDeflateDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeDeflate, properties, unpackSize);\n}\n"],"names":["inflateRaw","createBufferingDecoder","decodeDeflate","input","_properties","_unpackSize","createDeflateDecoder","properties","unpackSize"],"mappings":"AAAA,gDAAgD;AAChD,mDAAmD;AACnD,EAAE;AACF,2EAA2E;AAE3E,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,8BAA8B;AAEjE;;;;;;;CAOC,GACD,OAAO,SAASC,cAAcC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACrF,OAAOL,WAAWG;AACpB;AAEA;;CAEC,GACD,OAAO,SAASG,qBAAqBC,UAAmB,EAAEC,UAAmB;IAC3E,OAAOP,uBAAuBC,eAAeK,YAAYC;AAC3D"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Deflate.ts"],"sourcesContent":["// Deflate codec - standard zlib/zip compression\n// 7z uses raw deflate without zlib or gzip headers\n//\n// Uses native zlib.createInflateRaw() for true streaming decompression\n// Falls back to pako for older Node versions via extract-base-iterator\n\nimport { createInflateRawStream, inflateRaw } from 'extract-base-iterator';\nimport type { Transform } from 'stream';\n\n/**\n * Decode Deflate compressed data synchronously\n *\n * @param input - Deflate compressed data\n * @param _properties - Unused for Deflate\n * @param _unpackSize - Unused for Deflate\n * @returns Decompressed data\n */\nexport function decodeDeflate(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer {\n  return inflateRaw(input);\n}\n\n/**\n * Create a Deflate decoder Transform stream.\n * Uses zlib's streaming createInflateRaw() for true streaming decompression.\n * Data is decompressed incrementally as it flows through, not buffered.\n */\nexport function createDeflateDecoder(_properties?: Buffer, _unpackSize?: number): Transform {\n  return createInflateRawStream() as Transform;\n}\n"],"names":["createInflateRawStream","inflateRaw","decodeDeflate","input","_properties","_unpackSize","createDeflateDecoder"],"mappings":"AAAA,gDAAgD;AAChD,mDAAmD;AACnD,EAAE;AACF,uEAAuE;AACvE,uEAAuE;AAEvE,SAASA,sBAAsB,EAAEC,UAAU,QAAQ,wBAAwB;AAG3E;;;;;;;CAOC,GACD,OAAO,SAASC,cAAcC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACrF,OAAOJ,WAAWE;AACpB;AAEA;;;;CAIC,GACD,OAAO,SAASG,qBAAqBF,WAAoB,EAAEC,WAAoB;IAC7E,OAAOL;AACT"}

package/dist/esm/sevenz/codecs/Delta.d.ts

@@ -1,6 +1,6 @@
-import type { Transform } from 'readable-stream';
+import { Transform } from 'extract-base-iterator';
 /**
- * Decode Delta filtered data
+ * Decode Delta filtered data (synchronous, for buffered use)
  * Reverses the delta transformation by adding previous values
  *
  * @param input - Delta filtered data
@@ -10,6 +10,7 @@ import type { Transform } from 'readable-stream';
  */
 export declare function decodeDelta(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer;
 /**
- * Create a Delta decoder Transform stream
+ * Create a streaming Delta decoder Transform.
+ * Processes data chunk by chunk, maintaining state between chunks.
  */
-export declare function createDeltaDecoder(properties?: Buffer, unpackSize?: number): Transform;
+export declare function createDeltaDecoder(properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform>;

package/dist/esm/sevenz/codecs/Delta.js

@@ -4,10 +4,12 @@
 // The Delta filter stores the difference between each byte and the byte
 // N positions before it, where N is the "distance" parameter (default 1).
 // This makes data with regular patterns more compressible.
-import { bufferFrom } from 'extract-base-iterator';
-import createBufferingDecoder from './createBufferingDecoder.js';
+//
+// This implementation uses true streaming - processes data chunk by chunk
+// while maintaining state between chunks.
+import { allocBuffer, bufferFrom, Transform } from 'extract-base-iterator';
 /**
- * Decode Delta filtered data
+ * Decode Delta filtered data (synchronous, for buffered use)
  * Reverses the delta transformation by adding previous values
  *
  * @param input - Delta filtered data
@@ -23,9 +25,9 @@ import createBufferingDecoder from './createBufferingDecoder.js';
     }
     const output = bufferFrom(input); // Copy since we modify in place
     // State buffer for multi-byte distance
-    const state = new Array(distance);
+    const state = [];
     for(let i = 0; i < distance; i++){
-        state[i] = 0;
+        state.push(0);
     }
     for(let j = 0; j < output.length; j++){
         const idx = j % distance;
@@ -35,7 +37,30 @@ import createBufferingDecoder from './createBufferingDecoder.js';
     return output;
 }
 /**
- * Create a Delta decoder Transform stream
- */ export function createDeltaDecoder(properties, unpackSize) {
-    return createBufferingDecoder(decodeDelta, properties, unpackSize);
+ * Create a streaming Delta decoder Transform.
+ * Processes data chunk by chunk, maintaining state between chunks.
+ */ export function createDeltaDecoder(properties, _unpackSize) {
+    // Distance parameter: default is 1
+    let distance = 1;
+    if (properties && properties.length >= 1) {
+        distance = properties[0] + 1;
+    }
+    // State buffer for multi-byte distance
+    const state = [];
+    for(let i = 0; i < distance; i++){
+        state.push(0);
+    }
+    let byteIndex = 0;
+    return new Transform({
+        transform: (chunk, _encoding, callback)=>{
+            const output = allocBuffer(chunk.length);
+            for(let j = 0; j < chunk.length; j++){
+                const idx = byteIndex % distance;
+                state[idx] = state[idx] + chunk[j] & 0xff;
+                output[j] = state[idx];
+                byteIndex++;
+            }
+            callback(null, output);
+        }
+    });
 }

package/dist/esm/sevenz/codecs/Delta.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Delta.ts"],"sourcesContent":["// Delta filter codec - stores differences between consecutive bytes\n// Useful for data with gradual changes (images, audio, sensor data)\n//\n// The Delta filter stores the difference between each byte and the byte\n// N positions before it, where N is the \"distance\" parameter (default 1).\n// This makes data with regular patterns more compressible.\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\n\n/**\n * Decode Delta filtered data\n * Reverses the delta transformation by adding previous values\n *\n * @param input - Delta filtered data\n * @param properties - Optional 1-byte properties (distance - 1)\n * @param _unpackSize - Unused for Delta\n * @returns Unfiltered data\n */\nexport function decodeDelta(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer {\n  // Distance parameter: default is 1\n  let distance = 1;\n  if (properties && properties.length >= 1) {\n    // Properties byte contains (distance - 1)\n    distance = properties[0] + 1;\n  }\n\n  const output = bufferFrom(input); // Copy since we modify in place\n\n  // State buffer for multi-byte distance\n  const state = new Array(distance);\n  for (let i = 0; i < distance; i++) {\n    state[i] = 0;\n  }\n\n  for (let j = 0; j < output.length; j++) {\n    const idx = j % distance;\n    state[idx] = (state[idx] + output[j]) & 0xff;\n    output[j] = state[idx];\n  }\n\n  return output;\n}\n\n/**\n * Create a Delta decoder Transform stream\n */\nexport function createDeltaDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeDelta, properties, unpackSize);\n}\n"],"names":["bufferFrom","createBufferingDecoder","decodeDelta","input","properties","_unpackSize","distance","length","output","state","Array","i","j","idx","createDeltaDecoder","unpackSize"],"mappings":"AAAA,oEAAoE;AACpE,oEAAoE;AACpE,EAAE;AACF,wEAAwE;AACxE,0EAA0E;AAC1E,2DAA2D;AAE3D,SAASA,UAAU,QAAQ,wBAAwB;AAEnD,OAAOC,4BAA4B,8BAA8B;AAEjE;;;;;;;;CAQC,GACD,OAAO,SAASC,YAAYC,KAAa,EAAEC,UAAmB,EAAEC,WAAoB;IAClF,mCAAmC;IACnC,IAAIC,WAAW;IACf,IAAIF,cAAcA,WAAWG,MAAM,IAAI,GAAG;QACxC,0CAA0C;QAC1CD,WAAWF,UAAU,CAAC,EAAE,GAAG;IAC7B;IAEA,MAAMI,SAASR,WAAWG,QAAQ,gCAAgC;IAElE,uCAAuC;IACvC,MAAMM,QAAQ,IAAIC,MAAMJ;IACxB,IAAK,IAAIK,IAAI,GAAGA,IAAIL,UAAUK,IAAK;QACjCF,KAAK,CAACE,EAAE,GAAG;IACb;IAEA,IAAK,IAAIC,IAAI,GAAGA,IAAIJ,OAAOD,MAAM,EAAEK,IAAK;QACtC,MAAMC,MAAMD,IAAIN;QAChBG,KAAK,CAACI,IAAI,GAAG,AAACJ,KAAK,CAACI,IAAI,GAAGL,MAAM,CAACI,EAAE,GAAI;QACxCJ,MAAM,CAACI,EAAE,GAAGH,KAAK,CAACI,IAAI;IACxB;IAEA,OAAOL;AACT;AAEA;;CAEC,GACD,OAAO,SAASM,mBAAmBV,UAAmB,EAAEW,UAAmB;IACzE,OAAOd,uBAAuBC,aAAaE,YAAYW;AACzD"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Delta.ts"],"sourcesContent":["// Delta filter codec - stores differences between consecutive bytes\n// Useful for data with gradual changes (images, audio, sensor data)\n//\n// The Delta filter stores the difference between each byte and the byte\n// N positions before it, where N is the \"distance\" parameter (default 1).\n// This makes data with regular patterns more compressible.\n//\n// This implementation uses true streaming - processes data chunk by chunk\n// while maintaining state between chunks.\n\nimport { allocBuffer, bufferFrom, Transform } from 'extract-base-iterator';\n\n/**\n * Decode Delta filtered data (synchronous, for buffered use)\n * Reverses the delta transformation by adding previous values\n *\n * @param input - Delta filtered data\n * @param properties - Optional 1-byte properties (distance - 1)\n * @param _unpackSize - Unused for Delta\n * @returns Unfiltered data\n */\nexport function decodeDelta(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer {\n  // Distance parameter: default is 1\n  let distance = 1;\n  if (properties && properties.length >= 1) {\n    // Properties byte contains (distance - 1)\n    distance = properties[0] + 1;\n  }\n\n  const output = bufferFrom(input); // Copy since we modify in place\n\n  // State buffer for multi-byte distance\n  const state: number[] = [];\n  for (let i = 0; i < distance; i++) {\n    state.push(0);\n  }\n\n  for (let j = 0; j < output.length; j++) {\n    const idx = j % distance;\n    state[idx] = (state[idx] + output[j]) & 0xff;\n    output[j] = state[idx];\n  }\n\n  return output;\n}\n\n/**\n * Create a streaming Delta decoder Transform.\n * Processes data chunk by chunk, maintaining state between chunks.\n */\nexport function createDeltaDecoder(properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform> {\n  // Distance parameter: default is 1\n  let distance = 1;\n  if (properties && properties.length >= 1) {\n    distance = properties[0] + 1;\n  }\n\n  // State buffer for multi-byte distance\n  const state: number[] = [];\n  for (let i = 0; i < distance; i++) {\n    state.push(0);\n  }\n\n  let byteIndex = 0;\n\n  return new Transform({\n    transform: (chunk: Buffer, _encoding: string, callback: (err?: Error | null, data?: Buffer) => void) => {\n      const output = allocBuffer(chunk.length);\n\n      for (let j = 0; j < chunk.length; j++) {\n        const idx = byteIndex % distance;\n        state[idx] = (state[idx] + chunk[j]) & 0xff;\n        output[j] = state[idx];\n        byteIndex++;\n      }\n\n      callback(null, output);\n    },\n  });\n}\n"],"names":["allocBuffer","bufferFrom","Transform","decodeDelta","input","properties","_unpackSize","distance","length","output","state","i","push","j","idx","createDeltaDecoder","byteIndex","transform","chunk","_encoding","callback"],"mappings":"AAAA,oEAAoE;AACpE,oEAAoE;AACpE,EAAE;AACF,wEAAwE;AACxE,0EAA0E;AAC1E,2DAA2D;AAC3D,EAAE;AACF,0EAA0E;AAC1E,0CAA0C;AAE1C,SAASA,WAAW,EAAEC,UAAU,EAAEC,SAAS,QAAQ,wBAAwB;AAE3E;;;;;;;;CAQC,GACD,OAAO,SAASC,YAAYC,KAAa,EAAEC,UAAmB,EAAEC,WAAoB;IAClF,mCAAmC;IACnC,IAAIC,WAAW;IACf,IAAIF,cAAcA,WAAWG,MAAM,IAAI,GAAG;QACxC,0CAA0C;QAC1CD,WAAWF,UAAU,CAAC,EAAE,GAAG;IAC7B;IAEA,MAAMI,SAASR,WAAWG,QAAQ,gCAAgC;IAElE,uCAAuC;IACvC,MAAMM,QAAkB,EAAE;IAC1B,IAAK,IAAIC,IAAI,GAAGA,IAAIJ,UAAUI,IAAK;QACjCD,MAAME,IAAI,CAAC;IACb;IAEA,IAAK,IAAIC,IAAI,GAAGA,IAAIJ,OAAOD,MAAM,EAAEK,IAAK;QACtC,MAAMC,MAAMD,IAAIN;QAChBG,KAAK,CAACI,IAAI,GAAG,AAACJ,KAAK,CAACI,IAAI,GAAGL,MAAM,CAACI,EAAE,GAAI;QACxCJ,MAAM,CAACI,EAAE,GAAGH,KAAK,CAACI,IAAI;IACxB;IAEA,OAAOL;AACT;AAEA;;;CAGC,GACD,OAAO,SAASM,mBAAmBV,UAAmB,EAAEC,WAAoB;IAC1E,mCAAmC;IACnC,IAAIC,WAAW;IACf,IAAIF,cAAcA,WAAWG,MAAM,IAAI,GAAG;QACxCD,WAAWF,UAAU,CAAC,EAAE,GAAG;IAC7B;IAEA,uCAAuC;IACvC,MAAMK,QAAkB,EAAE;IAC1B,IAAK,IAAIC,IAAI,GAAGA,IAAIJ,UAAUI,IAAK;QACjCD,MAAME,IAAI,CAAC;IACb;IAEA,IAAII,YAAY;IAEhB,OAAO,IAAId,UAAU;QACnBe,WAAW,CAACC,OAAeC,WAAmBC;YAC5C,MAAMX,SAAST,YAAYkB,MAAMV,MAAM;YAEvC,IAAK,IAAIK,IAAI,GAAGA,IAAIK,MAAMV,MAAM,EAAEK,IAAK;gBACrC,MAAMC,MAAME,YAAYT;gBACxBG,KAAK,CAACI,IAAI,GAAG,AAACJ,KAAK,CAACI,IAAI,GAAGI,KAAK,CAACL,EAAE,GAAI;gBACvCJ,MAAM,CAACI,EAAE,GAAGH,KAAK,CAACI,IAAI;gBACtBE;YACF;YAEAI,SAAS,MAAMX;QACjB;IACF;AACF"}

package/dist/esm/sevenz/codecs/Lzma.d.ts

@@ -1,14 +1,17 @@
-import type { Transform } from 'readable-stream';
+import type { Transform } from 'stream';
 /**
  * Decode LZMA compressed data to buffer
  *
  * @param input - LZMA compressed data
  * @param properties - Properties buffer (5 bytes: lc/lp/pb + dict size)
- * @param unpackSize - Expected output size (optional, -1 for unknown)
+ * @param unpackSize - Expected output size
  * @returns Decompressed data
  */
 export declare function decodeLzma(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer;
 /**
  * Create an LZMA decoder Transform stream
+ *
+ * Note: LZMA1 has no chunk boundaries, so this buffers all input
+ * and decompresses when the stream ends.
  */
 export declare function createLzmaDecoder(properties?: Buffer, unpackSize?: number): Transform;

package/dist/esm/sevenz/codecs/Lzma.js

@@ -1,40 +1,33 @@
-import Module from 'module';
-const _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;
-import createBufferingDecoder from './createBufferingDecoder.js';
-import { createInputStream, createOutputStream } from './streams.js';
-// Import vendored lzma-purejs - provides raw LZMA decoder (patched for LZMA2 support)
-// Path accounts for build output in dist/esm/sevenz/codecs/
-const { LZMA } = _require('../../../../assets/lzma-purejs');
-const LzmaDecoder = LZMA.Decoder;
+// LZMA codec using TypeScript LZMA decoder
+// LZMA properties in 7z are 5 bytes: 1 byte lc/lp/pb + 4 bytes dictionary size (little-endian)
+import { createLzmaDecoder as createLzmaTransform, decodeLzma as lzmaDecode } from '../../lzma/index.js';
 /**
  * Decode LZMA compressed data to buffer
  *
  * @param input - LZMA compressed data
  * @param properties - Properties buffer (5 bytes: lc/lp/pb + dict size)
- * @param unpackSize - Expected output size (optional, -1 for unknown)
+ * @param unpackSize - Expected output size
  * @returns Decompressed data
  */ export function decodeLzma(input, properties, unpackSize) {
     if (!properties || properties.length < 5) {
         throw new Error('LZMA requires 5-byte properties');
     }
-    const decoder = new LzmaDecoder();
-    // setDecoderProperties expects array-like with 5 bytes
-    if (!decoder.setDecoderProperties(properties)) {
-        throw new Error('Invalid LZMA properties');
+    if (typeof unpackSize !== 'number' || unpackSize < 0) {
+        throw new Error('LZMA requires known unpack size');
     }
-    const inStream = createInputStream(input, 0, input.length);
-    // Use -1 for unknown size (decoder will use end marker)
-    const size = typeof unpackSize === 'number' ? unpackSize : -1;
-    // Pre-allocate output stream if size is known (memory optimization)
-    const outStream = createOutputStream(size > 0 ? size : undefined);
-    const success = decoder.code(inStream, outStream, size);
-    if (!success) {
-        throw new Error('LZMA decompression failed');
-    }
-    return outStream.toBuffer();
+    return lzmaDecode(input, properties, unpackSize);
 }
 /**
  * Create an LZMA decoder Transform stream
+ *
+ * Note: LZMA1 has no chunk boundaries, so this buffers all input
+ * and decompresses when the stream ends.
  */ export function createLzmaDecoder(properties, unpackSize) {
-    return createBufferingDecoder(decodeLzma, properties, unpackSize);
+    if (!properties || properties.length < 5) {
+        throw new Error('LZMA requires 5-byte properties');
+    }
+    if (typeof unpackSize !== 'number' || unpackSize < 0) {
+        throw new Error('LZMA requires known unpack size');
+    }
+    return createLzmaTransform(properties, unpackSize);
 }

package/dist/esm/sevenz/codecs/Lzma.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Lzma.ts"],"sourcesContent":["import Module from 'module';\n\nconst _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n\n// LZMA codec using lzma-purejs\n// LZMA properties in 7z are 5 bytes: 1 byte lc/lp/pb + 4 bytes dictionary size (little-endian)\n\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\nimport { createInputStream, createOutputStream } from './streams.ts';\n\n// Import vendored lzma-purejs - provides raw LZMA decoder (patched for LZMA2 support)\n// Path accounts for build output in dist/esm/sevenz/codecs/\nconst { LZMA } = _require('../../../../assets/lzma-purejs');\nconst LzmaDecoder = LZMA.Decoder;\n\n/**\n * Decode LZMA compressed data to buffer\n *\n * @param input - LZMA compressed data\n * @param properties - Properties buffer (5 bytes: lc/lp/pb + dict size)\n * @param unpackSize - Expected output size (optional, -1 for unknown)\n * @returns Decompressed data\n */\nexport function decodeLzma(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer {\n  if (!properties || properties.length < 5) {\n    throw new Error('LZMA requires 5-byte properties');\n  }\n\n  const decoder = new LzmaDecoder();\n\n  // setDecoderProperties expects array-like with 5 bytes\n  if (!decoder.setDecoderProperties(properties)) {\n    throw new Error('Invalid LZMA properties');\n  }\n\n  const inStream = createInputStream(input, 0, input.length);\n\n  // Use -1 for unknown size (decoder will use end marker)\n  const size = typeof unpackSize === 'number' ? unpackSize : -1;\n\n  // Pre-allocate output stream if size is known (memory optimization)\n  const outStream = createOutputStream(size > 0 ? size : undefined);\n\n  const success = decoder.code(inStream, outStream, size);\n  if (!success) {\n    throw new Error('LZMA decompression failed');\n  }\n\n  return outStream.toBuffer();\n}\n\n/**\n * Create an LZMA decoder Transform stream\n */\nexport function createLzmaDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeLzma, properties, unpackSize);\n}\n"],"names":["Module","_require","require","createRequire","url","createBufferingDecoder","createInputStream","createOutputStream","LZMA","LzmaDecoder","Decoder","decodeLzma","input","properties","unpackSize","length","Error","decoder","setDecoderProperties","inStream","size","outStream","undefined","success","code","toBuffer","createLzmaDecoder"],"mappings":"AAAA,OAAOA,YAAY,SAAS;AAE5B,MAAMC,WAAW,OAAOC,YAAY,cAAcF,OAAOG,aAAa,CAAC,YAAYC,GAAG,IAAIF;AAM1F,OAAOG,4BAA4B,8BAA8B;AACjE,SAASC,iBAAiB,EAAEC,kBAAkB,QAAQ,eAAe;AAErE,sFAAsF;AACtF,4DAA4D;AAC5D,MAAM,EAAEC,IAAI,EAAE,GAAGP,SAAS;AAC1B,MAAMQ,cAAcD,KAAKE,OAAO;AAEhC;;;;;;;CAOC,GACD,OAAO,SAASC,WAAWC,KAAa,EAAEC,UAAmB,EAAEC,UAAmB;IAChF,IAAI,CAACD,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,UAAU,IAAIR;IAEpB,uDAAuD;IACvD,IAAI,CAACQ,QAAQC,oBAAoB,CAACL,aAAa;QAC7C,MAAM,IAAIG,MAAM;IAClB;IAEA,MAAMG,WAAWb,kBAAkBM,OAAO,GAAGA,MAAMG,MAAM;IAEzD,wDAAwD;IACxD,MAAMK,OAAO,OAAON,eAAe,WAAWA,aAAa,CAAC;IAE5D,oEAAoE;IACpE,MAAMO,YAAYd,mBAAmBa,OAAO,IAAIA,OAAOE;IAEvD,MAAMC,UAAUN,QAAQO,IAAI,CAACL,UAAUE,WAAWD;IAClD,IAAI,CAACG,SAAS;QACZ,MAAM,IAAIP,MAAM;IAClB;IAEA,OAAOK,UAAUI,QAAQ;AAC3B;AAEA;;CAEC,GACD,OAAO,SAASC,kBAAkBb,UAAmB,EAAEC,UAAmB;IACxE,OAAOT,uBAAuBM,YAAYE,YAAYC;AACxD"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Lzma.ts"],"sourcesContent":["// LZMA codec using TypeScript LZMA decoder\n// LZMA properties in 7z are 5 bytes: 1 byte lc/lp/pb + 4 bytes dictionary size (little-endian)\n\nimport type { Transform } from 'stream';\nimport { createLzmaDecoder as createLzmaTransform, decodeLzma as lzmaDecode } from '../../lzma/index.ts';\n\n/**\n * Decode LZMA compressed data to buffer\n *\n * @param input - LZMA compressed data\n * @param properties - Properties buffer (5 bytes: lc/lp/pb + dict size)\n * @param unpackSize - Expected output size\n * @returns Decompressed data\n */\nexport function decodeLzma(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer {\n  if (!properties || properties.length < 5) {\n    throw new Error('LZMA requires 5-byte properties');\n  }\n\n  if (typeof unpackSize !== 'number' || unpackSize < 0) {\n    throw new Error('LZMA requires known unpack size');\n  }\n\n  return lzmaDecode(input, properties, unpackSize);\n}\n\n/**\n * Create an LZMA decoder Transform stream\n *\n * Note: LZMA1 has no chunk boundaries, so this buffers all input\n * and decompresses when the stream ends.\n */\nexport function createLzmaDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  if (!properties || properties.length < 5) {\n    throw new Error('LZMA requires 5-byte properties');\n  }\n\n  if (typeof unpackSize !== 'number' || unpackSize < 0) {\n    throw new Error('LZMA requires known unpack size');\n  }\n\n  return createLzmaTransform(properties, unpackSize) as Transform;\n}\n"],"names":["createLzmaDecoder","createLzmaTransform","decodeLzma","lzmaDecode","input","properties","unpackSize","length","Error"],"mappings":"AAAA,2CAA2C;AAC3C,+FAA+F;AAG/F,SAASA,qBAAqBC,mBAAmB,EAAEC,cAAcC,UAAU,QAAQ,sBAAsB;AAEzG;;;;;;;CAOC,GACD,OAAO,SAASD,WAAWE,KAAa,EAAEC,UAAmB,EAAEC,UAAmB;IAChF,IAAI,CAACD,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,IAAI,OAAOF,eAAe,YAAYA,aAAa,GAAG;QACpD,MAAM,IAAIE,MAAM;IAClB;IAEA,OAAOL,WAAWC,OAAOC,YAAYC;AACvC;AAEA;;;;;CAKC,GACD,OAAO,SAASN,kBAAkBK,UAAmB,EAAEC,UAAmB;IACxE,IAAI,CAACD,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,IAAI,OAAOF,eAAe,YAAYA,aAAa,GAAG;QACpD,MAAM,IAAIE,MAAM;IAClB;IAEA,OAAOP,oBAAoBI,YAAYC;AACzC"}

package/dist/esm/sevenz/codecs/Lzma2.d.ts

@@ -1,14 +1,20 @@
-import type { Transform } from 'readable-stream';
+import type { Transform } from 'stream';
 /**
  * Decode LZMA2 compressed data to buffer
  *
  * @param input - LZMA2 compressed data
  * @param properties - Properties buffer (1 byte: dictionary size)
- * @param unpackSize - Expected output size (used for pre-allocation to reduce memory)
+ * @param unpackSize - Expected output size (optional, for pre-allocation)
  * @returns Decompressed data
  */
 export declare function decodeLzma2(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer;
 /**
  * Create an LZMA2 decoder Transform stream
+ *
+ * This is a true streaming decoder that processes LZMA2 chunks incrementally.
+ * Memory usage is O(dictionary_size + max_chunk_size) instead of O(folder_size).
+ *
+ * LZMA2 chunks are up to ~2MB uncompressed, so memory is bounded regardless of
+ * total archive size.
  */
-export declare function createLzma2Decoder(properties?: Buffer, unpackSize?: number): Transform;
+export declare function createLzma2Decoder(properties?: Buffer, _unpackSize?: number): Transform;