7z-iterator 0.1.7 → 0.1.9

package/assets/lzma-purejs/lib/LZMA/Decoder.js

@@ -79,23 +79,29 @@ LiteralDecoder.prototype.create = function(numPosBits, numPrevBits){
   this._numPosBits = numPosBits;
   this._posMask = (1 << numPosBits) - 1;
   this._numPrevBits = numPrevBits;
+  // Lazy allocation: only create coders array, allocate individual coders on demand
+  // This saves significant memory for archives that don't use all coder slots
   this._coders = [];
-  var count = 1 << (this._numPrevBits + this._numPosBits);
-  for (var i = 0; i < count; i++){
-    this._coders[i] = new LiteralDecoder.Decoder2();
-  }
+  this._coderCount = 1 << (this._numPrevBits + this._numPosBits);
 };
 
 LiteralDecoder.prototype.init = function(){
-  var count = 1 << (this._numPrevBits + this._numPosBits);
-  for (var i = 0; i < count; i++){
-    this._coders[i].init();
+  // Only init coders that have been allocated (lazy allocation support)
+  for (var i = 0; i < this._coders.length; i++){
+    if (this._coders[i]) {
+      this._coders[i].init();
+    }
   }
 };
 
 LiteralDecoder.prototype.getDecoder = function(pos, prevByte){
-  return this._coders[((pos & this._posMask) << this._numPrevBits) +
-                      ((prevByte & 0xff) >>> (8 - this._numPrevBits))];
+  var index = ((pos & this._posMask) << this._numPrevBits) +
+              ((prevByte & 0xff) >>> (8 - this._numPrevBits));
+  // Lazy allocation: create coder on first access
+  if (!this._coders[index]) {
+    this._coders[index] = new LiteralDecoder.Decoder2();
+  }
+  return this._coders[index];
 };
 
 var Decoder = function(){

package/assets/lzma-purejs/lib/makeBuffer.js

@@ -1,7 +1,18 @@
 'use strict';
 
 // Node 0.8 compatible buffer allocation
+// Note: For OutWindow, zero-fill is not required since we write before reading.
+// Using allocUnsafe/uninitialized buffer saves significant memory and time.
 var makeBuffer = function(len) {
+  if (Buffer.allocUnsafe) {
+    return Buffer.allocUnsafe(len);
+  }
+  // Node 0.8 fallback - new Buffer() is uninitialized (fast)
+  return new Buffer(len);
+};
+
+// Safe version that zero-fills (use when buffer may be read before written)
+makeBuffer.safe = function(len) {
   if (Buffer.alloc) {
     return Buffer.alloc(len);
   }

package/dist/cjs/FileEntry.js

@@ -118,20 +118,20 @@ var SevenZipFileEntry = /*#__PURE__*/ function(FileEntry) {
             callback(new Error('7z FileEntry missing entry. Check for calling create multiple times'));
             return;
         }
-        try {
-            var stream = this.parser.getEntryStream(this.entry);
+        // Use callback-based async decompression
+        this.parser.getEntryStreamAsync(this.entry, function(err, stream) {
+            if (err) return callback(err);
+            if (!stream) return callback(new Error('No stream returned'));
             var res = stream.pipe(_fs.default.createWriteStream(fullPath));
             (0, _onone.default)(res, [
                 'error',
                 'end',
                 'close',
                 'finish'
-            ], function(err) {
-                err ? callback(err) : (0, _extractbaseiterator.waitForAccess)(fullPath, callback);
+            ], function(writeErr) {
+                writeErr ? callback(writeErr) : (0, _extractbaseiterator.waitForAccess)(fullPath, callback);
             });
-        } catch (err) {
-            callback(err);
-        }
+        });
     };
     _proto.destroy = function destroy() {
         _extractbaseiterator.FileEntry.prototype.destroy.call(this);

package/dist/cjs/FileEntry.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/FileEntry.ts"],"sourcesContent":["import { type FileAttributes, FileEntry, type NoParamCallback, waitForAccess } from 'extract-base-iterator';\nimport fs from 'fs';\nimport oo from 'on-one';\nimport type { SevenZipEntry, SevenZipParser } from './sevenz/SevenZipParser.ts';\nimport type { ExtractOptions, LockT } from './types.ts';\n\nexport default class SevenZipFileEntry extends FileEntry {\n  private lock: LockT;\n  private entry: SevenZipEntry;\n  private parser: SevenZipParser;\n\n  constructor(attributes: FileAttributes, entry: SevenZipEntry, parser: SevenZipParser, lock: LockT) {\n    super(attributes);\n    this.entry = entry;\n    this.parser = parser;\n    this.lock = lock;\n    this.lock.retain();\n  }\n\n  create(dest: string, options: ExtractOptions | NoParamCallback, callback: NoParamCallback): undefined | Promise<boolean> {\n    if (typeof options === 'function') {\n      callback = options;\n      options = null;\n    }\n\n    if (typeof callback === 'function') {\n      options = options || {};\n      return FileEntry.prototype.create.call(this, dest, options, (err?: Error) => {\n        callback(err);\n        if (this.lock) {\n          this.lock.release();\n          this.lock = null;\n        }\n      });\n    }\n    return new Promise((resolve, reject) => {\n      this.create(dest, options, (err?: Error, done?: boolean) => {\n        err ? reject(err) : resolve(done);\n      });\n    });\n  }\n\n  _writeFile(fullPath: string, _options: ExtractOptions, callback: NoParamCallback): undefined {\n    if (!this.entry || !this.parser) {\n      callback(new Error('7z FileEntry missing entry. Check for calling create multiple times'));\n      return;\n    }\n\n    try {\n      var stream = this.parser.getEntryStream(this.entry);\n      var res = stream.pipe(fs.createWriteStream(fullPath));\n      oo(res, ['error', 'end', 'close', 'finish'], (err?: Error) => {\n        err ? callback(err) : waitForAccess(fullPath, callback);\n      });\n    } catch (err) {\n      callback(err);\n    }\n  }\n\n  destroy() {\n    FileEntry.prototype.destroy.call(this);\n    this.entry = null;\n    this.parser = null;\n    if (this.lock) {\n      this.lock.release();\n      this.lock = null;\n    }\n  }\n}\n"],"names":["SevenZipFileEntry","attributes","entry","parser","lock","retain","create","dest","options","callback","FileEntry","prototype","call","err","release","Promise","resolve","reject","done","_writeFile","fullPath","_options","Error","stream","getEntryStream","res","pipe","fs","createWriteStream","oo","waitForAccess","destroy"],"mappings":";;;;;;;eAMqBA;;;mCAN+D;yDACrE;4DACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,IAAA,AAAMA,kCAAN;;cAAMA;aAAAA,kBAKPC,UAA0B,EAAEC,KAAoB,EAAEC,MAAsB,EAAEC,IAAW;gCAL9EJ;;gBAMjB,kBANiBA;YAMXC;;QACN,MAAKC,KAAK,GAAGA;QACb,MAAKC,MAAM,GAAGA;QACd,MAAKC,IAAI,GAAGA;QACZ,MAAKA,IAAI,CAACC,MAAM;;;iBAVCL;IAanBM,OAAAA,MAqBC,GArBDA,SAAAA,OAAOC,IAAY,EAAEC,OAAyC,EAAEC,QAAyB;;QACvF,IAAI,OAAOD,YAAY,YAAY;YACjCC,WAAWD;YACXA,UAAU;QACZ;QAEA,IAAI,OAAOC,aAAa,YAAY;YAClCD,UAAUA,WAAW,CAAC;YACtB,OAAOE,8BAAS,CAACC,SAAS,CAACL,MAAM,CAACM,IAAI,CAAC,IAAI,EAAEL,MAAMC,SAAS,SAACK;gBAC3DJ,SAASI;gBACT,IAAI,MAAKT,IAAI,EAAE;oBACb,MAAKA,IAAI,CAACU,OAAO;oBACjB,MAAKV,IAAI,GAAG;gBACd;YACF;QACF;QACA,OAAO,IAAIW,QAAQ,SAACC,SAASC;YAC3B,MAAKX,MAAM,CAACC,MAAMC,SAAS,SAACK,KAAaK;gBACvCL,MAAMI,OAAOJ,OAAOG,QAAQE;YAC9B;QACF;IACF;IAEAC,OAAAA,UAeC,GAfDA,SAAAA,WAAWC,QAAgB,EAAEC,QAAwB,EAAEZ,QAAyB;QAC9E,IAAI,CAAC,IAAI,CAACP,KAAK,IAAI,CAAC,IAAI,CAACC,MAAM,EAAE;YAC/BM,SAAS,IAAIa,MAAM;YACnB;QACF;QAEA,IAAI;YACF,IAAIC,SAAS,IAAI,CAACpB,MAAM,CAACqB,cAAc,CAAC,IAAI,CAACtB,KAAK;YAClD,IAAIuB,MAAMF,OAAOG,IAAI,CAACC,WAAE,CAACC,iBAAiB,CAACR;YAC3CS,IAAAA,cAAE,EAACJ,KAAK;gBAAC;gBAAS;gBAAO;gBAAS;aAAS,EAAE,SAACZ;gBAC5CA,MAAMJ,SAASI,OAAOiB,IAAAA,kCAAa,EAACV,UAAUX;YAChD;QACF,EAAE,OAAOI,KAAK;YACZJ,SAASI;QACX;IACF;IAEAkB,OAAAA,OAQC,GARDA,SAAAA;QACErB,8BAAS,CAACC,SAAS,CAACoB,OAAO,CAACnB,IAAI,CAAC,IAAI;QACrC,IAAI,CAACV,KAAK,GAAG;QACb,IAAI,CAACC,MAAM,GAAG;QACd,IAAI,IAAI,CAACC,IAAI,EAAE;YACb,IAAI,CAACA,IAAI,CAACU,OAAO;YACjB,IAAI,CAACV,IAAI,GAAG;QACd;IACF;WA7DmBJ;EAA0BU,8BAAS"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/FileEntry.ts"],"sourcesContent":["import { type FileAttributes, FileEntry, type NoParamCallback, waitForAccess } from 'extract-base-iterator';\nimport fs from 'fs';\nimport oo from 'on-one';\nimport type { SevenZipEntry, SevenZipParser } from './sevenz/SevenZipParser.ts';\nimport type { ExtractOptions, LockT } from './types.ts';\n\nexport default class SevenZipFileEntry extends FileEntry {\n  private lock: LockT;\n  private entry: SevenZipEntry;\n  private parser: SevenZipParser;\n\n  constructor(attributes: FileAttributes, entry: SevenZipEntry, parser: SevenZipParser, lock: LockT) {\n    super(attributes);\n    this.entry = entry;\n    this.parser = parser;\n    this.lock = lock;\n    this.lock.retain();\n  }\n\n  create(dest: string, options: ExtractOptions | NoParamCallback, callback: NoParamCallback): undefined | Promise<boolean> {\n    if (typeof options === 'function') {\n      callback = options;\n      options = null;\n    }\n\n    if (typeof callback === 'function') {\n      options = options || {};\n      return FileEntry.prototype.create.call(this, dest, options, (err?: Error) => {\n        callback(err);\n        if (this.lock) {\n          this.lock.release();\n          this.lock = null;\n        }\n      });\n    }\n    return new Promise((resolve, reject) => {\n      this.create(dest, options, (err?: Error, done?: boolean) => {\n        err ? reject(err) : resolve(done);\n      });\n    });\n  }\n\n  _writeFile(fullPath: string, _options: ExtractOptions, callback: NoParamCallback): undefined {\n    if (!this.entry || !this.parser) {\n      callback(new Error('7z FileEntry missing entry. Check for calling create multiple times'));\n      return;\n    }\n\n    // Use callback-based async decompression\n    this.parser.getEntryStreamAsync(this.entry, (err, stream) => {\n      if (err) return callback(err);\n      if (!stream) return callback(new Error('No stream returned'));\n\n      var res = stream.pipe(fs.createWriteStream(fullPath));\n      oo(res, ['error', 'end', 'close', 'finish'], (writeErr?: Error) => {\n        writeErr ? callback(writeErr) : waitForAccess(fullPath, callback);\n      });\n    });\n  }\n\n  destroy() {\n    FileEntry.prototype.destroy.call(this);\n    this.entry = null;\n    this.parser = null;\n    if (this.lock) {\n      this.lock.release();\n      this.lock = null;\n    }\n  }\n}\n"],"names":["SevenZipFileEntry","attributes","entry","parser","lock","retain","create","dest","options","callback","FileEntry","prototype","call","err","release","Promise","resolve","reject","done","_writeFile","fullPath","_options","Error","getEntryStreamAsync","stream","res","pipe","fs","createWriteStream","oo","writeErr","waitForAccess","destroy"],"mappings":";;;;;;;eAMqBA;;;mCAN+D;yDACrE;4DACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,IAAA,AAAMA,kCAAN;;cAAMA;aAAAA,kBAKPC,UAA0B,EAAEC,KAAoB,EAAEC,MAAsB,EAAEC,IAAW;gCAL9EJ;;gBAMjB,kBANiBA;YAMXC;;QACN,MAAKC,KAAK,GAAGA;QACb,MAAKC,MAAM,GAAGA;QACd,MAAKC,IAAI,GAAGA;QACZ,MAAKA,IAAI,CAACC,MAAM;;;iBAVCL;IAanBM,OAAAA,MAqBC,GArBDA,SAAAA,OAAOC,IAAY,EAAEC,OAAyC,EAAEC,QAAyB;;QACvF,IAAI,OAAOD,YAAY,YAAY;YACjCC,WAAWD;YACXA,UAAU;QACZ;QAEA,IAAI,OAAOC,aAAa,YAAY;YAClCD,UAAUA,WAAW,CAAC;YACtB,OAAOE,8BAAS,CAACC,SAAS,CAACL,MAAM,CAACM,IAAI,CAAC,IAAI,EAAEL,MAAMC,SAAS,SAACK;gBAC3DJ,SAASI;gBACT,IAAI,MAAKT,IAAI,EAAE;oBACb,MAAKA,IAAI,CAACU,OAAO;oBACjB,MAAKV,IAAI,GAAG;gBACd;YACF;QACF;QACA,OAAO,IAAIW,QAAQ,SAACC,SAASC;YAC3B,MAAKX,MAAM,CAACC,MAAMC,SAAS,SAACK,KAAaK;gBACvCL,MAAMI,OAAOJ,OAAOG,QAAQE;YAC9B;QACF;IACF;IAEAC,OAAAA,UAgBC,GAhBDA,SAAAA,WAAWC,QAAgB,EAAEC,QAAwB,EAAEZ,QAAyB;QAC9E,IAAI,CAAC,IAAI,CAACP,KAAK,IAAI,CAAC,IAAI,CAACC,MAAM,EAAE;YAC/BM,SAAS,IAAIa,MAAM;YACnB;QACF;QAEA,yCAAyC;QACzC,IAAI,CAACnB,MAAM,CAACoB,mBAAmB,CAAC,IAAI,CAACrB,KAAK,EAAE,SAACW,KAAKW;YAChD,IAAIX,KAAK,OAAOJ,SAASI;YACzB,IAAI,CAACW,QAAQ,OAAOf,SAAS,IAAIa,MAAM;YAEvC,IAAIG,MAAMD,OAAOE,IAAI,CAACC,WAAE,CAACC,iBAAiB,CAACR;YAC3CS,IAAAA,cAAE,EAACJ,KAAK;gBAAC;gBAAS;gBAAO;gBAAS;aAAS,EAAE,SAACK;gBAC5CA,WAAWrB,SAASqB,YAAYC,IAAAA,kCAAa,EAACX,UAAUX;YAC1D;QACF;IACF;IAEAuB,OAAAA,OAQC,GARDA,SAAAA;QACEtB,8BAAS,CAACC,SAAS,CAACqB,OAAO,CAACpB,IAAI,CAAC,IAAI;QACrC,IAAI,CAACV,KAAK,GAAG;QACb,IAAI,CAACC,MAAM,GAAG;QACd,IAAI,IAAI,CAACC,IAAI,EAAE;YACb,IAAI,CAACA,IAAI,CAACU,OAAO;YACjB,IAAI,CAACV,IAAI,GAAG;QACd;IACF;WA9DmBJ;EAA0BU,8BAAS"}

package/dist/cjs/nextEntry.js

@@ -69,23 +69,27 @@ function nextEntry(iterator, callback) {
                 // For symlinks, the file content IS the symlink target path
                 // Read the content to get the linkpath for SymbolicLinkEntry
                 var parser = iterator.iterator.getParser();
-                var stream = parser.getEntryStream(entry);
-                var chunks = [];
-                stream.on('data', function(chunk) {
-                    chunks.push(chunk);
-                });
-                stream.on('end', function() {
-                    var linkpath = Buffer.concat(chunks).toString('utf8');
-                    var linkAttributes = {
-                        path: attributes.path,
-                        mtime: attributes.mtime,
-                        mode: attributes.mode,
-                        linkpath: linkpath
-                    };
-                    nextCallback(null, new _extractbaseiterator.SymbolicLinkEntry(linkAttributes));
-                });
-                stream.on('error', function(err) {
-                    nextCallback(err);
+                // Use callback-based async decompression
+                parser.getEntryStreamAsync(entry, function(err, stream) {
+                    if (err) return nextCallback(err);
+                    if (!stream) return nextCallback(new Error('No stream returned'));
+                    var chunks = [];
+                    stream.on('data', function(chunk) {
+                        chunks.push(chunk);
+                    });
+                    stream.on('end', function() {
+                        var linkpath = Buffer.concat(chunks).toString('utf8');
+                        var linkAttributes = {
+                            path: attributes.path,
+                            mtime: attributes.mtime,
+                            mode: attributes.mode,
+                            linkpath: linkpath
+                        };
+                        nextCallback(null, new _extractbaseiterator.SymbolicLinkEntry(linkAttributes));
+                    });
+                    stream.on('error', function(streamErr) {
+                        nextCallback(streamErr);
+                    });
                 });
                 return;
             }

package/dist/cjs/nextEntry.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/nextEntry.ts"],"sourcesContent":["import once from 'call-once-fn';\nimport { type DirectoryAttributes, DirectoryEntry, type FileAttributes, type LinkAttributes, SymbolicLinkEntry } from 'extract-base-iterator';\nimport compact from 'lodash.compact';\nimport path from 'path';\nimport FileEntry from './FileEntry.ts';\nimport type SevenZipIterator from './SevenZipIterator.ts';\nimport type { SevenZipEntry } from './sevenz/SevenZipParser.ts';\nimport type { Entry, EntryCallback } from './types.ts';\n\nexport type NextCallback = (error?: Error, entry?: Entry) => undefined;\n\n// Entry attributes object that gets mutated in switch - union of possible shapes\n// mtime is number for FileAttributes compatibility (timestamp in ms)\ntype EntryAttributesBuilder = {\n  path: string;\n  basename: string;\n  mtime: number;\n  mode: number;\n  type?: 'file' | 'directory';\n  size?: number;\n};\n\nexport default function nextEntry<_T>(iterator: SevenZipIterator, callback: EntryCallback): undefined {\n  if (!iterator.iterator) {\n    callback(new Error('iterator missing'));\n    return;\n  }\n\n  var entry: SevenZipEntry | null = null;\n  entry = iterator.iterator.next();\n\n  var nextCallback = once((err?: Error, entry?: Entry) => {\n    // keep processing\n    if (entry) iterator.push(nextEntry);\n    err ? callback(err) : callback(null, entry ? { done: false, value: entry } : { done: true, value: null });\n  }) as NextCallback;\n\n  // done: signal iteration is complete (guard against stale lock)\n  if (!iterator.lock || iterator.isDone() || !entry) return callback(null, { done: true, value: null });\n\n  // Skip anti-files (these mark files to delete in delta archives)\n  if (entry.isAntiFile) {\n    iterator.push(nextEntry);\n    return callback(null, null);\n  }\n\n  // Determine type from entry\n  var type = entry.type;\n\n  // Default modes (decimal values for Node 0.8 compatibility)\n  // 0o755 = 493, 0o644 = 420\n  var defaultMode = type === 'directory' ? 493 : 420;\n\n  // Build attributes from 7z entry\n  // mtime must be timestamp (number) for FileAttributes compatibility\n  var mtimeDate = entry.mtime || new Date();\n  var attributes: EntryAttributesBuilder = {\n    path: compact(entry.path.split(path.sep)).join(path.sep),\n    basename: entry.name,\n    mtime: mtimeDate.getTime(),\n    mode: entry.mode !== undefined ? entry.mode : defaultMode,\n  };\n\n  switch (type) {\n    case 'directory':\n      attributes.type = 'directory';\n      return nextCallback(null, new DirectoryEntry(attributes as DirectoryAttributes));\n\n    case 'link': {\n      // For symlinks, the file content IS the symlink target path\n      // Read the content to get the linkpath for SymbolicLinkEntry\n      var parser = iterator.iterator.getParser();\n      var stream = parser.getEntryStream(entry);\n      var chunks: Buffer[] = [];\n\n      stream.on('data', (chunk: Buffer) => {\n        chunks.push(chunk);\n      });\n      stream.on('end', () => {\n        var linkpath = Buffer.concat(chunks).toString('utf8');\n\n        var linkAttributes: LinkAttributes = {\n          path: attributes.path,\n          mtime: attributes.mtime,\n          mode: attributes.mode,\n          linkpath: linkpath,\n        };\n\n        nextCallback(null, new SymbolicLinkEntry(linkAttributes));\n      });\n      stream.on('error', (err: Error) => {\n        nextCallback(err);\n      });\n      return;\n    }\n\n    case 'file': {\n      attributes.type = 'file';\n      attributes.size = entry.size;\n      var parser2 = iterator.iterator.getParser();\n      return nextCallback(null, new FileEntry(attributes as FileAttributes, entry, parser2, iterator.lock));\n    }\n  }\n\n  return callback(new Error(`Unrecognized entry type: ${type}`));\n}\n"],"names":["nextEntry","iterator","callback","Error","entry","next","nextCallback","once","err","push","done","value","lock","isDone","isAntiFile","type","defaultMode","mtimeDate","mtime","Date","attributes","path","compact","split","sep","join","basename","name","getTime","mode","undefined","DirectoryEntry","parser","getParser","stream","getEntryStream","chunks","on","chunk","linkpath","Buffer","concat","toString","linkAttributes","SymbolicLinkEntry","size","parser2","FileEntry"],"mappings":";;;;+BAsBA;;;eAAwBA;;;iEAtBP;mCACqG;oEAClG;2DACH;kEACK;;;;;;AAkBP,SAASA,UAAcC,QAA0B,EAAEC,QAAuB;IACvF,IAAI,CAACD,SAASA,QAAQ,EAAE;QACtBC,SAAS,IAAIC,MAAM;QACnB;IACF;IAEA,IAAIC,QAA8B;IAClCA,QAAQH,SAASA,QAAQ,CAACI,IAAI;IAE9B,IAAIC,eAAeC,IAAAA,mBAAI,EAAC,SAACC,KAAaJ;QACpC,kBAAkB;QAClB,IAAIA,OAAOH,SAASQ,IAAI,CAACT;QACzBQ,MAAMN,SAASM,OAAON,SAAS,MAAME,QAAQ;YAAEM,MAAM;YAAOC,OAAOP;QAAM,IAAI;YAAEM,MAAM;YAAMC,OAAO;QAAK;IACzG;IAEA,gEAAgE;IAChE,IAAI,CAACV,SAASW,IAAI,IAAIX,SAASY,MAAM,MAAM,CAACT,OAAO,OAAOF,SAAS,MAAM;QAAEQ,MAAM;QAAMC,OAAO;IAAK;IAEnG,iEAAiE;IACjE,IAAIP,MAAMU,UAAU,EAAE;QACpBb,SAASQ,IAAI,CAACT;QACd,OAAOE,SAAS,MAAM;IACxB;IAEA,4BAA4B;IAC5B,IAAIa,OAAOX,MAAMW,IAAI;IAErB,4DAA4D;IAC5D,2BAA2B;IAC3B,IAAIC,cAAcD,SAAS,cAAc,MAAM;IAE/C,iCAAiC;IACjC,oEAAoE;IACpE,IAAIE,YAAYb,MAAMc,KAAK,IAAI,IAAIC;IACnC,IAAIC,aAAqC;QACvCC,MAAMC,IAAAA,sBAAO,EAAClB,MAAMiB,IAAI,CAACE,KAAK,CAACF,aAAI,CAACG,GAAG,GAAGC,IAAI,CAACJ,aAAI,CAACG,GAAG;QACvDE,UAAUtB,MAAMuB,IAAI;QACpBT,OAAOD,UAAUW,OAAO;QACxBC,MAAMzB,MAAMyB,IAAI,KAAKC,YAAY1B,MAAMyB,IAAI,GAAGb;IAChD;IAEA,OAAQD;QACN,KAAK;YACHK,WAAWL,IAAI,GAAG;YAClB,OAAOT,aAAa,MAAM,IAAIyB,mCAAc,CAACX;QAE/C,KAAK;YAAQ;gBACX,4DAA4D;gBAC5D,6DAA6D;gBAC7D,IAAIY,SAAS/B,SAASA,QAAQ,CAACgC,SAAS;gBACxC,IAAIC,SAASF,OAAOG,cAAc,CAAC/B;gBACnC,IAAIgC,SAAmB,EAAE;gBAEzBF,OAAOG,EAAE,CAAC,QAAQ,SAACC;oBACjBF,OAAO3B,IAAI,CAAC6B;gBACd;gBACAJ,OAAOG,EAAE,CAAC,OAAO;oBACf,IAAIE,WAAWC,OAAOC,MAAM,CAACL,QAAQM,QAAQ,CAAC;oBAE9C,IAAIC,iBAAiC;wBACnCtB,MAAMD,WAAWC,IAAI;wBACrBH,OAAOE,WAAWF,KAAK;wBACvBW,MAAMT,WAAWS,IAAI;wBACrBU,UAAUA;oBACZ;oBAEAjC,aAAa,MAAM,IAAIsC,sCAAiB,CAACD;gBAC3C;gBACAT,OAAOG,EAAE,CAAC,SAAS,SAAC7B;oBAClBF,aAAaE;gBACf;gBACA;YACF;QAEA,KAAK;YAAQ;gBACXY,WAAWL,IAAI,GAAG;gBAClBK,WAAWyB,IAAI,GAAGzC,MAAMyC,IAAI;gBAC5B,IAAIC,UAAU7C,SAASA,QAAQ,CAACgC,SAAS;gBACzC,OAAO3B,aAAa,MAAM,IAAIyC,oBAAS,CAAC3B,YAA8BhB,OAAO0C,SAAS7C,SAASW,IAAI;YACrG;IACF;IAEA,OAAOV,SAAS,IAAIC,MAAM,AAAC,4BAAgC,OAALY;AACxD"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/nextEntry.ts"],"sourcesContent":["import once from 'call-once-fn';\nimport { type DirectoryAttributes, DirectoryEntry, type FileAttributes, type LinkAttributes, SymbolicLinkEntry } from 'extract-base-iterator';\nimport compact from 'lodash.compact';\nimport path from 'path';\nimport FileEntry from './FileEntry.ts';\nimport type SevenZipIterator from './SevenZipIterator.ts';\nimport type { SevenZipEntry } from './sevenz/SevenZipParser.ts';\nimport type { Entry, EntryCallback } from './types.ts';\n\nexport type NextCallback = (error?: Error, entry?: Entry) => undefined;\n\n// Entry attributes object that gets mutated in switch - union of possible shapes\n// mtime is number for FileAttributes compatibility (timestamp in ms)\ntype EntryAttributesBuilder = {\n  path: string;\n  basename: string;\n  mtime: number;\n  mode: number;\n  type?: 'file' | 'directory';\n  size?: number;\n};\n\nexport default function nextEntry<_T>(iterator: SevenZipIterator, callback: EntryCallback): undefined {\n  if (!iterator.iterator) {\n    callback(new Error('iterator missing'));\n    return;\n  }\n\n  var entry: SevenZipEntry | null = null;\n  entry = iterator.iterator.next();\n\n  var nextCallback = once((err?: Error, entry?: Entry) => {\n    // keep processing\n    if (entry) iterator.push(nextEntry);\n    err ? callback(err) : callback(null, entry ? { done: false, value: entry } : { done: true, value: null });\n  }) as NextCallback;\n\n  // done: signal iteration is complete (guard against stale lock)\n  if (!iterator.lock || iterator.isDone() || !entry) return callback(null, { done: true, value: null });\n\n  // Skip anti-files (these mark files to delete in delta archives)\n  if (entry.isAntiFile) {\n    iterator.push(nextEntry);\n    return callback(null, null);\n  }\n\n  // Determine type from entry\n  var type = entry.type;\n\n  // Default modes (decimal values for Node 0.8 compatibility)\n  // 0o755 = 493, 0o644 = 420\n  var defaultMode = type === 'directory' ? 493 : 420;\n\n  // Build attributes from 7z entry\n  // mtime must be timestamp (number) for FileAttributes compatibility\n  var mtimeDate = entry.mtime || new Date();\n  var attributes: EntryAttributesBuilder = {\n    path: compact(entry.path.split(path.sep)).join(path.sep),\n    basename: entry.name,\n    mtime: mtimeDate.getTime(),\n    mode: entry.mode !== undefined ? entry.mode : defaultMode,\n  };\n\n  switch (type) {\n    case 'directory':\n      attributes.type = 'directory';\n      return nextCallback(null, new DirectoryEntry(attributes as DirectoryAttributes));\n\n    case 'link': {\n      // For symlinks, the file content IS the symlink target path\n      // Read the content to get the linkpath for SymbolicLinkEntry\n      var parser = iterator.iterator.getParser();\n\n      // Use callback-based async decompression\n      parser.getEntryStreamAsync(entry, (err, stream) => {\n        if (err) return nextCallback(err);\n        if (!stream) return nextCallback(new Error('No stream returned'));\n\n        var chunks: Buffer[] = [];\n\n        stream.on('data', (chunk: Buffer) => {\n          chunks.push(chunk);\n        });\n        stream.on('end', () => {\n          var linkpath = Buffer.concat(chunks).toString('utf8');\n\n          var linkAttributes: LinkAttributes = {\n            path: attributes.path,\n            mtime: attributes.mtime,\n            mode: attributes.mode,\n            linkpath: linkpath,\n          };\n\n          nextCallback(null, new SymbolicLinkEntry(linkAttributes));\n        });\n        stream.on('error', (streamErr: Error) => {\n          nextCallback(streamErr);\n        });\n      });\n      return;\n    }\n\n    case 'file': {\n      attributes.type = 'file';\n      attributes.size = entry.size;\n      var parser2 = iterator.iterator.getParser();\n      return nextCallback(null, new FileEntry(attributes as FileAttributes, entry, parser2, iterator.lock));\n    }\n  }\n\n  return callback(new Error(`Unrecognized entry type: ${type}`));\n}\n"],"names":["nextEntry","iterator","callback","Error","entry","next","nextCallback","once","err","push","done","value","lock","isDone","isAntiFile","type","defaultMode","mtimeDate","mtime","Date","attributes","path","compact","split","sep","join","basename","name","getTime","mode","undefined","DirectoryEntry","parser","getParser","getEntryStreamAsync","stream","chunks","on","chunk","linkpath","Buffer","concat","toString","linkAttributes","SymbolicLinkEntry","streamErr","size","parser2","FileEntry"],"mappings":"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"}

package/dist/cjs/sevenz/SevenZipParser.d.cts

@@ -87,6 +87,11 @@ export declare class SevenZipParser {
      * Get a readable stream for an entry's content
      */
     getEntryStream(entry: SevenZipEntry): Readable;
+    /**
+     * Get a readable stream for an entry's content (callback-based async version)
+     * Uses streaming decompression for non-blocking I/O
+     */
+    getEntryStreamAsync(entry: SevenZipEntry, callback: (err: Error | null, stream?: Readable) => void): void;
     /**
      * Check if a folder uses BCJ2 codec
      */
@@ -96,6 +101,11 @@ export declare class SevenZipParser {
      * Only caches when multiple files share a block, releases when last file extracted
      */
     private getDecompressedFolder;
+    /**
+     * Get decompressed data for a folder using streaming (callback-based async)
+     * Uses createDecoder() streams for non-blocking decompression
+     */
+    private getDecompressedFolderAsync;
     /**
      * Decompress a BCJ2 folder with multi-stream handling
      * BCJ2 uses 4 input streams: main, call, jump, range coder

package/dist/cjs/sevenz/SevenZipParser.d.ts

@@ -87,6 +87,11 @@ export declare class SevenZipParser {
      * Get a readable stream for an entry's content
      */
     getEntryStream(entry: SevenZipEntry): Readable;
+    /**
+     * Get a readable stream for an entry's content (callback-based async version)
+     * Uses streaming decompression for non-blocking I/O
+     */
+    getEntryStreamAsync(entry: SevenZipEntry, callback: (err: Error | null, stream?: Readable) => void): void;
     /**
      * Check if a folder uses BCJ2 codec
      */
@@ -96,6 +101,11 @@ export declare class SevenZipParser {
      * Only caches when multiple files share a block, releases when last file extracted
      */
     private getDecompressedFolder;
+    /**
+     * Get decompressed data for a folder using streaming (callback-based async)
+     * Uses createDecoder() streams for non-blocking decompression
+     */
+    private getDecompressedFolderAsync;
     /**
      * Decompress a BCJ2 folder with multi-stream handling
      * BCJ2 uses 4 input streams: main, call, jump, range coder

package/dist/cjs/sevenz/SevenZipParser.js

@@ -23,6 +23,7 @@ _export(exports, {
 });
 var _extractbaseiterator = require("extract-base-iterator");
 var _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+var _onone = /*#__PURE__*/ _interop_require_default(require("on-one"));
 var _readablestream = require("readable-stream");
 var _indexts = require("./codecs/index.js");
 var _constantsts = require("./constants.js");
@@ -467,6 +468,66 @@ var SevenZipParser = /*#__PURE__*/ function() {
         return outputStream;
     };
     /**
+   * Get a readable stream for an entry's content (callback-based async version)
+   * Uses streaming decompression for non-blocking I/O
+   */ _proto.getEntryStreamAsync = function getEntryStreamAsync(entry, callback) {
+        var _this = this;
+        if (!entry._hasStream || entry.type === 'directory') {
+            // Return empty stream for directories and empty files
+            var emptyStream = new _readablestream.PassThrough();
+            emptyStream.end();
+            callback(null, emptyStream);
+            return;
+        }
+        if (!this.streamsInfo) {
+            callback((0, _constantsts.createCodedError)('No streams info available', _constantsts.ErrorCode.CORRUPT_HEADER));
+            return;
+        }
+        // Get folder info
+        var folder = this.streamsInfo.folders[entry._folderIndex];
+        if (!folder) {
+            callback((0, _constantsts.createCodedError)('Invalid folder index', _constantsts.ErrorCode.CORRUPT_HEADER));
+            return;
+        }
+        // Check codec support
+        for(var i = 0; i < folder.coders.length; i++){
+            var coder = folder.coders[i];
+            if (!(0, _indexts.isCodecSupported)(coder.id)) {
+                var codecName = (0, _indexts.getCodecName)(coder.id);
+                callback((0, _constantsts.createCodedError)("Unsupported codec: ".concat(codecName), _constantsts.ErrorCode.UNSUPPORTED_CODEC));
+                return;
+            }
+        }
+        // Get decompressed data for this folder using async method
+        var folderIdx = entry._folderIndex;
+        var streamsInfo = this.streamsInfo;
+        this.getDecompressedFolderAsync(folderIdx, function(err, data) {
+            if (err) return callback(err);
+            if (!data) return callback(new Error('No data returned from decompression'));
+            // Calculate file offset within the decompressed block
+            var fileStart = 0;
+            for(var m = 0; m < entry._streamIndexInFolder; m++){
+                var prevStreamGlobalIndex = entry._streamIndex - entry._streamIndexInFolder + m;
+                fileStart += streamsInfo.unpackSizes[prevStreamGlobalIndex];
+            }
+            var fileSize = entry.size;
+            // Bounds check
+            if (fileStart + fileSize > data.length) {
+                return callback((0, _constantsts.createCodedError)("File data out of bounds: offset ".concat(fileStart, " + size ").concat(fileSize, " > decompressed length ").concat(data.length), _constantsts.ErrorCode.DECOMPRESSION_FAILED));
+            }
+            // Create a PassThrough stream with the file data
+            var outputStream = new _readablestream.PassThrough();
+            var fileData = data.slice(fileStart, fileStart + fileSize);
+            outputStream.end(fileData);
+            // Track extraction and release cache when all files from this folder are done
+            _this.extractedPerFolder[folderIdx] = (_this.extractedPerFolder[folderIdx] || 0) + 1;
+            if (_this.extractedPerFolder[folderIdx] >= _this.filesPerFolder[folderIdx]) {
+                delete _this.decompressedCache[folderIdx];
+            }
+            callback(null, outputStream);
+        });
+    };
+    /**
    * Check if a folder uses BCJ2 codec
    */ _proto.folderHasBcj2 = function folderHasBcj2(folder) {
         for(var i = 0; i < folder.coders.length; i++){
@@ -532,6 +593,104 @@ var SevenZipParser = /*#__PURE__*/ function() {
         return data2;
     };
     /**
+   * Get decompressed data for a folder using streaming (callback-based async)
+   * Uses createDecoder() streams for non-blocking decompression
+   */ _proto.getDecompressedFolderAsync = function getDecompressedFolderAsync(folderIndex, callback) {
+        var self = this;
+        // Check cache first
+        if (this.decompressedCache[folderIndex]) {
+            callback(null, this.decompressedCache[folderIndex]);
+            return;
+        }
+        if (!this.streamsInfo) {
+            callback((0, _constantsts.createCodedError)('No streams info available', _constantsts.ErrorCode.CORRUPT_HEADER));
+            return;
+        }
+        var folder = this.streamsInfo.folders[folderIndex];
+        // Check how many files remain in this folder
+        var filesInFolder = this.filesPerFolder[folderIndex] || 1;
+        var extractedFromFolder = this.extractedPerFolder[folderIndex] || 0;
+        var remainingFiles = filesInFolder - extractedFromFolder;
+        var shouldCache = remainingFiles > 1;
+        // BCJ2 requires special handling - use sync version for now
+        // TODO: Add async BCJ2 support
+        if (this.folderHasBcj2(folder)) {
+            try {
+                var data = this.decompressBcj2Folder(folderIndex);
+                if (shouldCache) {
+                    this.decompressedCache[folderIndex] = data;
+                }
+                callback(null, data);
+            } catch (err) {
+                callback(err);
+            }
+            return;
+        }
+        // Calculate packed data position
+        var packPos = _constantsts.SIGNATURE_HEADER_SIZE + this.streamsInfo.packPos;
+        // Find which pack stream this folder uses
+        var packStreamIndex = 0;
+        for(var j = 0; j < folderIndex; j++){
+            packStreamIndex += this.streamsInfo.folders[j].packedStreams.length;
+        }
+        // Calculate position of this pack stream
+        for(var k = 0; k < packStreamIndex; k++){
+            packPos += this.streamsInfo.packSizes[k];
+        }
+        var packSize = this.streamsInfo.packSizes[packStreamIndex];
+        // Read packed data
+        var packedData = this.source.read(packPos, packSize);
+        // Create decoder stream chain and decompress
+        var coders = folder.coders;
+        var unpackSizes = folder.unpackSizes;
+        // Helper to decompress through a single codec stream
+        function decompressWithStream(input, coderIdx, cb) {
+            var coderInfo = coders[coderIdx];
+            var codec = (0, _indexts.getCodec)(coderInfo.id);
+            var decoder = codec.createDecoder(coderInfo.properties, unpackSizes[coderIdx]);
+            var chunks = [];
+            var errorOccurred = false;
+            decoder.on('data', function(chunk) {
+                chunks.push(chunk);
+            });
+            (0, _onone.default)(decoder, [
+                'error',
+                'end',
+                'close',
+                'finish'
+            ], function(err) {
+                if (errorOccurred) return;
+                if (err) {
+                    errorOccurred = true;
+                    return cb(err);
+                }
+                cb(null, Buffer.concat(chunks));
+            });
+            // Write input data to decoder and signal end
+            decoder.end(input);
+        }
+        // Chain decompression through all codecs
+        function decompressChain(input, idx) {
+            if (idx >= coders.length) {
+                // All done - cache and return
+                if (shouldCache) {
+                    self.decompressedCache[folderIndex] = input;
+                }
+                callback(null, input);
+                return;
+            }
+            decompressWithStream(input, idx, function(err, output) {
+                if (err) {
+                    callback(err);
+                    return;
+                }
+                decompressChain(output, idx + 1);
+            });
+        }
+        // Start the chain
+        decompressChain(packedData, 0);
+    };
+    /**
    * Decompress a BCJ2 folder with multi-stream handling
    * BCJ2 uses 4 input streams: main, call, jump, range coder
    */ _proto.decompressBcj2Folder = function decompressBcj2Folder(folderIndex) {