7z-iterator 1.1.2 → 1.2.0

package/dist/cjs/lib/streamToSource.js

@@ -1,15 +1,13 @@
-// Hybrid stream handling: buffers in memory up to threshold, then switches to temp file
+// Stream to source conversion: writes stream to temp file for random access
 "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
 Object.defineProperty(exports, /**
- * Convert a stream to an ArchiveSource (BufferSource for small files, FileSource for large)
+ * Convert a stream to a FileSource by writing to temp file
  *
- * Algorithm:
- * 1. Buffer stream data in memory up to memoryThreshold
- * 2. If threshold exceeded, write all buffered data to temp file and continue streaming
- * 3. When done, return BufferSource for memory buffer or FileSource for temp file
+ * 7z format requires random access for header parsing, so temp file is necessary for streams.
+ * Writes directly to temp file for predictable O(1) memory usage during stream consumption.
  */ "default", {
     enumerable: true,
     get: function() {
@@ -28,79 +26,35 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
-// Default memory threshold: 100 MB
-var DEFAULT_MEMORY_THRESHOLD = 100 * 1024 * 1024;
 function streamToSource(stream, options, callback) {
-    var threshold = options.memoryThreshold !== undefined ? options.memoryThreshold : DEFAULT_MEMORY_THRESHOLD;
     var tempPath = options.tempPath;
-    var chunks = [];
-    var totalSize = 0;
-    var writeStream = null;
-    var useTempFile = false;
     var end = (0, _calloncefn.default)(callback);
+    _mkdirpclassic.default.sync(_path.default.dirname(tempPath));
+    var writeStream = _fs.default.createWriteStream(tempPath);
     function onData(chunk) {
-        // Convert string chunks to Buffer
         var buf = typeof chunk === 'string' ? (0, _extractbaseiterator.bufferFrom)(chunk) : chunk;
-        totalSize += buf.length;
-        if (!useTempFile && totalSize <= threshold) {
-            // Still under threshold - buffer in memory
-            chunks.push(buf);
-        } else if (!useTempFile) {
-            // Just exceeded threshold - switch to temp file
-            useTempFile = true;
-            if (!tempPath) {
-                end(new Error('memoryThreshold exceeded but no tempPath provided'));
-                return;
-            }
-            _mkdirpclassic.default.sync(_path.default.dirname(tempPath));
-            writeStream = _fs.default.createWriteStream(tempPath);
-            // Write all buffered chunks to temp file
-            for(var i = 0; i < chunks.length; i++){
-                writeStream.write(chunks[i]);
-            }
-            chunks = []; // Allow GC
-            // Write current chunk
-            writeStream.write(buf);
-        } else {
-            // Already using temp file - write directly
-            if (writeStream) {
-                writeStream.write(buf);
-            }
-        }
+        writeStream.write(buf);
     }
     function onEnd() {
-        if (useTempFile && writeStream && tempPath) {
-            // Close write stream, then open for reading
-            var filePath = tempPath; // Capture for closure
-            writeStream.end(function() {
-                _fs.default.open(filePath, 'r', function(err, fd) {
-                    if (err) return end(err);
-                    _fs.default.stat(filePath, function(statErr, stats) {
-                        if (statErr) {
-                            _fs.default.closeSync(fd);
-                            return end(statErr);
-                        }
-                        end(null, {
-                            source: new _SevenZipParserts.FileSource(fd, stats.size),
-                            fd: fd,
-                            tempPath: filePath
-                        });
+        writeStream.end(function() {
+            _fs.default.open(tempPath, 'r', function(err, fd) {
+                if (err) return end(err);
+                _fs.default.stat(tempPath, function(statErr, stats) {
+                    if (statErr) {
+                        _fs.default.closeSync(fd);
+                        return end(statErr);
+                    }
+                    end(null, {
+                        source: new _SevenZipParserts.FileSource(fd, stats.size),
+                        fd: fd,
+                        tempPath: tempPath
                     });
                 });
             });
-        } else {
-            // Use memory buffer
-            var fullBuffer = Buffer.concat(chunks);
-            end(null, {
-                source: new _SevenZipParserts.BufferSource(fullBuffer)
-            });
-        }
+        });
     }
     function onError(err) {
-        // Clean up if we created a temp file
-        if (writeStream) {
-            writeStream.end();
-        }
+        writeStream.end();
         end(err);
     }
     stream.on('data', onData);

package/dist/cjs/lib/streamToSource.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/lib/streamToSource.ts"],"sourcesContent":["// Hybrid stream handling: buffers in memory up to threshold, then switches to temp file\nimport once from 'call-once-fn';\nimport { bufferFrom } from 'extract-base-iterator';\nimport fs from 'fs';\nimport mkdirp from 'mkdirp-classic';\nimport oo from 'on-one';\nimport path from 'path';\nimport { BufferSource, FileSource } from '../sevenz/SevenZipParser.ts';\n\n// Default memory threshold: 100 MB\nconst DEFAULT_MEMORY_THRESHOLD = 100 * 1024 * 1024;\n\nexport interface StreamToSourceOptions {\n  memoryThreshold?: number;\n  tempPath?: string;\n}\n\nexport interface SourceResult {\n  source: BufferSource | FileSource;\n  fd?: number; // Set if FileSource was used (caller must close)\n  tempPath?: string; // Set if temp file was created (caller must clean up)\n}\n\nexport type Callback = (error?: Error, result?: SourceResult) => void;\n\n/**\n * Convert a stream to an ArchiveSource (BufferSource for small files, FileSource for large)\n *\n * Algorithm:\n * 1. Buffer stream data in memory up to memoryThreshold\n * 2. If threshold exceeded, write all buffered data to temp file and continue streaming\n * 3. When done, return BufferSource for memory buffer or FileSource for temp file\n */\nexport default function streamToSource(stream: NodeJS.ReadableStream, options: StreamToSourceOptions, callback: Callback): void {\n  const threshold = options.memoryThreshold !== undefined ? options.memoryThreshold : DEFAULT_MEMORY_THRESHOLD;\n  const tempPath = options.tempPath;\n\n  let chunks: Buffer[] = [];\n  let totalSize = 0;\n  let writeStream: fs.WriteStream | null = null;\n  let useTempFile = false;\n\n  const end = once(callback);\n\n  function onData(chunk: Buffer | string): void {\n    // Convert string chunks to Buffer\n    const buf = typeof chunk === 'string' ? bufferFrom(chunk) : chunk;\n    totalSize += buf.length;\n\n    if (!useTempFile && totalSize <= threshold) {\n      // Still under threshold - buffer in memory\n      chunks.push(buf);\n    } else if (!useTempFile) {\n      // Just exceeded threshold - switch to temp file\n      useTempFile = true;\n\n      if (!tempPath) {\n        end(new Error('memoryThreshold exceeded but no tempPath provided'));\n        return;\n      }\n\n      mkdirp.sync(path.dirname(tempPath));\n      writeStream = fs.createWriteStream(tempPath);\n\n      // Write all buffered chunks to temp file\n      for (let i = 0; i < chunks.length; i++) {\n        writeStream.write(chunks[i]);\n      }\n      chunks = []; // Allow GC\n\n      // Write current chunk\n      writeStream.write(buf);\n    } else {\n      // Already using temp file - write directly\n      if (writeStream) {\n        writeStream.write(buf);\n      }\n    }\n  }\n\n  function onEnd(): void {\n    if (useTempFile && writeStream && tempPath) {\n      // Close write stream, then open for reading\n      const filePath = tempPath; // Capture for closure\n      writeStream.end(() => {\n        fs.open(filePath, 'r', (err, fd) => {\n          if (err) return end(err);\n          fs.stat(filePath, (statErr, stats) => {\n            if (statErr) {\n              fs.closeSync(fd);\n              return end(statErr);\n            }\n            end(null, {\n              source: new FileSource(fd, stats.size),\n              fd: fd,\n              tempPath: filePath,\n            });\n          });\n        });\n      });\n    } else {\n      // Use memory buffer\n      const fullBuffer = Buffer.concat(chunks);\n      end(null, {\n        source: new BufferSource(fullBuffer),\n      });\n    }\n  }\n\n  function onError(err: Error): void {\n    // Clean up if we created a temp file\n    if (writeStream) {\n      writeStream.end();\n    }\n    end(err);\n  }\n\n  stream.on('data', onData);\n  oo(stream, ['error'], onError);\n  oo(stream, ['end', 'close', 'finish'], onEnd);\n}\n"],"names":["streamToSource","DEFAULT_MEMORY_THRESHOLD","stream","options","callback","threshold","memoryThreshold","undefined","tempPath","chunks","totalSize","writeStream","useTempFile","end","once","onData","chunk","buf","bufferFrom","length","push","Error","mkdirp","sync","path","dirname","fs","createWriteStream","i","write","onEnd","filePath","open","err","fd","stat","statErr","stats","closeSync","source","FileSource","size","fullBuffer","Buffer","concat","BufferSource","onError","on","oo"],"mappings":"AAAA,wFAAwF;;;;;+BAyBxF;;;;;;;CAOC,GACD;;;eAAwBA;;;iEAhCP;mCACU;yDACZ;oEACI;4DACJ;2DACE;gCACwB;;;;;;AAEzC,mCAAmC;AACnC,IAAMC,2BAA2B,MAAM,OAAO;AAuB/B,SAASD,eAAeE,MAA6B,EAAEC,OAA8B,EAAEC,QAAkB;IACtH,IAAMC,YAAYF,QAAQG,eAAe,KAAKC,YAAYJ,QAAQG,eAAe,GAAGL;IACpF,IAAMO,WAAWL,QAAQK,QAAQ;IAEjC,IAAIC,SAAmB,EAAE;IACzB,IAAIC,YAAY;IAChB,IAAIC,cAAqC;IACzC,IAAIC,cAAc;IAElB,IAAMC,MAAMC,IAAAA,mBAAI,EAACV;IAEjB,SAASW,OAAOC,KAAsB;QACpC,kCAAkC;QAClC,IAAMC,MAAM,OAAOD,UAAU,WAAWE,IAAAA,+BAAU,EAACF,SAASA;QAC5DN,aAAaO,IAAIE,MAAM;QAEvB,IAAI,CAACP,eAAeF,aAAaL,WAAW;YAC1C,2CAA2C;YAC3CI,OAAOW,IAAI,CAACH;QACd,OAAO,IAAI,CAACL,aAAa;YACvB,gDAAgD;YAChDA,cAAc;YAEd,IAAI,CAACJ,UAAU;gBACbK,IAAI,IAAIQ,MAAM;gBACd;YACF;YAEAC,sBAAM,CAACC,IAAI,CAACC,aAAI,CAACC,OAAO,CAACjB;YACzBG,cAAce,WAAE,CAACC,iBAAiB,CAACnB;YAEnC,yCAAyC;YACzC,IAAK,IAAIoB,IAAI,GAAGA,IAAInB,OAAOU,MAAM,EAAES,IAAK;gBACtCjB,YAAYkB,KAAK,CAACpB,MAAM,CAACmB,EAAE;YAC7B;YACAnB,SAAS,EAAE,EAAE,WAAW;YAExB,sBAAsB;YACtBE,YAAYkB,KAAK,CAACZ;QACpB,OAAO;YACL,2CAA2C;YAC3C,IAAIN,aAAa;gBACfA,YAAYkB,KAAK,CAACZ;YACpB;QACF;IACF;IAEA,SAASa;QACP,IAAIlB,eAAeD,eAAeH,UAAU;YAC1C,4CAA4C;YAC5C,IAAMuB,WAAWvB,UAAU,sBAAsB;YACjDG,YAAYE,GAAG,CAAC;gBACda,WAAE,CAACM,IAAI,CAACD,UAAU,KAAK,SAACE,KAAKC;oBAC3B,IAAID,KAAK,OAAOpB,IAAIoB;oBACpBP,WAAE,CAACS,IAAI,CAACJ,UAAU,SAACK,SAASC;wBAC1B,IAAID,SAAS;4BACXV,WAAE,CAACY,SAAS,CAACJ;4BACb,OAAOrB,IAAIuB;wBACb;wBACAvB,IAAI,MAAM;4BACR0B,QAAQ,IAAIC,4BAAU,CAACN,IAAIG,MAAMI,IAAI;4BACrCP,IAAIA;4BACJ1B,UAAUuB;wBACZ;oBACF;gBACF;YACF;QACF,OAAO;YACL,oBAAoB;YACpB,IAAMW,aAAaC,OAAOC,MAAM,CAACnC;YACjCI,IAAI,MAAM;gBACR0B,QAAQ,IAAIM,8BAAY,CAACH;YAC3B;QACF;IACF;IAEA,SAASI,QAAQb,GAAU;QACzB,qCAAqC;QACrC,IAAItB,aAAa;YACfA,YAAYE,GAAG;QACjB;QACAA,IAAIoB;IACN;IAEA/B,OAAO6C,EAAE,CAAC,QAAQhC;IAClBiC,IAAAA,cAAE,EAAC9C,QAAQ;QAAC;KAAQ,EAAE4C;IACtBE,IAAAA,cAAE,EAAC9C,QAAQ;QAAC;QAAO;QAAS;KAAS,EAAE4B;AACzC"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/lib/streamToSource.ts"],"sourcesContent":["// Stream to source conversion: writes stream to temp file for random access\nimport once from 'call-once-fn';\nimport { bufferFrom } from 'extract-base-iterator';\nimport fs from 'fs';\nimport mkdirp from 'mkdirp-classic';\nimport oo from 'on-one';\nimport path from 'path';\nimport { FileSource } from '../sevenz/SevenZipParser.ts';\n\nexport interface StreamToSourceOptions {\n  tempPath: string;\n}\n\nexport interface SourceResult {\n  source: FileSource;\n  fd: number; // Caller must close\n  tempPath: string; // Caller must clean up\n}\n\nexport type Callback = (error?: Error, result?: SourceResult) => void;\n\n/**\n * Convert a stream to a FileSource by writing to temp file\n *\n * 7z format requires random access for header parsing, so temp file is necessary for streams.\n * Writes directly to temp file for predictable O(1) memory usage during stream consumption.\n */\nexport default function streamToSource(stream: NodeJS.ReadableStream, options: StreamToSourceOptions, callback: Callback): void {\n  const tempPath = options.tempPath;\n\n  const end = once(callback);\n\n  mkdirp.sync(path.dirname(tempPath));\n  const writeStream = fs.createWriteStream(tempPath);\n\n  function onData(chunk: Buffer | string): void {\n    const buf = typeof chunk === 'string' ? bufferFrom(chunk) : chunk;\n    writeStream.write(buf);\n  }\n\n  function onEnd(): void {\n    writeStream.end(() => {\n      fs.open(tempPath, 'r', (err, fd) => {\n        if (err) return end(err);\n        fs.stat(tempPath, (statErr, stats) => {\n          if (statErr) {\n            fs.closeSync(fd);\n            return end(statErr);\n          }\n          end(null, {\n            source: new FileSource(fd, stats.size),\n            fd: fd,\n            tempPath: tempPath,\n          });\n        });\n      });\n    });\n  }\n\n  function onError(err: Error): void {\n    writeStream.end();\n    end(err);\n  }\n\n  stream.on('data', onData);\n  oo(stream, ['error'], onError);\n  oo(stream, ['end', 'close', 'finish'], onEnd);\n}\n"],"names":["streamToSource","stream","options","callback","tempPath","end","once","mkdirp","sync","path","dirname","writeStream","fs","createWriteStream","onData","chunk","buf","bufferFrom","write","onEnd","open","err","fd","stat","statErr","stats","closeSync","source","FileSource","size","onError","on","oo"],"mappings":"AAAA,4EAA4E;;;;;+BAqB5E;;;;;CAKC,GACD;;;eAAwBA;;;iEA1BP;mCACU;yDACZ;oEACI;4DACJ;2DACE;gCACU;;;;;;AAoBZ,SAASA,eAAeC,MAA6B,EAAEC,OAA8B,EAAEC,QAAkB;IACtH,IAAMC,WAAWF,QAAQE,QAAQ;IAEjC,IAAMC,MAAMC,IAAAA,mBAAI,EAACH;IAEjBI,sBAAM,CAACC,IAAI,CAACC,aAAI,CAACC,OAAO,CAACN;IACzB,IAAMO,cAAcC,WAAE,CAACC,iBAAiB,CAACT;IAEzC,SAASU,OAAOC,KAAsB;QACpC,IAAMC,MAAM,OAAOD,UAAU,WAAWE,IAAAA,+BAAU,EAACF,SAASA;QAC5DJ,YAAYO,KAAK,CAACF;IACpB;IAEA,SAASG;QACPR,YAAYN,GAAG,CAAC;YACdO,WAAE,CAACQ,IAAI,CAAChB,UAAU,KAAK,SAACiB,KAAKC;gBAC3B,IAAID,KAAK,OAAOhB,IAAIgB;gBACpBT,WAAE,CAACW,IAAI,CAACnB,UAAU,SAACoB,SAASC;oBAC1B,IAAID,SAAS;wBACXZ,WAAE,CAACc,SAAS,CAACJ;wBACb,OAAOjB,IAAImB;oBACb;oBACAnB,IAAI,MAAM;wBACRsB,QAAQ,IAAIC,4BAAU,CAACN,IAAIG,MAAMI,IAAI;wBACrCP,IAAIA;wBACJlB,UAAUA;oBACZ;gBACF;YACF;QACF;IACF;IAEA,SAAS0B,QAAQT,GAAU;QACzBV,YAAYN,GAAG;QACfA,IAAIgB;IACN;IAEApB,OAAO8B,EAAE,CAAC,QAAQjB;IAClBkB,IAAAA,cAAE,EAAC/B,QAAQ;QAAC;KAAQ,EAAE6B;IACtBE,IAAAA,cAAE,EAAC/B,QAAQ;QAAC;QAAO;QAAS;KAAS,EAAEkB;AACzC"}

package/dist/cjs/lzma/Lzma2ChunkParser.d.cts

@@ -0,0 +1,73 @@
+/**
+ * LZMA2 Chunk Parser
+ *
+ * Shared parsing logic for LZMA2 chunk headers.
+ * Used by both synchronous and streaming decoders.
+ *
+ * LZMA2 control byte ranges:
+ * 0x00         = End of stream
+ * 0x01         = Uncompressed chunk, dictionary reset
+ * 0x02         = Uncompressed chunk, no dictionary reset
+ * 0x80-0x9F    = LZMA chunk, no reset (solid mode)
+ * 0xA0-0xBF    = LZMA chunk, reset state (probabilities)
+ * 0xC0-0xDF    = LZMA chunk, reset state + new properties
+ * 0xE0-0xFF    = LZMA chunk, reset dictionary + state + new properties
+ */
+/**
+ * LZMA properties extracted from chunk header
+ */
+export interface LzmaChunkProps {
+    lc: number;
+    lp: number;
+    pb: number;
+}
+/**
+ * Parsed LZMA2 chunk information
+ */
+export interface Lzma2Chunk {
+    /** Chunk type */
+    type: 'end' | 'uncompressed' | 'lzma';
+    /** Total bytes consumed by header (including control byte) */
+    headerSize: number;
+    /** Whether to reset dictionary */
+    dictReset: boolean;
+    /** Whether to reset state/probabilities */
+    stateReset: boolean;
+    /** New LZMA properties (only for control >= 0xC0) */
+    newProps: LzmaChunkProps | null;
+    /** Uncompressed data size */
+    uncompSize: number;
+    /** Compressed data size (0 for uncompressed chunks) */
+    compSize: number;
+}
+/**
+ * Result of parsing attempt
+ */
+export type ParseResult = {
+    success: true;
+    chunk: Lzma2Chunk;
+} | {
+    success: false;
+    needBytes: number;
+};
+/**
+ * Parse an LZMA2 chunk header
+ *
+ * @param input - Input buffer
+ * @param offset - Offset to start parsing
+ * @returns Parsed chunk info or number of bytes needed
+ */
+export declare function parseLzma2ChunkHeader(input: Buffer, offset: number): ParseResult;
+/** Result type for hasCompleteChunk with totalSize included on success */
+export type CompleteChunkResult = {
+    success: true;
+    chunk: Lzma2Chunk;
+    totalSize: number;
+} | {
+    success: false;
+    needBytes: number;
+};
+/**
+ * Check if we have enough data for the complete chunk (header + data)
+ */
+export declare function hasCompleteChunk(input: Buffer, offset: number): CompleteChunkResult;

package/dist/cjs/lzma/Lzma2ChunkParser.d.ts

@@ -0,0 +1,73 @@
+/**
+ * LZMA2 Chunk Parser
+ *
+ * Shared parsing logic for LZMA2 chunk headers.
+ * Used by both synchronous and streaming decoders.
+ *
+ * LZMA2 control byte ranges:
+ * 0x00         = End of stream
+ * 0x01         = Uncompressed chunk, dictionary reset
+ * 0x02         = Uncompressed chunk, no dictionary reset
+ * 0x80-0x9F    = LZMA chunk, no reset (solid mode)
+ * 0xA0-0xBF    = LZMA chunk, reset state (probabilities)
+ * 0xC0-0xDF    = LZMA chunk, reset state + new properties
+ * 0xE0-0xFF    = LZMA chunk, reset dictionary + state + new properties
+ */
+/**
+ * LZMA properties extracted from chunk header
+ */
+export interface LzmaChunkProps {
+    lc: number;
+    lp: number;
+    pb: number;
+}
+/**
+ * Parsed LZMA2 chunk information
+ */
+export interface Lzma2Chunk {
+    /** Chunk type */
+    type: 'end' | 'uncompressed' | 'lzma';
+    /** Total bytes consumed by header (including control byte) */
+    headerSize: number;
+    /** Whether to reset dictionary */
+    dictReset: boolean;
+    /** Whether to reset state/probabilities */
+    stateReset: boolean;
+    /** New LZMA properties (only for control >= 0xC0) */
+    newProps: LzmaChunkProps | null;
+    /** Uncompressed data size */
+    uncompSize: number;
+    /** Compressed data size (0 for uncompressed chunks) */
+    compSize: number;
+}
+/**
+ * Result of parsing attempt
+ */
+export type ParseResult = {
+    success: true;
+    chunk: Lzma2Chunk;
+} | {
+    success: false;
+    needBytes: number;
+};
+/**
+ * Parse an LZMA2 chunk header
+ *
+ * @param input - Input buffer
+ * @param offset - Offset to start parsing
+ * @returns Parsed chunk info or number of bytes needed
+ */
+export declare function parseLzma2ChunkHeader(input: Buffer, offset: number): ParseResult;
+/** Result type for hasCompleteChunk with totalSize included on success */
+export type CompleteChunkResult = {
+    success: true;
+    chunk: Lzma2Chunk;
+    totalSize: number;
+} | {
+    success: false;
+    needBytes: number;
+};
+/**
+ * Check if we have enough data for the complete chunk (header + data)
+ */
+export declare function hasCompleteChunk(input: Buffer, offset: number): CompleteChunkResult;

package/dist/cjs/lzma/Lzma2ChunkParser.js

@@ -0,0 +1,148 @@
+/**
+ * LZMA2 Chunk Parser
+ *
+ * Shared parsing logic for LZMA2 chunk headers.
+ * Used by both synchronous and streaming decoders.
+ *
+ * LZMA2 control byte ranges:
+ * 0x00         = End of stream
+ * 0x01         = Uncompressed chunk, dictionary reset
+ * 0x02         = Uncompressed chunk, no dictionary reset
+ * 0x80-0x9F    = LZMA chunk, no reset (solid mode)
+ * 0xA0-0xBF    = LZMA chunk, reset state (probabilities)
+ * 0xC0-0xDF    = LZMA chunk, reset state + new properties
+ * 0xE0-0xFF    = LZMA chunk, reset dictionary + state + new properties
+ */ /**
+ * LZMA properties extracted from chunk header
+ */ "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 hasCompleteChunk () {
+        return hasCompleteChunk;
+    },
+    get parseLzma2ChunkHeader () {
+        return parseLzma2ChunkHeader;
+    }
+});
+function parseLzma2ChunkHeader(input, offset) {
+    if (offset >= input.length) {
+        return {
+            success: false,
+            needBytes: 1
+        };
+    }
+    var control = input[offset];
+    // End of stream
+    if (control === 0x00) {
+        return {
+            success: true,
+            chunk: {
+                type: 'end',
+                headerSize: 1,
+                dictReset: false,
+                stateReset: false,
+                newProps: null,
+                uncompSize: 0,
+                compSize: 0
+            }
+        };
+    }
+    // Uncompressed chunk
+    if (control === 0x01 || control === 0x02) {
+        // Need 3 bytes: control + 2 size bytes
+        if (offset + 3 > input.length) {
+            return {
+                success: false,
+                needBytes: 3 - (input.length - offset)
+            };
+        }
+        var uncompSize = (input[offset + 1] << 8 | input[offset + 2]) + 1;
+        return {
+            success: true,
+            chunk: {
+                type: 'uncompressed',
+                headerSize: 3,
+                dictReset: control === 0x01,
+                stateReset: false,
+                newProps: null,
+                uncompSize: uncompSize,
+                compSize: 0
+            }
+        };
+    }
+    // LZMA compressed chunk
+    if (control >= 0x80) {
+        var hasNewProps = control >= 0xc0;
+        var minHeaderSize = hasNewProps ? 6 : 5; // control + 2 uncomp + 2 comp + (1 props)
+        if (offset + minHeaderSize > input.length) {
+            return {
+                success: false,
+                needBytes: minHeaderSize - (input.length - offset)
+            };
+        }
+        // Parse sizes
+        var uncompHigh = control & 0x1f;
+        var uncompSize1 = (uncompHigh << 16 | input[offset + 1] << 8 | input[offset + 2]) + 1;
+        var compSize = (input[offset + 3] << 8 | input[offset + 4]) + 1;
+        // Parse properties if present
+        var newProps = null;
+        if (hasNewProps) {
+            var propsByte = input[offset + 5];
+            var lc = propsByte % 9;
+            var remainder = ~~(propsByte / 9);
+            var lp = remainder % 5;
+            var pb = ~~(remainder / 5);
+            newProps = {
+                lc: lc,
+                lp: lp,
+                pb: pb
+            };
+        }
+        return {
+            success: true,
+            chunk: {
+                type: 'lzma',
+                headerSize: minHeaderSize,
+                dictReset: control >= 0xe0,
+                stateReset: control >= 0xa0,
+                newProps: newProps,
+                uncompSize: uncompSize1,
+                compSize: compSize
+            }
+        };
+    }
+    // Invalid control byte
+    throw new Error("Invalid LZMA2 control byte: 0x".concat(control.toString(16)));
+}
+function hasCompleteChunk(input, offset) {
+    var result = parseLzma2ChunkHeader(input, offset);
+    if (result.success === false) {
+        return {
+            success: false,
+            needBytes: result.needBytes
+        };
+    }
+    var chunk = result.chunk;
+    var dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;
+    var totalSize = chunk.headerSize + dataSize;
+    if (offset + totalSize > input.length) {
+        return {
+            success: false,
+            needBytes: totalSize - (input.length - offset)
+        };
+    }
+    return {
+        success: true,
+        chunk: chunk,
+        totalSize: totalSize
+    };
+}
+/* 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/lzma/Lzma2ChunkParser.js.map

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

package/dist/cjs/lzma/index.d.cts

@@ -0,0 +1,13 @@
+/**
+ * LZMA Decoder Module
+ *
+ * Provides both synchronous and streaming LZMA1/LZMA2 decoders.
+ *
+ * Synchronous API: Use when input is a complete Buffer
+ * Streaming API: Use with Transform streams for memory-efficient decompression
+ */
+export { createLzma2Decoder, createLzmaDecoder } from './stream/transforms.js';
+export { decodeLzma2, Lzma2Decoder } from './sync/Lzma2Decoder.js';
+export { decodeLzma, LzmaDecoder } from './sync/LzmaDecoder.js';
+export { BitTreeDecoder, RangeDecoder } from './sync/RangeDecoder.js';
+export * from './types.js';

package/dist/cjs/lzma/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * LZMA Decoder Module
+ *
+ * Provides both synchronous and streaming LZMA1/LZMA2 decoders.
+ *
+ * Synchronous API: Use when input is a complete Buffer
+ * Streaming API: Use with Transform streams for memory-efficient decompression
+ */
+export { createLzma2Decoder, createLzmaDecoder } from './stream/transforms.js';
+export { decodeLzma2, Lzma2Decoder } from './sync/Lzma2Decoder.js';
+export { decodeLzma, LzmaDecoder } from './sync/LzmaDecoder.js';
+export { BitTreeDecoder, RangeDecoder } from './sync/RangeDecoder.js';
+export * from './types.js';

package/dist/cjs/lzma/index.js

@@ -0,0 +1,63 @@
+/**
+ * LZMA Decoder Module
+ *
+ * Provides both synchronous and streaming LZMA1/LZMA2 decoders.
+ *
+ * Synchronous API: Use when input is a complete Buffer
+ * Streaming API: Use with Transform streams for memory-efficient decompression
+ */ // Streaming decoders (Transform streams)
+"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 BitTreeDecoder () {
+        return _RangeDecoderts.BitTreeDecoder;
+    },
+    get Lzma2Decoder () {
+        return _Lzma2Decoderts.Lzma2Decoder;
+    },
+    get LzmaDecoder () {
+        return _LzmaDecoderts.LzmaDecoder;
+    },
+    get RangeDecoder () {
+        return _RangeDecoderts.RangeDecoder;
+    },
+    get createLzma2Decoder () {
+        return _transformsts.createLzma2Decoder;
+    },
+    get createLzmaDecoder () {
+        return _transformsts.createLzmaDecoder;
+    },
+    get decodeLzma () {
+        return _LzmaDecoderts.decodeLzma;
+    },
+    get decodeLzma2 () {
+        return _Lzma2Decoderts.decodeLzma2;
+    }
+});
+var _transformsts = require("./stream/transforms.js");
+var _Lzma2Decoderts = require("./sync/Lzma2Decoder.js");
+var _LzmaDecoderts = require("./sync/LzmaDecoder.js");
+var _RangeDecoderts = require("./sync/RangeDecoder.js");
+_export_star(require("./types.js"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+/* 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/lzma/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/lzma/index.ts"],"sourcesContent":["/**\n * LZMA Decoder Module\n *\n * Provides both synchronous and streaming LZMA1/LZMA2 decoders.\n *\n * Synchronous API: Use when input is a complete Buffer\n * Streaming API: Use with Transform streams for memory-efficient decompression\n */\n\n// Streaming decoders (Transform streams)\nexport { createLzma2Decoder, createLzmaDecoder } from './stream/transforms.ts';\nexport { decodeLzma2, Lzma2Decoder } from './sync/Lzma2Decoder.ts';\n// Synchronous decoders (for Buffer input)\nexport { decodeLzma, LzmaDecoder } from './sync/LzmaDecoder.ts';\nexport { BitTreeDecoder, RangeDecoder } from './sync/RangeDecoder.ts';\n// Type exports\nexport * from './types.ts';\n"],"names":["BitTreeDecoder","Lzma2Decoder","LzmaDecoder","RangeDecoder","createLzma2Decoder","createLzmaDecoder","decodeLzma","decodeLzma2"],"mappings":"AAAA;;;;;;;CAOC,GAED,yCAAyC;;;;;;;;;;;;QAKhCA;eAAAA,8BAAc;;QAHDC;eAAAA,4BAAY;;QAEbC;eAAAA,0BAAW;;QACPC;eAAAA,4BAAY;;QAJ5BC;eAAAA,gCAAkB;;QAAEC;eAAAA,+BAAiB;;QAGrCC;eAAAA,yBAAU;;QAFVC;eAAAA,2BAAW;;;4BADkC;8BACZ;6BAEF;8BACK;qBAE/B"}

package/dist/cjs/lzma/stream/transforms.d.cts

@@ -0,0 +1,38 @@
+/**
+ * LZMA Transform Stream Wrappers
+ *
+ * Provides Transform streams for LZMA1 and LZMA2 decompression.
+ *
+ * LZMA2 streaming works by buffering until a complete chunk is available,
+ * then decoding synchronously. LZMA2 chunks are bounded in size (~2MB max
+ * uncompressed), so memory usage is predictable and bounded.
+ *
+ * True byte-by-byte async LZMA streaming would require rewriting the entire
+ * decoder with continuation-passing style, which is complex and not worth
+ * the effort given LZMA2's chunked format.
+ */
+import { Transform } from 'extract-base-iterator';
+/**
+ * Create an LZMA2 decoder Transform stream
+ *
+ * This is a streaming decoder that processes LZMA2 chunks incrementally.
+ * Memory usage is O(dictionary_size + max_chunk_size) instead of O(folder_size).
+ *
+ * @param properties - 1-byte LZMA2 properties (dictionary size)
+ * @returns Transform stream that decompresses LZMA2 data
+ */
+export declare function createLzma2Decoder(properties: Buffer | Uint8Array): InstanceType<typeof Transform>;
+/**
+ * Create an LZMA1 decoder Transform stream
+ *
+ * Note: LZMA1 has no chunk boundaries, so this requires knowing the
+ * uncompressed size upfront. The stream buffers all input, then
+ * decompresses when complete.
+ *
+ * For true streaming, use LZMA2 which has built-in chunking.
+ *
+ * @param properties - 5-byte LZMA properties
+ * @param unpackSize - Expected uncompressed size
+ * @returns Transform stream that decompresses LZMA1 data
+ */
+export declare function createLzmaDecoder(properties: Buffer | Uint8Array, unpackSize: number): InstanceType<typeof Transform>;

package/dist/cjs/lzma/stream/transforms.d.ts

@@ -0,0 +1,38 @@
+/**
+ * LZMA Transform Stream Wrappers
+ *
+ * Provides Transform streams for LZMA1 and LZMA2 decompression.
+ *
+ * LZMA2 streaming works by buffering until a complete chunk is available,
+ * then decoding synchronously. LZMA2 chunks are bounded in size (~2MB max
+ * uncompressed), so memory usage is predictable and bounded.
+ *
+ * True byte-by-byte async LZMA streaming would require rewriting the entire
+ * decoder with continuation-passing style, which is complex and not worth
+ * the effort given LZMA2's chunked format.
+ */
+import { Transform } from 'extract-base-iterator';
+/**
+ * Create an LZMA2 decoder Transform stream
+ *
+ * This is a streaming decoder that processes LZMA2 chunks incrementally.
+ * Memory usage is O(dictionary_size + max_chunk_size) instead of O(folder_size).
+ *
+ * @param properties - 1-byte LZMA2 properties (dictionary size)
+ * @returns Transform stream that decompresses LZMA2 data
+ */
+export declare function createLzma2Decoder(properties: Buffer | Uint8Array): InstanceType<typeof Transform>;
+/**
+ * Create an LZMA1 decoder Transform stream
+ *
+ * Note: LZMA1 has no chunk boundaries, so this requires knowing the
+ * uncompressed size upfront. The stream buffers all input, then
+ * decompresses when complete.
+ *
+ * For true streaming, use LZMA2 which has built-in chunking.
+ *
+ * @param properties - 5-byte LZMA properties
+ * @param unpackSize - Expected uncompressed size
+ * @returns Transform stream that decompresses LZMA1 data
+ */
+export declare function createLzmaDecoder(properties: Buffer | Uint8Array, unpackSize: number): InstanceType<typeof Transform>;