extract-base-iterator 3.3.4 → 3.3.5

package/dist/cjs/LinkEntry.js

@@ -65,6 +65,7 @@ var LinkEntry = /*#__PURE__*/ function() {
                     });
                 }
                 queue.defer(_mkdirpclassic.default.bind(null, _path.default.dirname(fullPath)));
+                queue.defer(_waitForAccessts.default.bind(null, linkFullPath)); // ensure target file is accessible before linking
                 queue.defer(_fs.default.link.bind(_fs.default, linkFullPath, fullPath));
                 queue.defer(_waitForAccessts.default.bind(null, fullPath));
                 queue.defer(_chmodts.default.bind(null, fullPath, this, options));

package/dist/cjs/LinkEntry.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/LinkEntry.ts"],"sourcesContent":["import fs from 'fs';\nimport { rm } from 'fs-remove-compat';\nimport mkdirp from 'mkdirp-classic';\nimport path from 'path';\nimport Queue from 'queue-cb';\nimport chmod from './fs/chmod.ts';\nimport chown from './fs/chown.ts';\nimport utimes from './fs/utimes.ts';\nimport { objectAssign } from './shared/index.ts';\nimport stripPath from './shared/stripPath.ts';\nimport validateAttributes from './validateAttributes.ts';\nimport waitForAccess from './waitForAccess.ts';\n\nconst MANDATORY_ATTRIBUTES = ['mode', 'mtime', 'path', 'linkpath'];\n\nimport type { Mode } from 'fs';\nimport type { ExtractOptions, LinkAttributes, NoParamCallback } from './types.ts';\n\nexport default class LinkEntry {\n  mode: Mode;\n  mtime: number;\n  path: string;\n  linkpath: string;\n  basename: string;\n  type: string;\n\n  constructor(attributes: LinkAttributes) {\n    validateAttributes(attributes, MANDATORY_ATTRIBUTES);\n    objectAssign(this, attributes);\n    if (this.basename === undefined) this.basename = path.basename(this.path);\n    if (this.type === undefined) this.type = 'link';\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      try {\n        const normalizedPath = path.normalize(this.path);\n        const fullPath = path.join(dest, stripPath(normalizedPath, options));\n        const normalizedLinkpath = path.normalize(this.linkpath);\n        const linkFullPath = path.join(dest, stripPath(normalizedLinkpath, options));\n\n        const queue = new Queue(1);\n        if (options.force) {\n          queue.defer((callback) => {\n            rm(fullPath, (err) => {\n              err && err.code !== 'ENOENT' ? callback(err) : callback();\n            });\n          });\n        }\n        queue.defer(mkdirp.bind(null, path.dirname(fullPath)));\n        queue.defer(fs.link.bind(fs, linkFullPath, fullPath));\n        queue.defer(waitForAccess.bind(null, fullPath));\n        queue.defer(chmod.bind(null, fullPath, this, options));\n        queue.defer(chown.bind(null, fullPath, this, options));\n        queue.defer(utimes.bind(null, fullPath, this, options));\n        queue.await(callback);\n        return;\n      } catch (err) {\n        callback(err);\n        return;\n      }\n    }\n\n    return new Promise((resolve, reject) => {\n      this.create(dest, options, (err?: Error, done?: boolean) => (err ? reject(err) : resolve(done)));\n    });\n  }\n\n  destroy() {}\n}\n"],"names":["LinkEntry","MANDATORY_ATTRIBUTES","attributes","validateAttributes","objectAssign","basename","undefined","path","type","create","dest","options","callback","normalizedPath","normalize","fullPath","join","stripPath","normalizedLinkpath","linkpath","linkFullPath","queue","Queue","force","defer","rm","err","code","mkdirp","bind","dirname","fs","link","waitForAccess","chmod","chown","utimes","await","Promise","resolve","reject","done","destroy"],"mappings":";;;;;;;eAkBqBA;;;yDAlBN;8BACI;oEACA;2DACF;8DACC;8DACA;8DACA;+DACC;uBACU;kEACP;2EACS;sEACL;;;;;;;;;;;AAE1B,IAAMC,uBAAuB;IAAC;IAAQ;IAAS;IAAQ;CAAW;AAKnD,IAAA,AAAMD,0BAAN;;aAAMA,UAQPE,UAA0B;gCARnBF;QASjBG,IAAAA,6BAAkB,EAACD,YAAYD;QAC/BG,IAAAA,qBAAY,EAAC,IAAI,EAAEF;QACnB,IAAI,IAAI,CAACG,QAAQ,KAAKC,WAAW,IAAI,CAACD,QAAQ,GAAGE,aAAI,CAACF,QAAQ,CAAC,IAAI,CAACE,IAAI;QACxE,IAAI,IAAI,CAACC,IAAI,KAAKF,WAAW,IAAI,CAACE,IAAI,GAAG;;iBAZxBR;IAkBnBS,OAAAA,MAoCC,GApCDA,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,IAAI;gBACF,IAAMC,iBAAiBN,aAAI,CAACO,SAAS,CAAC,IAAI,CAACP,IAAI;gBAC/C,IAAMQ,WAAWR,aAAI,CAACS,IAAI,CAACN,MAAMO,IAAAA,oBAAS,EAACJ,gBAAgBF;gBAC3D,IAAMO,qBAAqBX,aAAI,CAACO,SAAS,CAAC,IAAI,CAACK,QAAQ;gBACvD,IAAMC,eAAeb,aAAI,CAACS,IAAI,CAACN,MAAMO,IAAAA,oBAAS,EAACC,oBAAoBP;gBAEnE,IAAMU,QAAQ,IAAIC,gBAAK,CAAC;gBACxB,IAAIX,QAAQY,KAAK,EAAE;oBACjBF,MAAMG,KAAK,CAAC,SAACZ;wBACXa,IAAAA,kBAAE,EAACV,UAAU,SAACW;4BACZA,OAAOA,IAAIC,IAAI,KAAK,WAAWf,SAASc,OAAOd;wBACjD;oBACF;gBACF;gBACAS,MAAMG,KAAK,CAACI,sBAAM,CAACC,IAAI,CAAC,MAAMtB,aAAI,CAACuB,OAAO,CAACf;gBAC3CM,MAAMG,KAAK,CAACO,WAAE,CAACC,IAAI,CAACH,IAAI,CAACE,WAAE,EAAEX,cAAcL;gBAC3CM,MAAMG,KAAK,CAACS,wBAAa,CAACJ,IAAI,CAAC,MAAMd;gBACrCM,MAAMG,KAAK,CAACU,gBAAK,CAACL,IAAI,CAAC,MAAMd,UAAU,IAAI,EAAEJ;gBAC7CU,MAAMG,KAAK,CAACW,gBAAK,CAACN,IAAI,CAAC,MAAMd,UAAU,IAAI,EAAEJ;gBAC7CU,MAAMG,KAAK,CAACY,iBAAM,CAACP,IAAI,CAAC,MAAMd,UAAU,IAAI,EAAEJ;gBAC9CU,MAAMgB,KAAK,CAACzB;gBACZ;YACF,EAAE,OAAOc,KAAK;gBACZd,SAASc;gBACT;YACF;QACF;QAEA,OAAO,IAAIY,QAAQ,SAACC,SAASC;YAC3B,MAAK/B,MAAM,CAACC,MAAMC,SAAS,SAACe,KAAae;uBAAoBf,MAAMc,OAAOd,OAAOa,QAAQE;;QAC3F;IACF;IAEAC,OAAAA,OAAY,GAAZA,SAAAA,WAAW;WAxDQ1C"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/LinkEntry.ts"],"sourcesContent":["import fs from 'fs';\nimport { rm } from 'fs-remove-compat';\nimport mkdirp from 'mkdirp-classic';\nimport path from 'path';\nimport Queue from 'queue-cb';\nimport chmod from './fs/chmod.ts';\nimport chown from './fs/chown.ts';\nimport utimes from './fs/utimes.ts';\nimport { objectAssign } from './shared/index.ts';\nimport stripPath from './shared/stripPath.ts';\nimport validateAttributes from './validateAttributes.ts';\nimport waitForAccess from './waitForAccess.ts';\n\nconst MANDATORY_ATTRIBUTES = ['mode', 'mtime', 'path', 'linkpath'];\n\nimport type { Mode } from 'fs';\nimport type { ExtractOptions, LinkAttributes, NoParamCallback } from './types.ts';\n\nexport default class LinkEntry {\n  mode: Mode;\n  mtime: number;\n  path: string;\n  linkpath: string;\n  basename: string;\n  type: string;\n\n  constructor(attributes: LinkAttributes) {\n    validateAttributes(attributes, MANDATORY_ATTRIBUTES);\n    objectAssign(this, attributes);\n    if (this.basename === undefined) this.basename = path.basename(this.path);\n    if (this.type === undefined) this.type = 'link';\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      try {\n        const normalizedPath = path.normalize(this.path);\n        const fullPath = path.join(dest, stripPath(normalizedPath, options));\n        const normalizedLinkpath = path.normalize(this.linkpath);\n        const linkFullPath = path.join(dest, stripPath(normalizedLinkpath, options));\n\n        const queue = new Queue(1);\n        if (options.force) {\n          queue.defer((callback) => {\n            rm(fullPath, (err) => {\n              err && err.code !== 'ENOENT' ? callback(err) : callback();\n            });\n          });\n        }\n        queue.defer(mkdirp.bind(null, path.dirname(fullPath)));\n        queue.defer(waitForAccess.bind(null, linkFullPath)); // ensure target file is accessible before linking\n        queue.defer(fs.link.bind(fs, linkFullPath, fullPath));\n        queue.defer(waitForAccess.bind(null, fullPath));\n        queue.defer(chmod.bind(null, fullPath, this, options));\n        queue.defer(chown.bind(null, fullPath, this, options));\n        queue.defer(utimes.bind(null, fullPath, this, options));\n        queue.await(callback);\n        return;\n      } catch (err) {\n        callback(err);\n        return;\n      }\n    }\n\n    return new Promise((resolve, reject) => {\n      this.create(dest, options, (err?: Error, done?: boolean) => (err ? reject(err) : resolve(done)));\n    });\n  }\n\n  destroy() {}\n}\n"],"names":["LinkEntry","MANDATORY_ATTRIBUTES","attributes","validateAttributes","objectAssign","basename","undefined","path","type","create","dest","options","callback","normalizedPath","normalize","fullPath","join","stripPath","normalizedLinkpath","linkpath","linkFullPath","queue","Queue","force","defer","rm","err","code","mkdirp","bind","dirname","waitForAccess","fs","link","chmod","chown","utimes","await","Promise","resolve","reject","done","destroy"],"mappings":";;;;;;;eAkBqBA;;;yDAlBN;8BACI;oEACA;2DACF;8DACC;8DACA;8DACA;+DACC;uBACU;kEACP;2EACS;sEACL;;;;;;;;;;;AAE1B,IAAMC,uBAAuB;IAAC;IAAQ;IAAS;IAAQ;CAAW;AAKnD,IAAA,AAAMD,0BAAN;;aAAMA,UAQPE,UAA0B;gCARnBF;QASjBG,IAAAA,6BAAkB,EAACD,YAAYD;QAC/BG,IAAAA,qBAAY,EAAC,IAAI,EAAEF;QACnB,IAAI,IAAI,CAACG,QAAQ,KAAKC,WAAW,IAAI,CAACD,QAAQ,GAAGE,aAAI,CAACF,QAAQ,CAAC,IAAI,CAACE,IAAI;QACxE,IAAI,IAAI,CAACC,IAAI,KAAKF,WAAW,IAAI,CAACE,IAAI,GAAG;;iBAZxBR;IAkBnBS,OAAAA,MAqCC,GArCDA,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,IAAI;gBACF,IAAMC,iBAAiBN,aAAI,CAACO,SAAS,CAAC,IAAI,CAACP,IAAI;gBAC/C,IAAMQ,WAAWR,aAAI,CAACS,IAAI,CAACN,MAAMO,IAAAA,oBAAS,EAACJ,gBAAgBF;gBAC3D,IAAMO,qBAAqBX,aAAI,CAACO,SAAS,CAAC,IAAI,CAACK,QAAQ;gBACvD,IAAMC,eAAeb,aAAI,CAACS,IAAI,CAACN,MAAMO,IAAAA,oBAAS,EAACC,oBAAoBP;gBAEnE,IAAMU,QAAQ,IAAIC,gBAAK,CAAC;gBACxB,IAAIX,QAAQY,KAAK,EAAE;oBACjBF,MAAMG,KAAK,CAAC,SAACZ;wBACXa,IAAAA,kBAAE,EAACV,UAAU,SAACW;4BACZA,OAAOA,IAAIC,IAAI,KAAK,WAAWf,SAASc,OAAOd;wBACjD;oBACF;gBACF;gBACAS,MAAMG,KAAK,CAACI,sBAAM,CAACC,IAAI,CAAC,MAAMtB,aAAI,CAACuB,OAAO,CAACf;gBAC3CM,MAAMG,KAAK,CAACO,wBAAa,CAACF,IAAI,CAAC,MAAMT,gBAAgB,kDAAkD;gBACvGC,MAAMG,KAAK,CAACQ,WAAE,CAACC,IAAI,CAACJ,IAAI,CAACG,WAAE,EAAEZ,cAAcL;gBAC3CM,MAAMG,KAAK,CAACO,wBAAa,CAACF,IAAI,CAAC,MAAMd;gBACrCM,MAAMG,KAAK,CAACU,gBAAK,CAACL,IAAI,CAAC,MAAMd,UAAU,IAAI,EAAEJ;gBAC7CU,MAAMG,KAAK,CAACW,gBAAK,CAACN,IAAI,CAAC,MAAMd,UAAU,IAAI,EAAEJ;gBAC7CU,MAAMG,KAAK,CAACY,iBAAM,CAACP,IAAI,CAAC,MAAMd,UAAU,IAAI,EAAEJ;gBAC9CU,MAAMgB,KAAK,CAACzB;gBACZ;YACF,EAAE,OAAOc,KAAK;gBACZd,SAASc;gBACT;YACF;QACF;QAEA,OAAO,IAAIY,QAAQ,SAACC,SAASC;YAC3B,MAAK/B,MAAM,CAACC,MAAMC,SAAS,SAACe,KAAae;uBAAoBf,MAAMc,OAAOd,OAAOa,QAAQE;;QAC3F;IACF;IAEAC,OAAAA,OAAY,GAAZA,SAAAA,WAAW;WAzDQ1C"}

package/dist/cjs/shared/compat.d.cts

