7z-iterator 1.1.2 → 1.2.0

package/dist/cjs/sevenz/codecs/BcjArm.d.ts

@@ -1,6 +1,6 @@
-import type { Transform } from 'readable-stream';
+import { 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:
@@ -15,6 +15,7 @@ import type { Transform } from 'readable-stream';
  */
 export declare function decodeBcjArm(input: Buffer, _properties?: Buffer, _unpackSize?: number): Buffer;
 /**
- * Create an ARM BCJ decoder Transform stream
+ * Create a streaming ARM BCJ decoder Transform.
+ * Processes data in 4-byte aligned chunks.
  */
-export declare function createBcjArmDecoder(properties?: Buffer, unpackSize?: number): Transform;
+export declare function createBcjArmDecoder(_properties?: Buffer, _unpackSize?: number): InstanceType<typeof Transform>;

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

@@ -5,6 +5,8 @@
 // these to absolute addresses during compression, and back during decompression.
 //
 // Reference: https://github.com/kornelski/7z/blob/main/C/Bra.c
+//
+// This implementation uses true streaming - processes data chunk by chunk.
 "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
@@ -24,12 +26,6 @@ _export(exports, {
     }
 });
 var _extractbaseiterator = require("extract-base-iterator");
-var _createBufferingDecoderts = /*#__PURE__*/ _interop_require_default(require("./createBufferingDecoder.js"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
 function decodeBcjArm(input, _properties, _unpackSize) {
     var output = (0, _extractbaseiterator.bufferFrom)(input); // Copy since we modify in place
     var pos = 0;
@@ -45,7 +41,6 @@ function decodeBcjArm(input, _properties, _unpackSize) {
             }
             // Convert absolute to relative:
             // Subtract current position (in words, so divide by 4)
-            // ARM PC is 2 words (8 bytes) ahead during execution
             var relAddr = addr - (pos >>> 2);
             // Write back lower 24 bits
             output[pos] = relAddr & 0xff;
@@ -56,7 +51,54 @@ function decodeBcjArm(input, _properties, _unpackSize) {
     }
     return output;
 }
-function createBcjArmDecoder(properties, unpackSize) {
-    return (0, _createBufferingDecoderts.default)(decodeBcjArm, properties, unpackSize);
+function createBcjArmDecoder(_properties, _unpackSize) {
+    var globalPos = 0; // Position in the overall stream (in bytes)
+    var pending = null; // Incomplete 4-byte group
+    var transform = new _extractbaseiterator.Transform({
+        transform: function(chunk, _encoding, callback) {
+            // Combine pending bytes with new chunk
+            var data;
+            if (pending && pending.length > 0) {
+                data = Buffer.concat([
+                    pending,
+                    chunk
+                ]);
+            } else {
+                data = chunk;
+            }
+            // Process only complete 4-byte groups
+            var completeBytes = data.length - data.length % 4;
+            if (completeBytes === 0) {
+                pending = data;
+                callback(null, (0, _extractbaseiterator.allocBuffer)(0));
+                return;
+            }
+            var output = (0, _extractbaseiterator.bufferFrom)(data.slice(0, completeBytes));
+            pending = data.length > completeBytes ? data.slice(completeBytes) : null;
+            var pos = 0;
+            while(pos + 4 <= output.length){
+                if (output[pos + 3] === 0xeb) {
+                    var addr = output[pos] | output[pos + 1] << 8 | output[pos + 2] << 16;
+                    if (addr & 0x800000) {
+                        addr |= 0xff000000;
+                    }
+                    var 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 flush(callback) {
+            if (pending && pending.length > 0) {
+                this.push(pending);
+            }
+            callback(null);
+        }
+    });
+    return transform;
 }
 /* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/sevenz/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":["createBcjArmDecoder","decodeBcjArm","input","_properties","_unpackSize","output","bufferFrom","pos","length","addr","relAddr","properties","unpackSize","createBufferingDecoder"],"mappings":"AAAA,4EAA4E;AAC5E,8DAA8D;AAC9D,EAAE;AACF,4EAA4E;AAC5E,iFAAiF;AACjF,EAAE;AACF,+DAA+D;;;;;;;;;;;;QAuD/CA;eAAAA;;QAnCAC;eAAAA;;;mCAlBW;+EAEQ;;;;;;AAgB5B,SAASA,aAAaC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACpF,IAAMC,SAASC,IAAAA,+BAAU,EAACJ,QAAQ,gCAAgC;IAClE,IAAIK,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKF,OAAOG,MAAM,CAAE;QAC/B,2CAA2C;QAC3C,IAAIH,MAAM,CAACE,MAAM,EAAE,KAAK,MAAM;YAC5B,mDAAmD;YACnD,IAAIE,OAAOJ,MAAM,CAACE,IAAI,GAAIF,MAAM,CAACE,MAAM,EAAE,IAAI,IAAMF,MAAM,CAACE,MAAM,EAAE,IAAI;YAEtE,+BAA+B;YAC/B,IAAIE,OAAO,UAAU;gBACnBA,QAAQ;YACV;YAEA,gCAAgC;YAChC,uDAAuD;YACvD,qDAAqD;YACrD,IAAMC,UAAUD,OAAQF,CAAAA,QAAQ,CAAA;YAEhC,2BAA2B;YAC3BF,MAAM,CAACE,IAAI,GAAGG,UAAU;YACxBL,MAAM,CAACE,MAAM,EAAE,GAAG,AAACG,YAAY,IAAK;YACpCL,MAAM,CAACE,MAAM,EAAE,GAAG,AAACG,YAAY,KAAM;QACvC;QACAH,OAAO;IACT;IAEA,OAAOF;AACT;AAKO,SAASL,oBAAoBW,UAAmB,EAAEC,UAAmB;IAC1E,OAAOC,IAAAA,iCAAsB,EAACZ,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":["createBcjArmDecoder","decodeBcjArm","input","_properties","_unpackSize","output","bufferFrom","pos","length","addr","relAddr","globalPos","pending","transform","Transform","chunk","_encoding","callback","data","Buffer","concat","completeBytes","allocBuffer","slice","flush","push"],"mappings":"AAAA,4EAA4E;AAC5E,8DAA8D;AAC9D,EAAE;AACF,4EAA4E;AAC5E,iFAAiF;AACjF,EAAE;AACF,+DAA+D;AAC/D,EAAE;AACF,2EAA2E;;;;;;;;;;;;QAqD3DA;eAAAA;;QAnCAC;eAAAA;;;mCAhBmC;AAgB5C,SAASA,aAAaC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACpF,IAAMC,SAASC,IAAAA,+BAAU,EAACJ,QAAQ,gCAAgC;IAClE,IAAIK,MAAM;IAEV,mCAAmC;IACnC,MAAOA,MAAM,KAAKF,OAAOG,MAAM,CAAE;QAC/B,2CAA2C;QAC3C,IAAIH,MAAM,CAACE,MAAM,EAAE,KAAK,MAAM;YAC5B,mDAAmD;YACnD,IAAIE,OAAOJ,MAAM,CAACE,IAAI,GAAIF,MAAM,CAACE,MAAM,EAAE,IAAI,IAAMF,MAAM,CAACE,MAAM,EAAE,IAAI;YAEtE,+BAA+B;YAC/B,IAAIE,OAAO,UAAU;gBACnBA,QAAQ;YACV;YAEA,gCAAgC;YAChC,uDAAuD;YACvD,IAAMC,UAAUD,OAAQF,CAAAA,QAAQ,CAAA;YAEhC,2BAA2B;YAC3BF,MAAM,CAACE,IAAI,GAAGG,UAAU;YACxBL,MAAM,CAACE,MAAM,EAAE,GAAG,AAACG,YAAY,IAAK;YACpCL,MAAM,CAACE,MAAM,EAAE,GAAG,AAACG,YAAY,KAAM;QACvC;QACAH,OAAO;IACT;IAEA,OAAOF;AACT;AAMO,SAASL,oBAAoBG,WAAoB,EAAEC,WAAoB;IAC5E,IAAIO,YAAY,GAAG,4CAA4C;IAC/D,IAAIC,UAAyB,MAAM,0BAA0B;IAE7D,IAAMC,YAAY,IAAIC,8BAAS,CAAC;QAC9BD,WAAW,SAACE,OAAeC,WAAmBC;YAC5C,uCAAuC;YACvC,IAAIC;YACJ,IAAIN,WAAWA,QAAQJ,MAAM,GAAG,GAAG;gBACjCU,OAAOC,OAAOC,MAAM,CAAC;oBAACR;oBAASG;iBAAM;YACvC,OAAO;gBACLG,OAAOH;YACT;YAEA,sCAAsC;YACtC,IAAMM,gBAAgBH,KAAKV,MAAM,GAAIU,KAAKV,MAAM,GAAG;YACnD,IAAIa,kBAAkB,GAAG;gBACvBT,UAAUM;gBACVD,SAAS,MAAMK,IAAAA,gCAAW,EAAC;gBAC3B;YACF;YAEA,IAAMjB,SAASC,IAAAA,+BAAU,EAACY,KAAKK,KAAK,CAAC,GAAGF;YACxCT,UAAUM,KAAKV,MAAM,GAAGa,gBAAgBH,KAAKK,KAAK,CAACF,iBAAiB;YAEpE,IAAId,MAAM;YACV,MAAOA,MAAM,KAAKF,OAAOG,MAAM,CAAE;gBAC/B,IAAIH,MAAM,CAACE,MAAM,EAAE,KAAK,MAAM;oBAC5B,IAAIE,OAAOJ,MAAM,CAACE,IAAI,GAAIF,MAAM,CAACE,MAAM,EAAE,IAAI,IAAMF,MAAM,CAACE,MAAM,EAAE,IAAI;oBACtE,IAAIE,OAAO,UAAU;wBACnBA,QAAQ;oBACV;oBACA,IAAMC,UAAUD,OAAQE,CAAAA,cAAc,CAAA;oBACtCN,MAAM,CAACE,IAAI,GAAGG,UAAU;oBACxBL,MAAM,CAACE,MAAM,EAAE,GAAG,AAACG,YAAY,IAAK;oBACpCL,MAAM,CAACE,MAAM,EAAE,GAAG,AAACG,YAAY,KAAM;gBACvC;gBACAH,OAAO;gBACPI,aAAa;YACf;YAEAM,SAAS,MAAMZ;QACjB;QACAmB,OAAO,SAAPA,MAAuDP,QAAsC;YAC3F,IAAIL,WAAWA,QAAQJ,MAAM,GAAG,GAAG;gBACjC,IAAI,CAACiB,IAAI,CAACb;YACZ;YACAK,SAAS;QACX;IACF;IAEA,OAAOJ;AACT"}

package/dist/cjs/sevenz/codecs/Copy.d.cts

@@ -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/cjs/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/cjs/sevenz/codecs/Copy.js

@@ -18,22 +18,9 @@ _export(exports, {
         return decodeCopy;
     }
 });
-var _stream = /*#__PURE__*/ _interop_require_default(require("stream"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-// Use native streams when available, readable-stream only for Node 0.x
-var major = +process.versions.node.split('.')[0];
-var PassThrough;
-if (major > 0) {
-    PassThrough = _stream.default.PassThrough;
-} else {
-    PassThrough = require('readable-stream').PassThrough;
-}
+var _extractbaseiterator = require("extract-base-iterator");
 function createCopyDecoder() {
-    return new PassThrough();
+    return new _extractbaseiterator.PassThrough();
 }
 function decodeCopy(input, _properties, _unpackSize) {
     return input;

package/dist/cjs/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":["createCopyDecoder","decodeCopy","major","process","versions","node","split","PassThrough","Stream","require","input","_properties","_unpackSize"],"mappings":"AAAA,4CAA4C;AAC5C,iEAAiE;;;;;;;;;;;;QAkBjDA;eAAAA;;QAWAC;eAAAA;;;6DA3BG;;;;;;AAEnB,uEAAuE;AACvE,IAAMC,QAAQ,CAACC,QAAQC,QAAQ,CAACC,IAAI,CAACC,KAAK,CAAC,IAAI,CAAC,EAAE;AAClD,IAAIC;AACJ,IAAIL,QAAQ,GAAG;IACbK,cAAcC,eAAM,CAACD,WAAW;AAClC,OAAO;IACLA,cAAcE,QAAQ,mBAAmBF,WAAW;AACtD;AAOO,SAASP;IACd,OAAO,IAAIO;AACb;AASO,SAASN,WAAWS,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":["createCopyDecoder","decodeCopy","PassThrough","input","_properties","_unpackSize"],"mappings":"AAAA,4CAA4C;AAC5C,iEAAiE;;;;;;;;;;;;QAQjDA;eAAAA;;QAWAC;eAAAA;;;mCAjB4B;AAMrC,SAASD;IACd,OAAO,IAAIE,gCAAW;AACxB;AASO,SAASD,WAAWE,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IAClF,OAAOF;AACT"}

package/dist/cjs/sevenz/codecs/Deflate.d.cts

@@ -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/cjs/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/cjs/sevenz/codecs/Deflate.js

@@ -1,7 +1,8 @@
 // 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
+// Uses native zlib.createInflateRaw() for true streaming decompression
+// Falls back to pako for older Node versions via extract-base-iterator
 "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
@@ -21,16 +22,10 @@ _export(exports, {
     }
 });
 var _extractbaseiterator = require("extract-base-iterator");
-var _createBufferingDecoderts = /*#__PURE__*/ _interop_require_default(require("./createBufferingDecoder.js"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
 function decodeDeflate(input, _properties, _unpackSize) {
     return (0, _extractbaseiterator.inflateRaw)(input);
 }
-function createDeflateDecoder(properties, unpackSize) {
-    return (0, _createBufferingDecoderts.default)(decodeDeflate, properties, unpackSize);
+function createDeflateDecoder(_properties, _unpackSize) {
+    return (0, _extractbaseiterator.createInflateRawStream)();
 }
 /* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/sevenz/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":["createDeflateDecoder","decodeDeflate","input","_properties","_unpackSize","inflateRaw","properties","unpackSize","createBufferingDecoder"],"mappings":"AAAA,gDAAgD;AAChD,mDAAmD;AACnD,EAAE;AACF,2EAA2E;;;;;;;;;;;;QAqB3DA;eAAAA;;QAPAC;eAAAA;;;mCAZW;+EAEQ;;;;;;AAU5B,SAASA,cAAcC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACrF,OAAOC,IAAAA,+BAAU,EAACH;AACpB;AAKO,SAASF,qBAAqBM,UAAmB,EAAEC,UAAmB;IAC3E,OAAOC,IAAAA,iCAAsB,EAACP,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":["createDeflateDecoder","decodeDeflate","input","_properties","_unpackSize","inflateRaw","createInflateRawStream"],"mappings":"AAAA,gDAAgD;AAChD,mDAAmD;AACnD,EAAE;AACF,uEAAuE;AACvE,uEAAuE;;;;;;;;;;;;QAsBvDA;eAAAA;;QATAC;eAAAA;;;mCAXmC;AAW5C,SAASA,cAAcC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACrF,OAAOC,IAAAA,+BAAU,EAACH;AACpB;AAOO,SAASF,qBAAqBG,WAAoB,EAAEC,WAAoB;IAC7E,OAAOE,IAAAA,2CAAsB;AAC/B"}

package/dist/cjs/sevenz/codecs/Delta.d.cts

@@ -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/cjs/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/cjs/sevenz/codecs/Delta.js

@@ -4,6 +4,9 @@
 // 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.
+//
+// This implementation uses true streaming - processes data chunk by chunk
+// while maintaining state between chunks.
 "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
@@ -23,12 +26,6 @@ _export(exports, {
     }
 });
 var _extractbaseiterator = require("extract-base-iterator");
-var _createBufferingDecoderts = /*#__PURE__*/ _interop_require_default(require("./createBufferingDecoder.js"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
 function decodeDelta(input, properties, _unpackSize) {
     // Distance parameter: default is 1
     var distance = 1;
@@ -38,9 +35,9 @@ function decodeDelta(input, properties, _unpackSize) {
     }
     var output = (0, _extractbaseiterator.bufferFrom)(input); // Copy since we modify in place
     // State buffer for multi-byte distance
-    var state = new Array(distance);
+    var state = [];
     for(var i = 0; i < distance; i++){
-        state[i] = 0;
+        state.push(0);
     }
     for(var j = 0; j < output.length; j++){
         var idx = j % distance;
@@ -49,7 +46,29 @@ function decodeDelta(input, properties, _unpackSize) {
     }
     return output;
 }
-function createDeltaDecoder(properties, unpackSize) {
-    return (0, _createBufferingDecoderts.default)(decodeDelta, properties, unpackSize);
+function createDeltaDecoder(properties, _unpackSize) {
+    // Distance parameter: default is 1
+    var distance = 1;
+    if (properties && properties.length >= 1) {
+        distance = properties[0] + 1;
+    }
+    // State buffer for multi-byte distance
+    var state = [];
+    for(var i = 0; i < distance; i++){
+        state.push(0);
+    }
+    var byteIndex = 0;
+    return new _extractbaseiterator.Transform({
+        transform: function(chunk, _encoding, callback) {
+            var output = (0, _extractbaseiterator.allocBuffer)(chunk.length);
+            for(var j = 0; j < chunk.length; j++){
+                var idx = byteIndex % distance;
+                state[idx] = state[idx] + chunk[j] & 0xff;
+                output[j] = state[idx];
+                byteIndex++;
+            }
+            callback(null, output);
+        }
+    });
 }
 /* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/sevenz/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":["createDeltaDecoder","decodeDelta","input","properties","_unpackSize","distance","length","output","bufferFrom","state","Array","i","j","idx","unpackSize","createBufferingDecoder"],"mappings":"AAAA,oEAAoE;AACpE,oEAAoE;AACpE,EAAE;AACF,wEAAwE;AACxE,0EAA0E;AAC1E,2DAA2D;;;;;;;;;;;;QA2C3CA;eAAAA;;QA5BAC;eAAAA;;;mCAbW;+EAEQ;;;;;;AAW5B,SAASA,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,IAAMI,SAASC,IAAAA,+BAAU,EAACN,QAAQ,gCAAgC;IAElE,uCAAuC;IACvC,IAAMO,QAAQ,IAAIC,MAAML;IACxB,IAAK,IAAIM,IAAI,GAAGA,IAAIN,UAAUM,IAAK;QACjCF,KAAK,CAACE,EAAE,GAAG;IACb;IAEA,IAAK,IAAIC,IAAI,GAAGA,IAAIL,OAAOD,MAAM,EAAEM,IAAK;QACtC,IAAMC,MAAMD,IAAIP;QAChBI,KAAK,CAACI,IAAI,GAAG,AAACJ,KAAK,CAACI,IAAI,GAAGN,MAAM,CAACK,EAAE,GAAI;QACxCL,MAAM,CAACK,EAAE,GAAGH,KAAK,CAACI,IAAI;IACxB;IAEA,OAAON;AACT;AAKO,SAASP,mBAAmBG,UAAmB,EAAEW,UAAmB;IACzE,OAAOC,IAAAA,iCAAsB,EAACd,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":["createDeltaDecoder","decodeDelta","input","properties","_unpackSize","distance","length","output","bufferFrom","state","i","push","j","idx","byteIndex","Transform","transform","chunk","_encoding","callback","allocBuffer"],"mappings":"AAAA,oEAAoE;AACpE,oEAAoE;AACpE,EAAE;AACF,wEAAwE;AACxE,0EAA0E;AAC1E,2DAA2D;AAC3D,EAAE;AACF,0EAA0E;AAC1E,0CAA0C;;;;;;;;;;;;QA0C1BA;eAAAA;;QA7BAC;eAAAA;;;mCAXmC;AAW5C,SAASA,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,IAAMI,SAASC,IAAAA,+BAAU,EAACN,QAAQ,gCAAgC;IAElE,uCAAuC;IACvC,IAAMO,QAAkB,EAAE;IAC1B,IAAK,IAAIC,IAAI,GAAGA,IAAIL,UAAUK,IAAK;QACjCD,MAAME,IAAI,CAAC;IACb;IAEA,IAAK,IAAIC,IAAI,GAAGA,IAAIL,OAAOD,MAAM,EAAEM,IAAK;QACtC,IAAMC,MAAMD,IAAIP;QAChBI,KAAK,CAACI,IAAI,GAAG,AAACJ,KAAK,CAACI,IAAI,GAAGN,MAAM,CAACK,EAAE,GAAI;QACxCL,MAAM,CAACK,EAAE,GAAGH,KAAK,CAACI,IAAI;IACxB;IAEA,OAAON;AACT;AAMO,SAASP,mBAAmBG,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,IAAMM,QAAkB,EAAE;IAC1B,IAAK,IAAIC,IAAI,GAAGA,IAAIL,UAAUK,IAAK;QACjCD,MAAME,IAAI,CAAC;IACb;IAEA,IAAIG,YAAY;IAEhB,OAAO,IAAIC,8BAAS,CAAC;QACnBC,WAAW,SAACC,OAAeC,WAAmBC;YAC5C,IAAMZ,SAASa,IAAAA,gCAAW,EAACH,MAAMX,MAAM;YAEvC,IAAK,IAAIM,IAAI,GAAGA,IAAIK,MAAMX,MAAM,EAAEM,IAAK;gBACrC,IAAMC,MAAMC,YAAYT;gBACxBI,KAAK,CAACI,IAAI,GAAG,AAACJ,KAAK,CAACI,IAAI,GAAGI,KAAK,CAACL,EAAE,GAAI;gBACvCL,MAAM,CAACK,EAAE,GAAGH,KAAK,CAACI,IAAI;gBACtBC;YACF;YAEAK,SAAS,MAAMZ;QACjB;IACF;AACF"}

package/dist/cjs/sevenz/codecs/Lzma.d.cts

@@ -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/cjs/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/cjs/sevenz/codecs/Lzma.js

@@ -1,3 +1,5 @@
+// LZMA codec using TypeScript LZMA decoder
+// LZMA properties in 7z are 5 bytes: 1 byte lc/lp/pb + 4 bytes dictionary size (little-endian)
 "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
@@ -16,40 +18,23 @@ _export(exports, {
         return decodeLzma;
     }
 });
-var _module = /*#__PURE__*/ _interop_require_default(require("module"));
-var _createBufferingDecoderts = /*#__PURE__*/ _interop_require_default(require("./createBufferingDecoder.js"));
-var _streamsts = require("./streams.js");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-var _require = typeof require === 'undefined' ? _module.default.createRequire(require("url").pathToFileURL(__filename).toString()) : require;
-// Import vendored lzma-purejs - provides raw LZMA decoder (patched for LZMA2 support)
-// Path accounts for build output in dist/esm/sevenz/codecs/
-var LZMA = _require('../../../../assets/lzma-purejs').LZMA;
-var LzmaDecoder = LZMA.Decoder;
+var _indexts = require("../../lzma/index.js");
 function decodeLzma(input, properties, unpackSize) {
     if (!properties || properties.length < 5) {
         throw new Error('LZMA requires 5-byte properties');
     }
-    var decoder = new LzmaDecoder();
-    // setDecoderProperties expects array-like with 5 bytes
-    if (!decoder.setDecoderProperties(properties)) {
-        throw new Error('Invalid LZMA properties');
-    }
-    var inStream = (0, _streamsts.createInputStream)(input, 0, input.length);
-    // Use -1 for unknown size (decoder will use end marker)
-    var size = typeof unpackSize === 'number' ? unpackSize : -1;
-    // Pre-allocate output stream if size is known (memory optimization)
-    var outStream = (0, _streamsts.createOutputStream)(size > 0 ? size : undefined);
-    var success = decoder.code(inStream, outStream, size);
-    if (!success) {
-        throw new Error('LZMA decompression failed');
+    if (typeof unpackSize !== 'number' || unpackSize < 0) {
+        throw new Error('LZMA requires known unpack size');
     }
-    return outStream.toBuffer();
+    return (0, _indexts.decodeLzma)(input, properties, unpackSize);
 }
 function createLzmaDecoder(properties, unpackSize) {
-    return (0, _createBufferingDecoderts.default)(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 (0, _indexts.createLzmaDecoder)(properties, unpackSize);
 }
 /* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/sevenz/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":["createLzmaDecoder","decodeLzma","_require","require","Module","createRequire","LZMA","LzmaDecoder","Decoder","input","properties","unpackSize","length","Error","decoder","setDecoderProperties","inStream","createInputStream","size","outStream","createOutputStream","undefined","success","code","toBuffer","createBufferingDecoder"],"mappings":";;;;;;;;;;;QAuDgBA;eAAAA;;QA/BAC;eAAAA;;;6DAxBG;+EAQgB;yBACmB;;;;;;AAPtD,IAAMC,WAAW,OAAOC,YAAY,cAAcC,eAAM,CAACC,aAAa,CAAC,uDAAmBF;AAS1F,sFAAsF;AACtF,4DAA4D;AAC5D,IAAM,AAAEG,OAASJ,SAAS,kCAAlBI;AACR,IAAMC,cAAcD,KAAKE,OAAO;AAUzB,SAASP,WAAWQ,KAAa,EAAEC,UAAmB,EAAEC,UAAmB;IAChF,IAAI,CAACD,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,IAAMC,UAAU,IAAIP;IAEpB,uDAAuD;IACvD,IAAI,CAACO,QAAQC,oBAAoB,CAACL,aAAa;QAC7C,MAAM,IAAIG,MAAM;IAClB;IAEA,IAAMG,WAAWC,IAAAA,4BAAiB,EAACR,OAAO,GAAGA,MAAMG,MAAM;IAEzD,wDAAwD;IACxD,IAAMM,OAAO,OAAOP,eAAe,WAAWA,aAAa,CAAC;IAE5D,oEAAoE;IACpE,IAAMQ,YAAYC,IAAAA,6BAAkB,EAACF,OAAO,IAAIA,OAAOG;IAEvD,IAAMC,UAAUR,QAAQS,IAAI,CAACP,UAAUG,WAAWD;IAClD,IAAI,CAACI,SAAS;QACZ,MAAM,IAAIT,MAAM;IAClB;IAEA,OAAOM,UAAUK,QAAQ;AAC3B;AAKO,SAASxB,kBAAkBU,UAAmB,EAAEC,UAAmB;IACxE,OAAOc,IAAAA,iCAAsB,EAACxB,YAAYS,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","decodeLzma","input","properties","unpackSize","length","Error","lzmaDecode","createLzmaTransform"],"mappings":"AAAA,2CAA2C;AAC3C,+FAA+F;;;;;;;;;;;;QA+B/EA;eAAAA;;QAlBAC;eAAAA;;;uBAVmE;AAU5E,SAASA,WAAWC,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,OAAOC,IAAAA,mBAAU,EAACL,OAAOC,YAAYC;AACvC;AAQO,SAASJ,kBAAkBG,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,OAAOE,IAAAA,0BAAmB,EAACL,YAAYC;AACzC"}

package/dist/cjs/sevenz/codecs/Lzma2.d.cts

@@ -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;

package/dist/cjs/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;