extract-base-iterator 3.3.0 → 3.3.1

package/dist/cjs/waitForAccess.d.cts

@@ -1,2 +1,2 @@
 import type { NoParamCallback } from './types.js';
-export default function waitForAccess(fullPath: string, noFollowOrCallback: boolean | NoParamCallback, callbackOrAttempts?: NoParamCallback | number, attempts?: number): void;
+export default function waitForAccess(fullPath: string, noFollow: boolean | NoParamCallback, callback?: NoParamCallback | number): void;

package/dist/cjs/waitForAccess.d.ts

@@ -1,2 +1,2 @@
 import type { NoParamCallback } from './types.js';
-export default function waitForAccess(fullPath: string, noFollowOrCallback: boolean | NoParamCallback, callbackOrAttempts?: NoParamCallback | number, attempts?: number): void;
+export default function waitForAccess(fullPath: string, noFollow: boolean | NoParamCallback, callback?: NoParamCallback | number): void;

package/dist/cjs/waitForAccess.js

@@ -15,58 +15,45 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
-var isWindows = process.platform === 'win32' || /^(msys|cygwin)$/.test(process.env.OSTYPE);
-function waitForAccess(fullPath, noFollowOrCallback, callbackOrAttempts) {
-    var attempts = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0;
-    // Parse arguments for backward compatibility
-    var noFollow;
-    var callback;
-    if (typeof noFollowOrCallback === 'function') {
-        // Old signature: waitForAccess(path, callback, attempts?)
-        noFollow = false;
-        callback = noFollowOrCallback;
-        attempts = callbackOrAttempts || 0;
-    } else {
-        // New signature: waitForAccess(path, noFollow, callback, attempts?)
-        noFollow = noFollowOrCallback;
-        callback = callbackOrAttempts;
-    }
-    // POSIX: finish event is reliable after decompression stream fixes
-    // Avoid Zalgo: ensure callback is always async for consistent API
-    if (!isWindows) return process.nextTick(callback);
-    // Windows: NTFS metadata may not be committed yet, verify accessibility
-    // For symlinks (noFollow=true), use lstat to check the link itself exists
-    // For files/dirs/hardlinks, use open to verify the file is accessible
-    if (noFollow) {
+function waitForAccess(fullPath, noFollow, callback) {
+    callback = typeof noFollow === 'function' ? noFollow : callback;
+    noFollow = typeof noFollow === 'function' ? false : noFollow;
+    // Exponential backoff: 5, 10, 20, 40, 80, 160, 320, 640, 1280, 2560ms
+    // Total max wait: ~5 seconds
+    function waitSymlink(attempts, cb) {
         _fs.default.lstat(fullPath, function(err) {
             if (err) {
                 if (err.code === 'ENOENT' && attempts < 10) {
                     var delay = Math.min(5 * Math.pow(2, attempts), 2560);
                     return setTimeout(function() {
-                        return waitForAccess(fullPath, noFollow, callback, attempts + 1);
+                        return waitSymlink(attempts + 1, cb);
                     }, delay);
                 }
-                return callback(err);
+                return cb(err);
             }
-            callback();
+            cb();
         });
-    } else {
+    }
+    function waitOpen(attempts, cb) {
         _fs.default.open(fullPath, 'r', function(err, fd) {
             if (err) {
                 if (err.code === 'ENOENT' && attempts < 10) {
-                    // Exponential backoff: 5, 10, 20, 40, 80, 160, 320, 640, 1280, 2560ms
-                    // Total max wait: ~5 seconds
                     var delay = Math.min(5 * Math.pow(2, attempts), 2560);
                     return setTimeout(function() {
-                        return waitForAccess(fullPath, noFollow, callback, attempts + 1);
+                        return waitOpen(attempts + 1, cb);
                     }, delay);
                 }
-                return callback(err);
+                return cb(err);
             }
             _fs.default.close(fd, function() {
-                return callback();
+                return cb();
             });
         });
     }
+    // Windows: NTFS metadata may not be committed yet, verify accessibility
+    // Node 0.10: the write stream's finish/close events may fire before the file is fully flushed to disk
+    // For symlinks (noFollow=true), use lstat to check the link itself exists
+    // For files/dirs/hardlinks, use open to verify the file is accessible
+    noFollow ? waitSymlink(0, callback) : waitOpen(0, callback);
 }
 /* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/waitForAccess.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/waitForAccess.ts"],"sourcesContent":["import fs from 'fs';\n\nimport type { NoParamCallback } from './types.ts';\n\nconst isWindows = process.platform === 'win32' || /^(msys|cygwin)$/.test(process.env.OSTYPE);\n\n// Backward compatible: waitForAccess(path, callback) or waitForAccess(path, noFollow, callback)\nexport default function waitForAccess(fullPath: string, noFollowOrCallback: boolean | NoParamCallback, callbackOrAttempts?: NoParamCallback | number, attempts = 0) {\n  // Parse arguments for backward compatibility\n  let noFollow: boolean;\n  let callback: NoParamCallback;\n  if (typeof noFollowOrCallback === 'function') {\n    // Old signature: waitForAccess(path, callback, attempts?)\n    noFollow = false;\n    callback = noFollowOrCallback;\n    attempts = (callbackOrAttempts as number) || 0;\n  } else {\n    // New signature: waitForAccess(path, noFollow, callback, attempts?)\n    noFollow = noFollowOrCallback;\n    callback = callbackOrAttempts as NoParamCallback;\n  }\n\n  // POSIX: finish event is reliable after decompression stream fixes\n  // Avoid Zalgo: ensure callback is always async for consistent API\n  if (!isWindows) return process.nextTick(callback);\n\n  // Windows: NTFS metadata may not be committed yet, verify accessibility\n  // For symlinks (noFollow=true), use lstat to check the link itself exists\n  // For files/dirs/hardlinks, use open to verify the file is accessible\n  if (noFollow) {\n    fs.lstat(fullPath, (err) => {\n      if (err) {\n        if (err.code === 'ENOENT' && attempts < 10) {\n          const delay = Math.min(5 * 2 ** attempts, 2560);\n          return setTimeout(() => waitForAccess(fullPath, noFollow, callback, attempts + 1), delay);\n        }\n        return callback(err);\n      }\n      callback();\n    });\n  } else {\n    fs.open(fullPath, 'r', (err, fd) => {\n      if (err) {\n        if (err.code === 'ENOENT' && attempts < 10) {\n          // Exponential backoff: 5, 10, 20, 40, 80, 160, 320, 640, 1280, 2560ms\n          // Total max wait: ~5 seconds\n          const delay = Math.min(5 * 2 ** attempts, 2560);\n          return setTimeout(() => waitForAccess(fullPath, noFollow, callback, attempts + 1), delay);\n        }\n        return callback(err);\n      }\n      fs.close(fd, () => callback());\n    });\n  }\n}\n"],"names":["waitForAccess","isWindows","process","platform","test","env","OSTYPE","fullPath","noFollowOrCallback","callbackOrAttempts","attempts","noFollow","callback","nextTick","fs","lstat","err","code","delay","Math","min","setTimeout","open","fd","close"],"mappings":";;;;+BAMA,gGAAgG;AAChG;;;eAAwBA;;;yDAPT;;;;;;AAIf,IAAMC,YAAYC,QAAQC,QAAQ,KAAK,WAAW,kBAAkBC,IAAI,CAACF,QAAQG,GAAG,CAACC,MAAM;AAG5E,SAASN,cAAcO,QAAgB,EAAEC,kBAA6C,EAAEC,kBAA6C;QAAEC,WAAAA,iEAAW;IAC/J,6CAA6C;IAC7C,IAAIC;IACJ,IAAIC;IACJ,IAAI,OAAOJ,uBAAuB,YAAY;QAC5C,0DAA0D;QAC1DG,WAAW;QACXC,WAAWJ;QACXE,WAAW,AAACD,sBAAiC;IAC/C,OAAO;QACL,oEAAoE;QACpEE,WAAWH;QACXI,WAAWH;IACb;IAEA,mEAAmE;IACnE,kEAAkE;IAClE,IAAI,CAACR,WAAW,OAAOC,QAAQW,QAAQ,CAACD;IAExC,wEAAwE;IACxE,0EAA0E;IAC1E,sEAAsE;IACtE,IAAID,UAAU;QACZG,WAAE,CAACC,KAAK,CAACR,UAAU,SAACS;YAClB,IAAIA,KAAK;gBACP,IAAIA,IAAIC,IAAI,KAAK,YAAYP,WAAW,IAAI;oBAC1C,IAAMQ,QAAQC,KAAKC,GAAG,CAAC,aAAI,GAAKV,WAAU;oBAC1C,OAAOW,WAAW;+BAAMrB,cAAcO,UAAUI,UAAUC,UAAUF,WAAW;uBAAIQ;gBACrF;gBACA,OAAON,SAASI;YAClB;YACAJ;QACF;IACF,OAAO;QACLE,WAAE,CAACQ,IAAI,CAACf,UAAU,KAAK,SAACS,KAAKO;YAC3B,IAAIP,KAAK;gBACP,IAAIA,IAAIC,IAAI,KAAK,YAAYP,WAAW,IAAI;oBAC1C,sEAAsE;oBACtE,6BAA6B;oBAC7B,IAAMQ,QAAQC,KAAKC,GAAG,CAAC,aAAI,GAAKV,WAAU;oBAC1C,OAAOW,WAAW;+BAAMrB,cAAcO,UAAUI,UAAUC,UAAUF,WAAW;uBAAIQ;gBACrF;gBACA,OAAON,SAASI;YAClB;YACAF,WAAE,CAACU,KAAK,CAACD,IAAI;uBAAMX;;QACrB;IACF;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/waitForAccess.ts"],"sourcesContent":["import fs from 'fs';\n\nimport type { NoParamCallback } from './types.ts';\n\n// Backward compatible: waitForAccess(path, callback) or waitForAccess(path, noFollow, callback)\nexport default function waitForAccess(fullPath: string, noFollow: boolean | NoParamCallback, callback?: NoParamCallback | number) {\n  callback = typeof noFollow === 'function' ? noFollow : callback;\n  noFollow = typeof noFollow === 'function' ? false : (noFollow as boolean);\n\n  // Exponential backoff: 5, 10, 20, 40, 80, 160, 320, 640, 1280, 2560ms\n  // Total max wait: ~5 seconds\n  function waitSymlink(attempts, cb) {\n    fs.lstat(fullPath, (err) => {\n      if (err) {\n        if (err.code === 'ENOENT' && attempts < 10) {\n          const delay = Math.min(5 * 2 ** attempts, 2560);\n          return setTimeout(() => waitSymlink(attempts + 1, cb), delay);\n        }\n        return cb(err);\n      }\n      cb();\n    });\n  }\n  function waitOpen(attempts, cb) {\n    fs.open(fullPath, 'r', (err, fd) => {\n      if (err) {\n        if (err.code === 'ENOENT' && attempts < 10) {\n          const delay = Math.min(5 * 2 ** attempts, 2560);\n          return setTimeout(() => waitOpen(attempts + 1, cb), delay);\n        }\n        return cb(err);\n      }\n      fs.close(fd, () => cb());\n    });\n  }\n\n  // Windows: NTFS metadata may not be committed yet, verify accessibility\n  // Node 0.10: the write stream's finish/close events may fire before the file is fully flushed to disk\n  // For symlinks (noFollow=true), use lstat to check the link itself exists\n  // For files/dirs/hardlinks, use open to verify the file is accessible\n  noFollow ? waitSymlink(0, callback) : waitOpen(0, callback);\n}\n"],"names":["waitForAccess","fullPath","noFollow","callback","waitSymlink","attempts","cb","fs","lstat","err","code","delay","Math","min","setTimeout","waitOpen","open","fd","close"],"mappings":";;;;+BAIA,gGAAgG;AAChG;;;eAAwBA;;;yDALT;;;;;;AAKA,SAASA,cAAcC,QAAgB,EAAEC,QAAmC,EAAEC,QAAmC;IAC9HA,WAAW,OAAOD,aAAa,aAAaA,WAAWC;IACvDD,WAAW,OAAOA,aAAa,aAAa,QAASA;IAErD,sEAAsE;IACtE,6BAA6B;IAC7B,SAASE,YAAYC,QAAQ,EAAEC,EAAE;QAC/BC,WAAE,CAACC,KAAK,CAACP,UAAU,SAACQ;YAClB,IAAIA,KAAK;gBACP,IAAIA,IAAIC,IAAI,KAAK,YAAYL,WAAW,IAAI;oBAC1C,IAAMM,QAAQC,KAAKC,GAAG,CAAC,aAAI,GAAKR,WAAU;oBAC1C,OAAOS,WAAW;+BAAMV,YAAYC,WAAW,GAAGC;uBAAKK;gBACzD;gBACA,OAAOL,GAAGG;YACZ;YACAH;QACF;IACF;IACA,SAASS,SAASV,QAAQ,EAAEC,EAAE;QAC5BC,WAAE,CAACS,IAAI,CAACf,UAAU,KAAK,SAACQ,KAAKQ;YAC3B,IAAIR,KAAK;gBACP,IAAIA,IAAIC,IAAI,KAAK,YAAYL,WAAW,IAAI;oBAC1C,IAAMM,QAAQC,KAAKC,GAAG,CAAC,aAAI,GAAKR,WAAU;oBAC1C,OAAOS,WAAW;+BAAMC,SAASV,WAAW,GAAGC;uBAAKK;gBACtD;gBACA,OAAOL,GAAGG;YACZ;YACAF,WAAE,CAACW,KAAK,CAACD,IAAI;uBAAMX;;QACrB;IACF;IAEA,wEAAwE;IACxE,sGAAsG;IACtG,0EAA0E;IAC1E,sEAAsE;IACtEJ,WAAWE,YAAY,GAAGD,YAAYY,SAAS,GAAGZ;AACpD"}

package/dist/esm/waitForAccess.d.ts

@@ -1,2 +1,2 @@
 import type { NoParamCallback } from './types.js';
-export default function waitForAccess(fullPath: string, noFollowOrCallback: boolean | NoParamCallback, callbackOrAttempts?: NoParamCallback | number, attempts?: number): void;
+export default function waitForAccess(fullPath: string, noFollow: boolean | NoParamCallback, callback?: NoParamCallback | number): void;

package/dist/esm/waitForAccess.js

@@ -1,49 +1,37 @@
 import fs from 'fs';
-const isWindows = process.platform === 'win32' || /^(msys|cygwin)$/.test(process.env.OSTYPE);
 // Backward compatible: waitForAccess(path, callback) or waitForAccess(path, noFollow, callback)
-export default function waitForAccess(fullPath, noFollowOrCallback, callbackOrAttempts, attempts = 0) {
-    // Parse arguments for backward compatibility
-    let noFollow;
-    let callback;
-    if (typeof noFollowOrCallback === 'function') {
-        // Old signature: waitForAccess(path, callback, attempts?)
-        noFollow = false;
-        callback = noFollowOrCallback;
-        attempts = callbackOrAttempts || 0;
-    } else {
-        // New signature: waitForAccess(path, noFollow, callback, attempts?)
-        noFollow = noFollowOrCallback;
-        callback = callbackOrAttempts;
-    }
-    // POSIX: finish event is reliable after decompression stream fixes
-    // Avoid Zalgo: ensure callback is always async for consistent API
-    if (!isWindows) return process.nextTick(callback);
-    // Windows: NTFS metadata may not be committed yet, verify accessibility
-    // For symlinks (noFollow=true), use lstat to check the link itself exists
-    // For files/dirs/hardlinks, use open to verify the file is accessible
-    if (noFollow) {
+export default function waitForAccess(fullPath, noFollow, callback) {
+    callback = typeof noFollow === 'function' ? noFollow : callback;
+    noFollow = typeof noFollow === 'function' ? false : noFollow;
+    // Exponential backoff: 5, 10, 20, 40, 80, 160, 320, 640, 1280, 2560ms
+    // Total max wait: ~5 seconds
+    function waitSymlink(attempts, cb) {
         fs.lstat(fullPath, (err)=>{
             if (err) {
                 if (err.code === 'ENOENT' && attempts < 10) {
                     const delay = Math.min(5 * 2 ** attempts, 2560);
-                    return setTimeout(()=>waitForAccess(fullPath, noFollow, callback, attempts + 1), delay);
+                    return setTimeout(()=>waitSymlink(attempts + 1, cb), delay);
                 }
-                return callback(err);
+                return cb(err);
             }
-            callback();
+            cb();
         });
-    } else {
+    }
+    function waitOpen(attempts, cb) {
         fs.open(fullPath, 'r', (err, fd)=>{
             if (err) {
                 if (err.code === 'ENOENT' && attempts < 10) {
-                    // Exponential backoff: 5, 10, 20, 40, 80, 160, 320, 640, 1280, 2560ms
-                    // Total max wait: ~5 seconds
                     const delay = Math.min(5 * 2 ** attempts, 2560);
-                    return setTimeout(()=>waitForAccess(fullPath, noFollow, callback, attempts + 1), delay);
+                    return setTimeout(()=>waitOpen(attempts + 1, cb), delay);
                 }
-                return callback(err);
+                return cb(err);
             }
-            fs.close(fd, ()=>callback());
+            fs.close(fd, ()=>cb());
         });
     }
+    // Windows: NTFS metadata may not be committed yet, verify accessibility
+    // Node 0.10: the write stream's finish/close events may fire before the file is fully flushed to disk
+    // For symlinks (noFollow=true), use lstat to check the link itself exists
+    // For files/dirs/hardlinks, use open to verify the file is accessible
+    noFollow ? waitSymlink(0, callback) : waitOpen(0, callback);
 }

package/dist/esm/waitForAccess.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/waitForAccess.ts"],"sourcesContent":["import fs from 'fs';\n\nimport type { NoParamCallback } from './types.ts';\n\nconst isWindows = process.platform === 'win32' || /^(msys|cygwin)$/.test(process.env.OSTYPE);\n\n// Backward compatible: waitForAccess(path, callback) or waitForAccess(path, noFollow, callback)\nexport default function waitForAccess(fullPath: string, noFollowOrCallback: boolean | NoParamCallback, callbackOrAttempts?: NoParamCallback | number, attempts = 0) {\n  // Parse arguments for backward compatibility\n  let noFollow: boolean;\n  let callback: NoParamCallback;\n  if (typeof noFollowOrCallback === 'function') {\n    // Old signature: waitForAccess(path, callback, attempts?)\n    noFollow = false;\n    callback = noFollowOrCallback;\n    attempts = (callbackOrAttempts as number) || 0;\n  } else {\n    // New signature: waitForAccess(path, noFollow, callback, attempts?)\n    noFollow = noFollowOrCallback;\n    callback = callbackOrAttempts as NoParamCallback;\n  }\n\n  // POSIX: finish event is reliable after decompression stream fixes\n  // Avoid Zalgo: ensure callback is always async for consistent API\n  if (!isWindows) return process.nextTick(callback);\n\n  // Windows: NTFS metadata may not be committed yet, verify accessibility\n  // For symlinks (noFollow=true), use lstat to check the link itself exists\n  // For files/dirs/hardlinks, use open to verify the file is accessible\n  if (noFollow) {\n    fs.lstat(fullPath, (err) => {\n      if (err) {\n        if (err.code === 'ENOENT' && attempts < 10) {\n          const delay = Math.min(5 * 2 ** attempts, 2560);\n          return setTimeout(() => waitForAccess(fullPath, noFollow, callback, attempts + 1), delay);\n        }\n        return callback(err);\n      }\n      callback();\n    });\n  } else {\n    fs.open(fullPath, 'r', (err, fd) => {\n      if (err) {\n        if (err.code === 'ENOENT' && attempts < 10) {\n          // Exponential backoff: 5, 10, 20, 40, 80, 160, 320, 640, 1280, 2560ms\n          // Total max wait: ~5 seconds\n          const delay = Math.min(5 * 2 ** attempts, 2560);\n          return setTimeout(() => waitForAccess(fullPath, noFollow, callback, attempts + 1), delay);\n        }\n        return callback(err);\n      }\n      fs.close(fd, () => callback());\n    });\n  }\n}\n"],"names":["fs","isWindows","process","platform","test","env","OSTYPE","waitForAccess","fullPath","noFollowOrCallback","callbackOrAttempts","attempts","noFollow","callback","nextTick","lstat","err","code","delay","Math","min","setTimeout","open","fd","close"],"mappings":"AAAA,OAAOA,QAAQ,KAAK;AAIpB,MAAMC,YAAYC,QAAQC,QAAQ,KAAK,WAAW,kBAAkBC,IAAI,CAACF,QAAQG,GAAG,CAACC,MAAM;AAE3F,gGAAgG;AAChG,eAAe,SAASC,cAAcC,QAAgB,EAAEC,kBAA6C,EAAEC,kBAA6C,EAAEC,WAAW,CAAC;IAChK,6CAA6C;IAC7C,IAAIC;IACJ,IAAIC;IACJ,IAAI,OAAOJ,uBAAuB,YAAY;QAC5C,0DAA0D;QAC1DG,WAAW;QACXC,WAAWJ;QACXE,WAAW,AAACD,sBAAiC;IAC/C,OAAO;QACL,oEAAoE;QACpEE,WAAWH;QACXI,WAAWH;IACb;IAEA,mEAAmE;IACnE,kEAAkE;IAClE,IAAI,CAACT,WAAW,OAAOC,QAAQY,QAAQ,CAACD;IAExC,wEAAwE;IACxE,0EAA0E;IAC1E,sEAAsE;IACtE,IAAID,UAAU;QACZZ,GAAGe,KAAK,CAACP,UAAU,CAACQ;YAClB,IAAIA,KAAK;gBACP,IAAIA,IAAIC,IAAI,KAAK,YAAYN,WAAW,IAAI;oBAC1C,MAAMO,QAAQC,KAAKC,GAAG,CAAC,IAAI,KAAKT,UAAU;oBAC1C,OAAOU,WAAW,IAAMd,cAAcC,UAAUI,UAAUC,UAAUF,WAAW,IAAIO;gBACrF;gBACA,OAAOL,SAASG;YAClB;YACAH;QACF;IACF,OAAO;QACLb,GAAGsB,IAAI,CAACd,UAAU,KAAK,CAACQ,KAAKO;YAC3B,IAAIP,KAAK;gBACP,IAAIA,IAAIC,IAAI,KAAK,YAAYN,WAAW,IAAI;oBAC1C,sEAAsE;oBACtE,6BAA6B;oBAC7B,MAAMO,QAAQC,KAAKC,GAAG,CAAC,IAAI,KAAKT,UAAU;oBAC1C,OAAOU,WAAW,IAAMd,cAAcC,UAAUI,UAAUC,UAAUF,WAAW,IAAIO;gBACrF;gBACA,OAAOL,SAASG;YAClB;YACAhB,GAAGwB,KAAK,CAACD,IAAI,IAAMV;QACrB;IACF;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/waitForAccess.ts"],"sourcesContent":["import fs from 'fs';\n\nimport type { NoParamCallback } from './types.ts';\n\n// Backward compatible: waitForAccess(path, callback) or waitForAccess(path, noFollow, callback)\nexport default function waitForAccess(fullPath: string, noFollow: boolean | NoParamCallback, callback?: NoParamCallback | number) {\n  callback = typeof noFollow === 'function' ? noFollow : callback;\n  noFollow = typeof noFollow === 'function' ? false : (noFollow as boolean);\n\n  // Exponential backoff: 5, 10, 20, 40, 80, 160, 320, 640, 1280, 2560ms\n  // Total max wait: ~5 seconds\n  function waitSymlink(attempts, cb) {\n    fs.lstat(fullPath, (err) => {\n      if (err) {\n        if (err.code === 'ENOENT' && attempts < 10) {\n          const delay = Math.min(5 * 2 ** attempts, 2560);\n          return setTimeout(() => waitSymlink(attempts + 1, cb), delay);\n        }\n        return cb(err);\n      }\n      cb();\n    });\n  }\n  function waitOpen(attempts, cb) {\n    fs.open(fullPath, 'r', (err, fd) => {\n      if (err) {\n        if (err.code === 'ENOENT' && attempts < 10) {\n          const delay = Math.min(5 * 2 ** attempts, 2560);\n          return setTimeout(() => waitOpen(attempts + 1, cb), delay);\n        }\n        return cb(err);\n      }\n      fs.close(fd, () => cb());\n    });\n  }\n\n  // Windows: NTFS metadata may not be committed yet, verify accessibility\n  // Node 0.10: the write stream's finish/close events may fire before the file is fully flushed to disk\n  // For symlinks (noFollow=true), use lstat to check the link itself exists\n  // For files/dirs/hardlinks, use open to verify the file is accessible\n  noFollow ? waitSymlink(0, callback) : waitOpen(0, callback);\n}\n"],"names":["fs","waitForAccess","fullPath","noFollow","callback","waitSymlink","attempts","cb","lstat","err","code","delay","Math","min","setTimeout","waitOpen","open","fd","close"],"mappings":"AAAA,OAAOA,QAAQ,KAAK;AAIpB,gGAAgG;AAChG,eAAe,SAASC,cAAcC,QAAgB,EAAEC,QAAmC,EAAEC,QAAmC;IAC9HA,WAAW,OAAOD,aAAa,aAAaA,WAAWC;IACvDD,WAAW,OAAOA,aAAa,aAAa,QAASA;IAErD,sEAAsE;IACtE,6BAA6B;IAC7B,SAASE,YAAYC,QAAQ,EAAEC,EAAE;QAC/BP,GAAGQ,KAAK,CAACN,UAAU,CAACO;YAClB,IAAIA,KAAK;gBACP,IAAIA,IAAIC,IAAI,KAAK,YAAYJ,WAAW,IAAI;oBAC1C,MAAMK,QAAQC,KAAKC,GAAG,CAAC,IAAI,KAAKP,UAAU;oBAC1C,OAAOQ,WAAW,IAAMT,YAAYC,WAAW,GAAGC,KAAKI;gBACzD;gBACA,OAAOJ,GAAGE;YACZ;YACAF;QACF;IACF;IACA,SAASQ,SAAST,QAAQ,EAAEC,EAAE;QAC5BP,GAAGgB,IAAI,CAACd,UAAU,KAAK,CAACO,KAAKQ;YAC3B,IAAIR,KAAK;gBACP,IAAIA,IAAIC,IAAI,KAAK,YAAYJ,WAAW,IAAI;oBAC1C,MAAMK,QAAQC,KAAKC,GAAG,CAAC,IAAI,KAAKP,UAAU;oBAC1C,OAAOQ,WAAW,IAAMC,SAAST,WAAW,GAAGC,KAAKI;gBACtD;gBACA,OAAOJ,GAAGE;YACZ;YACAT,GAAGkB,KAAK,CAACD,IAAI,IAAMV;QACrB;IACF;IAEA,wEAAwE;IACxE,sGAAsG;IACtG,0EAA0E;IAC1E,sEAAsE;IACtEJ,WAAWE,YAAY,GAAGD,YAAYW,SAAS,GAAGX;AACpD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "extract-base-iterator",
-  "version": "3.3.0",
+  "version": "3.3.1",
   "description": "Base iterator for extract iterators like tar-iterator and zip-iterator",
   "keywords": [
     "extract",