@@ -12,15 +12,17 @@
  * Solution: Feature detection with graceful fallback in both directions.
  */
 /**
- * Allocate a zero-filled buffer (safe)
+ * Allocate a zero-filled buffer (safe) - handles very large allocations
  * - Uses Buffer.alloc() on Node 4.5+
  * - Falls back to new Buffer() + fill on Node 0.8-4.4
+ * - For sizes > MAX_SAFE_BUFFER_LENGTH, allocates in chunks and copies
  */
 export declare function allocBuffer(size: number): Buffer;
 /**
  * Allocate a buffer without initialization (unsafe but faster)
  * - Uses Buffer.allocUnsafe() on Node 4.5+
  * - Falls back to new Buffer() on Node 0.8-4.4
+ * - For sizes > MAX_SAFE_BUFFER_LENGTH, allocates in chunks without zeroing
  *
  * WARNING: Buffer contents are uninitialized and may contain sensitive data.
  * Only use when you will immediately overwrite all bytes.
@@ -63,8 +65,9 @@ export declare function readUInt64LE(buf: Buffer, offset: number): number;
  */
 export declare function writeUInt64LE(buf: Buffer, value: number, offset: number): void;
 /**
- * Concatenate buffers - compatible with Node 0.8
+ * Concatenate buffers - compatible with Node 0.8+
  * Handles crypto output which may not be proper Buffer instances in old Node.
+ * Also handles very large concatenations that would exceed buffer limits.
  *
  * NOTE: This function is primarily needed for AES decryption compatibility
  * in Node 0.8 where crypto output may not be proper Buffer instances.

package/dist/cjs/shared/compat.d.ts

@@ -12,15 +12,17 @@
  * Solution: Feature detection with graceful fallback in both directions.
  */
 /**
- * Allocate a zero-filled buffer (safe)
+ * Allocate a zero-filled buffer (safe) - handles very large allocations
  * - Uses Buffer.alloc() on Node 4.5+
  * - Falls back to new Buffer() + fill on Node 0.8-4.4
+ * - For sizes > MAX_SAFE_BUFFER_LENGTH, allocates in chunks and copies
  */
 export declare function allocBuffer(size: number): Buffer;
 /**
  * Allocate a buffer without initialization (unsafe but faster)
  * - Uses Buffer.allocUnsafe() on Node 4.5+
  * - Falls back to new Buffer() on Node 0.8-4.4
+ * - For sizes > MAX_SAFE_BUFFER_LENGTH, allocates in chunks without zeroing
  *
  * WARNING: Buffer contents are uninitialized and may contain sensitive data.
  * Only use when you will immediately overwrite all bytes.
@@ -63,8 +65,9 @@ export declare function readUInt64LE(buf: Buffer, offset: number): number;
  */
 export declare function writeUInt64LE(buf: Buffer, value: number, offset: number): void;
 /**
- * Concatenate buffers - compatible with Node 0.8
+ * Concatenate buffers - compatible with Node 0.8+
  * Handles crypto output which may not be proper Buffer instances in old Node.
+ * Also handles very large concatenations that would exceed buffer limits.
  *
  * NOTE: This function is primarily needed for AES decryption compatibility
  * in Node 0.8 where crypto output may not be proper Buffer instances.

package/dist/cjs/shared/compat.js

@@ -92,20 +92,123 @@ var _require = typeof require === 'undefined' ? _module.default.createRequire(re
 var hasBufferAlloc = typeof Buffer.alloc === 'function';
 var hasBufferAllocUnsafe = typeof Buffer.allocUnsafe === 'function';
 var hasBufferFrom = typeof Buffer.from === 'function' && Buffer.from !== Uint8Array.from;
-function allocBuffer(size) {
+// Maximum buffer size that works across all Node.js versions
+// Node 0.8-4.x: kMaxLength = 0x3fffffff (~1073MB) but actual limit may be lower
+// Node 6-7.x: ~1073MB for Uint8Array
+// Node 8+: ~2GB for Buffer
+// Node 10+: 2^31-1 (~2147MB) for Buffer.allocUnsafe
+// Use 128MB as a conservative limit for buffer operations
+var MAX_SAFE_BUFFER_LENGTH = 128 * 1024 * 1024; // 128MB
+// Try to detect the actual kMaxLength for this Node version
+// If we can't detect it (older Node), assume conservative limit
+var DETECTED_MAX_LENGTH = null;
+function _getMaxBufferLength() {
+    if (DETECTED_MAX_LENGTH !== null) return DETECTED_MAX_LENGTH;
+    // Try to detect the actual limit
+    // kMaxLength exists on BufferConstructor in newer TypeScript definitions
+    // but may not exist at runtime on very old Node
+    var maxLen = Buffer.kMaxLength;
+    if (maxLen !== undefined) {
+        DETECTED_MAX_LENGTH = maxLen;
+    } else {
+        // Older Node - use conservative estimate
+        DETECTED_MAX_LENGTH = 0x3fffffff; // ~1073MB
+    }
+    return DETECTED_MAX_LENGTH;
+}
+/**
+ * Check if a buffer size can be safely allocated on this Node version
+ * Uses conservative limit to work across all versions
+ */ function canAllocateBufferSize(size) {
+    return size >= 0 && size <= MAX_SAFE_BUFFER_LENGTH;
+}
+/**
+ * Create a single chunk of the specified size
+ */ function createChunk(size, zeroFill) {
     if (hasBufferAlloc) {
         return Buffer.alloc(size);
     }
-    // Legacy fallback: new Buffer() is uninitialized, must zero-fill
     var buf = new Buffer(size);
-    buf.fill(0);
+    if (zeroFill) buf.fill(0);
     return buf;
 }
