7z-iterator 1.1.2 → 1.2.0

package/dist/esm/SevenZipIterator.js

@@ -37,7 +37,61 @@ let SevenZipIterator = class SevenZipIterator extends BaseIterator {
             lock.release();
         }
         // Don't call base end here - Lock.__destroy() handles it
-        this.iterator = null;
+        this._iterator = null;
+    }
+    /**
+   * Check if streaming extraction is available for any folder in this archive.
+   * Streaming is possible when folders use codecs like BZip2, Deflate, or Copy
+   * that can decompress incrementally without buffering the entire input.
+   *
+   * @returns true if at least one folder supports streaming
+   */ canStream() {
+        if (!this._iterator) return false;
+        const parser = this._iterator.getParser();
+        if (!parser) return false;
+        const entries = parser.getEntries();
+        const checkedFolders = {};
+        for(let i = 0; i < entries.length; i++){
+            const folderIndex = entries[i]._folderIndex;
+            if (folderIndex >= 0 && checkedFolders[folderIndex] === undefined) {
+                checkedFolders[folderIndex] = parser.canStreamFolder(folderIndex);
+                if (checkedFolders[folderIndex]) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+   * Get entries sorted for optimal streaming extraction.
+   *
+   * Entries are sorted by:
+   * 1. Folder index (process one folder at a time)
+   * 2. Stream index within folder (for solid block streaming)
+   *
+   * This ordering allows multi-file solid folders to stream with
+   * O(largest file) memory instead of O(folder size).
+   *
+   * @returns Array of entries in streaming order
+   */ getStreamingOrder() {
+        if (!this._iterator) return [];
+        const parser = this._iterator.getParser();
+        if (!parser) return [];
+        const entries = parser.getEntries();
+        // Create a copy and sort for streaming order
+        const sorted = [];
+        for(let i = 0; i < entries.length; i++){
+            sorted.push(entries[i]);
+        }
+        sorted.sort((a, b)=>{
+            // First by folder index
+            if (a._folderIndex !== b._folderIndex) {
+                return a._folderIndex - b._folderIndex;
+            }
+            // Then by stream index within folder
+            return a._streamIndexInFolder - b._streamIndexInFolder;
+        });
+        return sorted;
     }
     constructor(source, options = {}){
         super(options);
@@ -71,7 +125,7 @@ let SevenZipIterator = class SevenZipIterator extends BaseIterator {
                 });
             });
         } else {
-            // Stream input - use hybrid memory/temp-file approach
+            // Stream input - write to temp file for random access
             // Register cleanup for source stream
             const stream = source;
             this.lock.registerCleanup(()=>{
@@ -81,30 +135,23 @@ let SevenZipIterator = class SevenZipIterator extends BaseIterator {
             const tempPath = path.join(tmpdir(), '7z-iterator', shortHash(process.cwd()), tempSuffix('tmp.7z'));
             queue.defer((cb)=>{
                 streamToSource(source, {
-                    memoryThreshold: options.memoryThreshold,
-                    tempPath: tempPath
+                    tempPath
                 }, (err, result)=>{
                     if (this.done || cancelled) return;
                     if (err) return cb(err);
                     if (!result) return cb(new Error('No result from streamToSource'));
                     archiveSource = result.source;
-                    if (result.fd !== undefined) {
-                        const fd = result.fd;
-                        // Register cleanup for file descriptor
-                        this.lock.registerCleanup(()=>{
-                            fs.closeSync(fd);
-                        });
-                    }
-                    if (result.tempPath) {
-                        const tp = result.tempPath;
-                        // Register cleanup for temp file
-                        this.lock.registerCleanup(()=>{
-                            try {
-                                rmSync(tp);
-                            } catch (_e) {
-                            /* ignore */ }
-                        });
-                    }
+                    // Register cleanup for file descriptor
+                    this.lock.registerCleanup(()=>{
+                        fs.closeSync(result.fd);
+                    });
+                    // Register cleanup for temp file
+                    this.lock.registerCleanup(()=>{
+                        try {
+                            rmSync(result.tempPath);
+                        } catch (_e) {
+                        /* ignore */ }
+                    });
                     cb();
                 });
             });
@@ -116,7 +163,7 @@ let SevenZipIterator = class SevenZipIterator extends BaseIterator {
             try {
                 const parser = new SevenZipParser(archiveSource);
                 parser.parse();
-                this.iterator = new EntryIterator(parser);
+                this._iterator = new EntryIterator(parser);
                 cb();
             } catch (parseErr) {
                 cb(parseErr);

package/dist/esm/SevenZipIterator.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/SevenZipIterator.ts"],"sourcesContent":["import BaseIterator, { Lock } from 'extract-base-iterator';\nimport fs from 'fs';\nimport { rmSync } from 'fs-remove-compat';\nimport path from 'path';\nimport Queue from 'queue-cb';\nimport shortHash from 'short-hash';\nimport tempSuffix from 'temp-suffix';\nimport { tmpdir } from './compat.ts';\nimport streamToSource, { type SourceResult } from './lib/streamToSource.ts';\nimport nextEntry from './nextEntry.ts';\nimport { setPassword } from './sevenz/codecs/index.ts';\nimport { type ArchiveSource, FileSource, type SevenZipEntry, SevenZipParser } from './sevenz/SevenZipParser.ts';\n\nimport type { Entry, ExtractOptions, SevenZipFileIterator } from './types.ts';\n\n/**\n * Iterator wrapper around SevenZipParser entries\n */\nclass EntryIterator implements SevenZipFileIterator {\n  private parser: SevenZipParser;\n  private entries: SevenZipEntry[];\n  private index = 0;\n\n  constructor(parser: SevenZipParser) {\n    this.parser = parser;\n    this.entries = parser.getEntries();\n  }\n\n  next(): SevenZipEntry | null {\n    if (this.index >= this.entries.length) {\n      return null;\n    }\n    return this.entries[this.index++];\n  }\n\n  getParser(): SevenZipParser {\n    return this.parser;\n  }\n}\n\nexport default class SevenZipIterator extends BaseIterator<Entry> {\n  lock: Lock | null;\n  iterator: SevenZipFileIterator;\n\n  constructor(source: string | NodeJS.ReadableStream, options: ExtractOptions = {}) {\n    super(options);\n    this.lock = new Lock();\n    this.lock.onDestroy = (err) => BaseIterator.prototype.end.call(this, err);\n    const queue = new Queue(1);\n    let cancelled = false;\n    let archiveSource: ArchiveSource | null = null;\n    const setup = (): void => {\n      cancelled = true;\n    };\n    this.processing.push(setup);\n\n    // Set password (or clear if not provided)\n    setPassword(options.password || null);\n\n    if (typeof source === 'string') {\n      // File path input - use FileSource directly\n      queue.defer((cb: (err?: Error) => void) => {\n        fs.stat(source, (statErr, stats) => {\n          if (this.done || cancelled) return;\n          if (statErr) return cb(statErr);\n\n          fs.open(source, 'r', (err, fd) => {\n            if (this.done || cancelled) return;\n            if (err) return cb(err);\n\n            archiveSource = new FileSource(fd, stats.size);\n            // Register cleanup for file descriptor\n            this.lock.registerCleanup(() => {\n              fs.closeSync(fd);\n            });\n            cb();\n          });\n        });\n      });\n    } else {\n      // Stream input - use hybrid memory/temp-file approach\n      // Register cleanup for source stream\n      const stream = source as NodeJS.ReadableStream;\n      this.lock.registerCleanup(() => {\n        const s = stream as NodeJS.ReadableStream & { destroy?: () => void };\n        if (typeof s.destroy === 'function') s.destroy();\n      });\n\n      const tempPath = path.join(tmpdir(), '7z-iterator', shortHash(process.cwd()), tempSuffix('tmp.7z'));\n      queue.defer((cb: (err?: Error) => void) => {\n        streamToSource(\n          source,\n          {\n            memoryThreshold: options.memoryThreshold,\n            tempPath: tempPath,\n          },\n          (err?: Error, result?: SourceResult) => {\n            if (this.done || cancelled) return;\n            if (err) return cb(err);\n            if (!result) return cb(new Error('No result from streamToSource'));\n\n            archiveSource = result.source;\n            if (result.fd !== undefined) {\n              const fd = result.fd;\n              // Register cleanup for file descriptor\n              this.lock.registerCleanup(() => {\n                fs.closeSync(fd);\n              });\n            }\n            if (result.tempPath) {\n              const tp = result.tempPath;\n              // Register cleanup for temp file\n              this.lock.registerCleanup(() => {\n                try {\n                  rmSync(tp);\n                } catch (_e) {\n                  /* ignore */\n                }\n              });\n            }\n            cb();\n          }\n        );\n      });\n    }\n\n    // Parse and build iterator\n    queue.defer((cb: (err?: Error) => void) => {\n      if (this.done || cancelled) return;\n      if (!archiveSource) return cb(new Error('No archive source'));\n\n      try {\n        const parser = new SevenZipParser(archiveSource);\n        parser.parse();\n        this.iterator = new EntryIterator(parser);\n        cb();\n      } catch (parseErr) {\n        cb(parseErr as Error);\n      }\n    });\n\n    // start processing\n    queue.await((err?: Error) => {\n      this.processing.remove(setup);\n      if (this.done || cancelled) return;\n      err ? this.end(err) : this.push(nextEntry);\n    });\n  }\n\n  end(err?: Error) {\n    if (this.lock) {\n      const lock = this.lock;\n      this.lock = null; // Clear before release to prevent re-entrancy\n      lock.err = err;\n      lock.release();\n    }\n    // Don't call base end here - Lock.__destroy() handles it\n    this.iterator = null;\n  }\n}\n"],"names":["BaseIterator","Lock","fs","rmSync","path","Queue","shortHash","tempSuffix","tmpdir","streamToSource","nextEntry","setPassword","FileSource","SevenZipParser","EntryIterator","next","index","entries","length","getParser","parser","getEntries","SevenZipIterator","end","err","lock","release","iterator","source","options","onDestroy","prototype","call","queue","cancelled","archiveSource","setup","processing","push","password","defer","cb","stat","statErr","stats","done","open","fd","size","registerCleanup","closeSync","stream","s","destroy","tempPath","join","process","cwd","memoryThreshold","result","Error","undefined","tp","_e","parse","parseErr","await","remove"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/SevenZipIterator.ts"],"sourcesContent":["import BaseIterator, { Lock } from 'extract-base-iterator';\nimport fs from 'fs';\nimport { rmSync } from 'fs-remove-compat';\nimport path from 'path';\nimport Queue from 'queue-cb';\nimport shortHash from 'short-hash';\nimport tempSuffix from 'temp-suffix';\nimport { tmpdir } from './compat.ts';\nimport streamToSource, { type SourceResult } from './lib/streamToSource.ts';\nimport nextEntry from './nextEntry.ts';\nimport { setPassword } from './sevenz/codecs/index.ts';\nimport { type ArchiveSource, FileSource, type SevenZipEntry, SevenZipParser } from './sevenz/SevenZipParser.ts';\n\nimport type { Entry, ExtractOptions } from './types.ts';\n\n/**\n * Internal iterator interface for SevenZipParser entries\n * @internal\n */\ninterface SevenZipFileIterator {\n  next(): SevenZipEntry | null;\n  getParser(): SevenZipParser;\n}\n\n/**\n * Iterator wrapper around SevenZipParser entries\n */\nclass EntryIterator implements SevenZipFileIterator {\n  private parser: SevenZipParser;\n  private entries: SevenZipEntry[];\n  private index = 0;\n\n  constructor(parser: SevenZipParser) {\n    this.parser = parser;\n    this.entries = parser.getEntries();\n  }\n\n  next(): SevenZipEntry | null {\n    if (this.index >= this.entries.length) {\n      return null;\n    }\n    return this.entries[this.index++];\n  }\n\n  getParser(): SevenZipParser {\n    return this.parser;\n  }\n}\n\nexport default class SevenZipIterator extends BaseIterator<Entry> {\n  lock: Lock | null;\n  /** @internal - Do not use directly */\n  _iterator: unknown;\n\n  constructor(source: string | NodeJS.ReadableStream, options: ExtractOptions = {}) {\n    super(options);\n    this.lock = new Lock();\n    this.lock.onDestroy = (err) => BaseIterator.prototype.end.call(this, err);\n    const queue = new Queue(1);\n    let cancelled = false;\n    let archiveSource: ArchiveSource | null = null;\n    const setup = (): void => {\n      cancelled = true;\n    };\n    this.processing.push(setup);\n\n    // Set password (or clear if not provided)\n    setPassword(options.password || null);\n\n    if (typeof source === 'string') {\n      // File path input - use FileSource directly\n      queue.defer((cb: (err?: Error) => void) => {\n        fs.stat(source, (statErr, stats) => {\n          if (this.done || cancelled) return;\n          if (statErr) return cb(statErr);\n\n          fs.open(source, 'r', (err, fd) => {\n            if (this.done || cancelled) return;\n            if (err) return cb(err);\n\n            archiveSource = new FileSource(fd, stats.size);\n            // Register cleanup for file descriptor\n            this.lock.registerCleanup(() => {\n              fs.closeSync(fd);\n            });\n            cb();\n          });\n        });\n      });\n    } else {\n      // Stream input - write to temp file for random access\n      // Register cleanup for source stream\n      const stream = source as NodeJS.ReadableStream;\n      this.lock.registerCleanup(() => {\n        const s = stream as NodeJS.ReadableStream & { destroy?: () => void };\n        if (typeof s.destroy === 'function') s.destroy();\n      });\n\n      const tempPath = path.join(tmpdir(), '7z-iterator', shortHash(process.cwd()), tempSuffix('tmp.7z'));\n      queue.defer((cb: (err?: Error) => void) => {\n        streamToSource(source, { tempPath }, (err?: Error, result?: SourceResult) => {\n          if (this.done || cancelled) return;\n          if (err) return cb(err);\n          if (!result) return cb(new Error('No result from streamToSource'));\n\n          archiveSource = result.source;\n\n          // Register cleanup for file descriptor\n          this.lock.registerCleanup(() => {\n            fs.closeSync(result.fd);\n          });\n\n          // Register cleanup for temp file\n          this.lock.registerCleanup(() => {\n            try {\n              rmSync(result.tempPath);\n            } catch (_e) {\n              /* ignore */\n            }\n          });\n\n          cb();\n        });\n      });\n    }\n\n    // Parse and build iterator\n    queue.defer((cb: (err?: Error) => void) => {\n      if (this.done || cancelled) return;\n      if (!archiveSource) return cb(new Error('No archive source'));\n\n      try {\n        const parser = new SevenZipParser(archiveSource);\n        parser.parse();\n        this._iterator = new EntryIterator(parser);\n        cb();\n      } catch (parseErr) {\n        cb(parseErr as Error);\n      }\n    });\n\n    // start processing\n    queue.await((err?: Error) => {\n      this.processing.remove(setup);\n      if (this.done || cancelled) return;\n      err ? this.end(err) : this.push(nextEntry);\n    });\n  }\n\n  end(err?: Error) {\n    if (this.lock) {\n      const lock = this.lock;\n      this.lock = null; // Clear before release to prevent re-entrancy\n      lock.err = err;\n      lock.release();\n    }\n    // Don't call base end here - Lock.__destroy() handles it\n    this._iterator = null;\n  }\n\n  /**\n   * Check if streaming extraction is available for any folder in this archive.\n   * Streaming is possible when folders use codecs like BZip2, Deflate, or Copy\n   * that can decompress incrementally without buffering the entire input.\n   *\n   * @returns true if at least one folder supports streaming\n   */\n  canStream(): boolean {\n    if (!this._iterator) return false;\n    const parser = (this._iterator as SevenZipFileIterator).getParser();\n    if (!parser) return false;\n\n    const entries = parser.getEntries();\n    const checkedFolders: { [key: number]: boolean } = {};\n\n    for (let i = 0; i < entries.length; i++) {\n      const folderIndex = entries[i]._folderIndex;\n      if (folderIndex >= 0 && checkedFolders[folderIndex] === undefined) {\n        checkedFolders[folderIndex] = parser.canStreamFolder(folderIndex);\n        if (checkedFolders[folderIndex]) {\n          return true;\n        }\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * Get entries sorted for optimal streaming extraction.\n   *\n   * Entries are sorted by:\n   * 1. Folder index (process one folder at a time)\n   * 2. Stream index within folder (for solid block streaming)\n   *\n   * This ordering allows multi-file solid folders to stream with\n   * O(largest file) memory instead of O(folder size).\n   *\n   * @returns Array of entries in streaming order\n   */\n  getStreamingOrder(): SevenZipEntry[] {\n    if (!this._iterator) return [];\n    const parser = (this._iterator as SevenZipFileIterator).getParser();\n    if (!parser) return [];\n\n    const entries = parser.getEntries();\n\n    // Create a copy and sort for streaming order\n    const sorted: SevenZipEntry[] = [];\n    for (let i = 0; i < entries.length; i++) {\n      sorted.push(entries[i]);\n    }\n\n    sorted.sort((a, b) => {\n      // First by folder index\n      if (a._folderIndex !== b._folderIndex) {\n        return a._folderIndex - b._folderIndex;\n      }\n      // Then by stream index within folder\n      return a._streamIndexInFolder - b._streamIndexInFolder;\n    });\n\n    return sorted;\n  }\n}\n"],"names":["BaseIterator","Lock","fs","rmSync","path","Queue","shortHash","tempSuffix","tmpdir","streamToSource","nextEntry","setPassword","FileSource","SevenZipParser","EntryIterator","next","index","entries","length","getParser","parser","getEntries","SevenZipIterator","end","err","lock","release","_iterator","canStream","checkedFolders","i","folderIndex","_folderIndex","undefined","canStreamFolder","getStreamingOrder","sorted","push","sort","a","b","_streamIndexInFolder","source","options","onDestroy","prototype","call","queue","cancelled","archiveSource","setup","processing","password","defer","cb","stat","statErr","stats","done","open","fd","size","registerCleanup","closeSync","stream","s","destroy","tempPath","join","process","cwd","result","Error","_e","parse","parseErr","await","remove"],"mappings":"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"}

package/dist/esm/index.d.ts

@@ -1,4 +1,2 @@
 export { default } from './SevenZipIterator.js';
-export type { ArchiveSource, SevenZipEntry } from './sevenz/index.js';
-export { SevenZipParser } from './sevenz/index.js';
 export * from './types.js';

package/dist/esm/index.js

@@ -1,3 +1,2 @@
 export { default } from './SevenZipIterator.js';
-export { SevenZipParser } from './sevenz/index.js';
 export * from './types.js';

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/index.ts"],"sourcesContent":["export { default } from './SevenZipIterator.ts';\nexport type { ArchiveSource, SevenZipEntry } from './sevenz/index.ts';\nexport { SevenZipParser } from './sevenz/index.ts';\nexport * from './types.ts';\n"],"names":["default","SevenZipParser"],"mappings":"AAAA,SAASA,OAAO,QAAQ,wBAAwB;AAEhD,SAASC,cAAc,QAAQ,oBAAoB;AACnD,cAAc,aAAa"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/index.ts"],"sourcesContent":["export { default } from './SevenZipIterator.ts';\nexport * from './types.ts';\n"],"names":["default"],"mappings":"AAAA,SAASA,OAAO,QAAQ,wBAAwB;AAChD,cAAc,aAAa"}

package/dist/esm/lib/streamToSource.d.ts

@@ -1,20 +1,17 @@
-import { BufferSource, FileSource } from '../sevenz/SevenZipParser.js';
+import { FileSource } from '../sevenz/SevenZipParser.js';
 export interface StreamToSourceOptions {
-    memoryThreshold?: number;
-    tempPath?: string;
+    tempPath: string;
 }
 export interface SourceResult {
-    source: BufferSource | FileSource;
-    fd?: number;
-    tempPath?: string;
+    source: FileSource;
+    fd: number;
+    tempPath: string;
 }
 export type Callback = (error?: Error, result?: SourceResult) => void;
 /**
- * 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.
  */
 export default function streamToSource(stream: NodeJS.ReadableStream, options: StreamToSourceOptions, callback: Callback): void;

package/dist/esm/lib/streamToSource.js

@@ -1,91 +1,45 @@
-// 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
 import once from 'call-once-fn';
 import { bufferFrom } from 'extract-base-iterator';
 import fs from 'fs';
 import mkdirp from 'mkdirp-classic';
 import oo from 'on-one';
 import path from 'path';
-import { BufferSource, FileSource } from '../sevenz/SevenZipParser.js';
-// Default memory threshold: 100 MB
-const DEFAULT_MEMORY_THRESHOLD = 100 * 1024 * 1024;
+import { FileSource } from '../sevenz/SevenZipParser.js';
 /**
- * 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.
  */ export default function streamToSource(stream, options, callback) {
-    const threshold = options.memoryThreshold !== undefined ? options.memoryThreshold : DEFAULT_MEMORY_THRESHOLD;
     const tempPath = options.tempPath;
-    let chunks = [];
-    let totalSize = 0;
-    let writeStream = null;
-    let useTempFile = false;
     const end = once(callback);
+    mkdirp.sync(path.dirname(tempPath));
+    const writeStream = fs.createWriteStream(tempPath);
     function onData(chunk) {
-        // Convert string chunks to Buffer
         const buf = typeof chunk === 'string' ? 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;
-            }
-            mkdirp.sync(path.dirname(tempPath));
-            writeStream = fs.createWriteStream(tempPath);
-            // Write all buffered chunks to temp file
-            for(let 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
-            const filePath = tempPath; // Capture for closure
-            writeStream.end(()=>{
-                fs.open(filePath, 'r', (err, fd)=>{
-                    if (err) return end(err);
-                    fs.stat(filePath, (statErr, stats)=>{
-                        if (statErr) {
-                            fs.closeSync(fd);
-                            return end(statErr);
-                        }
-                        end(null, {
-                            source: new FileSource(fd, stats.size),
-                            fd: fd,
-                            tempPath: filePath
-                        });
+        writeStream.end(()=>{
+            fs.open(tempPath, 'r', (err, fd)=>{
+                if (err) return end(err);
+                fs.stat(tempPath, (statErr, stats)=>{
+                    if (statErr) {
+                        fs.closeSync(fd);
+                        return end(statErr);
+                    }
+                    end(null, {
+                        source: new FileSource(fd, stats.size),
+                        fd: fd,
+                        tempPath: tempPath
                     });
                 });
             });
-        } else {
-            // Use memory buffer
-            const fullBuffer = Buffer.concat(chunks);
-            end(null, {
-                source: new 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/esm/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":["once","bufferFrom","fs","mkdirp","oo","path","BufferSource","FileSource","DEFAULT_MEMORY_THRESHOLD","streamToSource","stream","options","callback","threshold","memoryThreshold","undefined","tempPath","chunks","totalSize","writeStream","useTempFile","end","onData","chunk","buf","length","push","Error","sync","dirname","createWriteStream","i","write","onEnd","filePath","open","err","fd","stat","statErr","stats","closeSync","source","size","fullBuffer","Buffer","concat","onError","on"],"mappings":"AAAA,wFAAwF;AACxF,OAAOA,UAAU,eAAe;AAChC,SAASC,UAAU,QAAQ,wBAAwB;AACnD,OAAOC,QAAQ,KAAK;AACpB,OAAOC,YAAY,iBAAiB;AACpC,OAAOC,QAAQ,SAAS;AACxB,OAAOC,UAAU,OAAO;AACxB,SAASC,YAAY,EAAEC,UAAU,QAAQ,8BAA8B;AAEvE,mCAAmC;AACnC,MAAMC,2BAA2B,MAAM,OAAO;AAe9C;;;;;;;CAOC,GACD,eAAe,SAASC,eAAeC,MAA6B,EAAEC,OAA8B,EAAEC,QAAkB;IACtH,MAAMC,YAAYF,QAAQG,eAAe,KAAKC,YAAYJ,QAAQG,eAAe,GAAGN;IACpF,MAAMQ,WAAWL,QAAQK,QAAQ;IAEjC,IAAIC,SAAmB,EAAE;IACzB,IAAIC,YAAY;IAChB,IAAIC,cAAqC;IACzC,IAAIC,cAAc;IAElB,MAAMC,MAAMrB,KAAKY;IAEjB,SAASU,OAAOC,KAAsB;QACpC,kCAAkC;QAClC,MAAMC,MAAM,OAAOD,UAAU,WAAWtB,WAAWsB,SAASA;QAC5DL,aAAaM,IAAIC,MAAM;QAEvB,IAAI,CAACL,eAAeF,aAAaL,WAAW;YAC1C,2CAA2C;YAC3CI,OAAOS,IAAI,CAACF;QACd,OAAO,IAAI,CAACJ,aAAa;YACvB,gDAAgD;YAChDA,cAAc;YAEd,IAAI,CAACJ,UAAU;gBACbK,IAAI,IAAIM,MAAM;gBACd;YACF;YAEAxB,OAAOyB,IAAI,CAACvB,KAAKwB,OAAO,CAACb;YACzBG,cAAcjB,GAAG4B,iBAAiB,CAACd;YAEnC,yCAAyC;YACzC,IAAK,IAAIe,IAAI,GAAGA,IAAId,OAAOQ,MAAM,EAAEM,IAAK;gBACtCZ,YAAYa,KAAK,CAACf,MAAM,CAACc,EAAE;YAC7B;YACAd,SAAS,EAAE,EAAE,WAAW;YAExB,sBAAsB;YACtBE,YAAYa,KAAK,CAACR;QACpB,OAAO;YACL,2CAA2C;YAC3C,IAAIL,aAAa;gBACfA,YAAYa,KAAK,CAACR;YACpB;QACF;IACF;IAEA,SAASS;QACP,IAAIb,eAAeD,eAAeH,UAAU;YAC1C,4CAA4C;YAC5C,MAAMkB,WAAWlB,UAAU,sBAAsB;YACjDG,YAAYE,GAAG,CAAC;gBACdnB,GAAGiC,IAAI,CAACD,UAAU,KAAK,CAACE,KAAKC;oBAC3B,IAAID,KAAK,OAAOf,IAAIe;oBACpBlC,GAAGoC,IAAI,CAACJ,UAAU,CAACK,SAASC;wBAC1B,IAAID,SAAS;4BACXrC,GAAGuC,SAAS,CAACJ;4BACb,OAAOhB,IAAIkB;wBACb;wBACAlB,IAAI,MAAM;4BACRqB,QAAQ,IAAInC,WAAW8B,IAAIG,MAAMG,IAAI;4BACrCN,IAAIA;4BACJrB,UAAUkB;wBACZ;oBACF;gBACF;YACF;QACF,OAAO;YACL,oBAAoB;YACpB,MAAMU,aAAaC,OAAOC,MAAM,CAAC7B;YACjCI,IAAI,MAAM;gBACRqB,QAAQ,IAAIpC,aAAasC;YAC3B;QACF;IACF;IAEA,SAASG,QAAQX,GAAU;QACzB,qCAAqC;QACrC,IAAIjB,aAAa;YACfA,YAAYE,GAAG;QACjB;QACAA,IAAIe;IACN;IAEA1B,OAAOsC,EAAE,CAAC,QAAQ1B;IAClBlB,GAAGM,QAAQ;QAAC;KAAQ,EAAEqC;IACtB3C,GAAGM,QAAQ;QAAC;QAAO;QAAS;KAAS,EAAEuB;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":["once","bufferFrom","fs","mkdirp","oo","path","FileSource","streamToSource","stream","options","callback","tempPath","end","sync","dirname","writeStream","createWriteStream","onData","chunk","buf","write","onEnd","open","err","fd","stat","statErr","stats","closeSync","source","size","onError","on"],"mappings":"AAAA,4EAA4E;AAC5E,OAAOA,UAAU,eAAe;AAChC,SAASC,UAAU,QAAQ,wBAAwB;AACnD,OAAOC,QAAQ,KAAK;AACpB,OAAOC,YAAY,iBAAiB;AACpC,OAAOC,QAAQ,SAAS;AACxB,OAAOC,UAAU,OAAO;AACxB,SAASC,UAAU,QAAQ,8BAA8B;AAczD;;;;;CAKC,GACD,eAAe,SAASC,eAAeC,MAA6B,EAAEC,OAA8B,EAAEC,QAAkB;IACtH,MAAMC,WAAWF,QAAQE,QAAQ;IAEjC,MAAMC,MAAMZ,KAAKU;IAEjBP,OAAOU,IAAI,CAACR,KAAKS,OAAO,CAACH;IACzB,MAAMI,cAAcb,GAAGc,iBAAiB,CAACL;IAEzC,SAASM,OAAOC,KAAsB;QACpC,MAAMC,MAAM,OAAOD,UAAU,WAAWjB,WAAWiB,SAASA;QAC5DH,YAAYK,KAAK,CAACD;IACpB;IAEA,SAASE;QACPN,YAAYH,GAAG,CAAC;YACdV,GAAGoB,IAAI,CAACX,UAAU,KAAK,CAACY,KAAKC;gBAC3B,IAAID,KAAK,OAAOX,IAAIW;gBACpBrB,GAAGuB,IAAI,CAACd,UAAU,CAACe,SAASC;oBAC1B,IAAID,SAAS;wBACXxB,GAAG0B,SAAS,CAACJ;wBACb,OAAOZ,IAAIc;oBACb;oBACAd,IAAI,MAAM;wBACRiB,QAAQ,IAAIvB,WAAWkB,IAAIG,MAAMG,IAAI;wBACrCN,IAAIA;wBACJb,UAAUA;oBACZ;gBACF;YACF;QACF;IACF;IAEA,SAASoB,QAAQR,GAAU;QACzBR,YAAYH,GAAG;QACfA,IAAIW;IACN;IAEAf,OAAOwB,EAAE,CAAC,QAAQf;IAClBb,GAAGI,QAAQ;QAAC;KAAQ,EAAEuB;IACtB3B,GAAGI,QAAQ;QAAC;QAAO;QAAS;KAAS,EAAEa;AACzC"}

package/dist/esm/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/esm/lzma/Lzma2ChunkParser.js

@@ -0,0 +1,137 @@
+/**
+ * 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
+ */ /**
+ * 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 function parseLzma2ChunkHeader(input, offset) {
+    if (offset >= input.length) {
+        return {
+            success: false,
+            needBytes: 1
+        };
+    }
+    const 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)
+            };
+        }
+        const 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,
+                compSize: 0
+            }
+        };
+    }
+    // LZMA compressed chunk
+    if (control >= 0x80) {
+        const hasNewProps = control >= 0xc0;
+        const 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
+        const uncompHigh = control & 0x1f;
+        const uncompSize = (uncompHigh << 16 | input[offset + 1] << 8 | input[offset + 2]) + 1;
+        const compSize = (input[offset + 3] << 8 | input[offset + 4]) + 1;
+        // Parse properties if present
+        let newProps = null;
+        if (hasNewProps) {
+            const propsByte = input[offset + 5];
+            const lc = propsByte % 9;
+            const remainder = ~~(propsByte / 9);
+            const lp = remainder % 5;
+            const pb = ~~(remainder / 5);
+            newProps = {
+                lc,
+                lp,
+                pb
+            };
+        }
+        return {
+            success: true,
+            chunk: {
+                type: 'lzma',
+                headerSize: minHeaderSize,
+                dictReset: control >= 0xe0,
+                stateReset: control >= 0xa0,
+                newProps,
+                uncompSize,
+                compSize
+            }
+        };
+    }
+    // Invalid control byte
+    throw new Error(`Invalid LZMA2 control byte: 0x${control.toString(16)}`);
+}
+/**
+ * Check if we have enough data for the complete chunk (header + data)
+ */ export function hasCompleteChunk(input, offset) {
+    const result = parseLzma2ChunkHeader(input, offset);
+    if (result.success === false) {
+        return {
+            success: false,
+            needBytes: result.needBytes
+        };
+    }
+    const { chunk } = result;
+    const dataSize = chunk.type === 'uncompressed' ? chunk.uncompSize : chunk.compSize;
+    const totalSize = chunk.headerSize + dataSize;
+    if (offset + totalSize > input.length) {
+        return {
+            success: false,
+            needBytes: totalSize - (input.length - offset)
+        };
+    }
+    return {
+        success: true,
+        chunk,
+        totalSize
+    };
+}

package/dist/esm/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":["parseLzma2ChunkHeader","input","offset","length","success","needBytes","control","chunk","type","headerSize","dictReset","stateReset","newProps","uncompSize","compSize","hasNewProps","minHeaderSize","uncompHigh","propsByte","lc","remainder","lp","pb","Error","toString","hasCompleteChunk","result","dataSize","totalSize"],"mappings":"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"}

package/dist/esm/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/esm/lzma/index.js

@@ -0,0 +1,15 @@
+/**
+ * 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)
+export { createLzma2Decoder, createLzmaDecoder } from './stream/transforms.js';
+export { decodeLzma2, Lzma2Decoder } from './sync/Lzma2Decoder.js';
+// Synchronous decoders (for Buffer input)
+export { decodeLzma, LzmaDecoder } from './sync/LzmaDecoder.js';
+export { BitTreeDecoder, RangeDecoder } from './sync/RangeDecoder.js';
+// Type exports
+export * from './types.js';

package/dist/esm/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":["createLzma2Decoder","createLzmaDecoder","decodeLzma2","Lzma2Decoder","decodeLzma","LzmaDecoder","BitTreeDecoder","RangeDecoder"],"mappings":"AAAA;;;;;;;CAOC,GAED,yCAAyC;AACzC,SAASA,kBAAkB,EAAEC,iBAAiB,QAAQ,yBAAyB;AAC/E,SAASC,WAAW,EAAEC,YAAY,QAAQ,yBAAyB;AACnE,0CAA0C;AAC1C,SAASC,UAAU,EAAEC,WAAW,QAAQ,wBAAwB;AAChE,SAASC,cAAc,EAAEC,YAAY,QAAQ,yBAAyB;AACtE,eAAe;AACf,cAAc,aAAa"}