7z-iterator 0.1.0

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

@@ -0,0 +1,39 @@
+// Deflate codec - standard zlib/zip compression
+// 7z uses raw deflate without zlib or gzip headers
+//
+// Uses pako for pure JavaScript decompression (works on all Node versions)
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get createDeflateDecoder () {
+        return createDeflateDecoder;
+    },
+    get decodeDeflate () {
+        return decodeDeflate;
+    }
+});
+var _extractbaseiterator = require("extract-base-iterator");
+var _pako = /*#__PURE__*/ _interop_require_default(require("pako"));
+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) {
+    // pako.inflateRaw returns Uint8Array, convert to Buffer
+    var result = _pako.default.inflateRaw(input);
+    return (0, _extractbaseiterator.bufferFrom)(result);
+}
+function createDeflateDecoder(properties, unpackSize) {
+    return (0, _createBufferingDecoderts.default)(decodeDeflate, 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/Deflate.js.map

@@ -0,0 +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 pako for pure JavaScript decompression (works on all Node versions)\n\nimport { bufferFrom } from 'extract-base-iterator';\nimport pako from 'pako';\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  // pako.inflateRaw returns Uint8Array, convert to Buffer\n  var result = pako.inflateRaw(input);\n  return bufferFrom(result);\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","result","pako","inflateRaw","bufferFrom","properties","unpackSize","createBufferingDecoder"],"mappings":"AAAA,gDAAgD;AAChD,mDAAmD;AACnD,EAAE;AACF,2EAA2E;;;;;;;;;;;;QAwB3DA;eAAAA;;QATAC;eAAAA;;;mCAbW;2DACV;+EAEkB;;;;;;AAU5B,SAASA,cAAcC,KAAa,EAAEC,WAAoB,EAAEC,WAAoB;IACrF,wDAAwD;IACxD,IAAIC,SAASC,aAAI,CAACC,UAAU,CAACL;IAC7B,OAAOM,IAAAA,+BAAU,EAACH;AACpB;AAKO,SAASL,qBAAqBS,UAAmB,EAAEC,UAAmB;IAC3E,OAAOC,IAAAA,iCAAsB,EAACV,eAAeQ,YAAYC;AAC3D"}

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

@@ -0,0 +1,15 @@
+import type { Transform } from 'readable-stream';
+/**
+ * Decode Delta filtered data
+ * Reverses the delta transformation by adding previous values
+ *
+ * @param input - Delta filtered data
+ * @param properties - Optional 1-byte properties (distance - 1)
+ * @param _unpackSize - Unused for Delta
+ * @returns Unfiltered data
+ */
+export declare function decodeDelta(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer;
+/**
+ * Create a Delta decoder Transform stream
+ */
+export declare function createDeltaDecoder(properties?: Buffer, unpackSize?: number): Transform;

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

@@ -0,0 +1,15 @@
+import type { Transform } from 'readable-stream';
+/**
+ * Decode Delta filtered data
+ * Reverses the delta transformation by adding previous values
+ *
+ * @param input - Delta filtered data
+ * @param properties - Optional 1-byte properties (distance - 1)
+ * @param _unpackSize - Unused for Delta
+ * @returns Unfiltered data
+ */
+export declare function decodeDelta(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer;
+/**
+ * Create a Delta decoder Transform stream
+ */
+export declare function createDeltaDecoder(properties?: Buffer, unpackSize?: number): Transform;

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

@@ -0,0 +1,55 @@
+// Delta filter codec - stores differences between consecutive bytes
+// Useful for data with gradual changes (images, audio, sensor data)
+//
+// 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.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get createDeltaDecoder () {
+        return createDeltaDecoder;
+    },
+    get decodeDelta () {
+        return decodeDelta;
+    }
+});
+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;
+    if (properties && properties.length >= 1) {
+        // Properties byte contains (distance - 1)
+        distance = properties[0] + 1;
+    }
+    var output = (0, _extractbaseiterator.bufferFrom)(input); // Copy since we modify in place
+    // State buffer for multi-byte distance
+    var state = new Array(distance);
+    for(var i = 0; i < distance; i++){
+        state[i] = 0;
+    }
+    for(var j = 0; j < output.length; j++){
+        var idx = j % distance;
+        state[idx] = state[idx] + output[j] & 0xff;
+        output[j] = state[idx];
+    }
+    return output;
+}
+function createDeltaDecoder(properties, unpackSize) {
+    return (0, _createBufferingDecoderts.default)(decodeDelta, 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/Delta.js.map

@@ -0,0 +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  var distance = 1;\n  if (properties && properties.length >= 1) {\n    // Properties byte contains (distance - 1)\n    distance = properties[0] + 1;\n  }\n\n  var output = bufferFrom(input); // Copy since we modify in place\n\n  // State buffer for multi-byte distance\n  var state = new Array(distance);\n  for (var i = 0; i < distance; i++) {\n    state[i] = 0;\n  }\n\n  for (var j = 0; j < output.length; j++) {\n    var 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,IAAII,SAASC,IAAAA,+BAAU,EAACN,QAAQ,gCAAgC;IAEhE,uCAAuC;IACvC,IAAIO,QAAQ,IAAIC,MAAML;IACtB,IAAK,IAAIM,IAAI,GAAGA,IAAIN,UAAUM,IAAK;QACjCF,KAAK,CAACE,EAAE,GAAG;IACb;IAEA,IAAK,IAAIC,IAAI,GAAGA,IAAIL,OAAOD,MAAM,EAAEM,IAAK;QACtC,IAAIC,MAAMD,IAAIP;QACdI,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"}

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

@@ -0,0 +1,14 @@
+import type { Transform } from 'readable-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)
+ * @returns Decompressed data
+ */
+export declare function decodeLzma(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer;
+/**
+ * Create an LZMA decoder Transform stream
+ */
+export declare function createLzmaDecoder(properties?: Buffer, unpackSize?: number): Transform;

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

@@ -0,0 +1,14 @@
+import type { Transform } from 'readable-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)
+ * @returns Decompressed data
+ */
+export declare function decodeLzma(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer;
+/**
+ * Create an LZMA decoder Transform stream
+ */
+export declare function createLzmaDecoder(properties?: Buffer, unpackSize?: number): Transform;

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

@@ -0,0 +1,53 @@
+// LZMA codec - uses lzma-purejs for raw LZMA decompression
+// LZMA properties in 7z are 5 bytes: 1 byte lc/lp/pb + 4 bytes dictionary size (little-endian)
+// Import lzma-purejs - provides raw LZMA decoder
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get createLzmaDecoder () {
+        return createLzmaDecoder;
+    },
+    get decodeLzma () {
+        return decodeLzma;
+    }
+});
+var _lzmapurejs = /*#__PURE__*/ _interop_require_default(require("lzma-purejs"));
+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 LzmaDecoder = _lzmapurejs.default.LZMA.Decoder;
+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);
+    var outStream = (0, _streamsts.createOutputStream)();
+    // Use -1 for unknown size (decoder will use end marker)
+    var size = typeof unpackSize === 'number' ? unpackSize : -1;
+    var success = decoder.code(inStream, outStream, size);
+    if (!success) {
+        throw new Error('LZMA decompression failed');
+    }
+    return outStream.toBuffer();
+}
+function createLzmaDecoder(properties, unpackSize) {
+    return (0, _createBufferingDecoderts.default)(decodeLzma, 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

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Lzma.ts"],"sourcesContent":["// LZMA codec - uses lzma-purejs for raw LZMA decompression\n// LZMA properties in 7z are 5 bytes: 1 byte lc/lp/pb + 4 bytes dictionary size (little-endian)\n\n// Import lzma-purejs - provides raw LZMA decoder\nimport lzmajs from 'lzma-purejs';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\nimport { createInputStream, createOutputStream } from './streams.ts';\n\nvar LzmaDecoder = lzmajs.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  var 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  var inStream = createInputStream(input, 0, input.length);\n  var outStream = createOutputStream();\n\n  // Use -1 for unknown size (decoder will use end marker)\n  var size = typeof unpackSize === 'number' ? unpackSize : -1;\n\n  var 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","LzmaDecoder","lzmajs","LZMA","Decoder","input","properties","unpackSize","length","Error","decoder","setDecoderProperties","inStream","createInputStream","outStream","createOutputStream","size","success","code","toBuffer","createBufferingDecoder"],"mappings":"AAAA,2DAA2D;AAC3D,+FAA+F;AAE/F,iDAAiD;;;;;;;;;;;;QA6CjCA;eAAAA;;QA7BAC;eAAAA;;;iEAfG;+EAEgB;yBACmB;;;;;;AAEtD,IAAIC,cAAcC,mBAAM,CAACC,IAAI,CAACC,OAAO;AAU9B,SAASJ,WAAWK,KAAa,EAAEC,UAAmB,EAAEC,UAAmB;IAChF,IAAI,CAACD,cAAcA,WAAWE,MAAM,GAAG,GAAG;QACxC,MAAM,IAAIC,MAAM;IAClB;IAEA,IAAIC,UAAU,IAAIT;IAElB,uDAAuD;IACvD,IAAI,CAACS,QAAQC,oBAAoB,CAACL,aAAa;QAC7C,MAAM,IAAIG,MAAM;IAClB;IAEA,IAAIG,WAAWC,IAAAA,4BAAiB,EAACR,OAAO,GAAGA,MAAMG,MAAM;IACvD,IAAIM,YAAYC,IAAAA,6BAAkB;IAElC,wDAAwD;IACxD,IAAIC,OAAO,OAAOT,eAAe,WAAWA,aAAa,CAAC;IAE1D,IAAIU,UAAUP,QAAQQ,IAAI,CAACN,UAAUE,WAAWE;IAChD,IAAI,CAACC,SAAS;QACZ,MAAM,IAAIR,MAAM;IAClB;IAEA,OAAOK,UAAUK,QAAQ;AAC3B;AAKO,SAASpB,kBAAkBO,UAAmB,EAAEC,UAAmB;IACxE,OAAOa,IAAAA,iCAAsB,EAACpB,YAAYM,YAAYC;AACxD"}

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

@@ -0,0 +1,14 @@
+import type { Transform } from 'readable-stream';
+/**
+ * Decode LZMA2 compressed data to buffer
+ *
+ * @param input - LZMA2 compressed data
+ * @param properties - Properties buffer (1 byte: dictionary size)
+ * @param _unpackSize - Unused (LZMA2 has internal size markers)
+ * @returns Decompressed data
+ */
+export declare function decodeLzma2(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer;
+/**
+ * Create an LZMA2 decoder Transform stream
+ */
+export declare function createLzma2Decoder(properties?: Buffer, unpackSize?: number): Transform;

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

@@ -0,0 +1,14 @@
+import type { Transform } from 'readable-stream';
+/**
+ * Decode LZMA2 compressed data to buffer
+ *
+ * @param input - LZMA2 compressed data
+ * @param properties - Properties buffer (1 byte: dictionary size)
+ * @param _unpackSize - Unused (LZMA2 has internal size markers)
+ * @returns Decompressed data
+ */
+export declare function decodeLzma2(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer;
+/**
+ * Create an LZMA2 decoder Transform stream
+ */
+export declare function createLzma2Decoder(properties?: Buffer, unpackSize?: number): Transform;

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

@@ -0,0 +1,160 @@
+// LZMA2 codec - wrapper around lzma-purejs for LZMA2 decompression
+// LZMA2 is a container format that wraps LZMA chunks with framing
+//
+// LZMA2 format specification:
+// https://github.com/ulikunitz/xz/blob/master/doc/LZMA2.md
+//
+// Control byte values:
+// 0x00         = End of stream
+// 0x01         = Uncompressed chunk, dictionary reset
+// 0x02         = Uncompressed chunk, no dictionary reset
+// 0x80-0xFF    = LZMA compressed chunk (bits encode reset flags and size)
+// Import lzma-purejs - provides raw LZMA decoder
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get createLzma2Decoder () {
+        return createLzma2Decoder;
+    },
+    get decodeLzma2 () {
+        return decodeLzma2;
+    }
+});
+var _lzmapurejs = /*#__PURE__*/ _interop_require_default(require("lzma-purejs"));
+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 LzmaDecoder = _lzmapurejs.default.LZMA.Decoder;
+/**
+ * Decode LZMA2 dictionary size from properties byte
+ * Properties byte encodes dictionary size as: 2^(dictByte/2 + 12) or similar
+ *
+ * Per XZ spec, dictionary sizes are:
+ * 0x00 = 4 KiB (2^12)
+ * 0x01 = 6 KiB
+ * 0x02 = 8 KiB (2^13)
+ * ...
+ * 0x28 = 1.5 GiB
+ */ function decodeDictionarySize(propByte) {
+    if (propByte > 40) {
+        throw new Error("Invalid LZMA2 dictionary size property: ".concat(propByte));
+    }
+    if (propByte === 40) {
+        // Max dictionary size: 4 GiB - 1
+        return 0xffffffff;
+    }
+    // Dictionary size = 2 | (propByte & 1) << (propByte / 2 + 11)
+    var base = 2 | propByte & 1;
+    var shift = Math.floor(propByte / 2) + 11;
+    return base << shift;
+}
+function decodeLzma2(input, properties, _unpackSize) {
+    if (!properties || properties.length < 1) {
+        throw new Error('LZMA2 requires properties byte');
+    }
+    var dictSize = decodeDictionarySize(properties[0]);
+    var output = [];
+    var offset = 0;
+    // LZMA decoder instance - reused across chunks
+    var decoder = new LzmaDecoder();
+    decoder.setDictionarySize(dictSize);
+    // Track current LZMA properties (lc, lp, pb)
+    var propsSet = false;
+    while(offset < input.length){
+        var control = input[offset++];
+        if (control === 0x00) {
+            break;
+        }
+        if (control === 0x01 || control === 0x02) {
+            // Uncompressed chunk
+            // 0x01 = dictionary reset + uncompressed
+            // 0x02 = uncompressed (no reset)
+            // Note: Dictionary reset (0x01) is handled implicitly since we don't
+            // maintain dictionary state across uncompressed chunks in this implementation
+            if (offset + 2 > input.length) {
+                throw new Error('Truncated LZMA2 uncompressed chunk header');
+            }
+            // Size is big-endian, 16-bit, value + 1
+            var uncompSize = (input[offset] << 8 | input[offset + 1]) + 1;
+            offset += 2;
+            if (offset + uncompSize > input.length) {
+                throw new Error('Truncated LZMA2 uncompressed data');
+            }
+            // Copy uncompressed data
+            output.push(input.slice(offset, offset + uncompSize));
+            offset += uncompSize;
+        } else if (control >= 0x80) {
+            // LZMA compressed chunk
+            // Control byte format (bits 7-0):
+            // Bit 7: always 1 for LZMA chunk
+            // Bit 6: reset state
+            // Bit 5: new properties (implies state reset)
+            // Bits 4-0: high 5 bits of uncompressed size - 1
+            var newProps = (control & 0x20) !== 0;
+            if (offset + 4 > input.length) {
+                throw new Error('Truncated LZMA2 LZMA chunk header');
+            }
+            // Uncompressed size: 5 bits from control + 16 bits from next 2 bytes + 1
+            var uncompHigh = control & 0x1f;
+            var uncompSize2 = (uncompHigh << 16 | input[offset] << 8 | input[offset + 1]) + 1;
+            offset += 2;
+            // Compressed size: 16 bits + 1
+            var compSize = (input[offset] << 8 | input[offset + 1]) + 1;
+            offset += 2;
+            // If new properties, read 1-byte LZMA properties
+            if (newProps) {
+                if (offset >= input.length) {
+                    throw new Error('Truncated LZMA2 properties byte');
+                }
+                var propsByte = input[offset++];
+                // Properties byte: pb * 45 + lp * 9 + lc
+                // where pb, lp, lc are LZMA parameters
+                var lc = propsByte % 9;
+                var remainder = Math.floor(propsByte / 9);
+                var lp = remainder % 5;
+                var pb = Math.floor(remainder / 5);
+                if (!decoder.setLcLpPb(lc, lp, pb)) {
+                    throw new Error("Invalid LZMA properties: lc=".concat(lc, " lp=").concat(lp, " pb=").concat(pb));
+                }
+                propsSet = true;
+            }
+            if (!propsSet) {
+                throw new Error('LZMA chunk without properties');
+            }
+            if (offset + compSize > input.length) {
+                throw new Error('Truncated LZMA2 compressed data');
+            }
+            // Decode LZMA chunk
+            var inStream = (0, _streamsts.createInputStream)(input, offset, compSize);
+            var outStream = (0, _streamsts.createOutputStream)();
+            // Note: decoder.code() internally calls init() after setting streams
+            // For LZMA2, the decoder state is managed per-chunk through props resets
+            // Decode the chunk
+            var success = decoder.code(inStream, outStream, uncompSize2);
+            if (!success) {
+                throw new Error('LZMA decompression failed');
+            }
+            output.push(outStream.toBuffer());
+            offset += compSize;
+        } else {
+            throw new Error("Invalid LZMA2 control byte: 0x".concat(control.toString(16)));
+        }
+    }
+    return Buffer.concat(output);
+}
+function createLzma2Decoder(properties, unpackSize) {
+    return (0, _createBufferingDecoderts.default)(decodeLzma2, 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/Lzma2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/Lzma2.ts"],"sourcesContent":["// LZMA2 codec - wrapper around lzma-purejs for LZMA2 decompression\n// LZMA2 is a container format that wraps LZMA chunks with framing\n//\n// LZMA2 format specification:\n// https://github.com/ulikunitz/xz/blob/master/doc/LZMA2.md\n//\n// Control byte values:\n// 0x00         = End of stream\n// 0x01         = Uncompressed chunk, dictionary reset\n// 0x02         = Uncompressed chunk, no dictionary reset\n// 0x80-0xFF    = LZMA compressed chunk (bits encode reset flags and size)\n\n// Import lzma-purejs - provides raw LZMA decoder\nimport lzmajs from 'lzma-purejs';\nimport type { Transform } from 'readable-stream';\nimport createBufferingDecoder from './createBufferingDecoder.ts';\nimport { createInputStream, createOutputStream } from './streams.ts';\n\nvar LzmaDecoder = lzmajs.LZMA.Decoder;\n\n/**\n * Decode LZMA2 dictionary size from properties byte\n * Properties byte encodes dictionary size as: 2^(dictByte/2 + 12) or similar\n *\n * Per XZ spec, dictionary sizes are:\n * 0x00 = 4 KiB (2^12)\n * 0x01 = 6 KiB\n * 0x02 = 8 KiB (2^13)\n * ...\n * 0x28 = 1.5 GiB\n */\nfunction decodeDictionarySize(propByte: number): number {\n  if (propByte > 40) {\n    throw new Error(`Invalid LZMA2 dictionary size property: ${propByte}`);\n  }\n  if (propByte === 40) {\n    // Max dictionary size: 4 GiB - 1\n    return 0xffffffff;\n  }\n  // Dictionary size = 2 | (propByte & 1) << (propByte / 2 + 11)\n  var base = 2 | (propByte & 1);\n  var shift = Math.floor(propByte / 2) + 11;\n  return base << shift;\n}\n\n/**\n * Decode LZMA2 compressed data to buffer\n *\n * @param input - LZMA2 compressed data\n * @param properties - Properties buffer (1 byte: dictionary size)\n * @param _unpackSize - Unused (LZMA2 has internal size markers)\n * @returns Decompressed data\n */\nexport function decodeLzma2(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer {\n  if (!properties || properties.length < 1) {\n    throw new Error('LZMA2 requires properties byte');\n  }\n\n  var dictSize = decodeDictionarySize(properties[0]);\n  var output: Buffer[] = [];\n  var offset = 0;\n\n  // LZMA decoder instance - reused across chunks\n  var decoder = new LzmaDecoder();\n  decoder.setDictionarySize(dictSize);\n\n  // Track current LZMA properties (lc, lp, pb)\n  var propsSet = false;\n\n  while (offset < input.length) {\n    var control = input[offset++];\n\n    if (control === 0x00) {\n      // End of LZMA2 stream\n      break;\n    }\n\n    if (control === 0x01 || control === 0x02) {\n      // Uncompressed chunk\n      // 0x01 = dictionary reset + uncompressed\n      // 0x02 = uncompressed (no reset)\n      // Note: Dictionary reset (0x01) is handled implicitly since we don't\n      // maintain dictionary state across uncompressed chunks in this implementation\n\n      if (offset + 2 > input.length) {\n        throw new Error('Truncated LZMA2 uncompressed chunk header');\n      }\n\n      // Size is big-endian, 16-bit, value + 1\n      var uncompSize = ((input[offset] << 8) | input[offset + 1]) + 1;\n      offset += 2;\n\n      if (offset + uncompSize > input.length) {\n        throw new Error('Truncated LZMA2 uncompressed data');\n      }\n\n      // Copy uncompressed data\n      output.push(input.slice(offset, offset + uncompSize));\n      offset += uncompSize;\n    } else if (control >= 0x80) {\n      // LZMA compressed chunk\n      // Control byte format (bits 7-0):\n      // Bit 7: always 1 for LZMA chunk\n      // Bit 6: reset state\n      // Bit 5: new properties (implies state reset)\n      // Bits 4-0: high 5 bits of uncompressed size - 1\n\n      var newProps = (control & 0x20) !== 0;\n\n      if (offset + 4 > input.length) {\n        throw new Error('Truncated LZMA2 LZMA chunk header');\n      }\n\n      // Uncompressed size: 5 bits from control + 16 bits from next 2 bytes + 1\n      var uncompHigh = control & 0x1f;\n      var uncompSize2 = ((uncompHigh << 16) | (input[offset] << 8) | input[offset + 1]) + 1;\n      offset += 2;\n\n      // Compressed size: 16 bits + 1\n      var compSize = ((input[offset] << 8) | input[offset + 1]) + 1;\n      offset += 2;\n\n      // If new properties, read 1-byte LZMA properties\n      if (newProps) {\n        if (offset >= input.length) {\n          throw new Error('Truncated LZMA2 properties byte');\n        }\n        var propsByte = input[offset++];\n\n        // Properties byte: pb * 45 + lp * 9 + lc\n        // where pb, lp, lc are LZMA parameters\n        var lc = propsByte % 9;\n        var remainder = Math.floor(propsByte / 9);\n        var lp = remainder % 5;\n        var pb = Math.floor(remainder / 5);\n\n        if (!decoder.setLcLpPb(lc, lp, pb)) {\n          throw new Error(`Invalid LZMA properties: lc=${lc} lp=${lp} pb=${pb}`);\n        }\n        propsSet = true;\n      }\n\n      if (!propsSet) {\n        throw new Error('LZMA chunk without properties');\n      }\n\n      if (offset + compSize > input.length) {\n        throw new Error('Truncated LZMA2 compressed data');\n      }\n\n      // Decode LZMA chunk\n      var inStream = createInputStream(input, offset, compSize);\n      var outStream = createOutputStream();\n\n      // Note: decoder.code() internally calls init() after setting streams\n      // For LZMA2, the decoder state is managed per-chunk through props resets\n\n      // Decode the chunk\n      var success = decoder.code(inStream, outStream, uncompSize2);\n      if (!success) {\n        throw new Error('LZMA decompression failed');\n      }\n\n      output.push(outStream.toBuffer());\n      offset += compSize;\n    } else {\n      throw new Error(`Invalid LZMA2 control byte: 0x${control.toString(16)}`);\n    }\n  }\n\n  return Buffer.concat(output);\n}\n\n/**\n * Create an LZMA2 decoder Transform stream\n */\nexport function createLzma2Decoder(properties?: Buffer, unpackSize?: number): Transform {\n  return createBufferingDecoder(decodeLzma2, properties, unpackSize);\n}\n"],"names":["createLzma2Decoder","decodeLzma2","LzmaDecoder","lzmajs","LZMA","Decoder","decodeDictionarySize","propByte","Error","base","shift","Math","floor","input","properties","_unpackSize","length","dictSize","output","offset","decoder","setDictionarySize","propsSet","control","uncompSize","push","slice","newProps","uncompHigh","uncompSize2","compSize","propsByte","lc","remainder","lp","pb","setLcLpPb","inStream","createInputStream","outStream","createOutputStream","success","code","toBuffer","toString","Buffer","concat","unpackSize","createBufferingDecoder"],"mappings":"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"}

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

@@ -0,0 +1,7 @@
+import { Transform } from 'readable-stream';
+export type DecodeFn = (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;
+/**
+ * Create a Transform stream that buffers all input, then decodes in flush
+ * This is the common pattern for codecs that can't stream (need full input)
+ */
+export default function createBufferingDecoder(decodeFn: DecodeFn, properties?: Buffer, unpackSize?: number): Transform;

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

@@ -0,0 +1,7 @@
+import { Transform } from 'readable-stream';
+export type DecodeFn = (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;
+/**
+ * Create a Transform stream that buffers all input, then decodes in flush
+ * This is the common pattern for codecs that can't stream (need full input)
+ */
+export default function createBufferingDecoder(decodeFn: DecodeFn, properties?: Buffer, unpackSize?: number): Transform;

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

@@ -0,0 +1,36 @@
+// Helper to create a Transform stream that buffers all input before decoding
+// Used by codecs that need the full input before decompression (LZMA, LZMA2, BZip2, etc.)
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, /**
+ * Create a Transform stream that buffers all input, then decodes in flush
+ * This is the common pattern for codecs that can't stream (need full input)
+ */ "default", {
+    enumerable: true,
+    get: function() {
+        return createBufferingDecoder;
+    }
+});
+var _readablestream = require("readable-stream");
+function createBufferingDecoder(decodeFn, properties, unpackSize) {
+    var chunks = [];
+    return new _readablestream.Transform({
+        transform: function(chunk, _encoding, callback) {
+            chunks.push(chunk);
+            callback();
+        },
+        flush: function flush(callback) {
+            try {
+                var input = Buffer.concat(chunks);
+                var output = decodeFn(input, properties, unpackSize);
+                this.push(output);
+                callback();
+            } catch (err) {
+                callback(err);
+            }
+        }
+    });
+}
+/* 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/createBufferingDecoder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/createBufferingDecoder.ts"],"sourcesContent":["// Helper to create a Transform stream that buffers all input before decoding\n// Used by codecs that need the full input before decompression (LZMA, LZMA2, BZip2, etc.)\n\nimport { Transform, type TransformCallback } from 'readable-stream';\n\nexport type DecodeFn = (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;\n\n/**\n * Create a Transform stream that buffers all input, then decodes in flush\n * This is the common pattern for codecs that can't stream (need full input)\n */\nexport default function createBufferingDecoder(decodeFn: DecodeFn, properties?: Buffer, unpackSize?: number): Transform {\n  var chunks: Buffer[] = [];\n\n  return new Transform({\n    transform: (chunk: Buffer, _encoding: string, callback: TransformCallback) => {\n      chunks.push(chunk);\n      callback();\n    },\n    flush: function (callback: TransformCallback) {\n      try {\n        var input = Buffer.concat(chunks);\n        var output = decodeFn(input, properties, unpackSize);\n        this.push(output);\n        callback();\n      } catch (err) {\n        callback(err as Error);\n      }\n    },\n  });\n}\n"],"names":["createBufferingDecoder","decodeFn","properties","unpackSize","chunks","Transform","transform","chunk","_encoding","callback","push","flush","input","Buffer","concat","output","err"],"mappings":"AAAA,6EAA6E;AAC7E,0FAA0F;;;;;+BAM1F;;;CAGC,GACD;;;eAAwBA;;;8BAR0B;AAQnC,SAASA,uBAAuBC,QAAkB,EAAEC,UAAmB,EAAEC,UAAmB;IACzG,IAAIC,SAAmB,EAAE;IAEzB,OAAO,IAAIC,yBAAS,CAAC;QACnBC,WAAW,SAACC,OAAeC,WAAmBC;YAC5CL,OAAOM,IAAI,CAACH;YACZE;QACF;QACAE,OAAO,SAAPA,MAAiBF,QAA2B;YAC1C,IAAI;gBACF,IAAIG,QAAQC,OAAOC,MAAM,CAACV;gBAC1B,IAAIW,SAASd,SAASW,OAAOV,YAAYC;gBACzC,IAAI,CAACO,IAAI,CAACK;gBACVN;YACF,EAAE,OAAOO,KAAK;gBACZP,SAASO;YACX;QACF;IACF;AACF"}

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

@@ -0,0 +1,24 @@
+import type { Transform } from 'readable-stream';
+import { getPassword, setPassword } from './Aes.js';
+export { getPassword, setPassword };
+export interface Codec {
+    decode: (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;
+    createDecoder: (properties?: Buffer, unpackSize?: number) => Transform;
+}
+/**
+ * Register a codec
+ */
+export declare function registerCodec(id: number[], codec: Codec): void;
+/**
+ * Get a codec by ID
+ * @throws Error if codec is not supported
+ */
+export declare function getCodec(id: number[]): Codec;
+/**
+ * Check if a codec is supported
+ */
+export declare function isCodecSupported(id: number[]): boolean;
+/**
+ * Get human-readable codec name
+ */
+export declare function getCodecName(id: number[]): string;

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

@@ -0,0 +1,24 @@
+import type { Transform } from 'readable-stream';
+import { getPassword, setPassword } from './Aes.js';
+export { getPassword, setPassword };
+export interface Codec {
+    decode: (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;
+    createDecoder: (properties?: Buffer, unpackSize?: number) => Transform;
+}
+/**
+ * Register a codec
+ */
+export declare function registerCodec(id: number[], codec: Codec): void;
+/**
+ * Get a codec by ID
+ * @throws Error if codec is not supported
+ */
+export declare function getCodec(id: number[]): Codec;
+/**
+ * Check if a codec is supported
+ */
+export declare function isCodecSupported(id: number[]): boolean;
+/**
+ * Get human-readable codec name
+ */
+export declare function getCodecName(id: number[]): string;