+/**
+ * Combine an array of buffers into one by pairwise concatenation
+ * Each combination produces a buffer at most 2x MAX_SAFE_BUFFER_LENGTH (256MB)
+ * which is within kMaxLength for all Node versions
+ */ function combineBuffersPairwise(buffers) {
+    while(buffers.length > 1){
+        var newBuffers = [];
+        for(var i = 0; i < buffers.length; i += 2){
+            if (i + 1 < buffers.length) {
+                var size1 = buffers[i].length;
+                var size2 = buffers[i + 1].length;
+                var combinedSize = size1 + size2;
+                // Safe: combinedSize <= 2 * MAX_SAFE_BUFFER_LENGTH = 256MB
+                var combined = createChunk(combinedSize, false);
+                buffers[i].copy(combined, 0);
+                buffers[i + 1].copy(combined, size1);
+                newBuffers.push(combined);
+            } else {
+                newBuffers.push(buffers[i]);
+            }
+        }
+        // Clear old references to help GC and use traditional for loop for Node 0.8 compatibility
+        for(var j = 0; j < buffers.length; j++){
+            buffers[j] = undefined;
+        }
+        buffers.length = 0;
+        for(var j1 = 0; j1 < newBuffers.length; j1++){
+            buffers.push(newBuffers[j1]);
+        }
+    }
+    return buffers[0];
+}
+/**
+ * Allocate a large buffer by allocating in chunks and combining them
+ * Handles both zero-filled (safe) and uninitialized (unsafe) variants
+ */ function allocBufferLarge(size, zeroFill) {
+    // For large sizes, allocate smaller chunks and combine them
+    var numChunks = Math.ceil(size / MAX_SAFE_BUFFER_LENGTH);
+    var chunks = [];
+    // Allocate individual chunks (each <= MAX_SAFE_BUFFER_LENGTH)
+    for(var i = 0; i < numChunks; i++){
+        var chunkSize = Math.min(MAX_SAFE_BUFFER_LENGTH, size - i * MAX_SAFE_BUFFER_LENGTH);
+        chunks.push(createChunk(chunkSize, zeroFill));
+    }
+    // Combine chunks iteratively using pairwise combination
+    return combineBuffersPairwise(chunks);
+}
+function allocBuffer(size) {
+    if (size === 0) {
+        return new Buffer(0);
+    }
+    // Use native allocation for sizes within safe limits
+    if (canAllocateBufferSize(size)) {
+        if (hasBufferAlloc) {
+            return Buffer.alloc(size);
+        }
+        // Legacy fallback: new Buffer() is uninitialized, must zero-fill
+        var buf = new Buffer(size);
+        buf.fill(0);
+        return buf;
+    }
+    // For large sizes, allocate in chunks with zero-filling
+    return allocBufferLarge(size, true);
+}
 function allocBufferUnsafe(size) {
-    if (hasBufferAllocUnsafe) {
-        return Buffer.allocUnsafe(size);
+    if (size === 0) {
+        return new Buffer(0);
     }
-    return new Buffer(size);
+    // Use native allocation for sizes within safe limits
+    if (canAllocateBufferSize(size)) {
+        if (hasBufferAllocUnsafe) {
+            return Buffer.allocUnsafe(size);
+        }
+        return new Buffer(size);
+    }
+    // For large sizes, allocate in chunks without zero-filling
+    return allocBufferLarge(size, false);
 }
 function bufferFrom(data, encoding) {
     if (hasBufferFrom) {
@@ -176,26 +279,42 @@ function bufferConcat(list, totalLength) {
     }
     // Use specified totalLength or actual length
     var targetLength = totalLength !== undefined ? totalLength : actualLength;
-    // Check if all items are proper Buffers AND no truncation needed
-    // (Node 0.8's Buffer.concat doesn't handle truncation well)
-    var allBuffers = true;
-    for(var j = 0; j < list.length; j++){
-        if (!_instanceof(list[j], Buffer)) {
-            allBuffers = false;
-            break;
-        }
+    // Handle empty list
+    if (list.length === 0) {
+        return new Buffer(0);
     }
-    if (allBuffers && targetLength >= actualLength) {
-        return Buffer.concat(list, targetLength);
+    // Handle very large concatenations that would exceed buffer limits
+    // Use native Buffer.concat for smaller sizes (faster)
+    if (targetLength <= MAX_SAFE_BUFFER_LENGTH) {
+        // Check if all items are proper Buffers AND no truncation needed
+        // (Node 0.8's Buffer.concat doesn't handle truncation well)
+        var allBuffers = true;
+        for(var j = 0; j < list.length; j++){
+            if (!_instanceof(list[j], Buffer)) {
+                allBuffers = false;
+                break;
+            }
+        }
+        if (allBuffers && targetLength >= actualLength) {
+            return Buffer.concat(list, targetLength);
+        }
     }
-    // Manual concat for mixed types or when truncation is needed
+    // For large or complex concatenations, use chunked approach
+    // This will use allocBuffer which handles large sizes via chunking
     var result = allocBuffer(targetLength);
     var offset = 0;
     for(var k = 0; k < list.length && offset < targetLength; k++){
         var buf = list[k];
-        for(var l = 0; l < buf.length && offset < targetLength; l++){
-            result[offset++] = buf[l];
+        var toCopy = Math.min(buf.length, targetLength - offset);
+        if (_instanceof(buf, Buffer)) {
+            buf.copy(result, offset, 0, toCopy);
+        } else {
+            // Uint8Array - need to copy byte by byte
+            for(var l = 0; l < toCopy; l++){
+                result[offset + l] = buf[l];
+            }
         }
+        offset += toCopy;
     }
     return result;
 }

package/dist/cjs/shared/compat.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/compat.ts"],"sourcesContent":["/**\n * Buffer Compatibility Layer for Node.js 0.8+\n *\n * Provides buffer utilities that work across all Node.js versions\n * WITHOUT modifying global Buffer object.\n *\n * Version history:\n * - Node 0.8-4.4: Only has `new Buffer()`, no `Buffer.alloc/from`\n * - Node 4.5+: Has `Buffer.alloc/from`, deprecates `new Buffer()`\n * - Node 10+: Warns or errors on `new Buffer()`\n *\n * Solution: Feature detection with graceful fallback in both directions.\n */\n\n// ESM-compatible require - works in both CJS and ESM\nimport Module from 'module';\n\nconst _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n\n// Feature detection (runs once at module load)\nconst hasBufferAlloc = typeof Buffer.alloc === 'function';\nconst hasBufferAllocUnsafe = typeof Buffer.allocUnsafe === 'function';\nconst hasBufferFrom = typeof Buffer.from === 'function' && Buffer.from !== Uint8Array.from;\n\n/**\n * Allocate a zero-filled buffer (safe)\n * - Uses Buffer.alloc() on Node 4.5+\n * - Falls back to new Buffer() + fill on Node 0.8-4.4\n */\nexport function allocBuffer(size: number): Buffer {\n  if (hasBufferAlloc) {\n    return Buffer.alloc(size);\n  }\n  // Legacy fallback: new Buffer() is uninitialized, must zero-fill\n  const buf = new Buffer(size);\n  buf.fill(0);\n  return buf;\n}\n\n/**\n * Allocate a buffer without initialization (unsafe but faster)\n * - Uses Buffer.allocUnsafe() on Node 4.5+\n * - Falls back to new Buffer() on Node 0.8-4.4\n *\n * WARNING: Buffer contents are uninitialized and may contain sensitive data.\n * Only use when you will immediately overwrite all bytes.\n */\nexport function allocBufferUnsafe(size: number): Buffer {\n  if (hasBufferAllocUnsafe) {\n    return Buffer.allocUnsafe(size);\n  }\n  return new Buffer(size);\n}\n\n/**\n * Create a buffer from string, array, or existing buffer\n * - Uses Buffer.from() on Node 4.5+\n * - Falls back to new Buffer() on Node 0.8-4.4\n * - Handles Uint8Array conversion for Node 0.8 (crypto output compatibility)\n */\nexport function bufferFrom(data: string | number[] | Buffer | Uint8Array, encoding?: BufferEncoding): Buffer {\n  if (hasBufferFrom) {\n    if (typeof data === 'string') {\n      return Buffer.from(data, encoding);\n    }\n    return Buffer.from(data as number[] | Buffer);\n  }\n  // Node 0.8 compatibility - deprecated Buffer constructor\n  // For Uint8Array, convert to array first (needed for crypto output in Node 0.8)\n  if (data instanceof Uint8Array && !(data instanceof Buffer)) {\n    const arr: number[] = [];\n    for (let i = 0; i < data.length; i++) {\n      arr.push(data[i]);\n    }\n    return new Buffer(arr);\n  }\n  return new Buffer(data as string & number[], encoding);\n}\n\n/**\n * Compare two buffers or buffer regions\n * - Uses Buffer.compare() on Node 5.10+ (with offset support)\n * - Falls back to manual comparison on Node 0.8-5.9\n */\nexport function bufferCompare(source: Buffer, target: Buffer, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): number {\n  sourceStart = sourceStart || 0;\n  sourceEnd = sourceEnd || source.length;\n  targetStart = targetStart || 0;\n  targetEnd = targetEnd || target.length;\n\n  // Check if native compare with offset support exists (Node 5.10+)\n  if (source.compare && source.compare.length >= 5) {\n    return source.compare(target, targetStart, targetEnd, sourceStart, sourceEnd);\n  }\n\n  // Manual comparison for older Node versions\n  const sourceLen = sourceEnd - sourceStart;\n  const targetLen = targetEnd - targetStart;\n  const len = Math.min(sourceLen, targetLen);\n\n  for (let i = 0; i < len; i++) {\n    const s = source[sourceStart + i];\n    const t = target[targetStart + i];\n    if (s !== t) return s < t ? -1 : 1;\n  }\n\n  return sourceLen - targetLen;\n}\n\n/**\n * Check if buffer region equals byte array\n * Useful for magic number detection without Buffer.from()\n */\nexport function bufferEquals(buf: Buffer, offset: number, expected: number[]): boolean {\n  if (offset + expected.length > buf.length) return false;\n  for (let i = 0; i < expected.length; i++) {\n    if (buf[offset + i] !== expected[i]) return false;\n  }\n  return true;\n}\n\n/**\n * Copy buffer region to new buffer\n * Works on all Node versions\n */\nexport function bufferSliceCopy(buf: Buffer, start: number, end: number): Buffer {\n  const result = allocBuffer(end - start);\n  buf.copy(result, 0, start, end);\n  return result;\n}\n\n/**\n * Read 64-bit unsigned integer (little-endian)\n * Uses two 32-bit reads since BigInt not available until Node 10.4\n *\n * WARNING: Only accurate for values < Number.MAX_SAFE_INTEGER (2^53 - 1)\n * This covers files up to ~9 PB which is practical for all real use cases.\n */\nexport function readUInt64LE(buf: Buffer, offset: number): number {\n  const low = buf.readUInt32LE(offset);\n  const high = buf.readUInt32LE(offset + 4);\n  return high * 0x100000000 + low;\n}\n\n/**\n * Write 64-bit unsigned integer (little-endian)\n * Same precision limitation as readUInt64LE\n */\nexport function writeUInt64LE(buf: Buffer, value: number, offset: number): void {\n  const low = value >>> 0;\n  const high = (value / 0x100000000) >>> 0;\n  buf.writeUInt32LE(low, offset);\n  buf.writeUInt32LE(high, offset + 4);\n}\n\n/**\n * Concatenate buffers - compatible with Node 0.8\n * Handles crypto output which may not be proper Buffer instances in old Node.\n *\n * NOTE: This function is primarily needed for AES decryption compatibility\n * in Node 0.8 where crypto output may not be proper Buffer instances.\n * Libraries not using crypto can use native Buffer.concat() directly.\n */\nexport function bufferConcat(list: (Buffer | Uint8Array)[], totalLength?: number): Buffer {\n  // Calculate actual total length first\n  let actualLength = 0;\n  for (let i = 0; i < list.length; i++) {\n    actualLength += list[i].length;\n  }\n\n  // Use specified totalLength or actual length\n  const targetLength = totalLength !== undefined ? totalLength : actualLength;\n\n  // Check if all items are proper Buffers AND no truncation needed\n  // (Node 0.8's Buffer.concat doesn't handle truncation well)\n  let allBuffers = true;\n  for (let j = 0; j < list.length; j++) {\n    if (!(list[j] instanceof Buffer)) {\n      allBuffers = false;\n      break;\n    }\n  }\n  if (allBuffers && targetLength >= actualLength) {\n    return Buffer.concat(list as Buffer[], targetLength);\n  }\n\n  // Manual concat for mixed types or when truncation is needed\n  const result = allocBuffer(targetLength);\n  let offset = 0;\n  for (let k = 0; k < list.length && offset < targetLength; k++) {\n    const buf = list[k];\n    for (let l = 0; l < buf.length && offset < targetLength; l++) {\n      result[offset++] = buf[l];\n    }\n  }\n  return result;\n}\n\n/**\n * Node 0.8 compatible isNaN (Number.isNaN didn't exist until ES2015)\n * Uses self-comparison: NaN is the only value not equal to itself\n */\n// biome-ignore lint/suspicious/noShadowRestrictedNames: Legacy compatibility\nexport function isNaN(value: number): boolean {\n  // biome-ignore lint/suspicious/noSelfCompare: NaN check pattern\n  return value !== value;\n}\n\n/**\n * Decompress raw DEFLATE data (no zlib/gzip header)\n * - Uses native zlib.inflateRawSync() on Node 0.11.12+\n * - Falls back to pako for Node 0.8-0.10\n *\n * Version history:\n * - Node 0.8-0.10: No zlib sync methods, use pako\n * - Node 0.11.12+: zlib.inflateRawSync available\n */\n// Feature detection for native zlib sync methods (Node 0.11.12+)\nlet zlib: typeof import('zlib') | null = null;\ntry {\n  zlib = _require('zlib');\n} catch (_e) {\n  // zlib not available (shouldn't happen in Node.js)\n}\nconst hasNativeInflateRaw = zlib !== null && typeof zlib.inflateRawSync === 'function';\n\nexport function inflateRaw(input: Buffer): Buffer {\n  if (hasNativeInflateRaw && zlib) {\n    return zlib.inflateRawSync(input);\n  }\n  // Fallback to pako for Node 0.8-0.10\n  const pako = _require('pako');\n  return bufferFrom(pako.inflateRaw(input));\n}\n\n/**\n * Create a streaming raw DEFLATE decompressor (Transform stream)\n * Decompresses data incrementally to avoid holding full output in memory.\n *\n * - Uses native zlib.createInflateRaw() on Node 0.11.12+\n * - Falls back to pako-based Transform for Node 0.8-0.10\n *\n * @returns A Transform stream that decompresses raw DEFLATE data\n */\n// Check for native streaming inflate (Node 0.11.12+ has createInflateRaw)\n// biome-ignore lint/suspicious/noExplicitAny: createInflateRaw not in older TS definitions\nconst hasNativeStreamingInflate = zlib !== null && typeof (zlib as any).createInflateRaw === 'function';\n\nexport function createInflateRawStream(): NodeJS.ReadWriteStream {\n  if (hasNativeStreamingInflate && zlib) {\n    // Use native zlib streaming Transform\n    // biome-ignore lint/suspicious/noExplicitAny: createInflateRaw not in older TS definitions\n    return (zlib as any).createInflateRaw();\n  }\n\n  // Fallback to pako-based Transform for Node 0.8-0.10\n  // Use readable-stream for Node 0.8 compatibility\n  const Transform = _require('readable-stream').Transform;\n  const pako = _require('pako');\n\n  const inflate = new pako.Inflate({ raw: true, chunkSize: 16384 });\n  const transform = new Transform();\n  const pendingChunks: Buffer[] = [];\n  let ended = false;\n\n  // Pako calls onData synchronously during push()\n  inflate.onData = (chunk: Uint8Array) => {\n    pendingChunks.push(bufferFrom(chunk));\n  };\n\n  inflate.onEnd = (status: number) => {\n    ended = true;\n    if (status !== 0) {\n      transform.emit('error', new Error(`Inflate error: ${inflate.msg || 'unknown'}`));\n    }\n  };\n\n  transform._transform = function (chunk: Buffer, _encoding: string, callback: (err?: Error) => void) {\n    try {\n      inflate.push(chunk, false);\n      // Push any pending decompressed chunks\n      while (pendingChunks.length > 0) {\n        this.push(pendingChunks.shift());\n      }\n      callback();\n    } catch (err) {\n      callback(err as Error);\n    }\n  };\n\n  transform._flush = function (callback: (err?: Error) => void) {\n    try {\n      inflate.push(new Uint8Array(0), true); // Signal end\n      // Push any remaining decompressed chunks\n      while (pendingChunks.length > 0) {\n        this.push(pendingChunks.shift());\n      }\n      if (ended && inflate.err) {\n        callback(new Error(`Inflate error: ${inflate.msg || 'unknown'}`));\n      } else {\n        callback();\n      }\n    } catch (err) {\n      callback(err as Error);\n    }\n  };\n\n  return transform;\n}\n\n/**\n * Object.assign wrapper for Node.js 0.8+\n * - Uses native Object.assign on Node 4.0+\n * - Falls back to manual property copy on Node 0.8-3.x\n */\nconst hasObjectAssign = typeof Object.assign === 'function';\nconst _hasOwnProperty = Object.prototype.hasOwnProperty;\n\nexport function objectAssign<T, U>(target: T, source: U): T & U {\n  if (hasObjectAssign) return Object.assign(target, source);\n\n  for (const key in source) {\n    if (_hasOwnProperty.call(source, key)) (target as Record<string, unknown>)[key] = source[key];\n  }\n  return target as T & U;\n}\n\n/**\n * Stream compatibility - Transform class\n * - Uses native stream.Transform on Node 0.10+\n * - Falls back to readable-stream for Node 0.8\n */\nconst major = +process.versions.node.split('.')[0];\nexport const Readable: typeof import('stream').Readable = major > 0 ? _require('stream').Readable : _require('readable-stream').Readable;\nexport const Writable: typeof import('stream').Writable = major > 0 ? _require('stream').Writable : _require('readable-stream').Writable;\nexport const Transform: typeof import('stream').Transform = major > 0 ? _require('stream').Transform : _require('readable-stream').Transform;\nexport const PassThrough: typeof import('stream').PassThrough = major > 0 ? _require('stream').PassThrough : _require('readable-stream').PassThrough;\n"],"names":["PassThrough","Readable","Transform","Writable","allocBuffer","allocBufferUnsafe","bufferCompare","bufferConcat","bufferEquals","bufferFrom","bufferSliceCopy","createInflateRawStream","inflateRaw","isNaN","objectAssign","readUInt64LE","writeUInt64LE","_require","require","Module","createRequire","hasBufferAlloc","Buffer","alloc","hasBufferAllocUnsafe","allocUnsafe","hasBufferFrom","from","Uint8Array","size","buf","fill","data","encoding","arr","i","length","push","source","target","targetStart","targetEnd","sourceStart","sourceEnd","compare","sourceLen","targetLen","len","Math","min","s","t","offset","expected","start","end","result","copy","low","readUInt32LE","high","value","writeUInt32LE","list","totalLength","actualLength","targetLength","undefined","allBuffers","j","concat","k","l","zlib","_e","hasNativeInflateRaw","inflateRawSync","input","pako","hasNativeStreamingInflate","createInflateRaw","inflate","Inflate","raw","chunkSize","transform","pendingChunks","ended","onData","chunk","onEnd","status","emit","Error","msg","_transform","_encoding","callback","shift","err","_flush","hasObjectAssign","Object","assign","_hasOwnProperty","prototype","hasOwnProperty","key","call","major","process","versions","node","split"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/compat.ts"],"sourcesContent":["/**\n * Buffer Compatibility Layer for Node.js 0.8+\n *\n * Provides buffer utilities that work across all Node.js versions\n * WITHOUT modifying global Buffer object.\n *\n * Version history:\n * - Node 0.8-4.4: Only has `new Buffer()`, no `Buffer.alloc/from`\n * - Node 4.5+: Has `Buffer.alloc/from`, deprecates `new Buffer()`\n * - Node 10+: Warns or errors on `new Buffer()`\n *\n * Solution: Feature detection with graceful fallback in both directions.\n */\n\n// ESM-compatible require - works in both CJS and ESM\nimport Module from 'module';\n\nconst _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n\n// Feature detection (runs once at module load)\nconst hasBufferAlloc = typeof Buffer.alloc === 'function';\nconst hasBufferAllocUnsafe = typeof Buffer.allocUnsafe === 'function';\nconst hasBufferFrom = typeof Buffer.from === 'function' && Buffer.from !== Uint8Array.from;\n\n// Maximum buffer size that works across all Node.js versions\n// Node 0.8-4.x: kMaxLength = 0x3fffffff (~1073MB) but actual limit may be lower\n// Node 6-7.x: ~1073MB for Uint8Array\n// Node 8+: ~2GB for Buffer\n// Node 10+: 2^31-1 (~2147MB) for Buffer.allocUnsafe\n// Use 128MB as a conservative limit for buffer operations\nconst MAX_SAFE_BUFFER_LENGTH = 128 * 1024 * 1024; // 128MB\n\n// Try to detect the actual kMaxLength for this Node version\n// If we can't detect it (older Node), assume conservative limit\nlet DETECTED_MAX_LENGTH: number | null = null;\n\nfunction _getMaxBufferLength(): number {\n  if (DETECTED_MAX_LENGTH !== null) return DETECTED_MAX_LENGTH;\n\n  // Try to detect the actual limit\n  // kMaxLength exists on BufferConstructor in newer TypeScript definitions\n  // but may not exist at runtime on very old Node\n  const maxLen = (Buffer as { kMaxLength?: number }).kMaxLength;\n  if (maxLen !== undefined) {\n    DETECTED_MAX_LENGTH = maxLen;\n  } else {\n    // Older Node - use conservative estimate\n    DETECTED_MAX_LENGTH = 0x3fffffff; // ~1073MB\n  }\n\n  return DETECTED_MAX_LENGTH;\n}\n\n/**\n * Check if a buffer size can be safely allocated on this Node version\n * Uses conservative limit to work across all versions\n */\nfunction canAllocateBufferSize(size: number): boolean {\n  return size >= 0 && size <= MAX_SAFE_BUFFER_LENGTH;\n}\n\n/**\n * Create a single chunk of the specified size\n */\nfunction createChunk(size: number, zeroFill: boolean): Buffer {\n  if (hasBufferAlloc) {\n    return Buffer.alloc(size);\n  }\n  const buf = new Buffer(size);\n  if (zeroFill) buf.fill(0);\n  return buf;\n}\n\n/**\n * Combine an array of buffers into one by pairwise concatenation\n * Each combination produces a buffer at most 2x MAX_SAFE_BUFFER_LENGTH (256MB)\n * which is within kMaxLength for all Node versions\n */\nfunction combineBuffersPairwise(buffers: Buffer[]): Buffer {\n  while (buffers.length > 1) {\n    const newBuffers: Buffer[] = [];\n\n    for (let i = 0; i < buffers.length; i += 2) {\n      if (i + 1 < buffers.length) {\n        const size1 = buffers[i].length;\n        const size2 = buffers[i + 1].length;\n        const combinedSize = size1 + size2;\n\n        // Safe: combinedSize <= 2 * MAX_SAFE_BUFFER_LENGTH = 256MB\n        const combined = createChunk(combinedSize, false);\n        buffers[i].copy(combined, 0);\n        buffers[i + 1].copy(combined, size1);\n        newBuffers.push(combined);\n      } else {\n        newBuffers.push(buffers[i]);\n      }\n    }\n\n    // Clear old references to help GC and use traditional for loop for Node 0.8 compatibility\n    for (let j = 0; j < buffers.length; j++) {\n      buffers[j] = undefined as unknown as Buffer;\n    }\n    buffers.length = 0;\n    for (let j = 0; j < newBuffers.length; j++) {\n      buffers.push(newBuffers[j]);\n    }\n  }\n\n  return buffers[0];\n}\n\n/**\n * Allocate a large buffer by allocating in chunks and combining them\n * Handles both zero-filled (safe) and uninitialized (unsafe) variants\n */\nfunction allocBufferLarge(size: number, zeroFill: boolean): Buffer {\n  // For large sizes, allocate smaller chunks and combine them\n  const numChunks = Math.ceil(size / MAX_SAFE_BUFFER_LENGTH);\n  const chunks: Buffer[] = [];\n\n  // Allocate individual chunks (each <= MAX_SAFE_BUFFER_LENGTH)\n  for (let i = 0; i < numChunks; i++) {\n    const chunkSize = Math.min(MAX_SAFE_BUFFER_LENGTH, size - i * MAX_SAFE_BUFFER_LENGTH);\n    chunks.push(createChunk(chunkSize, zeroFill));\n  }\n\n  // Combine chunks iteratively using pairwise combination\n  return combineBuffersPairwise(chunks);\n}\n\n/**\n * Allocate a zero-filled buffer (safe) - handles very large allocations\n * - Uses Buffer.alloc() on Node 4.5+\n * - Falls back to new Buffer() + fill on Node 0.8-4.4\n * - For sizes > MAX_SAFE_BUFFER_LENGTH, allocates in chunks and copies\n */\nexport function allocBuffer(size: number): Buffer {\n  if (size === 0) {\n    return new Buffer(0);\n  }\n\n  // Use native allocation for sizes within safe limits\n  if (canAllocateBufferSize(size)) {\n    if (hasBufferAlloc) {\n      return Buffer.alloc(size);\n    }\n    // Legacy fallback: new Buffer() is uninitialized, must zero-fill\n    const buf = new Buffer(size);\n    buf.fill(0);\n    return buf;\n  }\n\n  // For large sizes, allocate in chunks with zero-filling\n  return allocBufferLarge(size, true);\n}\n\n/**\n * Allocate a buffer without initialization (unsafe but faster)\n * - Uses Buffer.allocUnsafe() on Node 4.5+\n * - Falls back to new Buffer() on Node 0.8-4.4\n * - For sizes > MAX_SAFE_BUFFER_LENGTH, allocates in chunks without zeroing\n *\n * WARNING: Buffer contents are uninitialized and may contain sensitive data.\n * Only use when you will immediately overwrite all bytes.\n */\nexport function allocBufferUnsafe(size: number): Buffer {\n  if (size === 0) {\n    return new Buffer(0);\n  }\n\n  // Use native allocation for sizes within safe limits\n  if (canAllocateBufferSize(size)) {\n    if (hasBufferAllocUnsafe) {\n      return Buffer.allocUnsafe(size);\n    }\n    return new Buffer(size);\n  }\n\n  // For large sizes, allocate in chunks without zero-filling\n  return allocBufferLarge(size, false);\n}\n\n/**\n * Create a buffer from string, array, or existing buffer\n * - Uses Buffer.from() on Node 4.5+\n * - Falls back to new Buffer() on Node 0.8-4.4\n * - Handles Uint8Array conversion for Node 0.8 (crypto output compatibility)\n */\nexport function bufferFrom(data: string | number[] | Buffer | Uint8Array, encoding?: BufferEncoding): Buffer {\n  if (hasBufferFrom) {\n    if (typeof data === 'string') {\n      return Buffer.from(data, encoding);\n    }\n    return Buffer.from(data as number[] | Buffer);\n  }\n  // Node 0.8 compatibility - deprecated Buffer constructor\n  // For Uint8Array, convert to array first (needed for crypto output in Node 0.8)\n  if (data instanceof Uint8Array && !(data instanceof Buffer)) {\n    const arr: number[] = [];\n    for (let i = 0; i < data.length; i++) {\n      arr.push(data[i]);\n    }\n    return new Buffer(arr);\n  }\n  return new Buffer(data as string & number[], encoding);\n}\n\n/**\n * Compare two buffers or buffer regions\n * - Uses Buffer.compare() on Node 5.10+ (with offset support)\n * - Falls back to manual comparison on Node 0.8-5.9\n */\nexport function bufferCompare(source: Buffer, target: Buffer, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): number {\n  sourceStart = sourceStart || 0;\n  sourceEnd = sourceEnd || source.length;\n  targetStart = targetStart || 0;\n  targetEnd = targetEnd || target.length;\n\n  // Check if native compare with offset support exists (Node 5.10+)\n  if (source.compare && source.compare.length >= 5) {\n    return source.compare(target, targetStart, targetEnd, sourceStart, sourceEnd);\n  }\n\n  // Manual comparison for older Node versions\n  const sourceLen = sourceEnd - sourceStart;\n  const targetLen = targetEnd - targetStart;\n  const len = Math.min(sourceLen, targetLen);\n\n  for (let i = 0; i < len; i++) {\n    const s = source[sourceStart + i];\n    const t = target[targetStart + i];\n    if (s !== t) return s < t ? -1 : 1;\n  }\n\n  return sourceLen - targetLen;\n}\n\n/**\n * Check if buffer region equals byte array\n * Useful for magic number detection without Buffer.from()\n */\nexport function bufferEquals(buf: Buffer, offset: number, expected: number[]): boolean {\n  if (offset + expected.length > buf.length) return false;\n  for (let i = 0; i < expected.length; i++) {\n    if (buf[offset + i] !== expected[i]) return false;\n  }\n  return true;\n}\n\n/**\n * Copy buffer region to new buffer\n * Works on all Node versions\n */\nexport function bufferSliceCopy(buf: Buffer, start: number, end: number): Buffer {\n  const result = allocBuffer(end - start);\n  buf.copy(result, 0, start, end);\n  return result;\n}\n\n/**\n * Read 64-bit unsigned integer (little-endian)\n * Uses two 32-bit reads since BigInt not available until Node 10.4\n *\n * WARNING: Only accurate for values < Number.MAX_SAFE_INTEGER (2^53 - 1)\n * This covers files up to ~9 PB which is practical for all real use cases.\n */\nexport function readUInt64LE(buf: Buffer, offset: number): number {\n  const low = buf.readUInt32LE(offset);\n  const high = buf.readUInt32LE(offset + 4);\n  return high * 0x100000000 + low;\n}\n\n/**\n * Write 64-bit unsigned integer (little-endian)\n * Same precision limitation as readUInt64LE\n */\nexport function writeUInt64LE(buf: Buffer, value: number, offset: number): void {\n  const low = value >>> 0;\n  const high = (value / 0x100000000) >>> 0;\n  buf.writeUInt32LE(low, offset);\n  buf.writeUInt32LE(high, offset + 4);\n}\n\n/**\n * Concatenate buffers - compatible with Node 0.8+\n * Handles crypto output which may not be proper Buffer instances in old Node.\n * Also handles very large concatenations that would exceed buffer limits.\n *\n * NOTE: This function is primarily needed for AES decryption compatibility\n * in Node 0.8 where crypto output may not be proper Buffer instances.\n * Libraries not using crypto can use native Buffer.concat() directly.\n */\nexport function bufferConcat(list: (Buffer | Uint8Array)[], totalLength?: number): Buffer {\n  // Calculate actual total length first\n  let actualLength = 0;\n  for (let i = 0; i < list.length; i++) {\n    actualLength += list[i].length;\n  }\n\n  // Use specified totalLength or actual length\n  const targetLength = totalLength !== undefined ? totalLength : actualLength;\n\n  // Handle empty list\n  if (list.length === 0) {\n    return new Buffer(0);\n  }\n\n  // Handle very large concatenations that would exceed buffer limits\n  // Use native Buffer.concat for smaller sizes (faster)\n  if (targetLength <= MAX_SAFE_BUFFER_LENGTH) {\n    // Check if all items are proper Buffers AND no truncation needed\n    // (Node 0.8's Buffer.concat doesn't handle truncation well)\n    let allBuffers = true;\n    for (let j = 0; j < list.length; j++) {\n      if (!(list[j] instanceof Buffer)) {\n        allBuffers = false;\n        break;\n      }\n    }\n    if (allBuffers && targetLength >= actualLength) {\n      return Buffer.concat(list as Buffer[], targetLength);\n    }\n  }\n\n  // For large or complex concatenations, use chunked approach\n  // This will use allocBuffer which handles large sizes via chunking\n  const result = allocBuffer(targetLength);\n  let offset = 0;\n\n  for (let k = 0; k < list.length && offset < targetLength; k++) {\n    const buf = list[k];\n    const toCopy = Math.min(buf.length, targetLength - offset);\n\n    if (buf instanceof Buffer) {\n      buf.copy(result, offset, 0, toCopy);\n    } else {\n      // Uint8Array - need to copy byte by byte\n      for (let l = 0; l < toCopy; l++) {\n        result[offset + l] = buf[l];\n      }\n    }\n    offset += toCopy;\n  }\n\n  return result;\n}\n\n/**\n * Node 0.8 compatible isNaN (Number.isNaN didn't exist until ES2015)\n * Uses self-comparison: NaN is the only value not equal to itself\n */\n// biome-ignore lint/suspicious/noShadowRestrictedNames: Legacy compatibility\nexport function isNaN(value: number): boolean {\n  // biome-ignore lint/suspicious/noSelfCompare: NaN check pattern\n  return value !== value;\n}\n\n/**\n * Decompress raw DEFLATE data (no zlib/gzip header)\n * - Uses native zlib.inflateRawSync() on Node 0.11.12+\n * - Falls back to pako for Node 0.8-0.10\n *\n * Version history:\n * - Node 0.8-0.10: No zlib sync methods, use pako\n * - Node 0.11.12+: zlib.inflateRawSync available\n */\n// Feature detection for native zlib sync methods (Node 0.11.12+)\nlet zlib: typeof import('zlib') | null = null;\ntry {\n  zlib = _require('zlib');\n} catch (_e) {\n  // zlib not available (shouldn't happen in Node.js)\n}\nconst hasNativeInflateRaw = zlib !== null && typeof zlib.inflateRawSync === 'function';\n\nexport function inflateRaw(input: Buffer): Buffer {\n  if (hasNativeInflateRaw && zlib) {\n    return zlib.inflateRawSync(input);\n  }\n  // Fallback to pako for Node 0.8-0.10\n  const pako = _require('pako');\n  return bufferFrom(pako.inflateRaw(input));\n}\n\n/**\n * Create a streaming raw DEFLATE decompressor (Transform stream)\n * Decompresses data incrementally to avoid holding full output in memory.\n *\n * - Uses native zlib.createInflateRaw() on Node 0.11.12+\n * - Falls back to pako-based Transform for Node 0.8-0.10\n *\n * @returns A Transform stream that decompresses raw DEFLATE data\n */\n// Check for native streaming inflate (Node 0.11.12+ has createInflateRaw)\n// biome-ignore lint/suspicious/noExplicitAny: createInflateRaw not in older TS definitions\nconst hasNativeStreamingInflate = zlib !== null && typeof (zlib as any).createInflateRaw === 'function';\n\nexport function createInflateRawStream(): NodeJS.ReadWriteStream {\n  if (hasNativeStreamingInflate && zlib) {\n    // Use native zlib streaming Transform\n    // biome-ignore lint/suspicious/noExplicitAny: createInflateRaw not in older TS definitions\n    return (zlib as any).createInflateRaw();\n  }\n\n  // Fallback to pako-based Transform for Node 0.8-0.10\n  // Use readable-stream for Node 0.8 compatibility\n  const Transform = _require('readable-stream').Transform;\n  const pako = _require('pako');\n\n  const inflate = new pako.Inflate({ raw: true, chunkSize: 16384 });\n  const transform = new Transform();\n  const pendingChunks: Buffer[] = [];\n  let ended = false;\n\n  // Pako calls onData synchronously during push()\n  inflate.onData = (chunk: Uint8Array) => {\n    pendingChunks.push(bufferFrom(chunk));\n  };\n\n  inflate.onEnd = (status: number) => {\n    ended = true;\n    if (status !== 0) {\n      transform.emit('error', new Error(`Inflate error: ${inflate.msg || 'unknown'}`));\n    }\n  };\n\n  transform._transform = function (chunk: Buffer, _encoding: string, callback: (err?: Error) => void) {\n    try {\n      inflate.push(chunk, false);\n      // Push any pending decompressed chunks\n      while (pendingChunks.length > 0) {\n        this.push(pendingChunks.shift());\n      }\n      callback();\n    } catch (err) {\n      callback(err as Error);\n    }\n  };\n\n  transform._flush = function (callback: (err?: Error) => void) {\n    try {\n      inflate.push(new Uint8Array(0), true); // Signal end\n      // Push any remaining decompressed chunks\n      while (pendingChunks.length > 0) {\n        this.push(pendingChunks.shift());\n      }\n      if (ended && inflate.err) {\n        callback(new Error(`Inflate error: ${inflate.msg || 'unknown'}`));\n      } else {\n        callback();\n      }\n    } catch (err) {\n      callback(err as Error);\n    }\n  };\n\n  return transform;\n}\n\n/**\n * Object.assign wrapper for Node.js 0.8+\n * - Uses native Object.assign on Node 4.0+\n * - Falls back to manual property copy on Node 0.8-3.x\n */\nconst hasObjectAssign = typeof Object.assign === 'function';\nconst _hasOwnProperty = Object.prototype.hasOwnProperty;\n\nexport function objectAssign<T, U>(target: T, source: U): T & U {\n  if (hasObjectAssign) return Object.assign(target, source);\n\n  for (const key in source) {\n    if (_hasOwnProperty.call(source, key)) (target as Record<string, unknown>)[key] = source[key];\n  }\n  return target as T & U;\n}\n\n/**\n * Stream compatibility - Transform class\n * - Uses native stream.Transform on Node 0.10+\n * - Falls back to readable-stream for Node 0.8\n */\nconst major = +process.versions.node.split('.')[0];\nexport const Readable: typeof import('stream').Readable = major > 0 ? _require('stream').Readable : _require('readable-stream').Readable;\nexport const Writable: typeof import('stream').Writable = major > 0 ? _require('stream').Writable : _require('readable-stream').Writable;\nexport const Transform: typeof import('stream').Transform = major > 0 ? _require('stream').Transform : _require('readable-stream').Transform;\nexport const PassThrough: typeof import('stream').PassThrough = major > 0 ? _require('stream').PassThrough : _require('readable-stream').PassThrough;\n"],"names":["PassThrough","Readable","Transform","Writable","allocBuffer","allocBufferUnsafe","bufferCompare","bufferConcat","bufferEquals","bufferFrom","bufferSliceCopy","createInflateRawStream","inflateRaw","isNaN","objectAssign","readUInt64LE","writeUInt64LE","_require","require","Module","createRequire","hasBufferAlloc","Buffer","alloc","hasBufferAllocUnsafe","allocUnsafe","hasBufferFrom","from","Uint8Array","MAX_SAFE_BUFFER_LENGTH","DETECTED_MAX_LENGTH","_getMaxBufferLength","maxLen","kMaxLength","undefined","canAllocateBufferSize","size","createChunk","zeroFill","buf","fill","combineBuffersPairwise","buffers","length","newBuffers","i","size1","size2","combinedSize","combined","copy","push","j","allocBufferLarge","numChunks","Math","ceil","chunks","chunkSize","min","data","encoding","arr","source","target","targetStart","targetEnd","sourceStart","sourceEnd","compare","sourceLen","targetLen","len","s","t","offset","expected","start","end","result","low","readUInt32LE","high","value","writeUInt32LE","list","totalLength","actualLength","targetLength","allBuffers","concat","k","toCopy","l","zlib","_e","hasNativeInflateRaw","inflateRawSync","input","pako","hasNativeStreamingInflate","createInflateRaw","inflate","Inflate","raw","transform","pendingChunks","ended","onData","chunk","onEnd","status","emit","Error","msg","_transform","_encoding","callback","shift","err","_flush","hasObjectAssign","Object","assign","_hasOwnProperty","prototype","hasOwnProperty","key","call","major","process","versions","node","split"],"mappings":"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"}

package/dist/esm/LinkEntry.js

@@ -35,6 +35,7 @@ let LinkEntry = class LinkEntry {
                     });
                 }
                 queue.defer(mkdirp.bind(null, path.dirname(fullPath)));
+                queue.defer(waitForAccess.bind(null, linkFullPath)); // ensure target file is accessible before linking
                 queue.defer(fs.link.bind(fs, linkFullPath, fullPath));
                 queue.defer(waitForAccess.bind(null, fullPath));
                 queue.defer(chmod.bind(null, fullPath, this, options));

package/dist/esm/LinkEntry.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/LinkEntry.ts"],"sourcesContent":["import fs from 'fs';\nimport { rm } from 'fs-remove-compat';\nimport mkdirp from 'mkdirp-classic';\nimport path from 'path';\nimport Queue from 'queue-cb';\nimport chmod from './fs/chmod.ts';\nimport chown from './fs/chown.ts';\nimport utimes from './fs/utimes.ts';\nimport { objectAssign } from './shared/index.ts';\nimport stripPath from './shared/stripPath.ts';\nimport validateAttributes from './validateAttributes.ts';\nimport waitForAccess from './waitForAccess.ts';\n\nconst MANDATORY_ATTRIBUTES = ['mode', 'mtime', 'path', 'linkpath'];\n\nimport type { Mode } from 'fs';\nimport type { ExtractOptions, LinkAttributes, NoParamCallback } from './types.ts';\n\nexport default class LinkEntry {\n  mode: Mode;\n  mtime: number;\n  path: string;\n  linkpath: string;\n  basename: string;\n  type: string;\n\n  constructor(attributes: LinkAttributes) {\n    validateAttributes(attributes, MANDATORY_ATTRIBUTES);\n    objectAssign(this, attributes);\n    if (this.basename === undefined) this.basename = path.basename(this.path);\n    if (this.type === undefined) this.type = 'link';\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      try {\n        const normalizedPath = path.normalize(this.path);\n        const fullPath = path.join(dest, stripPath(normalizedPath, options));\n        const normalizedLinkpath = path.normalize(this.linkpath);\n        const linkFullPath = path.join(dest, stripPath(normalizedLinkpath, options));\n\n        const queue = new Queue(1);\n        if (options.force) {\n          queue.defer((callback) => {\n            rm(fullPath, (err) => {\n              err && err.code !== 'ENOENT' ? callback(err) : callback();\n            });\n          });\n        }\n        queue.defer(mkdirp.bind(null, path.dirname(fullPath)));\n        queue.defer(fs.link.bind(fs, linkFullPath, fullPath));\n        queue.defer(waitForAccess.bind(null, fullPath));\n        queue.defer(chmod.bind(null, fullPath, this, options));\n        queue.defer(chown.bind(null, fullPath, this, options));\n        queue.defer(utimes.bind(null, fullPath, this, options));\n        queue.await(callback);\n        return;\n      } catch (err) {\n        callback(err);\n        return;\n      }\n    }\n\n    return new Promise((resolve, reject) => {\n      this.create(dest, options, (err?: Error, done?: boolean) => (err ? reject(err) : resolve(done)));\n    });\n  }\n\n  destroy() {}\n}\n"],"names":["fs","rm","mkdirp","path","Queue","chmod","chown","utimes","objectAssign","stripPath","validateAttributes","waitForAccess","MANDATORY_ATTRIBUTES","LinkEntry","create","dest","options","callback","normalizedPath","normalize","fullPath","join","normalizedLinkpath","linkpath","linkFullPath","queue","force","defer","err","code","bind","dirname","link","await","Promise","resolve","reject","done","destroy","attributes","basename","undefined","type"],"mappings":"AAAA,OAAOA,QAAQ,KAAK;AACpB,SAASC,EAAE,QAAQ,mBAAmB;AACtC,OAAOC,YAAY,iBAAiB;AACpC,OAAOC,UAAU,OAAO;AACxB,OAAOC,WAAW,WAAW;AAC7B,OAAOC,WAAW,gBAAgB;AAClC,OAAOC,WAAW,gBAAgB;AAClC,OAAOC,YAAY,iBAAiB;AACpC,SAASC,YAAY,QAAQ,oBAAoB;AACjD,OAAOC,eAAe,wBAAwB;AAC9C,OAAOC,wBAAwB,0BAA0B;AACzD,OAAOC,mBAAmB,qBAAqB;AAE/C,MAAMC,uBAAuB;IAAC;IAAQ;IAAS;IAAQ;CAAW;AAKnD,IAAA,AAAMC,YAAN,MAAMA;IAkBnBC,OAAOC,IAAY,EAAEC,OAA0C,EAAEC,QAA0B,EAA2B;QACpHA,WAAW,OAAOD,YAAY,aAAaA,UAAUC;QACrDD,UAAU,OAAOA,YAAY,aAAa,CAAC,IAAMA,WAAW,CAAC;QAE7D,IAAI,OAAOC,aAAa,YAAY;YAClC,IAAI;gBACF,MAAMC,iBAAiBf,KAAKgB,SAAS,CAAC,IAAI,CAAChB,IAAI;gBAC/C,MAAMiB,WAAWjB,KAAKkB,IAAI,CAACN,MAAMN,UAAUS,gBAAgBF;gBAC3D,MAAMM,qBAAqBnB,KAAKgB,SAAS,CAAC,IAAI,CAACI,QAAQ;gBACvD,MAAMC,eAAerB,KAAKkB,IAAI,CAACN,MAAMN,UAAUa,oBAAoBN;gBAEnE,MAAMS,QAAQ,IAAIrB,MAAM;gBACxB,IAAIY,QAAQU,KAAK,EAAE;oBACjBD,MAAME,KAAK,CAAC,CAACV;wBACXhB,GAAGmB,UAAU,CAACQ;4BACZA,OAAOA,IAAIC,IAAI,KAAK,WAAWZ,SAASW,OAAOX;wBACjD;oBACF;gBACF;gBACAQ,MAAME,KAAK,CAACzB,OAAO4B,IAAI,CAAC,MAAM3B,KAAK4B,OAAO,CAACX;gBAC3CK,MAAME,KAAK,CAAC3B,GAAGgC,IAAI,CAACF,IAAI,CAAC9B,IAAIwB,cAAcJ;gBAC3CK,MAAME,KAAK,CAAChB,cAAcmB,IAAI,CAAC,MAAMV;gBACrCK,MAAME,KAAK,CAACtB,MAAMyB,IAAI,CAAC,MAAMV,UAAU,IAAI,EAAEJ;gBAC7CS,MAAME,KAAK,CAACrB,MAAMwB,IAAI,CAAC,MAAMV,UAAU,IAAI,EAAEJ;gBAC7CS,MAAME,KAAK,CAACpB,OAAOuB,IAAI,CAAC,MAAMV,UAAU,IAAI,EAAEJ;gBAC9CS,MAAMQ,KAAK,CAAChB;gBACZ;YACF,EAAE,OAAOW,KAAK;gBACZX,SAASW;gBACT;YACF;QACF;QAEA,OAAO,IAAIM,QAAQ,CAACC,SAASC;YAC3B,IAAI,CAACtB,MAAM,CAACC,MAAMC,SAAS,CAACY,KAAaS,OAAoBT,MAAMQ,OAAOR,OAAOO,QAAQE;QAC3F;IACF;IAEAC,UAAU,CAAC;IAhDX,YAAYC,UAA0B,CAAE;QACtC7B,mBAAmB6B,YAAY3B;QAC/BJ,aAAa,IAAI,EAAE+B;QACnB,IAAI,IAAI,CAACC,QAAQ,KAAKC,WAAW,IAAI,CAACD,QAAQ,GAAGrC,KAAKqC,QAAQ,CAAC,IAAI,CAACrC,IAAI;QACxE,IAAI,IAAI,CAACuC,IAAI,KAAKD,WAAW,IAAI,CAACC,IAAI,GAAG;IAC3C;AA4CF;AAzDA,SAAqB7B,uBAyDpB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/LinkEntry.ts"],"sourcesContent":["import fs from 'fs';\nimport { rm } from 'fs-remove-compat';\nimport mkdirp from 'mkdirp-classic';\nimport path from 'path';\nimport Queue from 'queue-cb';\nimport chmod from './fs/chmod.ts';\nimport chown from './fs/chown.ts';\nimport utimes from './fs/utimes.ts';\nimport { objectAssign } from './shared/index.ts';\nimport stripPath from './shared/stripPath.ts';\nimport validateAttributes from './validateAttributes.ts';\nimport waitForAccess from './waitForAccess.ts';\n\nconst MANDATORY_ATTRIBUTES = ['mode', 'mtime', 'path', 'linkpath'];\n\nimport type { Mode } from 'fs';\nimport type { ExtractOptions, LinkAttributes, NoParamCallback } from './types.ts';\n\nexport default class LinkEntry {\n  mode: Mode;\n  mtime: number;\n  path: string;\n  linkpath: string;\n  basename: string;\n  type: string;\n\n  constructor(attributes: LinkAttributes) {\n    validateAttributes(attributes, MANDATORY_ATTRIBUTES);\n    objectAssign(this, attributes);\n    if (this.basename === undefined) this.basename = path.basename(this.path);\n    if (this.type === undefined) this.type = 'link';\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      try {\n        const normalizedPath = path.normalize(this.path);\n        const fullPath = path.join(dest, stripPath(normalizedPath, options));\n        const normalizedLinkpath = path.normalize(this.linkpath);\n        const linkFullPath = path.join(dest, stripPath(normalizedLinkpath, options));\n\n        const queue = new Queue(1);\n        if (options.force) {\n          queue.defer((callback) => {\n            rm(fullPath, (err) => {\n              err && err.code !== 'ENOENT' ? callback(err) : callback();\n            });\n          });\n        }\n        queue.defer(mkdirp.bind(null, path.dirname(fullPath)));\n        queue.defer(waitForAccess.bind(null, linkFullPath)); // ensure target file is accessible before linking\n        queue.defer(fs.link.bind(fs, linkFullPath, fullPath));\n        queue.defer(waitForAccess.bind(null, fullPath));\n        queue.defer(chmod.bind(null, fullPath, this, options));\n        queue.defer(chown.bind(null, fullPath, this, options));\n        queue.defer(utimes.bind(null, fullPath, this, options));\n        queue.await(callback);\n        return;\n      } catch (err) {\n        callback(err);\n        return;\n      }\n    }\n\n    return new Promise((resolve, reject) => {\n      this.create(dest, options, (err?: Error, done?: boolean) => (err ? reject(err) : resolve(done)));\n    });\n  }\n\n  destroy() {}\n}\n"],"names":["fs","rm","mkdirp","path","Queue","chmod","chown","utimes","objectAssign","stripPath","validateAttributes","waitForAccess","MANDATORY_ATTRIBUTES","LinkEntry","create","dest","options","callback","normalizedPath","normalize","fullPath","join","normalizedLinkpath","linkpath","linkFullPath","queue","force","defer","err","code","bind","dirname","link","await","Promise","resolve","reject","done","destroy","attributes","basename","undefined","type"],"mappings":"AAAA,OAAOA,QAAQ,KAAK;AACpB,SAASC,EAAE,QAAQ,mBAAmB;AACtC,OAAOC,YAAY,iBAAiB;AACpC,OAAOC,UAAU,OAAO;AACxB,OAAOC,WAAW,WAAW;AAC7B,OAAOC,WAAW,gBAAgB;AAClC,OAAOC,WAAW,gBAAgB;AAClC,OAAOC,YAAY,iBAAiB;AACpC,SAASC,YAAY,QAAQ,oBAAoB;AACjD,OAAOC,eAAe,wBAAwB;AAC9C,OAAOC,wBAAwB,0BAA0B;AACzD,OAAOC,mBAAmB,qBAAqB;AAE/C,MAAMC,uBAAuB;IAAC;IAAQ;IAAS;IAAQ;CAAW;AAKnD,IAAA,AAAMC,YAAN,MAAMA;IAkBnBC,OAAOC,IAAY,EAAEC,OAA0C,EAAEC,QAA0B,EAA2B;QACpHA,WAAW,OAAOD,YAAY,aAAaA,UAAUC;QACrDD,UAAU,OAAOA,YAAY,aAAa,CAAC,IAAMA,WAAW,CAAC;QAE7D,IAAI,OAAOC,aAAa,YAAY;YAClC,IAAI;gBACF,MAAMC,iBAAiBf,KAAKgB,SAAS,CAAC,IAAI,CAAChB,IAAI;gBAC/C,MAAMiB,WAAWjB,KAAKkB,IAAI,CAACN,MAAMN,UAAUS,gBAAgBF;gBAC3D,MAAMM,qBAAqBnB,KAAKgB,SAAS,CAAC,IAAI,CAACI,QAAQ;gBACvD,MAAMC,eAAerB,KAAKkB,IAAI,CAACN,MAAMN,UAAUa,oBAAoBN;gBAEnE,MAAMS,QAAQ,IAAIrB,MAAM;gBACxB,IAAIY,QAAQU,KAAK,EAAE;oBACjBD,MAAME,KAAK,CAAC,CAACV;wBACXhB,GAAGmB,UAAU,CAACQ;4BACZA,OAAOA,IAAIC,IAAI,KAAK,WAAWZ,SAASW,OAAOX;wBACjD;oBACF;gBACF;gBACAQ,MAAME,KAAK,CAACzB,OAAO4B,IAAI,CAAC,MAAM3B,KAAK4B,OAAO,CAACX;gBAC3CK,MAAME,KAAK,CAAChB,cAAcmB,IAAI,CAAC,MAAMN,gBAAgB,kDAAkD;gBACvGC,MAAME,KAAK,CAAC3B,GAAGgC,IAAI,CAACF,IAAI,CAAC9B,IAAIwB,cAAcJ;gBAC3CK,MAAME,KAAK,CAAChB,cAAcmB,IAAI,CAAC,MAAMV;gBACrCK,MAAME,KAAK,CAACtB,MAAMyB,IAAI,CAAC,MAAMV,UAAU,IAAI,EAAEJ;gBAC7CS,MAAME,KAAK,CAACrB,MAAMwB,IAAI,CAAC,MAAMV,UAAU,IAAI,EAAEJ;gBAC7CS,MAAME,KAAK,CAACpB,OAAOuB,IAAI,CAAC,MAAMV,UAAU,IAAI,EAAEJ;gBAC9CS,MAAMQ,KAAK,CAAChB;gBACZ;YACF,EAAE,OAAOW,KAAK;gBACZX,SAASW;gBACT;YACF;QACF;QAEA,OAAO,IAAIM,QAAQ,CAACC,SAASC;YAC3B,IAAI,CAACtB,MAAM,CAACC,MAAMC,SAAS,CAACY,KAAaS,OAAoBT,MAAMQ,OAAOR,OAAOO,QAAQE;QAC3F;IACF;IAEAC,UAAU,CAAC;IAjDX,YAAYC,UAA0B,CAAE;QACtC7B,mBAAmB6B,YAAY3B;QAC/BJ,aAAa,IAAI,EAAE+B;QACnB,IAAI,IAAI,CAACC,QAAQ,KAAKC,WAAW,IAAI,CAACD,QAAQ,GAAGrC,KAAKqC,QAAQ,CAAC,IAAI,CAACrC,IAAI;QACxE,IAAI,IAAI,CAACuC,IAAI,KAAKD,WAAW,IAAI,CAACC,IAAI,GAAG;IAC3C;AA6CF;AA1DA,SAAqB7B,uBA0DpB"}

package/dist/esm/shared/compat.d.ts

@@ -12,15 +12,17 @@
  * Solution: Feature detection with graceful fallback in both directions.
  */
 /**
- * Allocate a zero-filled buffer (safe)
+ * Allocate a zero-filled buffer (safe) - handles very large allocations
  * - Uses Buffer.alloc() on Node 4.5+
  * - Falls back to new Buffer() + fill on Node 0.8-4.4
+ * - For sizes > MAX_SAFE_BUFFER_LENGTH, allocates in chunks and copies
  */
 export declare function allocBuffer(size: number): Buffer;
 /**
  * Allocate a buffer without initialization (unsafe but faster)
  * - Uses Buffer.allocUnsafe() on Node 4.5+
  * - Falls back to new Buffer() on Node 0.8-4.4
+ * - For sizes > MAX_SAFE_BUFFER_LENGTH, allocates in chunks without zeroing
  *
  * WARNING: Buffer contents are uninitialized and may contain sensitive data.
  * Only use when you will immediately overwrite all bytes.
@@ -63,8 +65,9 @@ export declare function readUInt64LE(buf: Buffer, offset: number): number;
  */
 export declare function writeUInt64LE(buf: Buffer, value: number, offset: number): void;
 /**
- * Concatenate buffers - compatible with Node 0.8
+ * Concatenate buffers - compatible with Node 0.8+
  * Handles crypto output which may not be proper Buffer instances in old Node.
+ * Also handles very large concatenations that would exceed buffer limits.
  *
  * NOTE: This function is primarily needed for AES decryption compatibility
  * in Node 0.8 where crypto output may not be proper Buffer instances.

package/dist/esm/shared/compat.js

@@ -17,31 +17,136 @@ const _require = typeof require === 'undefined' ? Module.createRequire(import.me
 const hasBufferAlloc = typeof Buffer.alloc === 'function';
 const hasBufferAllocUnsafe = typeof Buffer.allocUnsafe === 'function';
 const hasBufferFrom = typeof Buffer.from === 'function' && Buffer.from !== Uint8Array.from;
+// Maximum buffer size that works across all Node.js versions
+// Node 0.8-4.x: kMaxLength = 0x3fffffff (~1073MB) but actual limit may be lower
+// Node 6-7.x: ~1073MB for Uint8Array
+// Node 8+: ~2GB for Buffer
+// Node 10+: 2^31-1 (~2147MB) for Buffer.allocUnsafe
+// Use 128MB as a conservative limit for buffer operations
+const MAX_SAFE_BUFFER_LENGTH = 128 * 1024 * 1024; // 128MB
+// Try to detect the actual kMaxLength for this Node version
+// If we can't detect it (older Node), assume conservative limit
+let DETECTED_MAX_LENGTH = null;
+function _getMaxBufferLength() {
+    if (DETECTED_MAX_LENGTH !== null) return DETECTED_MAX_LENGTH;
+    // Try to detect the actual limit
+    // kMaxLength exists on BufferConstructor in newer TypeScript definitions
+    // but may not exist at runtime on very old Node
+    const maxLen = Buffer.kMaxLength;
+    if (maxLen !== undefined) {
+        DETECTED_MAX_LENGTH = maxLen;
+    } else {
+        // Older Node - use conservative estimate
+        DETECTED_MAX_LENGTH = 0x3fffffff; // ~1073MB
+    }
+    return DETECTED_MAX_LENGTH;
+}
 /**
- * Allocate a zero-filled buffer (safe)
- * - Uses Buffer.alloc() on Node 4.5+
- * - Falls back to new Buffer() + fill on Node 0.8-4.4
- */ export function allocBuffer(size) {
+ * Check if a buffer size can be safely allocated on this Node version
+ * Uses conservative limit to work across all versions
+ */ function canAllocateBufferSize(size) {
+    return size >= 0 && size <= MAX_SAFE_BUFFER_LENGTH;
+}
+/**
+ * Create a single chunk of the specified size
+ */ function createChunk(size, zeroFill) {
     if (hasBufferAlloc) {
         return Buffer.alloc(size);
     }
-    // Legacy fallback: new Buffer() is uninitialized, must zero-fill
     const buf = new Buffer(size);
-    buf.fill(0);
+    if (zeroFill) buf.fill(0);
     return buf;
 }
+/**
+ * Combine an array of buffers into one by pairwise concatenation
+ * Each combination produces a buffer at most 2x MAX_SAFE_BUFFER_LENGTH (256MB)
+ * which is within kMaxLength for all Node versions
+ */ function combineBuffersPairwise(buffers) {
+    while(buffers.length > 1){
+        const newBuffers = [];
+        for(let i = 0; i < buffers.length; i += 2){
+            if (i + 1 < buffers.length) {
+                const size1 = buffers[i].length;
+                const size2 = buffers[i + 1].length;
+                const combinedSize = size1 + size2;
+                // Safe: combinedSize <= 2 * MAX_SAFE_BUFFER_LENGTH = 256MB
+                const combined = createChunk(combinedSize, false);
+                buffers[i].copy(combined, 0);
+                buffers[i + 1].copy(combined, size1);
+                newBuffers.push(combined);
+            } else {
+                newBuffers.push(buffers[i]);
+            }
+        }
+        // Clear old references to help GC and use traditional for loop for Node 0.8 compatibility
+        for(let j = 0; j < buffers.length; j++){
+            buffers[j] = undefined;
+        }
+        buffers.length = 0;
+        for(let j = 0; j < newBuffers.length; j++){
+            buffers.push(newBuffers[j]);
+        }
+    }
+    return buffers[0];
+}
+/**
+ * Allocate a large buffer by allocating in chunks and combining them
+ * Handles both zero-filled (safe) and uninitialized (unsafe) variants
+ */ function allocBufferLarge(size, zeroFill) {
+    // For large sizes, allocate smaller chunks and combine them
+    const numChunks = Math.ceil(size / MAX_SAFE_BUFFER_LENGTH);
+    const chunks = [];
+    // Allocate individual chunks (each <= MAX_SAFE_BUFFER_LENGTH)
+    for(let i = 0; i < numChunks; i++){
+        const chunkSize = Math.min(MAX_SAFE_BUFFER_LENGTH, size - i * MAX_SAFE_BUFFER_LENGTH);
+        chunks.push(createChunk(chunkSize, zeroFill));
+    }
+    // Combine chunks iteratively using pairwise combination
+    return combineBuffersPairwise(chunks);
+}
+/**
+ * Allocate a zero-filled buffer (safe) - handles very large allocations
+ * - Uses Buffer.alloc() on Node 4.5+
+ * - Falls back to new Buffer() + fill on Node 0.8-4.4
+ * - For sizes > MAX_SAFE_BUFFER_LENGTH, allocates in chunks and copies
+ */ export function allocBuffer(size) {
+    if (size === 0) {
+        return new Buffer(0);
+    }
+    // Use native allocation for sizes within safe limits
+    if (canAllocateBufferSize(size)) {
+        if (hasBufferAlloc) {
+            return Buffer.alloc(size);
+        }
+        // Legacy fallback: new Buffer() is uninitialized, must zero-fill
+        const buf = new Buffer(size);
+        buf.fill(0);
+        return buf;
+    }
+    // For large sizes, allocate in chunks with zero-filling
+    return allocBufferLarge(size, true);
+}
 /**
  * Allocate a buffer without initialization (unsafe but faster)
  * - Uses Buffer.allocUnsafe() on Node 4.5+
  * - Falls back to new Buffer() on Node 0.8-4.4
+ * - For sizes > MAX_SAFE_BUFFER_LENGTH, allocates in chunks without zeroing
  *
  * WARNING: Buffer contents are uninitialized and may contain sensitive data.
  * Only use when you will immediately overwrite all bytes.
  */ export function allocBufferUnsafe(size) {
-    if (hasBufferAllocUnsafe) {
-        return Buffer.allocUnsafe(size);
+    if (size === 0) {
+        return new Buffer(0);
+    }
+    // Use native allocation for sizes within safe limits
+    if (canAllocateBufferSize(size)) {
+        if (hasBufferAllocUnsafe) {
+            return Buffer.allocUnsafe(size);
+        }
+        return new Buffer(size);
     }
-    return new Buffer(size);
+    // For large sizes, allocate in chunks without zero-filling
+    return allocBufferLarge(size, false);
 }
 /**
  * Create a buffer from string, array, or existing buffer
@@ -129,8 +234,9 @@ const hasBufferFrom = typeof Buffer.from === 'function' && Buffer.from !== Uint8
     buf.writeUInt32LE(high, offset + 4);
 }
 /**
- * Concatenate buffers - compatible with Node 0.8
+ * Concatenate buffers - compatible with Node 0.8+
  * Handles crypto output which may not be proper Buffer instances in old Node.
+ * Also handles very large concatenations that would exceed buffer limits.
  *
  * NOTE: This function is primarily needed for AES decryption compatibility
  * in Node 0.8 where crypto output may not be proper Buffer instances.
@@ -143,26 +249,42 @@ const hasBufferFrom = typeof Buffer.from === 'function' && Buffer.from !== Uint8
     }
     // Use specified totalLength or actual length
     const targetLength = totalLength !== undefined ? totalLength : actualLength;
-    // Check if all items are proper Buffers AND no truncation needed
-    // (Node 0.8's Buffer.concat doesn't handle truncation well)
-    let allBuffers = true;
-    for(let j = 0; j < list.length; j++){
-        if (!(list[j] instanceof Buffer)) {
-            allBuffers = false;
-            break;
-        }
+    // Handle empty list
+    if (list.length === 0) {
+        return new Buffer(0);
     }
-    if (allBuffers && targetLength >= actualLength) {
-        return Buffer.concat(list, targetLength);
+    // Handle very large concatenations that would exceed buffer limits
+    // Use native Buffer.concat for smaller sizes (faster)
+    if (targetLength <= MAX_SAFE_BUFFER_LENGTH) {
+        // Check if all items are proper Buffers AND no truncation needed
+        // (Node 0.8's Buffer.concat doesn't handle truncation well)
+        let allBuffers = true;
+        for(let j = 0; j < list.length; j++){
+            if (!(list[j] instanceof Buffer)) {
+                allBuffers = false;
+                break;
+            }
+        }
+        if (allBuffers && targetLength >= actualLength) {
+            return Buffer.concat(list, targetLength);
+        }
     }
-    // Manual concat for mixed types or when truncation is needed
+    // For large or complex concatenations, use chunked approach
+    // This will use allocBuffer which handles large sizes via chunking
     const result = allocBuffer(targetLength);
     let offset = 0;
     for(let k = 0; k < list.length && offset < targetLength; k++){
         const buf = list[k];
-        for(let l = 0; l < buf.length && offset < targetLength; l++){
-            result[offset++] = buf[l];
+        const toCopy = Math.min(buf.length, targetLength - offset);
+        if (buf instanceof Buffer) {
+            buf.copy(result, offset, 0, toCopy);
+        } else {
+            // Uint8Array - need to copy byte by byte
+            for(let l = 0; l < toCopy; l++){
+                result[offset + l] = buf[l];
+            }
         }
+        offset += toCopy;
     }
     return result;
 }

package/dist/esm/shared/compat.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/compat.ts"],"sourcesContent":["/**\n * Buffer Compatibility Layer for Node.js 0.8+\n *\n * Provides buffer utilities that work across all Node.js versions\n * WITHOUT modifying global Buffer object.\n *\n * Version history:\n * - Node 0.8-4.4: Only has `new Buffer()`, no `Buffer.alloc/from`\n * - Node 4.5+: Has `Buffer.alloc/from`, deprecates `new Buffer()`\n * - Node 10+: Warns or errors on `new Buffer()`\n *\n * Solution: Feature detection with graceful fallback in both directions.\n */\n\n// ESM-compatible require - works in both CJS and ESM\nimport Module from 'module';\n\nconst _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n\n// Feature detection (runs once at module load)\nconst hasBufferAlloc = typeof Buffer.alloc === 'function';\nconst hasBufferAllocUnsafe = typeof Buffer.allocUnsafe === 'function';\nconst hasBufferFrom = typeof Buffer.from === 'function' && Buffer.from !== Uint8Array.from;\n\n/**\n * Allocate a zero-filled buffer (safe)\n * - Uses Buffer.alloc() on Node 4.5+\n * - Falls back to new Buffer() + fill on Node 0.8-4.4\n */\nexport function allocBuffer(size: number): Buffer {\n  if (hasBufferAlloc) {\n    return Buffer.alloc(size);\n  }\n  // Legacy fallback: new Buffer() is uninitialized, must zero-fill\n  const buf = new Buffer(size);\n  buf.fill(0);\n  return buf;\n}\n\n/**\n * Allocate a buffer without initialization (unsafe but faster)\n * - Uses Buffer.allocUnsafe() on Node 4.5+\n * - Falls back to new Buffer() on Node 0.8-4.4\n *\n * WARNING: Buffer contents are uninitialized and may contain sensitive data.\n * Only use when you will immediately overwrite all bytes.\n */\nexport function allocBufferUnsafe(size: number): Buffer {\n  if (hasBufferAllocUnsafe) {\n    return Buffer.allocUnsafe(size);\n  }\n  return new Buffer(size);\n}\n\n/**\n * Create a buffer from string, array, or existing buffer\n * - Uses Buffer.from() on Node 4.5+\n * - Falls back to new Buffer() on Node 0.8-4.4\n * - Handles Uint8Array conversion for Node 0.8 (crypto output compatibility)\n */\nexport function bufferFrom(data: string | number[] | Buffer | Uint8Array, encoding?: BufferEncoding): Buffer {\n  if (hasBufferFrom) {\n    if (typeof data === 'string') {\n      return Buffer.from(data, encoding);\n    }\n    return Buffer.from(data as number[] | Buffer);\n  }\n  // Node 0.8 compatibility - deprecated Buffer constructor\n  // For Uint8Array, convert to array first (needed for crypto output in Node 0.8)\n  if (data instanceof Uint8Array && !(data instanceof Buffer)) {\n    const arr: number[] = [];\n    for (let i = 0; i < data.length; i++) {\n      arr.push(data[i]);\n    }\n    return new Buffer(arr);\n  }\n  return new Buffer(data as string & number[], encoding);\n}\n\n/**\n * Compare two buffers or buffer regions\n * - Uses Buffer.compare() on Node 5.10+ (with offset support)\n * - Falls back to manual comparison on Node 0.8-5.9\n */\nexport function bufferCompare(source: Buffer, target: Buffer, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): number {\n  sourceStart = sourceStart || 0;\n  sourceEnd = sourceEnd || source.length;\n  targetStart = targetStart || 0;\n  targetEnd = targetEnd || target.length;\n\n  // Check if native compare with offset support exists (Node 5.10+)\n  if (source.compare && source.compare.length >= 5) {\n    return source.compare(target, targetStart, targetEnd, sourceStart, sourceEnd);\n  }\n\n  // Manual comparison for older Node versions\n  const sourceLen = sourceEnd - sourceStart;\n  const targetLen = targetEnd - targetStart;\n  const len = Math.min(sourceLen, targetLen);\n\n  for (let i = 0; i < len; i++) {\n    const s = source[sourceStart + i];\n    const t = target[targetStart + i];\n    if (s !== t) return s < t ? -1 : 1;\n  }\n\n  return sourceLen - targetLen;\n}\n\n/**\n * Check if buffer region equals byte array\n * Useful for magic number detection without Buffer.from()\n */\nexport function bufferEquals(buf: Buffer, offset: number, expected: number[]): boolean {\n  if (offset + expected.length > buf.length) return false;\n  for (let i = 0; i < expected.length; i++) {\n    if (buf[offset + i] !== expected[i]) return false;\n  }\n  return true;\n}\n\n/**\n * Copy buffer region to new buffer\n * Works on all Node versions\n */\nexport function bufferSliceCopy(buf: Buffer, start: number, end: number): Buffer {\n  const result = allocBuffer(end - start);\n  buf.copy(result, 0, start, end);\n  return result;\n}\n\n/**\n * Read 64-bit unsigned integer (little-endian)\n * Uses two 32-bit reads since BigInt not available until Node 10.4\n *\n * WARNING: Only accurate for values < Number.MAX_SAFE_INTEGER (2^53 - 1)\n * This covers files up to ~9 PB which is practical for all real use cases.\n */\nexport function readUInt64LE(buf: Buffer, offset: number): number {\n  const low = buf.readUInt32LE(offset);\n  const high = buf.readUInt32LE(offset + 4);\n  return high * 0x100000000 + low;\n}\n\n/**\n * Write 64-bit unsigned integer (little-endian)\n * Same precision limitation as readUInt64LE\n */\nexport function writeUInt64LE(buf: Buffer, value: number, offset: number): void {\n  const low = value >>> 0;\n  const high = (value / 0x100000000) >>> 0;\n  buf.writeUInt32LE(low, offset);\n  buf.writeUInt32LE(high, offset + 4);\n}\n\n/**\n * Concatenate buffers - compatible with Node 0.8\n * Handles crypto output which may not be proper Buffer instances in old Node.\n *\n * NOTE: This function is primarily needed for AES decryption compatibility\n * in Node 0.8 where crypto output may not be proper Buffer instances.\n * Libraries not using crypto can use native Buffer.concat() directly.\n */\nexport function bufferConcat(list: (Buffer | Uint8Array)[], totalLength?: number): Buffer {\n  // Calculate actual total length first\n  let actualLength = 0;\n  for (let i = 0; i < list.length; i++) {\n    actualLength += list[i].length;\n  }\n\n  // Use specified totalLength or actual length\n  const targetLength = totalLength !== undefined ? totalLength : actualLength;\n\n  // Check if all items are proper Buffers AND no truncation needed\n  // (Node 0.8's Buffer.concat doesn't handle truncation well)\n  let allBuffers = true;\n  for (let j = 0; j < list.length; j++) {\n    if (!(list[j] instanceof Buffer)) {\n      allBuffers = false;\n      break;\n    }\n  }\n  if (allBuffers && targetLength >= actualLength) {\n    return Buffer.concat(list as Buffer[], targetLength);\n  }\n\n  // Manual concat for mixed types or when truncation is needed\n  const result = allocBuffer(targetLength);\n  let offset = 0;\n  for (let k = 0; k < list.length && offset < targetLength; k++) {\n    const buf = list[k];\n    for (let l = 0; l < buf.length && offset < targetLength; l++) {\n      result[offset++] = buf[l];\n    }\n  }\n  return result;\n}\n\n/**\n * Node 0.8 compatible isNaN (Number.isNaN didn't exist until ES2015)\n * Uses self-comparison: NaN is the only value not equal to itself\n */\n// biome-ignore lint/suspicious/noShadowRestrictedNames: Legacy compatibility\nexport function isNaN(value: number): boolean {\n  // biome-ignore lint/suspicious/noSelfCompare: NaN check pattern\n  return value !== value;\n}\n\n/**\n * Decompress raw DEFLATE data (no zlib/gzip header)\n * - Uses native zlib.inflateRawSync() on Node 0.11.12+\n * - Falls back to pako for Node 0.8-0.10\n *\n * Version history:\n * - Node 0.8-0.10: No zlib sync methods, use pako\n * - Node 0.11.12+: zlib.inflateRawSync available\n */\n// Feature detection for native zlib sync methods (Node 0.11.12+)\nlet zlib: typeof import('zlib') | null = null;\ntry {\n  zlib = _require('zlib');\n} catch (_e) {\n  // zlib not available (shouldn't happen in Node.js)\n}\nconst hasNativeInflateRaw = zlib !== null && typeof zlib.inflateRawSync === 'function';\n\nexport function inflateRaw(input: Buffer): Buffer {\n  if (hasNativeInflateRaw && zlib) {\n    return zlib.inflateRawSync(input);\n  }\n  // Fallback to pako for Node 0.8-0.10\n  const pako = _require('pako');\n  return bufferFrom(pako.inflateRaw(input));\n}\n\n/**\n * Create a streaming raw DEFLATE decompressor (Transform stream)\n * Decompresses data incrementally to avoid holding full output in memory.\n *\n * - Uses native zlib.createInflateRaw() on Node 0.11.12+\n * - Falls back to pako-based Transform for Node 0.8-0.10\n *\n * @returns A Transform stream that decompresses raw DEFLATE data\n */\n// Check for native streaming inflate (Node 0.11.12+ has createInflateRaw)\n// biome-ignore lint/suspicious/noExplicitAny: createInflateRaw not in older TS definitions\nconst hasNativeStreamingInflate = zlib !== null && typeof (zlib as any).createInflateRaw === 'function';\n\nexport function createInflateRawStream(): NodeJS.ReadWriteStream {\n  if (hasNativeStreamingInflate && zlib) {\n    // Use native zlib streaming Transform\n    // biome-ignore lint/suspicious/noExplicitAny: createInflateRaw not in older TS definitions\n    return (zlib as any).createInflateRaw();\n  }\n\n  // Fallback to pako-based Transform for Node 0.8-0.10\n  // Use readable-stream for Node 0.8 compatibility\n  const Transform = _require('readable-stream').Transform;\n  const pako = _require('pako');\n\n  const inflate = new pako.Inflate({ raw: true, chunkSize: 16384 });\n  const transform = new Transform();\n  const pendingChunks: Buffer[] = [];\n  let ended = false;\n\n  // Pako calls onData synchronously during push()\n  inflate.onData = (chunk: Uint8Array) => {\n    pendingChunks.push(bufferFrom(chunk));\n  };\n\n  inflate.onEnd = (status: number) => {\n    ended = true;\n    if (status !== 0) {\n      transform.emit('error', new Error(`Inflate error: ${inflate.msg || 'unknown'}`));\n    }\n  };\n\n  transform._transform = function (chunk: Buffer, _encoding: string, callback: (err?: Error) => void) {\n    try {\n      inflate.push(chunk, false);\n      // Push any pending decompressed chunks\n      while (pendingChunks.length > 0) {\n        this.push(pendingChunks.shift());\n      }\n      callback();\n    } catch (err) {\n      callback(err as Error);\n    }\n  };\n\n  transform._flush = function (callback: (err?: Error) => void) {\n    try {\n      inflate.push(new Uint8Array(0), true); // Signal end\n      // Push any remaining decompressed chunks\n      while (pendingChunks.length > 0) {\n        this.push(pendingChunks.shift());\n      }\n      if (ended && inflate.err) {\n        callback(new Error(`Inflate error: ${inflate.msg || 'unknown'}`));\n      } else {\n        callback();\n      }\n    } catch (err) {\n      callback(err as Error);\n    }\n  };\n\n  return transform;\n}\n\n/**\n * Object.assign wrapper for Node.js 0.8+\n * - Uses native Object.assign on Node 4.0+\n * - Falls back to manual property copy on Node 0.8-3.x\n */\nconst hasObjectAssign = typeof Object.assign === 'function';\nconst _hasOwnProperty = Object.prototype.hasOwnProperty;\n\nexport function objectAssign<T, U>(target: T, source: U): T & U {\n  if (hasObjectAssign) return Object.assign(target, source);\n\n  for (const key in source) {\n    if (_hasOwnProperty.call(source, key)) (target as Record<string, unknown>)[key] = source[key];\n  }\n  return target as T & U;\n}\n\n/**\n * Stream compatibility - Transform class\n * - Uses native stream.Transform on Node 0.10+\n * - Falls back to readable-stream for Node 0.8\n */\nconst major = +process.versions.node.split('.')[0];\nexport const Readable: typeof import('stream').Readable = major > 0 ? _require('stream').Readable : _require('readable-stream').Readable;\nexport const Writable: typeof import('stream').Writable = major > 0 ? _require('stream').Writable : _require('readable-stream').Writable;\nexport const Transform: typeof import('stream').Transform = major > 0 ? _require('stream').Transform : _require('readable-stream').Transform;\nexport const PassThrough: typeof import('stream').PassThrough = major > 0 ? _require('stream').PassThrough : _require('readable-stream').PassThrough;\n"],"names":["Module","_require","require","createRequire","url","hasBufferAlloc","Buffer","alloc","hasBufferAllocUnsafe","allocUnsafe","hasBufferFrom","from","Uint8Array","allocBuffer","size","buf","fill","allocBufferUnsafe","bufferFrom","data","encoding","arr","i","length","push","bufferCompare","source","target","targetStart","targetEnd","sourceStart","sourceEnd","compare","sourceLen","targetLen","len","Math","min","s","t","bufferEquals","offset","expected","bufferSliceCopy","start","end","result","copy","readUInt64LE","low","readUInt32LE","high","writeUInt64LE","value","writeUInt32LE","bufferConcat","list","totalLength","actualLength","targetLength","undefined","allBuffers","j","concat","k","l","isNaN","zlib","_e","hasNativeInflateRaw","inflateRawSync","inflateRaw","input","pako","hasNativeStreamingInflate","createInflateRaw","createInflateRawStream","Transform","inflate","Inflate","raw","chunkSize","transform","pendingChunks","ended","onData","chunk","onEnd","status","emit","Error","msg","_transform","_encoding","callback","shift","err","_flush","hasObjectAssign","Object","assign","_hasOwnProperty","prototype","hasOwnProperty","objectAssign","key","call","major","process","versions","node","split","Readable","Writable","PassThrough"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/compat.ts"],"sourcesContent":["/**\n * Buffer Compatibility Layer for Node.js 0.8+\n *\n * Provides buffer utilities that work across all Node.js versions\n * WITHOUT modifying global Buffer object.\n *\n * Version history:\n * - Node 0.8-4.4: Only has `new Buffer()`, no `Buffer.alloc/from`\n * - Node 4.5+: Has `Buffer.alloc/from`, deprecates `new Buffer()`\n * - Node 10+: Warns or errors on `new Buffer()`\n *\n * Solution: Feature detection with graceful fallback in both directions.\n */\n\n// ESM-compatible require - works in both CJS and ESM\nimport Module from 'module';\n\nconst _require = typeof require === 'undefined' ? Module.createRequire(import.meta.url) : require;\n\n// Feature detection (runs once at module load)\nconst hasBufferAlloc = typeof Buffer.alloc === 'function';\nconst hasBufferAllocUnsafe = typeof Buffer.allocUnsafe === 'function';\nconst hasBufferFrom = typeof Buffer.from === 'function' && Buffer.from !== Uint8Array.from;\n\n// Maximum buffer size that works across all Node.js versions\n// Node 0.8-4.x: kMaxLength = 0x3fffffff (~1073MB) but actual limit may be lower\n// Node 6-7.x: ~1073MB for Uint8Array\n// Node 8+: ~2GB for Buffer\n// Node 10+: 2^31-1 (~2147MB) for Buffer.allocUnsafe\n// Use 128MB as a conservative limit for buffer operations\nconst MAX_SAFE_BUFFER_LENGTH = 128 * 1024 * 1024; // 128MB\n\n// Try to detect the actual kMaxLength for this Node version\n// If we can't detect it (older Node), assume conservative limit\nlet DETECTED_MAX_LENGTH: number | null = null;\n\nfunction _getMaxBufferLength(): number {\n  if (DETECTED_MAX_LENGTH !== null) return DETECTED_MAX_LENGTH;\n\n  // Try to detect the actual limit\n  // kMaxLength exists on BufferConstructor in newer TypeScript definitions\n  // but may not exist at runtime on very old Node\n  const maxLen = (Buffer as { kMaxLength?: number }).kMaxLength;\n  if (maxLen !== undefined) {\n    DETECTED_MAX_LENGTH = maxLen;\n  } else {\n    // Older Node - use conservative estimate\n    DETECTED_MAX_LENGTH = 0x3fffffff; // ~1073MB\n  }\n\n  return DETECTED_MAX_LENGTH;\n}\n\n/**\n * Check if a buffer size can be safely allocated on this Node version\n * Uses conservative limit to work across all versions\n */\nfunction canAllocateBufferSize(size: number): boolean {\n  return size >= 0 && size <= MAX_SAFE_BUFFER_LENGTH;\n}\n\n/**\n * Create a single chunk of the specified size\n */\nfunction createChunk(size: number, zeroFill: boolean): Buffer {\n  if (hasBufferAlloc) {\n    return Buffer.alloc(size);\n  }\n  const buf = new Buffer(size);\n  if (zeroFill) buf.fill(0);\n  return buf;\n}\n\n/**\n * Combine an array of buffers into one by pairwise concatenation\n * Each combination produces a buffer at most 2x MAX_SAFE_BUFFER_LENGTH (256MB)\n * which is within kMaxLength for all Node versions\n */\nfunction combineBuffersPairwise(buffers: Buffer[]): Buffer {\n  while (buffers.length > 1) {\n    const newBuffers: Buffer[] = [];\n\n    for (let i = 0; i < buffers.length; i += 2) {\n      if (i + 1 < buffers.length) {\n        const size1 = buffers[i].length;\n        const size2 = buffers[i + 1].length;\n        const combinedSize = size1 + size2;\n\n        // Safe: combinedSize <= 2 * MAX_SAFE_BUFFER_LENGTH = 256MB\n        const combined = createChunk(combinedSize, false);\n        buffers[i].copy(combined, 0);\n        buffers[i + 1].copy(combined, size1);\n        newBuffers.push(combined);\n      } else {\n        newBuffers.push(buffers[i]);\n      }\n    }\n\n    // Clear old references to help GC and use traditional for loop for Node 0.8 compatibility\n    for (let j = 0; j < buffers.length; j++) {\n      buffers[j] = undefined as unknown as Buffer;\n    }\n    buffers.length = 0;\n    for (let j = 0; j < newBuffers.length; j++) {\n      buffers.push(newBuffers[j]);\n    }\n  }\n\n  return buffers[0];\n}\n\n/**\n * Allocate a large buffer by allocating in chunks and combining them\n * Handles both zero-filled (safe) and uninitialized (unsafe) variants\n */\nfunction allocBufferLarge(size: number, zeroFill: boolean): Buffer {\n  // For large sizes, allocate smaller chunks and combine them\n  const numChunks = Math.ceil(size / MAX_SAFE_BUFFER_LENGTH);\n  const chunks: Buffer[] = [];\n\n  // Allocate individual chunks (each <= MAX_SAFE_BUFFER_LENGTH)\n  for (let i = 0; i < numChunks; i++) {\n    const chunkSize = Math.min(MAX_SAFE_BUFFER_LENGTH, size - i * MAX_SAFE_BUFFER_LENGTH);\n    chunks.push(createChunk(chunkSize, zeroFill));\n  }\n\n  // Combine chunks iteratively using pairwise combination\n  return combineBuffersPairwise(chunks);\n}\n\n/**\n * Allocate a zero-filled buffer (safe) - handles very large allocations\n * - Uses Buffer.alloc() on Node 4.5+\n * - Falls back to new Buffer() + fill on Node 0.8-4.4\n * - For sizes > MAX_SAFE_BUFFER_LENGTH, allocates in chunks and copies\n */\nexport function allocBuffer(size: number): Buffer {\n  if (size === 0) {\n    return new Buffer(0);\n  }\n\n  // Use native allocation for sizes within safe limits\n  if (canAllocateBufferSize(size)) {\n    if (hasBufferAlloc) {\n      return Buffer.alloc(size);\n    }\n    // Legacy fallback: new Buffer() is uninitialized, must zero-fill\n    const buf = new Buffer(size);\n    buf.fill(0);\n    return buf;\n  }\n\n  // For large sizes, allocate in chunks with zero-filling\n  return allocBufferLarge(size, true);\n}\n\n/**\n * Allocate a buffer without initialization (unsafe but faster)\n * - Uses Buffer.allocUnsafe() on Node 4.5+\n * - Falls back to new Buffer() on Node 0.8-4.4\n * - For sizes > MAX_SAFE_BUFFER_LENGTH, allocates in chunks without zeroing\n *\n * WARNING: Buffer contents are uninitialized and may contain sensitive data.\n * Only use when you will immediately overwrite all bytes.\n */\nexport function allocBufferUnsafe(size: number): Buffer {\n  if (size === 0) {\n    return new Buffer(0);\n  }\n\n  // Use native allocation for sizes within safe limits\n  if (canAllocateBufferSize(size)) {\n    if (hasBufferAllocUnsafe) {\n      return Buffer.allocUnsafe(size);\n    }\n    return new Buffer(size);\n  }\n\n  // For large sizes, allocate in chunks without zero-filling\n  return allocBufferLarge(size, false);\n}\n\n/**\n * Create a buffer from string, array, or existing buffer\n * - Uses Buffer.from() on Node 4.5+\n * - Falls back to new Buffer() on Node 0.8-4.4\n * - Handles Uint8Array conversion for Node 0.8 (crypto output compatibility)\n */\nexport function bufferFrom(data: string | number[] | Buffer | Uint8Array, encoding?: BufferEncoding): Buffer {\n  if (hasBufferFrom) {\n    if (typeof data === 'string') {\n      return Buffer.from(data, encoding);\n    }\n    return Buffer.from(data as number[] | Buffer);\n  }\n  // Node 0.8 compatibility - deprecated Buffer constructor\n  // For Uint8Array, convert to array first (needed for crypto output in Node 0.8)\n  if (data instanceof Uint8Array && !(data instanceof Buffer)) {\n    const arr: number[] = [];\n    for (let i = 0; i < data.length; i++) {\n      arr.push(data[i]);\n    }\n    return new Buffer(arr);\n  }\n  return new Buffer(data as string & number[], encoding);\n}\n\n/**\n * Compare two buffers or buffer regions\n * - Uses Buffer.compare() on Node 5.10+ (with offset support)\n * - Falls back to manual comparison on Node 0.8-5.9\n */\nexport function bufferCompare(source: Buffer, target: Buffer, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): number {\n  sourceStart = sourceStart || 0;\n  sourceEnd = sourceEnd || source.length;\n  targetStart = targetStart || 0;\n  targetEnd = targetEnd || target.length;\n\n  // Check if native compare with offset support exists (Node 5.10+)\n  if (source.compare && source.compare.length >= 5) {\n    return source.compare(target, targetStart, targetEnd, sourceStart, sourceEnd);\n  }\n\n  // Manual comparison for older Node versions\n  const sourceLen = sourceEnd - sourceStart;\n  const targetLen = targetEnd - targetStart;\n  const len = Math.min(sourceLen, targetLen);\n\n  for (let i = 0; i < len; i++) {\n    const s = source[sourceStart + i];\n    const t = target[targetStart + i];\n    if (s !== t) return s < t ? -1 : 1;\n  }\n\n  return sourceLen - targetLen;\n}\n\n/**\n * Check if buffer region equals byte array\n * Useful for magic number detection without Buffer.from()\n */\nexport function bufferEquals(buf: Buffer, offset: number, expected: number[]): boolean {\n  if (offset + expected.length > buf.length) return false;\n  for (let i = 0; i < expected.length; i++) {\n    if (buf[offset + i] !== expected[i]) return false;\n  }\n  return true;\n}\n\n/**\n * Copy buffer region to new buffer\n * Works on all Node versions\n */\nexport function bufferSliceCopy(buf: Buffer, start: number, end: number): Buffer {\n  const result = allocBuffer(end - start);\n  buf.copy(result, 0, start, end);\n  return result;\n}\n\n/**\n * Read 64-bit unsigned integer (little-endian)\n * Uses two 32-bit reads since BigInt not available until Node 10.4\n *\n * WARNING: Only accurate for values < Number.MAX_SAFE_INTEGER (2^53 - 1)\n * This covers files up to ~9 PB which is practical for all real use cases.\n */\nexport function readUInt64LE(buf: Buffer, offset: number): number {\n  const low = buf.readUInt32LE(offset);\n  const high = buf.readUInt32LE(offset + 4);\n  return high * 0x100000000 + low;\n}\n\n/**\n * Write 64-bit unsigned integer (little-endian)\n * Same precision limitation as readUInt64LE\n */\nexport function writeUInt64LE(buf: Buffer, value: number, offset: number): void {\n  const low = value >>> 0;\n  const high = (value / 0x100000000) >>> 0;\n  buf.writeUInt32LE(low, offset);\n  buf.writeUInt32LE(high, offset + 4);\n}\n\n/**\n * Concatenate buffers - compatible with Node 0.8+\n * Handles crypto output which may not be proper Buffer instances in old Node.\n * Also handles very large concatenations that would exceed buffer limits.\n *\n * NOTE: This function is primarily needed for AES decryption compatibility\n * in Node 0.8 where crypto output may not be proper Buffer instances.\n * Libraries not using crypto can use native Buffer.concat() directly.\n */\nexport function bufferConcat(list: (Buffer | Uint8Array)[], totalLength?: number): Buffer {\n  // Calculate actual total length first\n  let actualLength = 0;\n  for (let i = 0; i < list.length; i++) {\n    actualLength += list[i].length;\n  }\n\n  // Use specified totalLength or actual length\n  const targetLength = totalLength !== undefined ? totalLength : actualLength;\n\n  // Handle empty list\n  if (list.length === 0) {\n    return new Buffer(0);\n  }\n\n  // Handle very large concatenations that would exceed buffer limits\n  // Use native Buffer.concat for smaller sizes (faster)\n  if (targetLength <= MAX_SAFE_BUFFER_LENGTH) {\n    // Check if all items are proper Buffers AND no truncation needed\n    // (Node 0.8's Buffer.concat doesn't handle truncation well)\n    let allBuffers = true;\n    for (let j = 0; j < list.length; j++) {\n      if (!(list[j] instanceof Buffer)) {\n        allBuffers = false;\n        break;\n      }\n    }\n    if (allBuffers && targetLength >= actualLength) {\n      return Buffer.concat(list as Buffer[], targetLength);\n    }\n  }\n\n  // For large or complex concatenations, use chunked approach\n  // This will use allocBuffer which handles large sizes via chunking\n  const result = allocBuffer(targetLength);\n  let offset = 0;\n\n  for (let k = 0; k < list.length && offset < targetLength; k++) {\n    const buf = list[k];\n    const toCopy = Math.min(buf.length, targetLength - offset);\n\n    if (buf instanceof Buffer) {\n      buf.copy(result, offset, 0, toCopy);\n    } else {\n      // Uint8Array - need to copy byte by byte\n      for (let l = 0; l < toCopy; l++) {\n        result[offset + l] = buf[l];\n      }\n    }\n    offset += toCopy;\n  }\n\n  return result;\n}\n\n/**\n * Node 0.8 compatible isNaN (Number.isNaN didn't exist until ES2015)\n * Uses self-comparison: NaN is the only value not equal to itself\n */\n// biome-ignore lint/suspicious/noShadowRestrictedNames: Legacy compatibility\nexport function isNaN(value: number): boolean {\n  // biome-ignore lint/suspicious/noSelfCompare: NaN check pattern\n  return value !== value;\n}\n\n/**\n * Decompress raw DEFLATE data (no zlib/gzip header)\n * - Uses native zlib.inflateRawSync() on Node 0.11.12+\n * - Falls back to pako for Node 0.8-0.10\n *\n * Version history:\n * - Node 0.8-0.10: No zlib sync methods, use pako\n * - Node 0.11.12+: zlib.inflateRawSync available\n */\n// Feature detection for native zlib sync methods (Node 0.11.12+)\nlet zlib: typeof import('zlib') | null = null;\ntry {\n  zlib = _require('zlib');\n} catch (_e) {\n  // zlib not available (shouldn't happen in Node.js)\n}\nconst hasNativeInflateRaw = zlib !== null && typeof zlib.inflateRawSync === 'function';\n\nexport function inflateRaw(input: Buffer): Buffer {\n  if (hasNativeInflateRaw && zlib) {\n    return zlib.inflateRawSync(input);\n  }\n  // Fallback to pako for Node 0.8-0.10\n  const pako = _require('pako');\n  return bufferFrom(pako.inflateRaw(input));\n}\n\n/**\n * Create a streaming raw DEFLATE decompressor (Transform stream)\n * Decompresses data incrementally to avoid holding full output in memory.\n *\n * - Uses native zlib.createInflateRaw() on Node 0.11.12+\n * - Falls back to pako-based Transform for Node 0.8-0.10\n *\n * @returns A Transform stream that decompresses raw DEFLATE data\n */\n// Check for native streaming inflate (Node 0.11.12+ has createInflateRaw)\n// biome-ignore lint/suspicious/noExplicitAny: createInflateRaw not in older TS definitions\nconst hasNativeStreamingInflate = zlib !== null && typeof (zlib as any).createInflateRaw === 'function';\n\nexport function createInflateRawStream(): NodeJS.ReadWriteStream {\n  if (hasNativeStreamingInflate && zlib) {\n    // Use native zlib streaming Transform\n    // biome-ignore lint/suspicious/noExplicitAny: createInflateRaw not in older TS definitions\n    return (zlib as any).createInflateRaw();\n  }\n\n  // Fallback to pako-based Transform for Node 0.8-0.10\n  // Use readable-stream for Node 0.8 compatibility\n  const Transform = _require('readable-stream').Transform;\n  const pako = _require('pako');\n\n  const inflate = new pako.Inflate({ raw: true, chunkSize: 16384 });\n  const transform = new Transform();\n  const pendingChunks: Buffer[] = [];\n  let ended = false;\n\n  // Pako calls onData synchronously during push()\n  inflate.onData = (chunk: Uint8Array) => {\n    pendingChunks.push(bufferFrom(chunk));\n  };\n\n  inflate.onEnd = (status: number) => {\n    ended = true;\n    if (status !== 0) {\n      transform.emit('error', new Error(`Inflate error: ${inflate.msg || 'unknown'}`));\n    }\n  };\n\n  transform._transform = function (chunk: Buffer, _encoding: string, callback: (err?: Error) => void) {\n    try {\n      inflate.push(chunk, false);\n      // Push any pending decompressed chunks\n      while (pendingChunks.length > 0) {\n        this.push(pendingChunks.shift());\n      }\n      callback();\n    } catch (err) {\n      callback(err as Error);\n    }\n  };\n\n  transform._flush = function (callback: (err?: Error) => void) {\n    try {\n      inflate.push(new Uint8Array(0), true); // Signal end\n      // Push any remaining decompressed chunks\n      while (pendingChunks.length > 0) {\n        this.push(pendingChunks.shift());\n      }\n      if (ended && inflate.err) {\n        callback(new Error(`Inflate error: ${inflate.msg || 'unknown'}`));\n      } else {\n        callback();\n      }\n    } catch (err) {\n      callback(err as Error);\n    }\n  };\n\n  return transform;\n}\n\n/**\n * Object.assign wrapper for Node.js 0.8+\n * - Uses native Object.assign on Node 4.0+\n * - Falls back to manual property copy on Node 0.8-3.x\n */\nconst hasObjectAssign = typeof Object.assign === 'function';\nconst _hasOwnProperty = Object.prototype.hasOwnProperty;\n\nexport function objectAssign<T, U>(target: T, source: U): T & U {\n  if (hasObjectAssign) return Object.assign(target, source);\n\n  for (const key in source) {\n    if (_hasOwnProperty.call(source, key)) (target as Record<string, unknown>)[key] = source[key];\n  }\n  return target as T & U;\n}\n\n/**\n * Stream compatibility - Transform class\n * - Uses native stream.Transform on Node 0.10+\n * - Falls back to readable-stream for Node 0.8\n */\nconst major = +process.versions.node.split('.')[0];\nexport const Readable: typeof import('stream').Readable = major > 0 ? _require('stream').Readable : _require('readable-stream').Readable;\nexport const Writable: typeof import('stream').Writable = major > 0 ? _require('stream').Writable : _require('readable-stream').Writable;\nexport const Transform: typeof import('stream').Transform = major > 0 ? _require('stream').Transform : _require('readable-stream').Transform;\nexport const PassThrough: typeof import('stream').PassThrough = major > 0 ? _require('stream').PassThrough : _require('readable-stream').PassThrough;\n"],"names":["Module","_require","require","createRequire","url","hasBufferAlloc","Buffer","alloc","hasBufferAllocUnsafe","allocUnsafe","hasBufferFrom","from","Uint8Array","MAX_SAFE_BUFFER_LENGTH","DETECTED_MAX_LENGTH","_getMaxBufferLength","maxLen","kMaxLength","undefined","canAllocateBufferSize","size","createChunk","zeroFill","buf","fill","combineBuffersPairwise","buffers","length","newBuffers","i","size1","size2","combinedSize","combined","copy","push","j","allocBufferLarge","numChunks","Math","ceil","chunks","chunkSize","min","allocBuffer","allocBufferUnsafe","bufferFrom","data","encoding","arr","bufferCompare","source","target","targetStart","targetEnd","sourceStart","sourceEnd","compare","sourceLen","targetLen","len","s","t","bufferEquals","offset","expected","bufferSliceCopy","start","end","result","readUInt64LE","low","readUInt32LE","high","writeUInt64LE","value","writeUInt32LE","bufferConcat","list","totalLength","actualLength","targetLength","allBuffers","concat","k","toCopy","l","isNaN","zlib","_e","hasNativeInflateRaw","inflateRawSync","inflateRaw","input","pako","hasNativeStreamingInflate","createInflateRaw","createInflateRawStream","Transform","inflate","Inflate","raw","transform","pendingChunks","ended","onData","chunk","onEnd","status","emit","Error","msg","_transform","_encoding","callback","shift","err","_flush","hasObjectAssign","Object","assign","_hasOwnProperty","prototype","hasOwnProperty","objectAssign","key","call","major","process","versions","node","split","Readable","Writable","PassThrough"],"mappings":"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"}

package/package.json

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