7z-iterator 2.2.6 → 2.2.8

package/dist/cjs/FileEntry.js

@@ -32,6 +32,22 @@ function _class_call_check(instance, Constructor) {
         throw new TypeError("Cannot call a class as a function");
     }
 }
+function _get(target, property, receiver) {
+    if (typeof Reflect !== "undefined" && Reflect.get) {
+        _get = Reflect.get;
+    } else {
+        _get = function get(target, property, receiver) {
+            var base = _super_prop_base(target, property);
+            if (!base) return;
+            var desc = Object.getOwnPropertyDescriptor(base, property);
+            if (desc.get) {
+                return desc.get.call(receiver || target);
+            }
+            return desc.value;
+        };
+    }
+    return _get(target, property, receiver || target);
+}
 function _get_prototype_of(o) {
     _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
         return o.__proto__ || Object.getPrototypeOf(o);
@@ -69,6 +85,13 @@ function _set_prototype_of(o, p) {
     };
     return _set_prototype_of(o, p);
 }
+function _super_prop_base(object, property) {
+    while(!Object.prototype.hasOwnProperty.call(object, property)){
+        object = _get_prototype_of(object);
+        if (object === null) break;
+    }
+    return object;
+}
 function _type_of(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
@@ -102,17 +125,19 @@ var SevenZipFileEntry = /*#__PURE__*/ function(FileEntry) {
         callback = typeof options === 'function' ? options : callback;
         options = typeof options === 'function' ? {} : options || {};
         if (typeof callback === 'function') {
-            return _extractbaseiterator.FileEntry.prototype.create.call(this, dest, options, function(err) {
+            var cb = function cb(err) {
                 callback(err);
                 if (_this.lock) {
                     _this.lock.release();
                     _this.lock = null;
                 }
-            });
+            };
+            _get(_get_prototype_of(SevenZipFileEntry.prototype), "create", this).call(this, dest, options, cb);
+            return;
         }
         return new Promise(function(resolve, reject) {
-            return _this.create(dest, options, function(err, done) {
-                return err ? reject(err) : resolve(done);
+            return _this.create(dest, options, function(err) {
+                return err ? reject(err) : resolve(true);
             });
         });
     };
@@ -123,7 +148,6 @@ var SevenZipFileEntry = /*#__PURE__*/ function(FileEntry) {
         }
         var stream = this.stream;
         this.stream = null; // Prevent reuse
-        // Use once since errors can come from either stream
         var cb = (0, _calloncefn.default)(function(err) {
             err ? callback(err) : (0, _extractbaseiterator.waitForAccess)(fullPath, callback);
         });
@@ -154,7 +178,7 @@ var SevenZipFileEntry = /*#__PURE__*/ function(FileEntry) {
         }
     };
     _proto.destroy = function destroy() {
-        _extractbaseiterator.FileEntry.prototype.destroy.call(this);
+        _get(_get_prototype_of(SevenZipFileEntry.prototype), "destroy", this).call(this);
         if (this.stream) {
             // Use destroy() to prevent decompression (our stream has custom destroy that sets destroyed flag)
             // Fallback to resume() for older Node versions without destroy()

package/dist/cjs/FileEntry.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/FileEntry.ts"],"sourcesContent":["/**\n * FileEntry for 7z archives\n *\n * Wraps a lazy stream - decompression happens when the stream is read.\n * API consistent with zip-iterator and tar-iterator.\n */\n\nimport once from 'call-once-fn';\nimport { type FileAttributes, FileEntry, type Lock, type NoParamCallback, waitForAccess } from 'extract-base-iterator';\nimport fs from 'graceful-fs';\nimport oo from 'on-one';\nimport type { ExtractOptions } from './types.ts';\n\nexport default class SevenZipFileEntry extends FileEntry {\n  private lock: Lock;\n  private stream: NodeJS.ReadableStream;\n\n  /**\n   * Whether this entry's folder supports streaming decompression.\n   */\n  readonly _canStream: boolean;\n\n  constructor(attributes: FileAttributes, stream: NodeJS.ReadableStream, lock: Lock, canStream: boolean) {\n    super(attributes);\n    this.stream = stream;\n    this.lock = lock;\n    this.lock.retain();\n    this._canStream = canStream;\n  }\n\n  create(dest: string, callback: NoParamCallback): void;\n  create(dest: string, options: ExtractOptions, callback: NoParamCallback): void;\n  create(dest: string, options?: ExtractOptions): Promise<boolean>;\n  create(dest: string, options?: ExtractOptions | NoParamCallback, callback?: NoParamCallback): void | Promise<boolean> {\n    callback = typeof options === 'function' ? options : callback;\n    options = typeof options === 'function' ? {} : ((options || {}) as ExtractOptions);\n\n    if (typeof callback === 'function') {\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) => this.create(dest, options, (err?: Error, done?: boolean) => (err ? reject(err) : resolve(done))));\n  }\n\n  _writeFile(fullPath: string, _options: ExtractOptions, callback: NoParamCallback): void {\n    if (!this.stream) {\n      callback(new Error('7z FileEntry missing stream. Check for calling create multiple times'));\n      return;\n    }\n\n    const stream = this.stream;\n    this.stream = null; // Prevent reuse\n\n    // Use once since errors can come from either stream\n    const cb = once((err?: Error) => {\n      err ? callback(err) : waitForAccess(fullPath, callback);\n    });\n\n    try {\n      const writeStream = fs.createWriteStream(fullPath);\n\n      // Listen for errors on source stream (errors don't propagate through pipe)\n      stream.on('error', (streamErr: Error) => {\n        // Destroy the write stream on source error.\n        // On Node 0.8, destroy() emits 'close' before 'error'. Since on-one is listening\n        // for ['error', 'close', 'finish'], it catches 'close' first, calls our callback,\n        // and removes ALL listeners - including the 'error' listener. The subsequent EBADF\n        // error then fires with no handler, causing an uncaught exception.\n        // Adding a no-op error handler ensures there's always a listener for any error.\n        const ws = writeStream as fs.WriteStream & { destroy?: () => void };\n        writeStream.on('error', () => {});\n        if (typeof ws.destroy === 'function') ws.destroy();\n        cb(streamErr);\n      });\n\n      // Pipe and listen for write stream completion/errors\n      stream.pipe(writeStream);\n      oo(writeStream, ['error', 'close', 'finish'], cb);\n    } catch (pipeErr) {\n      cb(pipeErr);\n    }\n  }\n\n  destroy() {\n    FileEntry.prototype.destroy.call(this);\n    if (this.stream) {\n      // Use destroy() to prevent decompression (our stream has custom destroy that sets destroyed flag)\n      // Fallback to resume() for older Node versions without destroy()\n      const s = this.stream as NodeJS.ReadableStream & { destroy?: () => void };\n      if (typeof s.destroy === 'function') {\n        s.destroy();\n      }\n      this.stream = null;\n    }\n    if (this.lock) {\n      this.lock.release();\n      this.lock = null;\n    }\n  }\n}\n"],"names":["SevenZipFileEntry","attributes","stream","lock","canStream","retain","_canStream","create","dest","options","callback","FileEntry","prototype","call","err","release","Promise","resolve","reject","done","_writeFile","fullPath","_options","Error","cb","once","waitForAccess","writeStream","fs","createWriteStream","on","streamErr","ws","destroy","pipe","oo","pipeErr","s"],"mappings":"AAAA;;;;;CAKC;;;;;;;eAQoBA;;;iEANJ;mCAC8E;iEAChF;4DACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,IAAA,AAAMA,kCAAN;;cAAMA;aAAAA,kBASPC,UAA0B,EAAEC,MAA6B,EAAEC,IAAU,EAAEC,SAAkB;gCATlFJ;;gBAUjB,kBAViBA;YAUXC;;QACN,MAAKC,MAAM,GAAGA;QACd,MAAKC,IAAI,GAAGA;QACZ,MAAKA,IAAI,CAACE,MAAM;QAChB,MAAKC,UAAU,GAAGF;;;iBAdDJ;IAoBnBO,OAAAA,MAcC,GAdDA,SAAAA,OAAOC,IAAY,EAAEC,OAA0C,EAAEC,QAA0B;;QACzFA,WAAW,OAAOD,YAAY,aAAaA,UAAUC;QACrDD,UAAU,OAAOA,YAAY,aAAa,CAAC,IAAMA,WAAW,CAAC;QAE7D,IAAI,OAAOC,aAAa,YAAY;YAClC,OAAOC,8BAAS,CAACC,SAAS,CAACL,MAAM,CAACM,IAAI,CAAC,IAAI,EAAEL,MAAMC,SAAS,SAACK;gBAC3DJ,SAASI;gBACT,IAAI,MAAKX,IAAI,EAAE;oBACb,MAAKA,IAAI,CAACY,OAAO;oBACjB,MAAKZ,IAAI,GAAG;gBACd;YACF;QACF;QACA,OAAO,IAAIa,QAAQ,SAACC,SAASC;mBAAW,MAAKX,MAAM,CAACC,MAAMC,SAAS,SAACK,KAAaK;uBAAoBL,MAAMI,OAAOJ,OAAOG,QAAQE;;;IACnI;IAEAC,OAAAA,UAqCC,GArCDA,SAAAA,WAAWC,QAAgB,EAAEC,QAAwB,EAAEZ,QAAyB;QAC9E,IAAI,CAAC,IAAI,CAACR,MAAM,EAAE;YAChBQ,SAAS,IAAIa,MAAM;YACnB;QACF;QAEA,IAAMrB,SAAS,IAAI,CAACA,MAAM;QAC1B,IAAI,CAACA,MAAM,GAAG,MAAM,gBAAgB;QAEpC,oDAAoD;QACpD,IAAMsB,KAAKC,IAAAA,mBAAI,EAAC,SAACX;YACfA,MAAMJ,SAASI,OAAOY,IAAAA,kCAAa,EAACL,UAAUX;QAChD;QAEA,IAAI;YACF,IAAMiB,cAAcC,mBAAE,CAACC,iBAAiB,CAACR;YAEzC,2EAA2E;YAC3EnB,OAAO4B,EAAE,CAAC,SAAS,SAACC;gBAClB,4CAA4C;gBAC5C,iFAAiF;gBACjF,kFAAkF;gBAClF,mFAAmF;gBACnF,mEAAmE;gBACnE,gFAAgF;gBAChF,IAAMC,KAAKL;gBACXA,YAAYG,EAAE,CAAC,SAAS,YAAO;gBAC/B,IAAI,OAAOE,GAAGC,OAAO,KAAK,YAAYD,GAAGC,OAAO;gBAChDT,GAAGO;YACL;YAEA,qDAAqD;YACrD7B,OAAOgC,IAAI,CAACP;YACZQ,IAAAA,cAAE,EAACR,aAAa;gBAAC;gBAAS;gBAAS;aAAS,EAAEH;QAChD,EAAE,OAAOY,SAAS;YAChBZ,GAAGY;QACL;IACF;IAEAH,OAAAA,OAeC,GAfDA,SAAAA;QACEtB,8BAAS,CAACC,SAAS,CAACqB,OAAO,CAACpB,IAAI,CAAC,IAAI;QACrC,IAAI,IAAI,CAACX,MAAM,EAAE;YACf,kGAAkG;YAClG,iEAAiE;YACjE,IAAMmC,IAAI,IAAI,CAACnC,MAAM;YACrB,IAAI,OAAOmC,EAAEJ,OAAO,KAAK,YAAY;gBACnCI,EAAEJ,OAAO;YACX;YACA,IAAI,CAAC/B,MAAM,GAAG;QAChB;QACA,IAAI,IAAI,CAACC,IAAI,EAAE;YACb,IAAI,CAACA,IAAI,CAACY,OAAO;YACjB,IAAI,CAACZ,IAAI,GAAG;QACd;IACF;WA1FmBH;EAA0BW,8BAAS"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/FileEntry.ts"],"sourcesContent":["/**\n * FileEntry for 7z archives\n *\n * Wraps a lazy stream - decompression happens when the stream is read.\n * API consistent with zip-iterator and tar-iterator.\n */\n\nimport type { CallFn } from 'call-once-fn';\nimport once from 'call-once-fn';\nimport { type FileAttributes, FileEntry, type Lock, type NoParamCallback, waitForAccess } from 'extract-base-iterator';\nimport fs from 'graceful-fs';\nimport oo from 'on-one';\nimport type { ExtractOptions } from './types.ts';\n\nexport default class SevenZipFileEntry extends FileEntry {\n  private lock: Lock | null;\n  private stream: NodeJS.ReadableStream | null;\n\n  /**\n   * Whether this entry's folder supports streaming decompression.\n   */\n  readonly _canStream: boolean;\n\n  constructor(attributes: FileAttributes, stream: NodeJS.ReadableStream, lock: Lock, canStream: boolean) {\n    super(attributes);\n    this.stream = stream;\n    this.lock = lock;\n    this.lock.retain();\n    this._canStream = canStream;\n  }\n\n  create(dest: string, callback: NoParamCallback): void;\n  create(dest: string, options: ExtractOptions, callback: NoParamCallback): void;\n  create(dest: string, options?: ExtractOptions): Promise<boolean>;\n  create(dest: string, options?: ExtractOptions | NoParamCallback, callback?: NoParamCallback): void | Promise<boolean> {\n    callback = typeof options === 'function' ? options : callback;\n    options = typeof options === 'function' ? {} : ((options || {}) as ExtractOptions);\n\n    if (typeof callback === 'function') {\n      const cb: NoParamCallback = (err?: Error) => {\n        (callback as NoParamCallback)(err);\n        if (this.lock) {\n          this.lock.release();\n          this.lock = null;\n        }\n      };\n      super.create(dest, options as ExtractOptions, cb);\n      return;\n    }\n    return new Promise((resolve, reject) => this.create(dest, options as ExtractOptions, (err?: Error) => (err ? reject(err) : resolve(true))));\n  }\n\n  _writeFile(fullPath: string, _options: ExtractOptions, callback: NoParamCallback): void {\n    if (!this.stream) {\n      callback(new Error('7z FileEntry missing stream. Check for calling create multiple times'));\n      return;\n    }\n\n    const stream = this.stream;\n    this.stream = null; // Prevent reuse\n\n    const cb = once(((err?: Error) => {\n      err ? callback(err) : waitForAccess(fullPath, callback);\n    }) as unknown as CallFn) as unknown as (err?: Error) => void;\n\n    try {\n      const writeStream = fs.createWriteStream(fullPath);\n\n      // Listen for errors on source stream (errors don't propagate through pipe)\n      stream.on('error', (streamErr: Error) => {\n        // Destroy the write stream on source error.\n        // On Node 0.8, destroy() emits 'close' before 'error'. Since on-one is listening\n        // for ['error', 'close', 'finish'], it catches 'close' first, calls our callback,\n        // and removes ALL listeners - including the 'error' listener. The subsequent EBADF\n        // error then fires with no handler, causing an uncaught exception.\n        // Adding a no-op error handler ensures there's always a listener for any error.\n        const ws = writeStream as fs.WriteStream & { destroy?: () => void };\n        writeStream.on('error', () => {});\n        if (typeof ws.destroy === 'function') ws.destroy();\n        cb(streamErr);\n      });\n\n      // Pipe and listen for write stream completion/errors\n      stream.pipe(writeStream);\n      oo(writeStream, ['error', 'close', 'finish'], cb as unknown as CallFn);\n    } catch (pipeErr) {\n      cb(pipeErr as Error);\n    }\n  }\n\n  destroy() {\n    super.destroy();\n    if (this.stream) {\n      // Use destroy() to prevent decompression (our stream has custom destroy that sets destroyed flag)\n      // Fallback to resume() for older Node versions without destroy()\n      const s = this.stream as NodeJS.ReadableStream & { destroy?: () => void };\n      if (typeof s.destroy === 'function') {\n        s.destroy();\n      }\n      this.stream = null;\n    }\n    if (this.lock) {\n      this.lock.release();\n      this.lock = null;\n    }\n  }\n}\n"],"names":["SevenZipFileEntry","attributes","stream","lock","canStream","retain","_canStream","create","dest","options","callback","cb","err","release","Promise","resolve","reject","_writeFile","fullPath","_options","Error","once","waitForAccess","writeStream","fs","createWriteStream","on","streamErr","ws","destroy","pipe","oo","pipeErr","s","FileEntry"],"mappings":"AAAA;;;;;CAKC;;;;;;;eASoBA;;;iEANJ;mCAC8E;iEAChF;4DACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,IAAA,AAAMA,kCAAN;;cAAMA;aAAAA,kBASPC,UAA0B,EAAEC,MAA6B,EAAEC,IAAU,EAAEC,SAAkB;gCATlFJ;;gBAUjB,kBAViBA;YAUXC;;QACN,MAAKC,MAAM,GAAGA;QACd,MAAKC,IAAI,GAAGA;QACZ,MAAKA,IAAI,CAACE,MAAM;QAChB,MAAKC,UAAU,GAAGF;;;iBAdDJ;IAoBnBO,OAAAA,MAgBC,GAhBDA,SAAAA,OAAOC,IAAY,EAAEC,OAA0C,EAAEC,QAA0B;;QACzFA,WAAW,OAAOD,YAAY,aAAaA,UAAUC;QACrDD,UAAU,OAAOA,YAAY,aAAa,CAAC,IAAMA,WAAW,CAAC;QAE7D,IAAI,OAAOC,aAAa,YAAY;YAClC,IAAMC,KAAsB,YAACC;gBAC1BF,SAA6BE;gBAC9B,IAAI,MAAKT,IAAI,EAAE;oBACb,MAAKA,IAAI,CAACU,OAAO;oBACjB,MAAKV,IAAI,GAAG;gBACd;YACF;YACA,uBAhCeH,8BAgCTO,UAAN,IAAK,aAAQC,MAAMC,SAA2BE;YAC9C;QACF;QACA,OAAO,IAAIG,QAAQ,SAACC,SAASC;mBAAW,MAAKT,MAAM,CAACC,MAAMC,SAA2B,SAACG;uBAAiBA,MAAMI,OAAOJ,OAAOG,QAAQ;;;IACrI;IAEAE,OAAAA,UAoCC,GApCDA,SAAAA,WAAWC,QAAgB,EAAEC,QAAwB,EAAET,QAAyB;QAC9E,IAAI,CAAC,IAAI,CAACR,MAAM,EAAE;YAChBQ,SAAS,IAAIU,MAAM;YACnB;QACF;QAEA,IAAMlB,SAAS,IAAI,CAACA,MAAM;QAC1B,IAAI,CAACA,MAAM,GAAG,MAAM,gBAAgB;QAEpC,IAAMS,KAAKU,IAAAA,mBAAI,EAAE,SAACT;YAChBA,MAAMF,SAASE,OAAOU,IAAAA,kCAAa,EAACJ,UAAUR;QAChD;QAEA,IAAI;YACF,IAAMa,cAAcC,mBAAE,CAACC,iBAAiB,CAACP;YAEzC,2EAA2E;YAC3EhB,OAAOwB,EAAE,CAAC,SAAS,SAACC;gBAClB,4CAA4C;gBAC5C,iFAAiF;gBACjF,kFAAkF;gBAClF,mFAAmF;gBACnF,mEAAmE;gBACnE,gFAAgF;gBAChF,IAAMC,KAAKL;gBACXA,YAAYG,EAAE,CAAC,SAAS,YAAO;gBAC/B,IAAI,OAAOE,GAAGC,OAAO,KAAK,YAAYD,GAAGC,OAAO;gBAChDlB,GAAGgB;YACL;YAEA,qDAAqD;YACrDzB,OAAO4B,IAAI,CAACP;YACZQ,IAAAA,cAAE,EAACR,aAAa;gBAAC;gBAAS;gBAAS;aAAS,EAAEZ;QAChD,EAAE,OAAOqB,SAAS;YAChBrB,GAAGqB;QACL;IACF;IAEAH,OAAAA,OAeC,GAfDA,SAAAA;QACE,uBA7EiB7B,8BA6EX6B,WAAN,IAAK;QACL,IAAI,IAAI,CAAC3B,MAAM,EAAE;YACf,kGAAkG;YAClG,iEAAiE;YACjE,IAAM+B,IAAI,IAAI,CAAC/B,MAAM;YACrB,IAAI,OAAO+B,EAAEJ,OAAO,KAAK,YAAY;gBACnCI,EAAEJ,OAAO;YACX;YACA,IAAI,CAAC3B,MAAM,GAAG;QAChB;QACA,IAAI,IAAI,CAACC,IAAI,EAAE;YACb,IAAI,CAACA,IAAI,CAACU,OAAO;YACjB,IAAI,CAACV,IAAI,GAAG;QACd;IACF;WA3FmBH;EAA0BkC,8BAAS"}

package/dist/cjs/SevenZipIterator.js

@@ -159,12 +159,12 @@ var SevenZipIterator = /*#__PURE__*/ function(BaseIterator) {
         ]);
         _this.lock = new _extractbaseiterator.Lock();
         _this.lock.onDestroy = function(err) {
-            return _extractbaseiterator.default.prototype.end.call(_this, err);
+            return _extractbaseiterator.default.prototype.end.call(_this, err !== null && err !== void 0 ? err : undefined);
         };
         var queue = new _queuecb.default(1);
         var cancelled = false;
         var archiveSource = null;
-        var setup = function() {
+        var setup = function setup() {
             cancelled = true;
         };
         _this.processing.push(setup);
@@ -180,7 +180,6 @@ var SevenZipIterator = /*#__PURE__*/ function(BaseIterator) {
                         if (_this.done || cancelled) return;
                         if (err) return cb(err);
                         archiveSource = new _SevenZipParserts.FileSource(fd, stats.size);
-                        // Register cleanup for file descriptor
                         _this.lock.registerCleanup(function() {
                             _gracefulfs.default.closeSync(fd);
                         });
@@ -205,11 +204,9 @@ var SevenZipIterator = /*#__PURE__*/ function(BaseIterator) {
                     if (err) return cb(err);
                     if (!result) return cb(new Error('No result from streamToSource'));
                     archiveSource = result.source;
-                    // Register cleanup for file descriptor
                     _this.lock.registerCleanup(function() {
                         _gracefulfs.default.closeSync(result.fd);
                     });
-                    // Register cleanup for temp file
                     _this.lock.registerCleanup(function() {
                         try {
                             (0, _fsremovecompat.rmSync)(result.tempPath);
@@ -251,7 +248,7 @@ var SevenZipIterator = /*#__PURE__*/ function(BaseIterator) {
         if (this.lock) {
             var lock = this.lock;
             this.lock = null; // Clear before release to prevent re-entrancy
-            lock.err = err;
+            lock.err = err !== null && err !== void 0 ? err : null;
             lock.release();
         }
         // Don't call base end here - Lock.__destroy() handles it

package/dist/cjs/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 { rmSync } from 'fs-remove-compat';\nimport fs from 'graceful-fs';\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      const parser = new SevenZipParser(archiveSource);\n      parser.parse((parseErr) => {\n        if (parseErr) {\n          cb(parseErr);\n          return;\n        }\n        try {\n          this._iterator = new EntryIterator(parser);\n          cb();\n        } catch (err) {\n          cb(err as Error);\n        }\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":["SevenZipIterator","EntryIterator","parser","index","entries","getEntries","next","length","getParser","source","options","lock","Lock","onDestroy","err","BaseIterator","prototype","end","call","queue","Queue","cancelled","archiveSource","setup","processing","push","setPassword","password","defer","cb","fs","stat","statErr","stats","done","open","fd","FileSource","size","registerCleanup","closeSync","stream","s","destroy","tempPath","path","join","tmpdir","shortHash","process","cwd","tempSuffix","streamToSource","result","Error","rmSync","_e","SevenZipParser","parse","parseErr","_iterator","await","remove","nextEntry","release","canStream","checkedFolders","i","folderIndex","_folderIndex","undefined","canStreamFolder","getStreamingOrder","sorted","sort","a","b","_streamIndexInFolder"],"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 { rmSync } from 'fs-remove-compat';\nimport fs from 'graceful-fs';\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: Error | null) => BaseIterator.prototype.end.call(this, err ?? undefined);\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            (this.lock as 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 as 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          (this.lock as Lock).registerCleanup(() => {\n            fs.closeSync(result.fd);\n          });\n\n          (this.lock as 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      const parser = new SevenZipParser(archiveSource);\n      parser.parse((parseErr) => {\n        if (parseErr) {\n          cb(parseErr);\n          return;\n        }\n        try {\n          this._iterator = new EntryIterator(parser);\n          cb();\n        } catch (err) {\n          cb(err as Error);\n        }\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 as unknown as Parameters<typeof this.push>[0]);\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 ?? null;\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":["SevenZipIterator","EntryIterator","parser","index","entries","getEntries","next","length","getParser","source","options","lock","Lock","onDestroy","err","BaseIterator","prototype","end","call","undefined","queue","Queue","cancelled","archiveSource","setup","processing","push","setPassword","password","defer","cb","fs","stat","statErr","stats","done","open","fd","FileSource","size","registerCleanup","closeSync","stream","s","destroy","tempPath","path","join","tmpdir","shortHash","process","cwd","tempSuffix","streamToSource","result","Error","rmSync","_e","SevenZipParser","parse","parseErr","_iterator","await","remove","nextEntry","release","canStream","checkedFolders","i","folderIndex","_folderIndex","canStreamFolder","getStreamingOrder","sorted","sort","a","b","_streamIndexInFolder"],"mappings":"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"}

package/dist/cjs/lib/streamToSource.js

@@ -44,7 +44,7 @@ function streamToSource(stream, options, callback) {
                         _gracefulfs.default.closeSync(fd);
                         return end(statErr);
                     }
-                    end(null, {
+                    end(undefined, {
                         source: new _SevenZipParserts.FileSource(fd, stats.size),
                         fd: fd,
                         tempPath: tempPath

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

@@ -1 +1 @@
-{"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 'graceful-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;iEACZ;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,mBAAE,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,mBAAE,CAACQ,IAAI,CAAChB,UAAU,KAAK,SAACiB,KAAKC;gBAC3B,IAAID,KAAK,OAAOhB,IAAIgB;gBACpBT,mBAAE,CAACW,IAAI,CAACnB,UAAU,SAACoB,SAASC;oBAC1B,IAAID,SAAS;wBACXZ,mBAAE,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"}
+{"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 type { CallFn } from 'call-once-fn';\nimport once from 'call-once-fn';\nimport { bufferFrom } from 'extract-base-iterator';\nimport fs from 'graceful-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 as unknown as CallFn) as unknown as 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(undefined, {\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 as unknown as CallFn);\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","undefined","source","FileSource","size","onError","on","oo"],"mappings":"AAAA,4EAA4E;;;;;+BAsB5E;;;;;CAKC,GACD;;;eAAwBA;;;iEA1BP;mCACU;iEACZ;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,mBAAE,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,mBAAE,CAACQ,IAAI,CAAChB,UAAU,KAAK,SAACiB,KAAKC;gBAC3B,IAAID,KAAK,OAAOhB,IAAIgB;gBACpBT,mBAAE,CAACW,IAAI,CAACnB,UAAU,SAACoB,SAASC;oBAC1B,IAAID,SAAS;wBACXZ,mBAAE,CAACc,SAAS,CAACJ;wBACb,OAAOjB,IAAImB;oBACb;oBACAnB,IAAIsB,WAAW;wBACbC,QAAQ,IAAIC,4BAAU,CAACP,IAAIG,MAAMK,IAAI;wBACrCR,IAAIA;wBACJlB,UAAUA;oBACZ;gBACF;YACF;QACF;IACF;IAEA,SAAS2B,QAAQV,GAAU;QACzBV,YAAYN,GAAG;QACfA,IAAIgB;IACN;IAEApB,OAAO+B,EAAE,CAAC,QAAQlB;IAClBmB,IAAAA,cAAE,EAAChC,QAAQ;QAAC;KAAQ,EAAE8B;IACtBE,IAAAA,cAAE,EAAChC,QAAQ;QAAC;QAAO;QAAS;KAAS,EAAEkB;AACzC"}

package/dist/cjs/nextEntry.js

@@ -12,6 +12,7 @@ var _calloncefn = /*#__PURE__*/ _interop_require_default(require("call-once-fn")
 var _extractbaseiterator = require("extract-base-iterator");
 var _path = /*#__PURE__*/ _interop_require_default(require("path"));
 var _FileEntryts = /*#__PURE__*/ _interop_require_default(require("./FileEntry.js"));
+var _constantsts = require("./sevenz/constants.js");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -26,31 +27,26 @@ function nextEntry(iterator, callback) {
     var entry = null;
     entry = internalIter.next();
     var nextCallback = (0, _calloncefn.default)(function(err, entry) {
-        // keep processing
         if (entry) iterator.push(nextEntry);
-        err ? callback(err) : callback(null, entry ? {
+        err ? callback(err) : callback(undefined, entry ? {
             done: false,
             value: entry
         } : {
             done: true,
-            value: null
+            value: undefined
         });
     });
-    // done: signal iteration is complete (guard against stale lock)
-    if (!iterator.lock || iterator.isDone() || !entry) return callback(null, {
+    if (!iterator.lock || iterator.isDone() || !entry) return callback(undefined, {
         done: true,
-        value: null
+        value: undefined
     });
-    // Skip anti-files (these mark files to delete in delta archives)
     if (entry.isAntiFile) {
         iterator.push(nextEntry);
-        return callback(null, null);
+        return callback();
     }
     // Determine type from entry
     var type = entry.type;
-    // Default modes (decimal values for Node 0.8 compatibility)
-    // 0o755 = 493, 0o644 = 420
-    var defaultMode = type === 'directory' ? 493 : 420;
+    var defaultMode = type === 'directory' ? _constantsts.UnixMode.DEFAULT_DIR : _constantsts.UnixMode.DEFAULT_FILE;
     // Build attributes from 7z entry
     // mtime must be timestamp (number) for FileAttributes compatibility
     var mtimeDate = entry.mtime || new Date();
@@ -63,7 +59,7 @@ function nextEntry(iterator, callback) {
     switch(type){
         case 'directory':
             attributes.type = 'directory';
-            return nextCallback(null, new _extractbaseiterator.DirectoryEntry(attributes));
+            return nextCallback(undefined, new _extractbaseiterator.DirectoryEntry(attributes));
         case 'link':
             {
                 // For symlinks, the file content IS the symlink target path
@@ -82,7 +78,7 @@ function nextEntry(iterator, callback) {
                         mode: attributes.mode,
                         linkpath: linkpath
                     };
-                    nextCallback(null, new _extractbaseiterator.SymbolicLinkEntry(linkAttributes));
+                    nextCallback(undefined, new _extractbaseiterator.SymbolicLinkEntry(linkAttributes));
                 });
                 stream.on('error', function(streamErr) {
                     nextCallback(streamErr);
@@ -95,7 +91,7 @@ function nextEntry(iterator, callback) {
                 attributes.size = entry.size;
                 var parser1 = internalIter.getParser();
                 var stream1 = parser1.getEntryStream(entry);
-                return nextCallback(null, new _FileEntryts.default(attributes, stream1, iterator.lock, entry._canStream));
+                return nextCallback(undefined, new _FileEntryts.default(attributes, stream1, iterator.lock, entry._canStream));
             }
     }
     return callback(new Error("Unrecognized entry type: ".concat(type)));

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 path from 'path';\nimport FileEntry from './FileEntry.ts';\nimport type SevenZipIterator from './SevenZipIterator.ts';\nimport type { SevenZipEntry, SevenZipParser } from './sevenz/SevenZipParser.ts';\nimport type { Entry, EntryCallback } from './types.ts';\n\nexport type NextCallback = (error?: Error, entry?: Entry) => void;\n\n/** @internal */\ninterface InternalIterator {\n  next(): SevenZipEntry | null;\n  getParser(): SevenZipParser;\n}\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): void {\n  const internalIter = iterator._iterator as InternalIterator | null;\n  if (!internalIter) {\n    callback(new Error('iterator missing'));\n    return;\n  }\n\n  let entry: SevenZipEntry | null = null;\n  entry = internalIter.next();\n\n  const 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  const type = entry.type;\n\n  // Default modes (decimal values for Node 0.8 compatibility)\n  // 0o755 = 493, 0o644 = 420\n  const defaultMode = type === 'directory' ? 493 : 420;\n\n  // Build attributes from 7z entry\n  // mtime must be timestamp (number) for FileAttributes compatibility\n  const mtimeDate = entry.mtime || new Date();\n  const attributes: EntryAttributesBuilder = {\n    path: entry.path.split(path.sep).filter(Boolean).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      const parser = internalIter.getParser();\n      const stream = parser.getEntryStream(entry);\n\n      const chunks: Buffer[] = [];\n\n      stream.on('data', (chunk: Buffer) => {\n        chunks.push(chunk);\n      });\n      stream.on('end', () => {\n        const linkpath = Buffer.concat(chunks).toString('utf8');\n\n        const 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      return;\n    }\n\n    case 'file': {\n      attributes.type = 'file';\n      attributes.size = entry.size;\n      const parser = internalIter.getParser();\n\n      const stream = parser.getEntryStream(entry);\n      return nextCallback(null, new FileEntry(attributes as FileAttributes, stream, iterator.lock, entry._canStream));\n    }\n  }\n\n  return callback(new Error(`Unrecognized entry type: ${type}`));\n}\n"],"names":["nextEntry","iterator","callback","internalIter","_iterator","Error","entry","next","nextCallback","once","err","push","done","value","lock","isDone","isAntiFile","type","defaultMode","mtimeDate","mtime","Date","attributes","path","split","sep","filter","Boolean","join","basename","name","getTime","mode","undefined","DirectoryEntry","parser","getParser","stream","getEntryStream","chunks","on","chunk","linkpath","Buffer","concat","toString","linkAttributes","SymbolicLinkEntry","streamErr","size","FileEntry","_canStream"],"mappings":";;;;+BA2BA;;;eAAwBA;;;iEA3BP;mCACqG;2DACrG;kEACK;;;;;;AAwBP,SAASA,UAAcC,QAA0B,EAAEC,QAAuB;IACvF,IAAMC,eAAeF,SAASG,SAAS;IACvC,IAAI,CAACD,cAAc;QACjBD,SAAS,IAAIG,MAAM;QACnB;IACF;IAEA,IAAIC,QAA8B;IAClCA,QAAQH,aAAaI,IAAI;IAEzB,IAAMC,eAAeC,IAAAA,mBAAI,EAAC,SAACC,KAAaJ;QACtC,kBAAkB;QAClB,IAAIA,OAAOL,SAASU,IAAI,CAACX;QACzBU,MAAMR,SAASQ,OAAOR,SAAS,MAAMI,QAAQ;YAAEM,MAAM;YAAOC,OAAOP;QAAM,IAAI;YAAEM,MAAM;YAAMC,OAAO;QAAK;IACzG;IAEA,gEAAgE;IAChE,IAAI,CAACZ,SAASa,IAAI,IAAIb,SAASc,MAAM,MAAM,CAACT,OAAO,OAAOJ,SAAS,MAAM;QAAEU,MAAM;QAAMC,OAAO;IAAK;IAEnG,iEAAiE;IACjE,IAAIP,MAAMU,UAAU,EAAE;QACpBf,SAASU,IAAI,CAACX;QACd,OAAOE,SAAS,MAAM;IACxB;IAEA,4BAA4B;IAC5B,IAAMe,OAAOX,MAAMW,IAAI;IAEvB,4DAA4D;IAC5D,2BAA2B;IAC3B,IAAMC,cAAcD,SAAS,cAAc,MAAM;IAEjD,iCAAiC;IACjC,oEAAoE;IACpE,IAAME,YAAYb,MAAMc,KAAK,IAAI,IAAIC;IACrC,IAAMC,aAAqC;QACzCC,MAAMjB,MAAMiB,IAAI,CAACC,KAAK,CAACD,aAAI,CAACE,GAAG,EAAEC,MAAM,CAACC,SAASC,IAAI,CAACL,aAAI,CAACE,GAAG;QAC9DI,UAAUvB,MAAMwB,IAAI;QACpBV,OAAOD,UAAUY,OAAO;QACxBC,MAAM1B,MAAM0B,IAAI,KAAKC,YAAY3B,MAAM0B,IAAI,GAAGd;IAChD;IAEA,OAAQD;QACN,KAAK;YACHK,WAAWL,IAAI,GAAG;YAClB,OAAOT,aAAa,MAAM,IAAI0B,mCAAc,CAACZ;QAE/C,KAAK;YAAQ;gBACX,4DAA4D;gBAC5D,6DAA6D;gBAC7D,IAAMa,SAAShC,aAAaiC,SAAS;gBACrC,IAAMC,SAASF,OAAOG,cAAc,CAAChC;gBAErC,IAAMiC,SAAmB,EAAE;gBAE3BF,OAAOG,EAAE,CAAC,QAAQ,SAACC;oBACjBF,OAAO5B,IAAI,CAAC8B;gBACd;gBACAJ,OAAOG,EAAE,CAAC,OAAO;oBACf,IAAME,WAAWC,OAAOC,MAAM,CAACL,QAAQM,QAAQ,CAAC;oBAEhD,IAAMC,iBAAiC;wBACrCvB,MAAMD,WAAWC,IAAI;wBACrBH,OAAOE,WAAWF,KAAK;wBACvBY,MAAMV,WAAWU,IAAI;wBACrBU,UAAUA;oBACZ;oBAEAlC,aAAa,MAAM,IAAIuC,sCAAiB,CAACD;gBAC3C;gBACAT,OAAOG,EAAE,CAAC,SAAS,SAACQ;oBAClBxC,aAAawC;gBACf;gBACA;YACF;QAEA,KAAK;YAAQ;gBACX1B,WAAWL,IAAI,GAAG;gBAClBK,WAAW2B,IAAI,GAAG3C,MAAM2C,IAAI;gBAC5B,IAAMd,UAAShC,aAAaiC,SAAS;gBAErC,IAAMC,UAASF,QAAOG,cAAc,CAAChC;gBACrC,OAAOE,aAAa,MAAM,IAAI0C,oBAAS,CAAC5B,YAA8Be,SAAQpC,SAASa,IAAI,EAAER,MAAM6C,UAAU;YAC/G;IACF;IAEA,OAAOjD,SAAS,IAAIG,MAAM,AAAC,4BAAgC,OAALY;AACxD"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/nextEntry.ts"],"sourcesContent":["import type { CallFn } from 'call-once-fn';\nimport once from 'call-once-fn';\nimport { type DirectoryAttributes, DirectoryEntry, type FileAttributes, type LinkAttributes, type Lock, SymbolicLinkEntry } from 'extract-base-iterator';\nimport path from 'path';\nimport FileEntry from './FileEntry.ts';\nimport type SevenZipIterator from './SevenZipIterator.ts';\nimport { UnixMode } from './sevenz/constants.ts';\nimport type { SevenZipEntry, SevenZipParser } from './sevenz/SevenZipParser.ts';\nimport type { Entry, EntryCallback } from './types.ts';\n\nexport type NextCallback = (error?: Error, entry?: Entry) => void;\n\n/** @internal */\ninterface InternalIterator {\n  next(): SevenZipEntry | null;\n  getParser(): SevenZipParser;\n}\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): void {\n  const internalIter = iterator._iterator as InternalIterator | null;\n  if (!internalIter) {\n    callback(new Error('iterator missing'));\n    return;\n  }\n\n  let entry: SevenZipEntry | null = null;\n  entry = internalIter.next();\n\n  const nextCallback = once(((err?: Error, entry?: Entry) => {\n    if (entry) iterator.push(nextEntry as unknown as Parameters<typeof iterator.push>[0]);\n    err ? callback(err) : callback(undefined, entry ? { done: false, value: entry } : { done: true, value: undefined as unknown as Entry });\n  }) as unknown as CallFn) as unknown as NextCallback;\n\n  if (!iterator.lock || iterator.isDone() || !entry) return callback(undefined, { done: true, value: undefined as unknown as Entry });\n\n  if (entry.isAntiFile) {\n    iterator.push(nextEntry as unknown as Parameters<typeof iterator.push>[0]);\n    return callback();\n  }\n\n  // Determine type from entry\n  const type = entry.type;\n\n  const defaultMode = type === 'directory' ? UnixMode.DEFAULT_DIR : UnixMode.DEFAULT_FILE;\n\n  // Build attributes from 7z entry\n  // mtime must be timestamp (number) for FileAttributes compatibility\n  const mtimeDate = entry.mtime || new Date();\n  const attributes: EntryAttributesBuilder = {\n    path: entry.path.split(path.sep).filter(Boolean).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(undefined, 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      const parser = internalIter.getParser();\n      const stream = parser.getEntryStream(entry);\n\n      const chunks: Buffer[] = [];\n\n      stream.on('data', (chunk: Buffer) => {\n        chunks.push(chunk);\n      });\n      stream.on('end', () => {\n        const linkpath = Buffer.concat(chunks).toString('utf8');\n\n        const linkAttributes: LinkAttributes = {\n          path: attributes.path,\n          mtime: attributes.mtime,\n          mode: attributes.mode,\n          linkpath: linkpath,\n        };\n\n        nextCallback(undefined, new SymbolicLinkEntry(linkAttributes));\n      });\n      stream.on('error', (streamErr: Error) => {\n        nextCallback(streamErr);\n      });\n      return;\n    }\n\n    case 'file': {\n      attributes.type = 'file';\n      attributes.size = entry.size;\n      const parser = internalIter.getParser();\n\n      const stream = parser.getEntryStream(entry);\n      return nextCallback(undefined, new FileEntry(attributes as FileAttributes, stream, iterator.lock as Lock, entry._canStream));\n    }\n  }\n\n  return callback(new Error(`Unrecognized entry type: ${type}`));\n}\n"],"names":["nextEntry","iterator","callback","internalIter","_iterator","Error","entry","next","nextCallback","once","err","push","undefined","done","value","lock","isDone","isAntiFile","type","defaultMode","UnixMode","DEFAULT_DIR","DEFAULT_FILE","mtimeDate","mtime","Date","attributes","path","split","sep","filter","Boolean","join","basename","name","getTime","mode","DirectoryEntry","parser","getParser","stream","getEntryStream","chunks","on","chunk","linkpath","Buffer","concat","toString","linkAttributes","SymbolicLinkEntry","streamErr","size","FileEntry","_canStream"],"mappings":";;;;+BA6BA;;;eAAwBA;;;iEA5BP;mCACgH;2DAChH;kEACK;2BAEG;;;;;;AAuBV,SAASA,UAAcC,QAA0B,EAAEC,QAAuB;IACvF,IAAMC,eAAeF,SAASG,SAAS;IACvC,IAAI,CAACD,cAAc;QACjBD,SAAS,IAAIG,MAAM;QACnB;IACF;IAEA,IAAIC,QAA8B;IAClCA,QAAQH,aAAaI,IAAI;IAEzB,IAAMC,eAAeC,IAAAA,mBAAI,EAAE,SAACC,KAAaJ;QACvC,IAAIA,OAAOL,SAASU,IAAI,CAACX;QACzBU,MAAMR,SAASQ,OAAOR,SAASU,WAAWN,QAAQ;YAAEO,MAAM;YAAOC,OAAOR;QAAM,IAAI;YAAEO,MAAM;YAAMC,OAAOF;QAA8B;IACvI;IAEA,IAAI,CAACX,SAASc,IAAI,IAAId,SAASe,MAAM,MAAM,CAACV,OAAO,OAAOJ,SAASU,WAAW;QAAEC,MAAM;QAAMC,OAAOF;IAA8B;IAEjI,IAAIN,MAAMW,UAAU,EAAE;QACpBhB,SAASU,IAAI,CAACX;QACd,OAAOE;IACT;IAEA,4BAA4B;IAC5B,IAAMgB,OAAOZ,MAAMY,IAAI;IAEvB,IAAMC,cAAcD,SAAS,cAAcE,qBAAQ,CAACC,WAAW,GAAGD,qBAAQ,CAACE,YAAY;IAEvF,iCAAiC;IACjC,oEAAoE;IACpE,IAAMC,YAAYjB,MAAMkB,KAAK,IAAI,IAAIC;IACrC,IAAMC,aAAqC;QACzCC,MAAMrB,MAAMqB,IAAI,CAACC,KAAK,CAACD,aAAI,CAACE,GAAG,EAAEC,MAAM,CAACC,SAASC,IAAI,CAACL,aAAI,CAACE,GAAG;QAC9DI,UAAU3B,MAAM4B,IAAI;QACpBV,OAAOD,UAAUY,OAAO;QACxBC,MAAM9B,MAAM8B,IAAI,KAAKxB,YAAYN,MAAM8B,IAAI,GAAGjB;IAChD;IAEA,OAAQD;QACN,KAAK;YACHQ,WAAWR,IAAI,GAAG;YAClB,OAAOV,aAAaI,WAAW,IAAIyB,mCAAc,CAACX;QAEpD,KAAK;YAAQ;gBACX,4DAA4D;gBAC5D,6DAA6D;gBAC7D,IAAMY,SAASnC,aAAaoC,SAAS;gBACrC,IAAMC,SAASF,OAAOG,cAAc,CAACnC;gBAErC,IAAMoC,SAAmB,EAAE;gBAE3BF,OAAOG,EAAE,CAAC,QAAQ,SAACC;oBACjBF,OAAO/B,IAAI,CAACiC;gBACd;gBACAJ,OAAOG,EAAE,CAAC,OAAO;oBACf,IAAME,WAAWC,OAAOC,MAAM,CAACL,QAAQM,QAAQ,CAAC;oBAEhD,IAAMC,iBAAiC;wBACrCtB,MAAMD,WAAWC,IAAI;wBACrBH,OAAOE,WAAWF,KAAK;wBACvBY,MAAMV,WAAWU,IAAI;wBACrBS,UAAUA;oBACZ;oBAEArC,aAAaI,WAAW,IAAIsC,sCAAiB,CAACD;gBAChD;gBACAT,OAAOG,EAAE,CAAC,SAAS,SAACQ;oBAClB3C,aAAa2C;gBACf;gBACA;YACF;QAEA,KAAK;YAAQ;gBACXzB,WAAWR,IAAI,GAAG;gBAClBQ,WAAW0B,IAAI,GAAG9C,MAAM8C,IAAI;gBAC5B,IAAMd,UAASnC,aAAaoC,SAAS;gBAErC,IAAMC,UAASF,QAAOG,cAAc,CAACnC;gBACrC,OAAOE,aAAaI,WAAW,IAAIyC,oBAAS,CAAC3B,YAA8Bc,SAAQvC,SAASc,IAAI,EAAUT,MAAMgD,UAAU;YAC5H;IACF;IAEA,OAAOpD,SAAS,IAAIG,MAAM,AAAC,4BAAgC,OAALa;AACxD"}

package/dist/cjs/sevenz/SevenZipParser.js

@@ -81,6 +81,7 @@ function _class_call_check(instance, Constructor) {
     }
 }
 function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
     } else {
@@ -273,7 +274,7 @@ var SevenZipParser = /*#__PURE__*/ function() {
             callback(err);
             return;
         }
-        var finalize = function() {
+        var finalize = function finalize() {
             try {
                 _this.buildEntries();
                 _this.parsed = true;
@@ -351,7 +352,7 @@ var SevenZipParser = /*#__PURE__*/ function() {
                 }
             }
         }
-        var tryCandidate = function(index) {
+        var tryCandidate = function tryCandidate1(index) {
             if (index >= candidates.length) {
                 callback((0, _constantsts.createCodedError)('Failed to decompress header - could not find valid LZMA data', _constantsts.ErrorCode.CORRUPT_HEADER));
                 return;
@@ -944,7 +945,7 @@ var SevenZipParser = /*#__PURE__*/ function() {
             inputToPackStream[folder.packedStreams[pi]] = pi;
         }
         var processOrder = this.getCoderProcessOrder(folder, bcj2CoderIndex);
-        var processNext = function(orderIndex) {
+        var processNext = function processNext1(orderIndex) {
             if (orderIndex >= processOrder.length) {
                 _this.finishBcj2Decode(folder, bcj2CoderIndex, coderOutputs, inputToPackStream, packStreams, callback);
                 return;
@@ -1172,13 +1173,13 @@ var SevenZipParser = /*#__PURE__*/ function() {
         }
         return {
             output: stream,
-            pause: function() {
+            pause: function pause() {
                 return packedStream.pause();
             },
-            resume: function() {
+            resume: function resume() {
                 return packedStream.resume();
             },
-            destroy: function(err) {
+            destroy: function destroy(err) {
                 // Check for destroy method existence (not available in Node 4 and earlier)
                 var ps = packedStream;
                 if (typeof ps.destroy === 'function') ps.destroy(err);