extract-base-iterator 3.3.3 → 3.3.4

package/dist/cjs/DirectoryEntry.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/DirectoryEntry.ts"],"sourcesContent":["import 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'];\n\nimport type { Mode } from 'fs';\nimport type { DirectoryAttributes, ExtractOptions, NoParamCallback } from './types.ts';\n\nexport default class DirectoryEntry {\n  mode: Mode;\n  mtime: number;\n  path: string;\n  basename: string;\n  type: string;\n\n  constructor(attributes: DirectoryAttributes) {\n    validateAttributes(attributes, MANDATORY_ATTRIBUTES);\n    objectAssign(this, attributes);\n    if (this.type === undefined) this.type = 'directory';\n    if (this.basename === undefined) this.basename = path.basename(this.path);\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\n        // do not check for the existence of the directory but allow out-of-order calling\n        const queue = new Queue(1);\n        queue.defer(mkdirp.bind(null, 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":["DirectoryEntry","MANDATORY_ATTRIBUTES","attributes","validateAttributes","objectAssign","type","undefined","basename","path","create","dest","options","callback","normalizedPath","normalize","fullPath","join","stripPath","queue","Queue","defer","mkdirp","bind","waitForAccess","chmod","chown","utimes","await","err","Promise","resolve","reject","done","destroy"],"mappings":";;;;;;;eAgBqBA;;;oEAhBF;2DACF;8DACC;8DACA;8DACA;+DACC;uBACU;kEACP;2EACS;sEACL;;;;;;;;;;;AAE1B,IAAMC,uBAAuB;IAAC;IAAQ;IAAS;CAAO;AAKvC,IAAA,AAAMD,+BAAN;;aAAMA,eAOPE,UAA+B;gCAPxBF;QAQjBG,IAAAA,6BAAkB,EAACD,YAAYD;QAC/BG,IAAAA,qBAAY,EAAC,IAAI,EAAEF;QACnB,IAAI,IAAI,CAACG,IAAI,KAAKC,WAAW,IAAI,CAACD,IAAI,GAAG;QACzC,IAAI,IAAI,CAACE,QAAQ,KAAKD,WAAW,IAAI,CAACC,QAAQ,GAAGC,aAAI,CAACD,QAAQ,CAAC,IAAI,CAACC,IAAI;;iBAXvDR;IAiBnBS,OAAAA,MA2BC,GA3BDA,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,iBAAiBL,aAAI,CAACM,SAAS,CAAC,IAAI,CAACN,IAAI;gBAC/C,IAAMO,WAAWP,aAAI,CAACQ,IAAI,CAACN,MAAMO,IAAAA,oBAAS,EAACJ,gBAAgBF;gBAE3D,iFAAiF;gBACjF,IAAMO,QAAQ,IAAIC,gBAAK,CAAC;gBACxBD,MAAME,KAAK,CAACC,sBAAM,CAACC,IAAI,CAAC,MAAMP;gBAC9BG,MAAME,KAAK,CAACG,wBAAa,CAACD,IAAI,CAAC,MAAMP;gBACrCG,MAAME,KAAK,CAACI,gBAAK,CAACF,IAAI,CAAC,MAAMP,UAAU,IAAI,EAAEJ;gBAC7CO,MAAME,KAAK,CAACK,gBAAK,CAACH,IAAI,CAAC,MAAMP,UAAU,IAAI,EAAEJ;gBAC7CO,MAAME,KAAK,CAACM,iBAAM,CAACJ,IAAI,CAAC,MAAMP,UAAU,IAAI,EAAEJ;gBAC9CO,MAAMS,KAAK,CAACf;gBACZ;YACF,EAAE,OAAOgB,KAAK;gBACZhB,SAASgB;gBACT;YACF;QACF;QAEA,OAAO,IAAIC,QAAQ,SAACC,SAASC;YAC3B,MAAKtB,MAAM,CAACC,MAAMC,SAAS,SAACiB,KAAaI;uBAAoBJ,MAAMG,OAAOH,OAAOE,QAAQE;;QAC3F;IACF;IAEAC,OAAAA,OAAY,GAAZA,SAAAA,WAAW;WA9CQjC"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/DirectoryEntry.ts"],"sourcesContent":["import 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'];\n\nimport type { Mode } from 'fs';\nimport type { DirectoryAttributes, ExtractOptions, NoParamCallback } from './types.ts';\n\nexport default class DirectoryEntry {\n  mode: Mode;\n  mtime: number;\n  path: string;\n  basename: string;\n  type: string;\n\n  constructor(attributes: DirectoryAttributes) {\n    validateAttributes(attributes, MANDATORY_ATTRIBUTES);\n    objectAssign(this, attributes);\n    if (this.type === undefined) this.type = 'directory';\n    if (this.basename === undefined) this.basename = path.basename(this.path);\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\n        // do not check for the existence of the directory but allow out-of-order calling\n        const queue = new Queue(1);\n        queue.defer(mkdirp.bind(null, 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":["DirectoryEntry","MANDATORY_ATTRIBUTES","attributes","validateAttributes","objectAssign","type","undefined","basename","path","create","dest","options","callback","normalizedPath","normalize","fullPath","join","stripPath","queue","Queue","defer","mkdirp","bind","waitForAccess","chmod","chown","utimes","await","err","Promise","resolve","reject","done","destroy"],"mappings":";;;;;;;eAgBqBA;;;oEAhBF;2DACF;8DACC;8DACA;8DACA;+DACC;uBACU;kEACP;2EACS;sEACL;;;;;;;;;;;AAE1B,IAAMC,uBAAuB;IAAC;IAAQ;IAAS;CAAO;AAKvC,IAAA,AAAMD,+BAAN;;aAAMA,eAOPE,UAA+B;gCAPxBF;QAQjBG,IAAAA,6BAAkB,EAACD,YAAYD;QAC/BG,IAAAA,qBAAY,EAAC,IAAI,EAAEF;QACnB,IAAI,IAAI,CAACG,IAAI,KAAKC,WAAW,IAAI,CAACD,IAAI,GAAG;QACzC,IAAI,IAAI,CAACE,QAAQ,KAAKD,WAAW,IAAI,CAACC,QAAQ,GAAGC,aAAI,CAACD,QAAQ,CAAC,IAAI,CAACC,IAAI;;iBAXvDR;IAiBnBS,OAAAA,MA2BC,GA3BDA,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,iBAAiBL,aAAI,CAACM,SAAS,CAAC,IAAI,CAACN,IAAI;gBAC/C,IAAMO,WAAWP,aAAI,CAACQ,IAAI,CAACN,MAAMO,IAAAA,oBAAS,EAACJ,gBAAgBF;gBAE3D,iFAAiF;gBACjF,IAAMO,QAAQ,IAAIC,gBAAK,CAAC;gBACxBD,MAAME,KAAK,CAACC,sBAAM,CAACC,IAAI,CAAC,MAAMP;gBAC9BG,MAAME,KAAK,CAACG,wBAAa,CAACD,IAAI,CAAC,MAAMP;gBACrCG,MAAME,KAAK,CAACI,gBAAK,CAACF,IAAI,CAAC,MAAMP,UAAU,IAAI,EAAEJ;gBAC7CO,MAAME,KAAK,CAACK,gBAAK,CAACH,IAAI,CAAC,MAAMP,UAAU,IAAI,EAAEJ;gBAC7CO,MAAME,KAAK,CAACM,iBAAM,CAACJ,IAAI,CAAC,MAAMP,UAAU,IAAI,EAAEJ;gBAC9CO,MAAMS,KAAK,CAACf;gBACZ;YACF,EAAE,OAAOgB,KAAK;gBACZhB,SAASgB;gBACT;YACF;QACF;QAEA,OAAO,IAAIC,QAAQ,SAACC,SAASC;YAC3B,MAAKtB,MAAM,CAACC,MAAMC,SAAS,SAACiB,KAAaI;uBAAoBJ,MAAMG,OAAOH,OAAOE,QAAQE;;QAC3F;IACF;IAEAC,OAAAA,OAAY,GAAZA,SAAAA,WAAW;WA9CQjC"}

package/dist/cjs/FileEntry.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/FileEntry.ts"],"sourcesContent":["import { rm } from 'fs-remove-compat';\nimport fs from 'graceful-fs';\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'];\n\nimport type { Mode } from 'fs';\nimport type { ExtractOptions, FileAttributes, NoParamCallback, WriteFileFn } from './types.ts';\n\ninterface AbstractFileEntry {\n  _writeFile: WriteFileFn;\n}\n\nexport default class FileEntry {\n  mode: Mode;\n  mtime: number;\n  path: string;\n  basename: string;\n  type: string;\n\n  constructor(attributes: FileAttributes) {\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 = 'file';\n    if ((this as unknown as AbstractFileEntry)._writeFile === undefined) throw new Error('File this missing _writeFile. Please implement this method in your subclass');\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\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        } else {\n          // Check if file exists - throw EEXIST if it does\n          queue.defer((callback) => {\n            fs.stat(fullPath, (err) => {\n              if (!err) {\n                const existsErr = new Error(`EEXIST: file already exists, open '${fullPath}'`) as NodeJS.ErrnoException;\n                existsErr.code = 'EEXIST';\n                existsErr.path = fullPath;\n                return callback(existsErr);\n              }\n              // ENOENT means file doesn't exist - that's what we want\n              if (err.code === 'ENOENT') return callback();\n              // Other errors should be reported\n              callback(err);\n            });\n          });\n        }\n        queue.defer(mkdirp.bind(null, path.dirname(fullPath)));\n        queue.defer((this as unknown as AbstractFileEntry)._writeFile.bind(this, fullPath, options));\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":["FileEntry","MANDATORY_ATTRIBUTES","attributes","validateAttributes","objectAssign","basename","undefined","path","type","_writeFile","Error","create","dest","options","callback","normalizedPath","normalize","fullPath","join","stripPath","queue","Queue","force","defer","rm","err","code","fs","stat","existsErr","mkdirp","bind","dirname","waitForAccess","chmod","chown","utimes","await","Promise","resolve","reject","done","destroy"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/FileEntry.ts"],"sourcesContent":["import { rm } from 'fs-remove-compat';\nimport fs from 'graceful-fs';\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'];\n\nimport type { Mode } from 'fs';\nimport type { ExtractOptions, FileAttributes, NoParamCallback, WriteFileFn } from './types.ts';\n\ninterface AbstractFileEntry {\n  _writeFile: WriteFileFn;\n}\n\nexport default class FileEntry {\n  mode: Mode;\n  mtime: number;\n  path: string;\n  basename: string;\n  type: string;\n\n  constructor(attributes: FileAttributes) {\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 = 'file';\n    if ((this as unknown as AbstractFileEntry)._writeFile === undefined) throw new Error('File this missing _writeFile. Please implement this method in your subclass');\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\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        } else {\n          // Check if file exists - throw EEXIST if it does\n          queue.defer((callback) => {\n            fs.stat(fullPath, (err) => {\n              if (!err) {\n                const existsErr = new Error(`EEXIST: file already exists, open '${fullPath}'`) as NodeJS.ErrnoException;\n                existsErr.code = 'EEXIST';\n                existsErr.path = fullPath;\n                return callback(existsErr);\n              }\n              // ENOENT means file doesn't exist - that's what we want\n              if (err.code === 'ENOENT') return callback();\n              // Other errors should be reported\n              callback(err);\n            });\n          });\n        }\n        queue.defer(mkdirp.bind(null, path.dirname(fullPath)));\n        queue.defer((this as unknown as AbstractFileEntry)._writeFile.bind(this, fullPath, options));\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":["FileEntry","MANDATORY_ATTRIBUTES","attributes","validateAttributes","objectAssign","basename","undefined","path","type","_writeFile","Error","create","dest","options","callback","normalizedPath","normalize","fullPath","join","stripPath","queue","Queue","force","defer","rm","err","code","fs","stat","existsErr","mkdirp","bind","dirname","waitForAccess","chmod","chown","utimes","await","Promise","resolve","reject","done","destroy"],"mappings":"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"}

package/dist/cjs/LinkEntry.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/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(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"}

package/dist/cjs/SymbolicLinkEntry.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/SymbolicLinkEntry.ts"],"sourcesContent":["import fs from 'fs';\nimport { rm } from 'fs-remove-compat';\nimport isAbsolute from 'is-absolute';\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 lutimes from './fs/lutimes.ts';\nimport symlinkWin32 from './fs/symlinkWin32.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 isWindows = process.platform === 'win32' || /^(msys|cygwin)$/.test(process.env.OSTYPE);\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 SymbolicLinkEntry {\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 = 'symlink';\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        let normalizedLinkpath = path.normalize(this.linkpath);\n        let linkFullPath = path.join(dest, stripPath(normalizedLinkpath, options));\n        if (!isAbsolute(normalizedLinkpath)) {\n          const linkRelativePath = path.join(path.dirname(normalizedPath), this.linkpath);\n          linkFullPath = path.join(dest, stripPath(linkRelativePath, options));\n          normalizedLinkpath = path.relative(path.dirname(fullPath), linkFullPath);\n        }\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        if (isWindows) queue.defer(symlinkWin32.bind(null, linkFullPath, normalizedLinkpath, fullPath));\n        else queue.defer(fs.symlink.bind(fs, normalizedLinkpath, fullPath));\n        queue.defer(waitForAccess.bind(null, fullPath, true)); // noFollow=true for symlinks\n        queue.defer(chmod.bind(null, fullPath, this, options));\n        queue.defer(chown.bind(null, fullPath, this, options));\n        queue.defer(lutimes.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":["SymbolicLinkEntry","isWindows","process","platform","test","env","OSTYPE","MANDATORY_ATTRIBUTES","attributes","validateAttributes","objectAssign","basename","undefined","path","type","create","dest","options","callback","normalizedPath","normalize","fullPath","join","stripPath","normalizedLinkpath","linkpath","linkFullPath","isAbsolute","linkRelativePath","dirname","relative","queue","Queue","force","defer","rm","err","code","mkdirp","bind","symlinkWin32","fs","symlink","waitForAccess","chmod","chown","lutimes","await","Promise","resolve","reject","done","destroy"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/SymbolicLinkEntry.ts"],"sourcesContent":["import fs from 'fs';\nimport { rm } from 'fs-remove-compat';\nimport isAbsolute from 'is-absolute';\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 lutimes from './fs/lutimes.ts';\nimport symlinkWin32 from './fs/symlinkWin32.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 isWindows = process.platform === 'win32' || /^(msys|cygwin)$/.test(process.env.OSTYPE);\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 SymbolicLinkEntry {\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 = 'symlink';\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        let normalizedLinkpath = path.normalize(this.linkpath);\n        let linkFullPath = path.join(dest, stripPath(normalizedLinkpath, options));\n        if (!isAbsolute(normalizedLinkpath)) {\n          const linkRelativePath = path.join(path.dirname(normalizedPath), this.linkpath);\n          linkFullPath = path.join(dest, stripPath(linkRelativePath, options));\n          normalizedLinkpath = path.relative(path.dirname(fullPath), linkFullPath);\n        }\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        if (isWindows) queue.defer(symlinkWin32.bind(null, linkFullPath, normalizedLinkpath, fullPath));\n        else queue.defer(fs.symlink.bind(fs, normalizedLinkpath, fullPath));\n        queue.defer(waitForAccess.bind(null, fullPath, true)); // noFollow=true for symlinks\n        queue.defer(chmod.bind(null, fullPath, this, options));\n        queue.defer(chown.bind(null, fullPath, this, options));\n        queue.defer(lutimes.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":["SymbolicLinkEntry","isWindows","process","platform","test","env","OSTYPE","MANDATORY_ATTRIBUTES","attributes","validateAttributes","objectAssign","basename","undefined","path","type","create","dest","options","callback","normalizedPath","normalize","fullPath","join","stripPath","normalizedLinkpath","linkpath","linkFullPath","isAbsolute","linkRelativePath","dirname","relative","queue","Queue","force","defer","rm","err","code","mkdirp","bind","symlinkWin32","fs","symlink","waitForAccess","chmod","chown","lutimes","await","Promise","resolve","reject","done","destroy"],"mappings":"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"}

package/dist/cjs/fs/chmod.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/fs/chmod.ts"],"sourcesContent":["// adapted from https://github.com/mafintosh/tar-fs\n\nimport fs, { type NoParamCallback } from 'fs';\nimport type { AbstractEntry, ExtractOptions } from '../types.ts';\n\nconst UMASK = process.umask ? process.umask() : null;\nconst DMODE = 0o755;\nconst FMODE = 0o644;\nconst SMODE = 0o755;\nconst LMODE = 0o644;\n\nexport default function chmodFn(fullPath: string, entry: AbstractEntry, _options: ExtractOptions, callback: NoParamCallback) {\n  const chmod = entry.type === 'symlink' ? fs.lchmod : fs.chmod;\n  if (!chmod || UMASK === null) return callback(null);\n\n  let mode = entry.mode;\n  if (!mode) {\n    switch (entry.type) {\n      case 'directory':\n        mode = DMODE;\n        break;\n      case 'file':\n        mode = FMODE;\n        break;\n      case 'symlink':\n        mode = SMODE;\n        break;\n      case 'link':\n        mode = LMODE;\n        break;\n    }\n  }\n  chmod(fullPath, (mode as number) & ~UMASK, callback);\n}\n"],"names":["chmodFn","UMASK","process","umask","DMODE","FMODE","SMODE","LMODE","fullPath","entry","_options","callback","chmod","type","fs","lchmod","mode"],"mappings":"AAAA,mDAAmD;;;;;+BAWnD;;;eAAwBA;;;yDATiB;;;;;;AAGzC,IAAMC,QAAQC,QAAQC,KAAK,GAAGD,QAAQC,KAAK,KAAK;AAChD,IAAMC,QAAQ;AACd,IAAMC,QAAQ;AACd,IAAMC,QAAQ;AACd,IAAMC,QAAQ;AAEC,SAASP,QAAQQ,QAAgB,EAAEC,KAAoB,EAAEC,QAAwB,EAAEC,QAAyB;IACzH,IAAMC,QAAQH,MAAMI,IAAI,KAAK,YAAYC,WAAE,CAACC,MAAM,GAAGD,WAAE,CAACF,KAAK;IAC7D,IAAI,CAACA,SAASX,UAAU,MAAM,OAAOU,SAAS;IAE9C,IAAIK,OAAOP,MAAMO,IAAI;IACrB,IAAI,CAACA,MAAM;QACT,OAAQP,MAAMI,IAAI;YAChB,KAAK;gBACHG,OAAOZ;gBACP;YACF,KAAK;gBACHY,OAAOX;gBACP;YACF,KAAK;gBACHW,OAAOV;gBACP;YACF,KAAK;gBACHU,OAAOT;gBACP;QACJ;IACF;IACAK,MAAMJ,UAAU,AAACQ,OAAkB,CAACf,OAAOU;AAC7C"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/fs/chmod.ts"],"sourcesContent":["// adapted from https://github.com/mafintosh/tar-fs\n\nimport fs, { type NoParamCallback } from 'fs';\nimport type { AbstractEntry, ExtractOptions } from '../types.ts';\n\nconst UMASK = process.umask ? process.umask() : null;\nconst DMODE = 0o755;\nconst FMODE = 0o644;\nconst SMODE = 0o755;\nconst LMODE = 0o644;\n\nexport default function chmodFn(fullPath: string, entry: AbstractEntry, _options: ExtractOptions, callback: NoParamCallback) {\n  const chmod = entry.type === 'symlink' ? fs.lchmod : fs.chmod;\n  if (!chmod || UMASK === null) return callback(null);\n\n  let mode = entry.mode;\n  if (!mode) {\n    switch (entry.type) {\n      case 'directory':\n        mode = DMODE;\n        break;\n      case 'file':\n        mode = FMODE;\n        break;\n      case 'symlink':\n        mode = SMODE;\n        break;\n      case 'link':\n        mode = LMODE;\n        break;\n    }\n  }\n  chmod(fullPath, (mode as number) & ~UMASK, callback);\n}\n"],"names":["chmodFn","UMASK","process","umask","DMODE","FMODE","SMODE","LMODE","fullPath","entry","_options","callback","chmod","type","fs","lchmod","mode"],"mappings":"AAAA,mDAAmD;;;;;+BAWnD;;;eAAwBA;;;yDATiB;;;;;;AAGzC,IAAMC,QAAQC,QAAQC,KAAK,GAAGD,QAAQC,KAAK,KAAK;AAChD,IAAMC,QAAQ;AACd,IAAMC,QAAQ;AACd,IAAMC,QAAQ;AACd,IAAMC,QAAQ;AAEC,SAASP,QAAQQ,QAAgB,EAAEC,KAAoB,EAAEC,QAAwB,EAAEC,QAAyB;IACzH,IAAMC,QAAQH,MAAMI,IAAI,KAAK,YAAYC,WAAE,CAACC,MAAM,GAAGD,WAAE,CAACF,KAAK;IAC7D,IAAI,CAACA,SAASX,UAAU,MAAM,OAAOU,SAAS;IAE9C,IAAIK,OAAOP,MAAMO,IAAI;IACrB,IAAI,CAACA,MAAM;QACT,OAAQP,MAAMI,IAAI;YAChB,KAAK;gBACHG,OAAOZ;gBACP;YACF,KAAK;gBACHY,OAAOX;gBACP;YACF,KAAK;gBACHW,OAAOV;gBACP;YACF,KAAK;gBACHU,OAAOT;gBACP;QACJ;IACF;IACAK,MAAMJ,UAAU,AAACQ,OAAkB,CAACf,OAAOU;AAC7C"}

package/dist/cjs/fs/chown.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/fs/chown.ts"],"sourcesContent":["// adapted from https://github.com/mafintosh/tar-fs\n\nimport fs, { type NoParamCallback } from 'fs';\nimport type { AbstractEntry, ExtractOptions } from '../types.ts';\n\nconst UID = process.getuid ? process.getuid() : -1;\nconst OWN = process.platform !== 'win32' && UID === 0;\n\nexport default function chownFn(fullPath: string, entry: AbstractEntry, _options: ExtractOptions, callback: NoParamCallback) {\n  const chown = entry.type === 'symlink' ? fs.lchown : fs.chown;\n  if (!chown || !OWN || !entry.uid || !entry.gid) return callback(null);\n  chown(fullPath, entry.uid, entry.gid, callback);\n}\n"],"names":["chownFn","UID","process","getuid","OWN","platform","fullPath","entry","_options","callback","chown","type","fs","lchown","uid","gid"],"mappings":"AAAA,mDAAmD;;;;;+BAQnD;;;eAAwBA;;;yDANiB;;;;;;AAGzC,IAAMC,MAAMC,QAAQC,MAAM,GAAGD,QAAQC,MAAM,KAAK,CAAC;AACjD,IAAMC,MAAMF,QAAQG,QAAQ,KAAK,WAAWJ,QAAQ;AAErC,SAASD,QAAQM,QAAgB,EAAEC,KAAoB,EAAEC,QAAwB,EAAEC,QAAyB;IACzH,IAAMC,QAAQH,MAAMI,IAAI,KAAK,YAAYC,WAAE,CAACC,MAAM,GAAGD,WAAE,CAACF,KAAK;IAC7D,IAAI,CAACA,SAAS,CAACN,OAAO,CAACG,MAAMO,GAAG,IAAI,CAACP,MAAMQ,GAAG,EAAE,OAAON,SAAS;IAChEC,MAAMJ,UAAUC,MAAMO,GAAG,EAAEP,MAAMQ,GAAG,EAAEN;AACxC"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/fs/chown.ts"],"sourcesContent":["// adapted from https://github.com/mafintosh/tar-fs\n\nimport fs, { type NoParamCallback } from 'fs';\nimport type { AbstractEntry, ExtractOptions } from '../types.ts';\n\nconst UID = process.getuid ? process.getuid() : -1;\nconst OWN = process.platform !== 'win32' && UID === 0;\n\nexport default function chownFn(fullPath: string, entry: AbstractEntry, _options: ExtractOptions, callback: NoParamCallback) {\n  const chown = entry.type === 'symlink' ? fs.lchown : fs.chown;\n  if (!chown || !OWN || !entry.uid || !entry.gid) return callback(null);\n  chown(fullPath, entry.uid, entry.gid, callback);\n}\n"],"names":["chownFn","UID","process","getuid","OWN","platform","fullPath","entry","_options","callback","chown","type","fs","lchown","uid","gid"],"mappings":"AAAA,mDAAmD;;;;;+BAQnD;;;eAAwBA;;;yDANiB;;;;;;AAGzC,IAAMC,MAAMC,QAAQC,MAAM,GAAGD,QAAQC,MAAM,KAAK,CAAC;AACjD,IAAMC,MAAMF,QAAQG,QAAQ,KAAK,WAAWJ,QAAQ;AAErC,SAASD,QAAQM,QAAgB,EAAEC,KAAoB,EAAEC,QAAwB,EAAEC,QAAyB;IACzH,IAAMC,QAAQH,MAAMI,IAAI,KAAK,YAAYC,WAAE,CAACC,MAAM,GAAGD,WAAE,CAACF,KAAK;IAC7D,IAAI,CAACA,SAAS,CAACN,OAAO,CAACG,MAAMO,GAAG,IAAI,CAACP,MAAMQ,GAAG,EAAE,OAAON,SAAS;IAChEC,MAAMJ,UAAUC,MAAMO,GAAG,EAAEP,MAAMQ,GAAG,EAAEN;AACxC"}

package/dist/cjs/fs/lstatReal.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/fs/lstatReal.ts"],"sourcesContent":["import fs, { type BigIntStats, type Stats } from 'fs';\n\nexport type Callback = (err: NodeJS.ErrnoException | null, stats?: Stats | BigIntStats) => void;\n\nexport default function lstatReal(path: string, callback: Callback): void {\n  fs.realpath(path, (err, realpath) => {\n    err ? callback(err) : fs.lstat(realpath, callback);\n  });\n}\n"],"names":["lstatReal","path","callback","fs","realpath","err","lstat"],"mappings":";;;;+BAIA;;;eAAwBA;;;yDAJyB;;;;;;AAIlC,SAASA,UAAUC,IAAY,EAAEC,QAAkB;IAChEC,WAAE,CAACC,QAAQ,CAACH,MAAM,SAACI,KAAKD;QACtBC,MAAMH,SAASG,OAAOF,WAAE,CAACG,KAAK,CAACF,UAAUF;IAC3C;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/fs/lstatReal.ts"],"sourcesContent":["import fs, { type BigIntStats, type Stats } from 'fs';\n\nexport type Callback = (err: NodeJS.ErrnoException | null, stats?: Stats | BigIntStats) => void;\n\nexport default function lstatReal(path: string, callback: Callback): void {\n  fs.realpath(path, (err, realpath) => {\n    err ? callback(err) : fs.lstat(realpath, callback);\n  });\n}\n"],"names":["lstatReal","path","callback","fs","realpath","err","lstat"],"mappings":";;;;+BAIA;;;eAAwBA;;;yDAJyB;;;;;;AAIlC,SAASA,UAAUC,IAAY,EAAEC,QAAkB;IAChEC,WAAE,CAACC,QAAQ,CAACH,MAAM,SAACI,KAAKD;QACtBC,MAAMH,SAASG,OAAOF,WAAE,CAACG,KAAK,CAACF,UAAUF;IAC3C;AACF"}

package/dist/cjs/fs/lutimes.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/fs/lutimes.ts"],"sourcesContent":["// lutimes - set times on symlinks without following them\n// fs.lutimes was added in Node.js 14.5.0\n// For older versions, we skip setting times on symlinks (no good alternative)\n\nimport fs, { type NoParamCallback } from 'fs';\nimport type { AbstractEntry, ExtractOptions } from '../types.ts';\n\n// biome-ignore lint/suspicious/noExplicitAny: fs.lutimes not in older @types/node\nconst HAS_LUTIMES = typeof (fs as any).lutimes === 'function';\n\nexport default function lutimes(fullPath: string, entry: AbstractEntry, options: ExtractOptions, callback: NoParamCallback): void {\n  if (HAS_LUTIMES) {\n    const now = options.now || new Date();\n    // biome-ignore lint/suspicious/noExplicitAny: fs.lutimes not in older @types/node\n    (fs as any).lutimes(fullPath, now, new Date(entry.mtime), callback);\n  } else {\n    // On older Node versions, skip setting times on symlinks\n    // fs.utimes follows symlinks and will fail with ENOENT if target doesn't exist\n    callback(null);\n  }\n}\n"],"names":["lutimes","HAS_LUTIMES","fs","fullPath","entry","options","callback","now","Date","mtime"],"mappings":"AAAA,yDAAyD;AACzD,yCAAyC;AACzC,8EAA8E;;;;;+BAQ9E;;;eAAwBA;;;yDANiB;;;;;;AAGzC,kFAAkF;AAClF,IAAMC,cAAc,OAAO,AAACC,WAAE,CAASF,OAAO,KAAK;AAEpC,SAASA,QAAQG,QAAgB,EAAEC,KAAoB,EAAEC,OAAuB,EAAEC,QAAyB;IACxH,IAAIL,aAAa;QACf,IAAMM,MAAMF,QAAQE,GAAG,IAAI,IAAIC;QAC/B,kFAAkF;QACjFN,WAAE,CAASF,OAAO,CAACG,UAAUI,KAAK,IAAIC,KAAKJ,MAAMK,KAAK,GAAGH;IAC5D,OAAO;QACL,yDAAyD;QACzD,+EAA+E;QAC/EA,SAAS;IACX;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/fs/lutimes.ts"],"sourcesContent":["// lutimes - set times on symlinks without following them\n// fs.lutimes was added in Node.js 14.5.0\n// For older versions, we skip setting times on symlinks (no good alternative)\n\nimport fs, { type NoParamCallback } from 'fs';\nimport type { AbstractEntry, ExtractOptions } from '../types.ts';\n\n// biome-ignore lint/suspicious/noExplicitAny: fs.lutimes not in older @types/node\nconst HAS_LUTIMES = typeof (fs as any).lutimes === 'function';\n\nexport default function lutimes(fullPath: string, entry: AbstractEntry, options: ExtractOptions, callback: NoParamCallback): void {\n  if (HAS_LUTIMES) {\n    const now = options.now || new Date();\n    // biome-ignore lint/suspicious/noExplicitAny: fs.lutimes not in older @types/node\n    (fs as any).lutimes(fullPath, now, new Date(entry.mtime), callback);\n  } else {\n    // On older Node versions, skip setting times on symlinks\n    // fs.utimes follows symlinks and will fail with ENOENT if target doesn't exist\n    callback(null);\n  }\n}\n"],"names":["lutimes","HAS_LUTIMES","fs","fullPath","entry","options","callback","now","Date","mtime"],"mappings":"AAAA,yDAAyD;AACzD,yCAAyC;AACzC,8EAA8E;;;;;+BAQ9E;;;eAAwBA;;;yDANiB;;;;;;AAGzC,kFAAkF;AAClF,IAAMC,cAAc,OAAO,AAACC,WAAE,CAASF,OAAO,KAAK;AAEpC,SAASA,QAAQG,QAAgB,EAAEC,KAAoB,EAAEC,OAAuB,EAAEC,QAAyB;IACxH,IAAIL,aAAa;QACf,IAAMM,MAAMF,QAAQE,GAAG,IAAI,IAAIC;QAC/B,kFAAkF;QACjFN,WAAE,CAASF,OAAO,CAACG,UAAUI,KAAK,IAAIC,KAAKJ,MAAMK,KAAK,GAAGH;IAC5D,OAAO;QACL,yDAAyD;QACzD,+EAA+E;QAC/EA,SAAS;IACX;AACF"}

package/dist/cjs/fs/symlinkWin32.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/fs/symlinkWin32.ts"],"sourcesContent":["import fs, { type NoParamCallback } from 'fs';\nimport lstatReal from './lstatReal.ts';\n\nexport default function symlinkWin32(linkFullPath: string, linkpath: string, fullPath: string, callback: NoParamCallback) {\n  lstatReal(linkFullPath, (err, targetStat) => {\n    // If target doesn't exist, default to 'file' type (Windows requires a type for symlinks)\n    const type = !err && targetStat?.isDirectory() ? 'dir' : 'file';\n    fs.symlink(linkpath, fullPath, type, callback);\n  });\n}\n"],"names":["symlinkWin32","linkFullPath","linkpath","fullPath","callback","lstatReal","err","targetStat","type","isDirectory","fs","symlink"],"mappings":";;;;+BAGA;;;eAAwBA;;;yDAHiB;kEACnB;;;;;;AAEP,SAASA,aAAaC,YAAoB,EAAEC,QAAgB,EAAEC,QAAgB,EAAEC,QAAyB;IACtHC,IAAAA,oBAAS,EAACJ,cAAc,SAACK,KAAKC;QAC5B,yFAAyF;QACzF,IAAMC,OAAO,CAACF,QAAOC,uBAAAA,iCAAAA,WAAYE,WAAW,MAAK,QAAQ;QACzDC,WAAE,CAACC,OAAO,CAACT,UAAUC,UAAUK,MAAMJ;IACvC;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/fs/symlinkWin32.ts"],"sourcesContent":["import fs, { type NoParamCallback } from 'fs';\nimport lstatReal from './lstatReal.ts';\n\nexport default function symlinkWin32(linkFullPath: string, linkpath: string, fullPath: string, callback: NoParamCallback) {\n  lstatReal(linkFullPath, (err, targetStat) => {\n    // If target doesn't exist, default to 'file' type (Windows requires a type for symlinks)\n    const type = !err && targetStat?.isDirectory() ? 'dir' : 'file';\n    fs.symlink(linkpath, fullPath, type, callback);\n  });\n}\n"],"names":["symlinkWin32","linkFullPath","linkpath","fullPath","callback","lstatReal","err","targetStat","type","isDirectory","fs","symlink"],"mappings":";;;;+BAGA;;;eAAwBA;;;yDAHiB;kEACnB;;;;;;AAEP,SAASA,aAAaC,YAAoB,EAAEC,QAAgB,EAAEC,QAAgB,EAAEC,QAAyB;IACtHC,IAAAA,oBAAS,EAACJ,cAAc,SAACK,KAAKC;QAC5B,yFAAyF;QACzF,IAAMC,OAAO,CAACF,QAAOC,uBAAAA,iCAAAA,WAAYE,WAAW,MAAK,QAAQ;QACzDC,WAAE,CAACC,OAAO,CAACT,UAAUC,UAAUK,MAAMJ;IACvC;AACF"}

package/dist/cjs/fs/utimes.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/fs/utimes.ts"],"sourcesContent":["// adapted from https://github.com/mafintosh/tar-fs\n\nimport fs, { type NoParamCallback } from 'fs';\nimport type { AbstractEntry, ExtractOptions } from '../types.ts';\n\nexport default function utimes(fullPath: string, entry: AbstractEntry, options: ExtractOptions, callback: NoParamCallback): void {\n  const now = options.now || new Date();\n  fs.utimes(fullPath, now, new Date(entry.mtime), callback);\n}\n"],"names":["utimes","fullPath","entry","options","callback","now","Date","fs","mtime"],"mappings":"AAAA,mDAAmD;;;;;+BAKnD;;;eAAwBA;;;yDAHiB;;;;;;AAG1B,SAASA,OAAOC,QAAgB,EAAEC,KAAoB,EAAEC,OAAuB,EAAEC,QAAyB;IACvH,IAAMC,MAAMF,QAAQE,GAAG,IAAI,IAAIC;IAC/BC,WAAE,CAACP,MAAM,CAACC,UAAUI,KAAK,IAAIC,KAAKJ,MAAMM,KAAK,GAAGJ;AAClD"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/fs/utimes.ts"],"sourcesContent":["// adapted from https://github.com/mafintosh/tar-fs\n\nimport fs, { type NoParamCallback } from 'fs';\nimport type { AbstractEntry, ExtractOptions } from '../types.ts';\n\nexport default function utimes(fullPath: string, entry: AbstractEntry, options: ExtractOptions, callback: NoParamCallback): void {\n  const now = options.now || new Date();\n  fs.utimes(fullPath, now, new Date(entry.mtime), callback);\n}\n"],"names":["utimes","fullPath","entry","options","callback","now","Date","fs","mtime"],"mappings":"AAAA,mDAAmD;;;;;+BAKnD;;;eAAwBA;;;yDAHiB;;;;;;AAG1B,SAASA,OAAOC,QAAgB,EAAEC,KAAoB,EAAEC,OAAuB,EAAEC,QAAyB;IACvH,IAAMC,MAAMF,QAAQE,GAAG,IAAI,IAAIC;IAC/BC,WAAE,CAACP,MAAM,CAACC,UAAUI,KAAK,IAAIC,KAAKJ,MAAMM,KAAK,GAAGJ;AAClD"}

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/index.ts"],"sourcesContent":["import StackBaseIterator from 'stack-base-iterator';\n\nimport type { Entry } from './types.ts';\n\nexport default class ExtractBaseIterator<T = Entry> extends StackBaseIterator<T> {}\n\nexport { default as DirectoryEntry } from './DirectoryEntry.ts';\nexport { default as FileEntry } from './FileEntry.ts';\nexport { default as LinkEntry } from './LinkEntry.ts';\nexport { default as SymbolicLinkEntry } from './SymbolicLinkEntry.ts';\n// Shared utilities for iterator libraries\nexport * from './shared/index.ts';\nexport * from './types.ts';\nexport { default as waitForAccess } from './waitForAccess.ts';\n"],"names":["DirectoryEntry","FileEntry","LinkEntry","SymbolicLinkEntry","ExtractBaseIterator","waitForAccess","StackBaseIterator"],"mappings":";;;;;;;;;;;QAMoBA;eAAAA,yBAAc;;QACdC;eAAAA,oBAAS;;QACTC;eAAAA,oBAAS;;QACTC;eAAAA,4BAAiB;;;eALhBC;;QASDC;eAAAA,wBAAa;;;wEAbH;uEAMY;kEACL;kEACA;0EACQ;qBAE/B;qBACA;sEAC2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAT1B,IAAA,AAAMD,oCAAN;;cAAMA;aAAAA;gCAAAA;QAAN,OAAA,kBAAMA;;WAAAA;EAAuCE,0BAAiB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/index.ts"],"sourcesContent":["import StackBaseIterator from 'stack-base-iterator';\n\nimport type { Entry } from './types.ts';\n\nexport default class ExtractBaseIterator<T = Entry> extends StackBaseIterator<T> {}\n\nexport { default as DirectoryEntry } from './DirectoryEntry.ts';\nexport { default as FileEntry } from './FileEntry.ts';\nexport { default as LinkEntry } from './LinkEntry.ts';\nexport { default as SymbolicLinkEntry } from './SymbolicLinkEntry.ts';\n// Shared utilities for iterator libraries\nexport * from './shared/index.ts';\nexport * from './types.ts';\nexport { default as waitForAccess } from './waitForAccess.ts';\n"],"names":["DirectoryEntry","FileEntry","LinkEntry","SymbolicLinkEntry","ExtractBaseIterator","waitForAccess","StackBaseIterator"],"mappings":";;;;;;;;;;;QAMoBA;eAAAA,yBAAc;;QACdC;eAAAA,oBAAS;;QACTC;eAAAA,oBAAS;;QACTC;eAAAA,4BAAiB;;;eALhBC;;QASDC;eAAAA,wBAAa;;;wEAbH;uEAMY;kEACL;kEACA;0EACQ;qBAE/B;qBACA;sEAC2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAT1B,IAAA,AAAMD,oCAAN;;cAAMA;aAAAA;gCAAAA;QAAN,OAAA,kBAAMA;;WAAAA;EAAuCE,0BAAiB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/shared/BufferList.ts"],"sourcesContent":["/**\n * Buffer List for Streaming\n *\n * Simple linked list for accumulating buffer chunks during streaming.\n * Provides efficient append, consume, and slice operations.\n */\n\nimport { allocBuffer } from 'extract-base-iterator';\n\ninterface BufferNode {\n  data: Buffer;\n  next: BufferNode | null;\n}\n\nexport default class BufferList {\n  private head: BufferNode | null = null;\n  private tail: BufferNode | null = null;\n\n  /** Total bytes in the buffer list */\n  public length = 0;\n\n  /**\n   * Append a buffer to the end of the list\n   */\n  append(buf: Buffer): void {\n    if (buf.length === 0) return;\n\n    const node: BufferNode = { data: buf, next: null };\n\n    if (this.tail) {\n      this.tail.next = node;\n      this.tail = node;\n    } else {\n      this.head = this.tail = node;\n    }\n\n    this.length += buf.length;\n  }\n\n  /**\n   * Prepend a buffer to the front of the list\n   */\n  prepend(buf: Buffer): void {\n    if (buf.length === 0) return;\n\n    const node: BufferNode = { data: buf, next: this.head };\n\n    if (!this.tail) {\n      this.tail = node;\n    }\n    this.head = node;\n\n    this.length += buf.length;\n  }\n\n  /**\n   * Consume n bytes from the front of the list\n   * Returns a new buffer containing the consumed bytes\n   */\n  consume(n: number): Buffer {\n    if (n <= 0) return allocBuffer(0);\n    if (n > this.length) n = this.length;\n\n    const result = allocBuffer(n);\n    let offset = 0;\n\n    while (offset < n && this.head) {\n      const chunk = this.head.data;\n      const needed = n - offset;\n\n      if (chunk.length <= needed) {\n        // Use entire chunk\n        chunk.copy(result, offset);\n        offset += chunk.length;\n        this.head = this.head.next;\n        if (!this.head) this.tail = null;\n      } else {\n        // Use partial chunk\n        chunk.copy(result, offset, 0, needed);\n        this.head.data = chunk.slice(needed);\n        offset = n;\n      }\n    }\n\n    this.length -= n;\n    return result;\n  }\n\n  /**\n   * Get a slice of the buffer without consuming\n   * Returns a new buffer containing the bytes\n   */\n  slice(start: number, end: number): Buffer {\n    const len = end - start;\n    if (len <= 0) return allocBuffer(0);\n    if (start >= this.length) return allocBuffer(0);\n\n    const result = allocBuffer(Math.min(len, this.length - start));\n    let resultOffset = 0;\n    let bufOffset = 0;\n    let node = this.head;\n\n    // Skip to start position\n    while (node && bufOffset + node.data.length <= start) {\n      bufOffset += node.data.length;\n      node = node.next;\n    }\n\n    // Copy data\n    while (node && resultOffset < result.length) {\n      const chunk = node.data;\n      const chunkStart = Math.max(0, start - bufOffset);\n      const chunkEnd = Math.min(chunk.length, end - bufOffset);\n      const toCopy = chunkEnd - chunkStart;\n\n      if (toCopy > 0) {\n        chunk.copy(result, resultOffset, chunkStart, chunkEnd);\n        resultOffset += toCopy;\n      }\n\n      bufOffset += chunk.length;\n      node = node.next;\n    }\n\n    return result;\n  }\n\n  /**\n   * Read a single byte at offset without consuming\n   */\n  readByte(offset: number): number {\n    if (offset < 0 || offset >= this.length) return -1;\n\n    let bufOffset = 0;\n    let node = this.head;\n\n    while (node) {\n      if (offset < bufOffset + node.data.length) {\n        return node.data[offset - bufOffset];\n      }\n      bufOffset += node.data.length;\n      node = node.next;\n    }\n\n    return -1;\n  }\n\n  /**\n   * Search for a byte sequence in the buffer\n   * Returns offset of first match, or -1 if not found\n   */\n  indexOf(signature: number[], startOffset = 0): number {\n    if (signature.length === 0) return startOffset;\n    if (startOffset + signature.length > this.length) return -1;\n\n    // Simple byte-by-byte search\n    // Could be optimized with KMP/Boyer-Moore for larger signatures\n    for (let i = startOffset; i <= this.length - signature.length; i++) {\n      let match = true;\n      for (let j = 0; j < signature.length; j++) {\n        if (this.readByte(i + j) !== signature[j]) {\n          match = false;\n          break;\n        }\n      }\n      if (match) return i;\n    }\n\n    return -1;\n  }\n\n  /**\n   * Skip (consume) n bytes without returning them\n   */\n  skip(n: number): void {\n    if (n <= 0) return;\n    if (n >= this.length) {\n      this.clear();\n      return;\n    }\n\n    let remaining = n;\n\n    while (remaining > 0 && this.head) {\n      const chunk = this.head.data;\n\n      if (chunk.length <= remaining) {\n        remaining -= chunk.length;\n        this.head = this.head.next;\n        if (!this.head) this.tail = null;\n      } else {\n        this.head.data = chunk.slice(remaining);\n        remaining = 0;\n      }\n    }\n\n    this.length -= n;\n  }\n\n  /**\n   * Clear all buffers\n   */\n  clear(): void {\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  /**\n   * Check if buffer has at least n bytes available\n   */\n  has(n: number): boolean {\n    return this.length >= n;\n  }\n\n  /**\n   * Check if the buffer starts with a signature at offset 0\n   */\n  startsWith(signature: number[]): boolean {\n    if (signature.length > this.length) return false;\n    for (let i = 0; i < signature.length; i++) {\n      if (this.readByte(i) !== signature[i]) return false;\n    }\n    return true;\n  }\n\n  /**\n   * Get a consolidated buffer of the entire contents\n   * Note: This creates a copy, so use sparingly for large buffers\n   */\n  toBuffer(): Buffer {\n    if (this.length === 0) return allocBuffer(0);\n    return this.slice(0, this.length);\n  }\n\n  /**\n   * Read UInt16 (little-endian) at offset without consuming\n   * Returns null if not enough data\n   */\n  readUInt16LEAt(offset: number): number | null {\n    if (offset < 0 || offset + 2 > this.length) return null;\n\n    const bytes = this.readBytesAt(offset, 2);\n    if (bytes.length < 2) return null;\n\n    return bytes.readUInt16LE(0);\n  }\n\n  /**\n   * Read UInt32 (little-endian) at offset without consuming\n   * Returns null if not enough data\n   */\n  readUInt32LEAt(offset: number): number | null {\n    if (offset < 0 || offset + 4 > this.length) return null;\n\n    const bytes = this.readBytesAt(offset, 4);\n    if (bytes.length < 4) return null;\n\n    return bytes.readUInt32LE(0);\n  }\n\n  /**\n   * Read bytes at offset without consuming.\n   * Returns a slice (zero-copy) when data fits within a single chunk,\n   * otherwise allocates and copies from multiple chunks.\n   */\n  readBytesAt(offset: number, length: number): Buffer {\n    if (length <= 0) return allocBuffer(0);\n    if (offset < 0 || offset >= this.length) return allocBuffer(0);\n\n    // Clamp length to available data\n    const available = this.length - offset;\n    if (length > available) length = available;\n\n    // Find the node containing the offset\n    let bufOffset = 0;\n    let node = this.head;\n    while (node && bufOffset + node.data.length <= offset) {\n      bufOffset += node.data.length;\n      node = node.next;\n    }\n\n    if (!node) return allocBuffer(0);\n\n    const startInChunk = offset - bufOffset;\n\n    // Single-buffer optimization: zero-copy slice\n    if (startInChunk + length <= node.data.length) {\n      return node.data.slice(startInChunk, startInChunk + length);\n    }\n\n    // Multi-buffer case: must allocate and copy\n    const result = allocBuffer(length);\n    let resultOffset = 0;\n\n    while (node && resultOffset < length) {\n      const chunk = node.data;\n      const chunkStart = resultOffset === 0 ? startInChunk : 0;\n      const chunkAvailable = chunk.length - chunkStart;\n      const toCopy = Math.min(chunkAvailable, length - resultOffset);\n\n      chunk.copy(result, resultOffset, chunkStart, chunkStart + toCopy);\n      resultOffset += toCopy;\n\n      node = node.next;\n    }\n\n    return result;\n  }\n}\n"],"names":["BufferList","head","tail","length","append","buf","node","data","next","prepend","consume","n","allocBuffer","result","offset","chunk","needed","copy","slice","start","end","len","Math","min","resultOffset","bufOffset","chunkStart","max","chunkEnd","toCopy","readByte","indexOf","signature","startOffset","i","match","j","skip","clear","remaining","has","startsWith","toBuffer","readUInt16LEAt","bytes","readBytesAt","readUInt16LE","readUInt32LEAt","readUInt32LE","available","startInChunk","chunkAvailable"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/BufferList.ts"],"sourcesContent":["/**\n * Buffer List for Streaming\n *\n * Simple linked list for accumulating buffer chunks during streaming.\n * Provides efficient append, consume, and slice operations.\n */\n\nimport { allocBuffer } from 'extract-base-iterator';\n\ninterface BufferNode {\n  data: Buffer;\n  next: BufferNode | null;\n}\n\nexport default class BufferList {\n  private head: BufferNode | null = null;\n  private tail: BufferNode | null = null;\n\n  /** Total bytes in the buffer list */\n  public length = 0;\n\n  /**\n   * Append a buffer to the end of the list\n   */\n  append(buf: Buffer): void {\n    if (buf.length === 0) return;\n\n    const node: BufferNode = { data: buf, next: null };\n\n    if (this.tail) {\n      this.tail.next = node;\n      this.tail = node;\n    } else {\n      this.head = this.tail = node;\n    }\n\n    this.length += buf.length;\n  }\n\n  /**\n   * Prepend a buffer to the front of the list\n   */\n  prepend(buf: Buffer): void {\n    if (buf.length === 0) return;\n\n    const node: BufferNode = { data: buf, next: this.head };\n\n    if (!this.tail) {\n      this.tail = node;\n    }\n    this.head = node;\n\n    this.length += buf.length;\n  }\n\n  /**\n   * Consume n bytes from the front of the list\n   * Returns a new buffer containing the consumed bytes\n   */\n  consume(n: number): Buffer {\n    if (n <= 0) return allocBuffer(0);\n    if (n > this.length) n = this.length;\n\n    const result = allocBuffer(n);\n    let offset = 0;\n\n    while (offset < n && this.head) {\n      const chunk = this.head.data;\n      const needed = n - offset;\n\n      if (chunk.length <= needed) {\n        // Use entire chunk\n        chunk.copy(result, offset);\n        offset += chunk.length;\n        this.head = this.head.next;\n        if (!this.head) this.tail = null;\n      } else {\n        // Use partial chunk\n        chunk.copy(result, offset, 0, needed);\n        this.head.data = chunk.slice(needed);\n        offset = n;\n      }\n    }\n\n    this.length -= n;\n    return result;\n  }\n\n  /**\n   * Get a slice of the buffer without consuming\n   * Returns a new buffer containing the bytes\n   */\n  slice(start: number, end: number): Buffer {\n    const len = end - start;\n    if (len <= 0) return allocBuffer(0);\n    if (start >= this.length) return allocBuffer(0);\n\n    const result = allocBuffer(Math.min(len, this.length - start));\n    let resultOffset = 0;\n    let bufOffset = 0;\n    let node = this.head;\n\n    // Skip to start position\n    while (node && bufOffset + node.data.length <= start) {\n      bufOffset += node.data.length;\n      node = node.next;\n    }\n\n    // Copy data\n    while (node && resultOffset < result.length) {\n      const chunk = node.data;\n      const chunkStart = Math.max(0, start - bufOffset);\n      const chunkEnd = Math.min(chunk.length, end - bufOffset);\n      const toCopy = chunkEnd - chunkStart;\n\n      if (toCopy > 0) {\n        chunk.copy(result, resultOffset, chunkStart, chunkEnd);\n        resultOffset += toCopy;\n      }\n\n      bufOffset += chunk.length;\n      node = node.next;\n    }\n\n    return result;\n  }\n\n  /**\n   * Read a single byte at offset without consuming\n   */\n  readByte(offset: number): number {\n    if (offset < 0 || offset >= this.length) return -1;\n\n    let bufOffset = 0;\n    let node = this.head;\n\n    while (node) {\n      if (offset < bufOffset + node.data.length) {\n        return node.data[offset - bufOffset];\n      }\n      bufOffset += node.data.length;\n      node = node.next;\n    }\n\n    return -1;\n  }\n\n  /**\n   * Search for a byte sequence in the buffer\n   * Returns offset of first match, or -1 if not found\n   */\n  indexOf(signature: number[], startOffset = 0): number {\n    if (signature.length === 0) return startOffset;\n    if (startOffset + signature.length > this.length) return -1;\n\n    // Simple byte-by-byte search\n    // Could be optimized with KMP/Boyer-Moore for larger signatures\n    for (let i = startOffset; i <= this.length - signature.length; i++) {\n      let match = true;\n      for (let j = 0; j < signature.length; j++) {\n        if (this.readByte(i + j) !== signature[j]) {\n          match = false;\n          break;\n        }\n      }\n      if (match) return i;\n    }\n\n    return -1;\n  }\n\n  /**\n   * Skip (consume) n bytes without returning them\n   */\n  skip(n: number): void {\n    if (n <= 0) return;\n    if (n >= this.length) {\n      this.clear();\n      return;\n    }\n\n    let remaining = n;\n\n    while (remaining > 0 && this.head) {\n      const chunk = this.head.data;\n\n      if (chunk.length <= remaining) {\n        remaining -= chunk.length;\n        this.head = this.head.next;\n        if (!this.head) this.tail = null;\n      } else {\n        this.head.data = chunk.slice(remaining);\n        remaining = 0;\n      }\n    }\n\n    this.length -= n;\n  }\n\n  /**\n   * Clear all buffers\n   */\n  clear(): void {\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  /**\n   * Check if buffer has at least n bytes available\n   */\n  has(n: number): boolean {\n    return this.length >= n;\n  }\n\n  /**\n   * Check if the buffer starts with a signature at offset 0\n   */\n  startsWith(signature: number[]): boolean {\n    if (signature.length > this.length) return false;\n    for (let i = 0; i < signature.length; i++) {\n      if (this.readByte(i) !== signature[i]) return false;\n    }\n    return true;\n  }\n\n  /**\n   * Get a consolidated buffer of the entire contents\n   * Note: This creates a copy, so use sparingly for large buffers\n   */\n  toBuffer(): Buffer {\n    if (this.length === 0) return allocBuffer(0);\n    return this.slice(0, this.length);\n  }\n\n  /**\n   * Read UInt16 (little-endian) at offset without consuming\n   * Returns null if not enough data\n   */\n  readUInt16LEAt(offset: number): number | null {\n    if (offset < 0 || offset + 2 > this.length) return null;\n\n    const bytes = this.readBytesAt(offset, 2);\n    if (bytes.length < 2) return null;\n\n    return bytes.readUInt16LE(0);\n  }\n\n  /**\n   * Read UInt32 (little-endian) at offset without consuming\n   * Returns null if not enough data\n   */\n  readUInt32LEAt(offset: number): number | null {\n    if (offset < 0 || offset + 4 > this.length) return null;\n\n    const bytes = this.readBytesAt(offset, 4);\n    if (bytes.length < 4) return null;\n\n    return bytes.readUInt32LE(0);\n  }\n\n  /**\n   * Read bytes at offset without consuming.\n   * Returns a slice (zero-copy) when data fits within a single chunk,\n   * otherwise allocates and copies from multiple chunks.\n   */\n  readBytesAt(offset: number, length: number): Buffer {\n    if (length <= 0) return allocBuffer(0);\n    if (offset < 0 || offset >= this.length) return allocBuffer(0);\n\n    // Clamp length to available data\n    const available = this.length - offset;\n    if (length > available) length = available;\n\n    // Find the node containing the offset\n    let bufOffset = 0;\n    let node = this.head;\n    while (node && bufOffset + node.data.length <= offset) {\n      bufOffset += node.data.length;\n      node = node.next;\n    }\n\n    if (!node) return allocBuffer(0);\n\n    const startInChunk = offset - bufOffset;\n\n    // Single-buffer optimization: zero-copy slice\n    if (startInChunk + length <= node.data.length) {\n      return node.data.slice(startInChunk, startInChunk + length);\n    }\n\n    // Multi-buffer case: must allocate and copy\n    const result = allocBuffer(length);\n    let resultOffset = 0;\n\n    while (node && resultOffset < length) {\n      const chunk = node.data;\n      const chunkStart = resultOffset === 0 ? startInChunk : 0;\n      const chunkAvailable = chunk.length - chunkStart;\n      const toCopy = Math.min(chunkAvailable, length - resultOffset);\n\n      chunk.copy(result, resultOffset, chunkStart, chunkStart + toCopy);\n      resultOffset += toCopy;\n\n      node = node.next;\n    }\n\n    return result;\n  }\n}\n"],"names":["BufferList","head","tail","length","append","buf","node","data","next","prepend","consume","n","allocBuffer","result","offset","chunk","needed","copy","slice","start","end","len","Math","min","resultOffset","bufOffset","chunkStart","max","chunkEnd","toCopy","readByte","indexOf","signature","startOffset","i","match","j","skip","clear","remaining","has","startsWith","toBuffer","readUInt16LEAt","bytes","readBytesAt","readUInt16LE","readUInt32LEAt","readUInt32LE","available","startInChunk","chunkAvailable"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/shared/EntryStream.ts"],"sourcesContent":["/**\n * EntryStream - Simple readable stream for entry content\n *\n * Extends Readable to emit 'data', 'end', 'error' events.\n * Node 0.8 compatible via readable-stream polyfill.\n *\n * This base class is designed to be used by:\n * - zip-iterator\n * - 7z-iterator\n * - tar-iterator\n * - Any other archive iterator library\n */\n\nimport Stream from 'stream';\n\n// Use native streams when available, readable-stream only for Node 0.x\nconst major = +process.versions.node.split('.')[0];\nlet ReadableBase: typeof Stream.Readable;\nif (major > 0) {\n  ReadableBase = Stream.Readable;\n} else {\n  ReadableBase = require('readable-stream').Readable;\n}\n\n/**\n * Base stream class for archive entry content.\n * Can be extended for special entry types like sparse files.\n */\nexport default class EntryStream extends ReadableBase {\n  protected _ended = false;\n\n  /**\n   * Signal end of stream by pushing null\n   */\n  end(): void {\n    if (this._ended) return;\n    this._ended = true;\n    this.push(null);\n  }\n\n  /**\n   * Check if stream has ended\n   */\n  get ended(): boolean {\n    return this._ended;\n  }\n\n  /**\n   * Required by Readable - called when consumer wants data.\n   * Data is pushed externally via push(), nothing to do here.\n   */\n  _read(_size: number): void {\n    // Data is pushed externally, nothing to do here\n  }\n}\n"],"names":["EntryStream","major","process","versions","node","split","ReadableBase","Stream","Readable","require","_ended","end","push","_read","_size","ended"],"mappings":"AAAA;;;;;;;;;;;CAWC;;;;;;;eAiBoBA;;;6DAfF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEnB,uEAAuE;AACvE,IAAMC,QAAQ,CAACC,QAAQC,QAAQ,CAACC,IAAI,CAACC,KAAK,CAAC,IAAI,CAAC,EAAE;AAClD,IAAIC;AACJ,IAAIL,QAAQ,GAAG;IACbK,eAAeC,eAAM,CAACC,QAAQ;AAChC,OAAO;IACLF,eAAeG,QAAQ,mBAAmBD,QAAQ;AACpD;AAMe,IAAA,AAAMR,4BAAN;;cAAMA;aAAAA;gCAAAA;;gBAAN,kBAAMA,+BACTU,SAAS;;;iBADAV;IAGnB;;GAEC,GACDW,OAAAA,GAIC,GAJDA,SAAAA;QACE,IAAI,IAAI,CAACD,MAAM,EAAE;QACjB,IAAI,CAACA,MAAM,GAAG;QACd,IAAI,CAACE,IAAI,CAAC;IACZ;IASA;;;GAGC,GACDC,OAAAA,KAEC,GAFDA,SAAAA,MAAMC,KAAa;IACjB,gDAAgD;IAClD;kBAzBmBd;;YAefe,KAAAA;iBAAJ,AAHA;;GAEC,GACD;gBACE,OAAO,IAAI,CAACL,MAAM;YACpB;;;WAjBmBV;EAAoBM"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/EntryStream.ts"],"sourcesContent":["/**\n * EntryStream - Simple readable stream for entry content\n *\n * Extends Readable to emit 'data', 'end', 'error' events.\n * Node 0.8 compatible via readable-stream polyfill.\n *\n * This base class is designed to be used by:\n * - zip-iterator\n * - 7z-iterator\n * - tar-iterator\n * - Any other archive iterator library\n */\n\nimport Stream from 'stream';\n\n// Use native streams when available, readable-stream only for Node 0.x\nconst major = +process.versions.node.split('.')[0];\nlet ReadableBase: typeof Stream.Readable;\nif (major > 0) {\n  ReadableBase = Stream.Readable;\n} else {\n  ReadableBase = require('readable-stream').Readable;\n}\n\n/**\n * Base stream class for archive entry content.\n * Can be extended for special entry types like sparse files.\n */\nexport default class EntryStream extends ReadableBase {\n  protected _ended = false;\n\n  /**\n   * Signal end of stream by pushing null\n   */\n  end(): void {\n    if (this._ended) return;\n    this._ended = true;\n    this.push(null);\n  }\n\n  /**\n   * Check if stream has ended\n   */\n  get ended(): boolean {\n    return this._ended;\n  }\n\n  /**\n   * Required by Readable - called when consumer wants data.\n   * Data is pushed externally via push(), nothing to do here.\n   */\n  _read(_size: number): void {\n    // Data is pushed externally, nothing to do here\n  }\n}\n"],"names":["EntryStream","major","process","versions","node","split","ReadableBase","Stream","Readable","require","_ended","end","push","_read","_size","ended"],"mappings":"AAAA;;;;;;;;;;;CAWC;;;;;;;eAiBoBA;;;6DAfF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEnB,uEAAuE;AACvE,IAAMC,QAAQ,CAACC,QAAQC,QAAQ,CAACC,IAAI,CAACC,KAAK,CAAC,IAAI,CAAC,EAAE;AAClD,IAAIC;AACJ,IAAIL,QAAQ,GAAG;IACbK,eAAeC,eAAM,CAACC,QAAQ;AAChC,OAAO;IACLF,eAAeG,QAAQ,mBAAmBD,QAAQ;AACpD;AAMe,IAAA,AAAMR,4BAAN;;cAAMA;aAAAA;gCAAAA;;gBAAN,kBAAMA,+BACTU,SAAS;;;iBADAV;IAGnB;;GAEC,GACDW,OAAAA,GAIC,GAJDA,SAAAA;QACE,IAAI,IAAI,CAACD,MAAM,EAAE;QACjB,IAAI,CAACA,MAAM,GAAG;QACd,IAAI,CAACE,IAAI,CAAC;IACZ;IASA;;;GAGC,GACDC,OAAAA,KAEC,GAFDA,SAAAA,MAAMC,KAAa;IACjB,gDAAgD;IAClD;kBAzBmBd;;YAefe,KAAAA;iBAAJ,AAHA;;GAEC,GACD;gBACE,OAAO,IAAI,CAACL,MAAM;YACpB;;;WAjBmBV;EAAoBM"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/shared/Lock.ts"],"sourcesContent":["/**\n * Lock - Reference counting for iterator lifecycle\n *\n * Ensures the iterator doesn't complete until all entries have been processed.\n * Uses cleanup registration pattern so each iterator can register its specific\n * cleanup functions (e.g., close file descriptors, delete temp files, end parsers).\n *\n * Usage:\n *   const lock = new Lock();\n *   lock.onDestroy = (err) => BaseIterator.prototype.end.call(this, err);\n *   lock.registerCleanup(() => { this.extract.end(); });\n *   lock.registerCleanup(() => { fs.unlinkSync(this.tempPath); });\n *\n *   // For each entry:\n *   lock.retain();\n *   // ... when entry is consumed:\n *   lock.release();\n *\n *   // When iteration complete:\n *   lock.err = err; // optional error\n *   lock.release(); // Initial count\n */\n\nexport type CleanupFn = () => void;\n\nexport default class Lock {\n  private count = 1;\n  private cleanupFns: CleanupFn[] = [];\n\n  /** Error to pass to onDestroy callback */\n  err: Error | null = null;\n\n  /** Called after all cleanups when count reaches 0 */\n  onDestroy: ((err: Error | null) => void) | null = null;\n\n  /**\n   * Register a cleanup function to be called when the lock is destroyed.\n   * Cleanup functions are called in registration order, before onDestroy.\n   * @param fn Cleanup function (should not throw)\n   */\n  registerCleanup(fn: CleanupFn): void {\n    this.cleanupFns.push(fn);\n  }\n\n  /**\n   * Increment reference count.\n   * Call when starting to process a new entry.\n   */\n  retain(): void {\n    this.count++;\n  }\n\n  /**\n   * Decrement reference count.\n   * Call when an entry has been fully consumed.\n   * When count reaches 0, cleanup is triggered.\n   */\n  release(): void {\n    if (this.count <= 0) {\n      throw new Error('Lock count is corrupted');\n    }\n    this.count--;\n    if (this.count === 0) {\n      this._destroy();\n    }\n  }\n\n  /**\n   * Internal cleanup - called when reference count reaches 0\n   */\n  private _destroy(): void {\n    // Run all registered cleanup functions in order\n    // Note: Use traditional for loop for Node 0.8 compatibility (no Symbol.iterator)\n    const fns = this.cleanupFns;\n    for (let i = 0; i < fns.length; i++) {\n      try {\n        fns[i]();\n      } catch (_e) {\n        // Ignore cleanup errors to ensure all cleanup runs\n      }\n    }\n    this.cleanupFns = [];\n\n    // Call onDestroy callback LAST (typically calls iterator.end())\n    if (this.onDestroy) {\n      this.onDestroy(this.err);\n      this.onDestroy = null;\n    }\n  }\n}\n"],"names":["Lock","count","cleanupFns","err","onDestroy","registerCleanup","fn","push","retain","release","Error","_destroy","fns","i","length","_e"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;CAqBC;;;;;;;eAIoBA;;;;;;;;AAAN,IAAA,AAAMA,qBAAN;;aAAMA;gCAAAA;aACXC,QAAQ;aACRC,aAA0B,EAAE;QAEpC,wCAAwC,QACxCC,MAAoB;QAEpB,mDAAmD,QACnDC,YAAkD;;iBAR/BJ;IAUnB;;;;GAIC,GACDK,OAAAA,eAEC,GAFDA,SAAAA,gBAAgBC,EAAa;QAC3B,IAAI,CAACJ,UAAU,CAACK,IAAI,CAACD;IACvB;IAEA;;;GAGC,GACDE,OAAAA,MAEC,GAFDA,SAAAA;QACE,IAAI,CAACP,KAAK;IACZ;IAEA;;;;GAIC,GACDQ,OAAAA,OAQC,GARDA,SAAAA;QACE,IAAI,IAAI,CAACR,KAAK,IAAI,GAAG;YACnB,MAAM,IAAIS,MAAM;QAClB;QACA,IAAI,CAACT,KAAK;QACV,IAAI,IAAI,CAACA,KAAK,KAAK,GAAG;YACpB,IAAI,CAACU,QAAQ;QACf;IACF;IAEA;;GAEC,GACD,OAAQA,QAkBP,GAlBD,SAAQA;QACN,gDAAgD;QAChD,iFAAiF;QACjF,IAAMC,MAAM,IAAI,CAACV,UAAU;QAC3B,IAAK,IAAIW,IAAI,GAAGA,IAAID,IAAIE,MAAM,EAAED,IAAK;YACnC,IAAI;gBACFD,GAAG,CAACC,EAAE;YACR,EAAE,OAAOE,IAAI;YACX,mDAAmD;YACrD;QACF;QACA,IAAI,CAACb,UAAU,GAAG,EAAE;QAEpB,gEAAgE;QAChE,IAAI,IAAI,CAACE,SAAS,EAAE;YAClB,IAAI,CAACA,SAAS,CAAC,IAAI,CAACD,GAAG;YACvB,IAAI,CAACC,SAAS,GAAG;QACnB;IACF;WA/DmBJ"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/Lock.ts"],"sourcesContent":["/**\n * Lock - Reference counting for iterator lifecycle\n *\n * Ensures the iterator doesn't complete until all entries have been processed.\n * Uses cleanup registration pattern so each iterator can register its specific\n * cleanup functions (e.g., close file descriptors, delete temp files, end parsers).\n *\n * Usage:\n *   const lock = new Lock();\n *   lock.onDestroy = (err) => BaseIterator.prototype.end.call(this, err);\n *   lock.registerCleanup(() => { this.extract.end(); });\n *   lock.registerCleanup(() => { fs.unlinkSync(this.tempPath); });\n *\n *   // For each entry:\n *   lock.retain();\n *   // ... when entry is consumed:\n *   lock.release();\n *\n *   // When iteration complete:\n *   lock.err = err; // optional error\n *   lock.release(); // Initial count\n */\n\nexport type CleanupFn = () => void;\n\nexport default class Lock {\n  private count = 1;\n  private cleanupFns: CleanupFn[] = [];\n\n  /** Error to pass to onDestroy callback */\n  err: Error | null = null;\n\n  /** Called after all cleanups when count reaches 0 */\n  onDestroy: ((err: Error | null) => void) | null = null;\n\n  /**\n   * Register a cleanup function to be called when the lock is destroyed.\n   * Cleanup functions are called in registration order, before onDestroy.\n   * @param fn Cleanup function (should not throw)\n   */\n  registerCleanup(fn: CleanupFn): void {\n    this.cleanupFns.push(fn);\n  }\n\n  /**\n   * Increment reference count.\n   * Call when starting to process a new entry.\n   */\n  retain(): void {\n    this.count++;\n  }\n\n  /**\n   * Decrement reference count.\n   * Call when an entry has been fully consumed.\n   * When count reaches 0, cleanup is triggered.\n   */\n  release(): void {\n    if (this.count <= 0) {\n      throw new Error('Lock count is corrupted');\n    }\n    this.count--;\n    if (this.count === 0) {\n      this._destroy();\n    }\n  }\n\n  /**\n   * Internal cleanup - called when reference count reaches 0\n   */\n  private _destroy(): void {\n    // Run all registered cleanup functions in order\n    // Note: Use traditional for loop for Node 0.8 compatibility (no Symbol.iterator)\n    const fns = this.cleanupFns;\n    for (let i = 0; i < fns.length; i++) {\n      try {\n        fns[i]();\n      } catch (_e) {\n        // Ignore cleanup errors to ensure all cleanup runs\n      }\n    }\n    this.cleanupFns = [];\n\n    // Call onDestroy callback LAST (typically calls iterator.end())\n    if (this.onDestroy) {\n      this.onDestroy(this.err);\n      this.onDestroy = null;\n    }\n  }\n}\n"],"names":["Lock","count","cleanupFns","err","onDestroy","registerCleanup","fn","push","retain","release","Error","_destroy","fns","i","length","_e"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;CAqBC;;;;;;;eAIoBA;;;;;;;;AAAN,IAAA,AAAMA,qBAAN;;aAAMA;gCAAAA;aACXC,QAAQ;aACRC,aAA0B,EAAE;QAEpC,wCAAwC,QACxCC,MAAoB;QAEpB,mDAAmD,QACnDC,YAAkD;;iBAR/BJ;IAUnB;;;;GAIC,GACDK,OAAAA,eAEC,GAFDA,SAAAA,gBAAgBC,EAAa;QAC3B,IAAI,CAACJ,UAAU,CAACK,IAAI,CAACD;IACvB;IAEA;;;GAGC,GACDE,OAAAA,MAEC,GAFDA,SAAAA;QACE,IAAI,CAACP,KAAK;IACZ;IAEA;;;;GAIC,GACDQ,OAAAA,OAQC,GARDA,SAAAA;QACE,IAAI,IAAI,CAACR,KAAK,IAAI,GAAG;YACnB,MAAM,IAAIS,MAAM;QAClB;QACA,IAAI,CAACT,KAAK;QACV,IAAI,IAAI,CAACA,KAAK,KAAK,GAAG;YACpB,IAAI,CAACU,QAAQ;QACf;IACF;IAEA;;GAEC,GACD,OAAQA,QAkBP,GAlBD,SAAQA;QACN,gDAAgD;QAChD,iFAAiF;QACjF,IAAMC,MAAM,IAAI,CAACV,UAAU;QAC3B,IAAK,IAAIW,IAAI,GAAGA,IAAID,IAAIE,MAAM,EAAED,IAAK;YACnC,IAAI;gBACFD,GAAG,CAACC,EAAE;YACR,EAAE,OAAOE,IAAI;YACX,mDAAmD;YACrD;QACF;QACA,IAAI,CAACb,UAAU,GAAG,EAAE;QAEpB,gEAAgE;QAChE,IAAI,IAAI,CAACE,SAAS,EAAE;YAClB,IAAI,CAACA,SAAS,CAAC,IAAI,CAACD,GAAG;YACvB,IAAI,CAACC,SAAS,GAAG;QACnB;IACF;WA/DmBJ"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/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/**\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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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/shared/crc32.ts"],"sourcesContent":["/**\n * CRC32 calculation for archive formats\n *\n * Uses IEEE polynomial 0xEDB88320 (same as ZIP, 7z, PNG, gzip, etc.)\n * All bit operations (>>>, ^, &) work correctly in Node 0.8\n *\n * This is the standard CRC-32 algorithm used by:\n * - ZIP/PKZIP\n * - 7-Zip\n * - PNG\n * - gzip\n * - Ethernet\n */\n\n// Pre-computed lookup table for performance\nconst CRC32_TABLE: number[] = [];\n\n// Initialize table at module load time\n(function initTable() {\n  for (let i = 0; i < 256; i++) {\n    let c = i;\n    for (let j = 0; j < 8; j++) {\n      if ((c & 1) !== 0) {\n        c = 0xedb88320 ^ (c >>> 1);\n      } else {\n        c = c >>> 1;\n      }\n    }\n    CRC32_TABLE[i] = c >>> 0; // Ensure unsigned\n  }\n})();\n\n/**\n * Calculate CRC32 of a buffer\n * @param buf - Buffer to calculate CRC32 for\n * @param initial - Optional initial CRC value (for streaming calculation)\n * @returns CRC32 value as unsigned 32-bit integer\n */\nexport function crc32(buf: Buffer, initial?: number): number {\n  let crc = initial === undefined ? 0xffffffff : ~initial >>> 0;\n\n  for (let i = 0; i < buf.length; i++) {\n    const index = (crc ^ buf[i]) & 0xff;\n    crc = CRC32_TABLE[index] ^ (crc >>> 8);\n  }\n\n  return ~crc >>> 0; // Return unsigned\n}\n\n/**\n * Calculate CRC32 of a buffer region\n * @param buf - Buffer containing data\n * @param offset - Start offset in buffer\n * @param length - Number of bytes to process\n * @param initial - Optional initial CRC value\n * @returns CRC32 value as unsigned 32-bit integer\n */\nexport function crc32Region(buf: Buffer, offset: number, length: number, initial?: number): number {\n  let crc = initial === undefined ? 0xffffffff : ~initial >>> 0;\n  const end = offset + length;\n\n  for (let i = offset; i < end; i++) {\n    const index = (crc ^ buf[i]) & 0xff;\n    crc = CRC32_TABLE[index] ^ (crc >>> 8);\n  }\n\n  return ~crc >>> 0; // Return unsigned\n}\n\n/**\n * Verify CRC32 matches expected value\n * @param buf - Buffer to verify\n * @param expected - Expected CRC32 value\n * @returns true if CRC matches, false otherwise\n */\nexport function verifyCrc32(buf: Buffer, expected: number): boolean {\n  return crc32(buf) === expected >>> 0;\n}\n\n/**\n * Verify CRC32 of a buffer region matches expected value\n * @param buf - Buffer containing data\n * @param offset - Start offset in buffer\n * @param length - Number of bytes to verify\n * @param expected - Expected CRC32 value\n * @returns true if CRC matches, false otherwise\n */\nexport function verifyCrc32Region(buf: Buffer, offset: number, length: number, expected: number): boolean {\n  return crc32Region(buf, offset, length) === expected >>> 0;\n}\n"],"names":["crc32","crc32Region","verifyCrc32","verifyCrc32Region","CRC32_TABLE","initTable","i","c","j","buf","initial","crc","undefined","length","index","offset","end","expected"],"mappings":";;;;;;;;;;;QAsCgBA;eAAAA;;QAmBAC;eAAAA;;QAkBAC;eAAAA;;QAYAC;eAAAA;;;AAvFhB;;;;;;;;;;;;CAYC,GAED,4CAA4C;AAC5C,IAAMC,cAAwB,EAAE;AAEhC,uCAAuC;AACtC,CAAA,SAASC;IACR,IAAK,IAAIC,IAAI,GAAGA,IAAI,KAAKA,IAAK;QAC5B,IAAIC,IAAID;QACR,IAAK,IAAIE,IAAI,GAAGA,IAAI,GAAGA,IAAK;YAC1B,IAAI,AAACD,CAAAA,IAAI,CAAA,MAAO,GAAG;gBACjBA,IAAI,aAAcA,MAAM;YAC1B,OAAO;gBACLA,IAAIA,MAAM;YACZ;QACF;QACAH,WAAW,CAACE,EAAE,GAAGC,MAAM,GAAG,kBAAkB;IAC9C;AACF,CAAA;AAQO,SAASP,MAAMS,GAAW,EAAEC,OAAgB;IACjD,IAAIC,MAAMD,YAAYE,YAAY,aAAa,CAACF,YAAY;IAE5D,IAAK,IAAIJ,IAAI,GAAGA,IAAIG,IAAII,MAAM,EAAEP,IAAK;QACnC,IAAMQ,QAAQ,AAACH,CAAAA,MAAMF,GAAG,CAACH,EAAE,AAAD,IAAK;QAC/BK,MAAMP,WAAW,CAACU,MAAM,GAAIH,QAAQ;IACtC;IAEA,OAAO,CAACA,QAAQ,GAAG,kBAAkB;AACvC;AAUO,SAASV,YAAYQ,GAAW,EAAEM,MAAc,EAAEF,MAAc,EAAEH,OAAgB;IACvF,IAAIC,MAAMD,YAAYE,YAAY,aAAa,CAACF,YAAY;IAC5D,IAAMM,MAAMD,SAASF;IAErB,IAAK,IAAIP,IAAIS,QAAQT,IAAIU,KAAKV,IAAK;QACjC,IAAMQ,QAAQ,AAACH,CAAAA,MAAMF,GAAG,CAACH,EAAE,AAAD,IAAK;QAC/BK,MAAMP,WAAW,CAACU,MAAM,GAAIH,QAAQ;IACtC;IAEA,OAAO,CAACA,QAAQ,GAAG,kBAAkB;AACvC;AAQO,SAAST,YAAYO,GAAW,EAAEQ,QAAgB;IACvD,OAAOjB,MAAMS,SAASQ,aAAa;AACrC;AAUO,SAASd,kBAAkBM,GAAW,EAAEM,MAAc,EAAEF,MAAc,EAAEI,QAAgB;IAC7F,OAAOhB,YAAYQ,KAAKM,QAAQF,YAAYI,aAAa;AAC3D"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/crc32.ts"],"sourcesContent":["/**\n * CRC32 calculation for archive formats\n *\n * Uses IEEE polynomial 0xEDB88320 (same as ZIP, 7z, PNG, gzip, etc.)\n * All bit operations (>>>, ^, &) work correctly in Node 0.8\n *\n * This is the standard CRC-32 algorithm used by:\n * - ZIP/PKZIP\n * - 7-Zip\n * - PNG\n * - gzip\n * - Ethernet\n */\n\n// Pre-computed lookup table for performance\nconst CRC32_TABLE: number[] = [];\n\n// Initialize table at module load time\n(function initTable() {\n  for (let i = 0; i < 256; i++) {\n    let c = i;\n    for (let j = 0; j < 8; j++) {\n      if ((c & 1) !== 0) {\n        c = 0xedb88320 ^ (c >>> 1);\n      } else {\n        c = c >>> 1;\n      }\n    }\n    CRC32_TABLE[i] = c >>> 0; // Ensure unsigned\n  }\n})();\n\n/**\n * Calculate CRC32 of a buffer\n * @param buf - Buffer to calculate CRC32 for\n * @param initial - Optional initial CRC value (for streaming calculation)\n * @returns CRC32 value as unsigned 32-bit integer\n */\nexport function crc32(buf: Buffer, initial?: number): number {\n  let crc = initial === undefined ? 0xffffffff : ~initial >>> 0;\n\n  for (let i = 0; i < buf.length; i++) {\n    const index = (crc ^ buf[i]) & 0xff;\n    crc = CRC32_TABLE[index] ^ (crc >>> 8);\n  }\n\n  return ~crc >>> 0; // Return unsigned\n}\n\n/**\n * Calculate CRC32 of a buffer region\n * @param buf - Buffer containing data\n * @param offset - Start offset in buffer\n * @param length - Number of bytes to process\n * @param initial - Optional initial CRC value\n * @returns CRC32 value as unsigned 32-bit integer\n */\nexport function crc32Region(buf: Buffer, offset: number, length: number, initial?: number): number {\n  let crc = initial === undefined ? 0xffffffff : ~initial >>> 0;\n  const end = offset + length;\n\n  for (let i = offset; i < end; i++) {\n    const index = (crc ^ buf[i]) & 0xff;\n    crc = CRC32_TABLE[index] ^ (crc >>> 8);\n  }\n\n  return ~crc >>> 0; // Return unsigned\n}\n\n/**\n * Verify CRC32 matches expected value\n * @param buf - Buffer to verify\n * @param expected - Expected CRC32 value\n * @returns true if CRC matches, false otherwise\n */\nexport function verifyCrc32(buf: Buffer, expected: number): boolean {\n  return crc32(buf) === expected >>> 0;\n}\n\n/**\n * Verify CRC32 of a buffer region matches expected value\n * @param buf - Buffer containing data\n * @param offset - Start offset in buffer\n * @param length - Number of bytes to verify\n * @param expected - Expected CRC32 value\n * @returns true if CRC matches, false otherwise\n */\nexport function verifyCrc32Region(buf: Buffer, offset: number, length: number, expected: number): boolean {\n  return crc32Region(buf, offset, length) === expected >>> 0;\n}\n"],"names":["crc32","crc32Region","verifyCrc32","verifyCrc32Region","CRC32_TABLE","initTable","i","c","j","buf","initial","crc","undefined","length","index","offset","end","expected"],"mappings":";;;;;;;;;;;QAsCgBA;eAAAA;;QAmBAC;eAAAA;;QAkBAC;eAAAA;;QAYAC;eAAAA;;;AAvFhB;;;;;;;;;;;;CAYC,GAED,4CAA4C;AAC5C,IAAMC,cAAwB,EAAE;AAEhC,uCAAuC;AACtC,CAAA,SAASC;IACR,IAAK,IAAIC,IAAI,GAAGA,IAAI,KAAKA,IAAK;QAC5B,IAAIC,IAAID;QACR,IAAK,IAAIE,IAAI,GAAGA,IAAI,GAAGA,IAAK;YAC1B,IAAI,AAACD,CAAAA,IAAI,CAAA,MAAO,GAAG;gBACjBA,IAAI,aAAcA,MAAM;YAC1B,OAAO;gBACLA,IAAIA,MAAM;YACZ;QACF;QACAH,WAAW,CAACE,EAAE,GAAGC,MAAM,GAAG,kBAAkB;IAC9C;AACF,CAAA;AAQO,SAASP,MAAMS,GAAW,EAAEC,OAAgB;IACjD,IAAIC,MAAMD,YAAYE,YAAY,aAAa,CAACF,YAAY;IAE5D,IAAK,IAAIJ,IAAI,GAAGA,IAAIG,IAAII,MAAM,EAAEP,IAAK;QACnC,IAAMQ,QAAQ,AAACH,CAAAA,MAAMF,GAAG,CAACH,EAAE,AAAD,IAAK;QAC/BK,MAAMP,WAAW,CAACU,MAAM,GAAIH,QAAQ;IACtC;IAEA,OAAO,CAACA,QAAQ,GAAG,kBAAkB;AACvC;AAUO,SAASV,YAAYQ,GAAW,EAAEM,MAAc,EAAEF,MAAc,EAAEH,OAAgB;IACvF,IAAIC,MAAMD,YAAYE,YAAY,aAAa,CAACF,YAAY;IAC5D,IAAMM,MAAMD,SAASF;IAErB,IAAK,IAAIP,IAAIS,QAAQT,IAAIU,KAAKV,IAAK;QACjC,IAAMQ,QAAQ,AAACH,CAAAA,MAAMF,GAAG,CAACH,EAAE,AAAD,IAAK;QAC/BK,MAAMP,WAAW,CAACU,MAAM,GAAIH,QAAQ;IACtC;IAEA,OAAO,CAACA,QAAQ,GAAG,kBAAkB;AACvC;AAQO,SAAST,YAAYO,GAAW,EAAEQ,QAAgB;IACvD,OAAOjB,MAAMS,SAASQ,aAAa;AACrC;AAUO,SAASd,kBAAkBM,GAAW,EAAEM,MAAc,EAAEF,MAAc,EAAEI,QAAgB;IAC7F,OAAOhB,YAAYQ,KAAKM,QAAQF,YAAYI,aAAa;AAC3D"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/shared/index.ts"],"sourcesContent":["/**\n * Shared utilities for iterator libraries\n *\n * These utilities are designed to be used by:\n * - zip-iterator\n * - 7z-iterator\n * - tar-iterator\n * - Any other archive iterator library\n *\n * All utilities support Node.js 0.8+\n */\n\nimport BufferList from './BufferList.ts';\n\nexport { BufferList };\n\n/**\n * Type alias for Buffer or BufferList - both can be read byte-by-byte.\n * Use this when an API should accept either contiguous data (Buffer)\n * or chunked streaming data (BufferList).\n */\nexport type BufferLike = Buffer | BufferList;\nexport {\n  allocBuffer,\n  allocBufferUnsafe,\n  bufferCompare,\n  bufferConcat,\n  bufferEquals,\n  bufferFrom,\n  bufferSliceCopy,\n  createInflateRawStream,\n  inflateRaw,\n  isNaN,\n  objectAssign,\n  PassThrough,\n  Readable,\n  readUInt64LE,\n  Transform,\n  Writable,\n  writeUInt64LE,\n} from './compat.ts';\nexport { crc32, crc32Region, verifyCrc32, verifyCrc32Region } from './crc32.ts';\nexport { default as EntryStream } from './EntryStream.ts';\nexport { type CleanupFn, default as Lock } from './Lock.ts';\nexport { default as normalizePath } from './normalizePath.ts';\nexport { default as streamToString, type StreamToStringCallback } from './streamToString.ts';\nexport { default as stripPath } from './stripPath.ts';\n"],"names":["BufferList","EntryStream","Lock","PassThrough","Readable","Transform","Writable","allocBuffer","allocBufferUnsafe","bufferCompare","bufferConcat","bufferEquals","bufferFrom","bufferSliceCopy","crc32","crc32Region","createInflateRawStream","inflateRaw","isNaN","normalizePath","objectAssign","readUInt64LE","streamToString","stripPath","verifyCrc32","verifyCrc32Region","writeUInt64LE"],"mappings":"AAAA;;;;;;;;;;CAUC;;;;;;;;;;;QAIQA;eAAAA,qBAAU;;QA4BCC;eAAAA,sBAAW;;QACKC;eAAAA,eAAI;;QATtCC;eAAAA,qBAAW;;QACXC;eAAAA,kBAAQ;;QAERC;eAAAA,mBAAS;;QACTC;eAAAA,kBAAQ;;QAfRC;eAAAA,qBAAW;;QACXC;eAAAA,2BAAiB;;QACjBC;eAAAA,uBAAa;;QACbC;eAAAA,sBAAY;;QACZC;eAAAA,sBAAY;;QACZC;eAAAA,oBAAU;;QACVC;eAAAA,yBAAe;;QAYRC;eAAAA,cAAK;;QAAEC;eAAAA,oBAAW;;QAXzBC;eAAAA,gCAAsB;;QACtBC;eAAAA,oBAAU;;QACVC;eAAAA,eAAK;;QAYaC;eAAAA,wBAAa;;QAX/BC;eAAAA,sBAAY;;QAGZC;eAAAA,sBAAY;;QASMC;eAAAA,yBAAc;;QACdC;eAAAA,oBAAS;;QALAC;eAAAA,oBAAW;;QAAEC;eAAAA,0BAAiB;;QAFzDC;eAAAA,uBAAa;;;mEA3BQ;wBA4BhB;uBAC4D;oEAC5B;6DACS;sEACP;uEAC8B;kEAClC"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/index.ts"],"sourcesContent":["/**\n * Shared utilities for iterator libraries\n *\n * These utilities are designed to be used by:\n * - zip-iterator\n * - 7z-iterator\n * - tar-iterator\n * - Any other archive iterator library\n *\n * All utilities support Node.js 0.8+\n */\n\nimport BufferList from './BufferList.ts';\n\nexport { BufferList };\n\n/**\n * Type alias for Buffer or BufferList - both can be read byte-by-byte.\n * Use this when an API should accept either contiguous data (Buffer)\n * or chunked streaming data (BufferList).\n */\nexport type BufferLike = Buffer | BufferList;\nexport {\n  allocBuffer,\n  allocBufferUnsafe,\n  bufferCompare,\n  bufferConcat,\n  bufferEquals,\n  bufferFrom,\n  bufferSliceCopy,\n  createInflateRawStream,\n  inflateRaw,\n  isNaN,\n  objectAssign,\n  PassThrough,\n  Readable,\n  readUInt64LE,\n  Transform,\n  Writable,\n  writeUInt64LE,\n} from './compat.ts';\nexport { crc32, crc32Region, verifyCrc32, verifyCrc32Region } from './crc32.ts';\nexport { default as EntryStream } from './EntryStream.ts';\nexport { type CleanupFn, default as Lock } from './Lock.ts';\nexport { default as normalizePath } from './normalizePath.ts';\nexport { default as streamToString, type StreamToStringCallback } from './streamToString.ts';\nexport { default as stripPath } from './stripPath.ts';\n"],"names":["BufferList","EntryStream","Lock","PassThrough","Readable","Transform","Writable","allocBuffer","allocBufferUnsafe","bufferCompare","bufferConcat","bufferEquals","bufferFrom","bufferSliceCopy","crc32","crc32Region","createInflateRawStream","inflateRaw","isNaN","normalizePath","objectAssign","readUInt64LE","streamToString","stripPath","verifyCrc32","verifyCrc32Region","writeUInt64LE"],"mappings":"AAAA;;;;;;;;;;CAUC;;;;;;;;;;;QAIQA;eAAAA,qBAAU;;QA4BCC;eAAAA,sBAAW;;QACKC;eAAAA,eAAI;;QATtCC;eAAAA,qBAAW;;QACXC;eAAAA,kBAAQ;;QAERC;eAAAA,mBAAS;;QACTC;eAAAA,kBAAQ;;QAfRC;eAAAA,qBAAW;;QACXC;eAAAA,2BAAiB;;QACjBC;eAAAA,uBAAa;;QACbC;eAAAA,sBAAY;;QACZC;eAAAA,sBAAY;;QACZC;eAAAA,oBAAU;;QACVC;eAAAA,yBAAe;;QAYRC;eAAAA,cAAK;;QAAEC;eAAAA,oBAAW;;QAXzBC;eAAAA,gCAAsB;;QACtBC;eAAAA,oBAAU;;QACVC;eAAAA,eAAK;;QAYaC;eAAAA,wBAAa;;QAX/BC;eAAAA,sBAAY;;QAGZC;eAAAA,sBAAY;;QASMC;eAAAA,yBAAc;;QACdC;eAAAA,oBAAS;;QALAC;eAAAA,oBAAW;;QAAEC;eAAAA,0BAAiB;;QAFzDC;eAAAA,uBAAa;;;mEA3BQ;wBA4BhB;uBAC4D;oEAC5B;6DACS;sEACP;uEAC8B;kEAClC"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/shared/normalizePath.ts"],"sourcesContent":["/**\n * Normalize archive entry path\n *\n * - Converts backslashes to forward slashes\n * - Removes empty segments\n * - Removes leading slashes\n *\n * Node 0.8+ compatible.\n */\n\nexport default function normalizePath(p: string): string {\n  // Split on both forward and back slashes, filter empty segments, rejoin with forward slash\n  const segments = p.split(/[/\\\\]/);\n  const result: string[] = [];\n  for (let i = 0; i < segments.length; i++) {\n    if (segments[i].length > 0) {\n      result.push(segments[i]);\n    }\n  }\n  return result.join('/');\n}\n"],"names":["normalizePath","p","segments","split","result","i","length","push","join"],"mappings":"AAAA;;;;;;;;CAQC;;;;+BAED;;;eAAwBA;;;AAAT,SAASA,cAAcC,CAAS;IAC7C,2FAA2F;IAC3F,IAAMC,WAAWD,EAAEE,KAAK,CAAC;IACzB,IAAMC,SAAmB,EAAE;IAC3B,IAAK,IAAIC,IAAI,GAAGA,IAAIH,SAASI,MAAM,EAAED,IAAK;QACxC,IAAIH,QAAQ,CAACG,EAAE,CAACC,MAAM,GAAG,GAAG;YAC1BF,OAAOG,IAAI,CAACL,QAAQ,CAACG,EAAE;QACzB;IACF;IACA,OAAOD,OAAOI,IAAI,CAAC;AACrB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/normalizePath.ts"],"sourcesContent":["/**\n * Normalize archive entry path\n *\n * - Converts backslashes to forward slashes\n * - Removes empty segments\n * - Removes leading slashes\n *\n * Node 0.8+ compatible.\n */\n\nexport default function normalizePath(p: string): string {\n  // Split on both forward and back slashes, filter empty segments, rejoin with forward slash\n  const segments = p.split(/[/\\\\]/);\n  const result: string[] = [];\n  for (let i = 0; i < segments.length; i++) {\n    if (segments[i].length > 0) {\n      result.push(segments[i]);\n    }\n  }\n  return result.join('/');\n}\n"],"names":["normalizePath","p","segments","split","result","i","length","push","join"],"mappings":"AAAA;;;;;;;;CAQC;;;;+BAED;;;eAAwBA;;;AAAT,SAASA,cAAcC,CAAS;IAC7C,2FAA2F;IAC3F,IAAMC,WAAWD,EAAEE,KAAK,CAAC;IACzB,IAAMC,SAAmB,EAAE;IAC3B,IAAK,IAAIC,IAAI,GAAGA,IAAIH,SAASI,MAAM,EAAED,IAAK;QACxC,IAAIH,QAAQ,CAACG,EAAE,CAACC,MAAM,GAAG,GAAG;YAC1BF,OAAOG,IAAI,CAACL,QAAQ,CAACG,EAAE;QACzB;IACF;IACA,OAAOD,OAAOI,IAAI,CAAC;AACrB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/shared/streamToString.ts"],"sourcesContent":["/**\n * Read entire stream content as string\n *\n * Handles both flowing streams and streams that have already\n * buffered data (using readable stream semantics).\n *\n * Node 0.8+ compatible.\n */\n\nimport oo from 'on-one';\nimport { bufferFrom } from './compat.ts';\n\nexport type StreamToStringCallback = (error?: Error, result?: string) => void;\n\nexport default function streamToString(stream: NodeJS.ReadableStream, callback: StreamToStringCallback): void {\n  const chunks: Buffer[] = [];\n\n  // Handle data from the stream\n  stream.on('data', (chunk: Buffer | string) => {\n    if (typeof chunk === 'string') {\n      chunks.push(bufferFrom(chunk, 'utf8'));\n    } else {\n      chunks.push(chunk);\n    }\n  });\n\n  // Handle stream end events using on-one for Node 0.8 compatibility\n  oo(stream, ['error', 'end', 'close'], (err?: Error) => {\n    if (err) {\n      callback(err);\n    } else {\n      const content = Buffer.concat(chunks).toString('utf8');\n      callback(null, content);\n    }\n  });\n\n  // Ensure stream is flowing (in case it's paused)\n  if (typeof (stream as NodeJS.ReadStream).resume === 'function') {\n    (stream as NodeJS.ReadStream).resume();\n  }\n}\n"],"names":["streamToString","stream","callback","chunks","on","chunk","push","bufferFrom","oo","err","content","Buffer","concat","toString","resume"],"mappings":"AAAA;;;;;;;CAOC;;;;+BAOD;;;eAAwBA;;;4DALT;wBACY;;;;;;AAIZ,SAASA,eAAeC,MAA6B,EAAEC,QAAgC;IACpG,IAAMC,SAAmB,EAAE;IAE3B,8BAA8B;IAC9BF,OAAOG,EAAE,CAAC,QAAQ,SAACC;QACjB,IAAI,OAAOA,UAAU,UAAU;YAC7BF,OAAOG,IAAI,CAACC,IAAAA,oBAAU,EAACF,OAAO;QAChC,OAAO;YACLF,OAAOG,IAAI,CAACD;QACd;IACF;IAEA,mEAAmE;IACnEG,IAAAA,cAAE,EAACP,QAAQ;QAAC;QAAS;QAAO;KAAQ,EAAE,SAACQ;QACrC,IAAIA,KAAK;YACPP,SAASO;QACX,OAAO;YACL,IAAMC,UAAUC,OAAOC,MAAM,CAACT,QAAQU,QAAQ,CAAC;YAC/CX,SAAS,MAAMQ;QACjB;IACF;IAEA,iDAAiD;IACjD,IAAI,OAAO,AAACT,OAA6Ba,MAAM,KAAK,YAAY;QAC7Db,OAA6Ba,MAAM;IACtC;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/streamToString.ts"],"sourcesContent":["/**\n * Read entire stream content as string\n *\n * Handles both flowing streams and streams that have already\n * buffered data (using readable stream semantics).\n *\n * Node 0.8+ compatible.\n */\n\nimport oo from 'on-one';\nimport { bufferFrom } from './compat.ts';\n\nexport type StreamToStringCallback = (error?: Error, result?: string) => void;\n\nexport default function streamToString(stream: NodeJS.ReadableStream, callback: StreamToStringCallback): void {\n  const chunks: Buffer[] = [];\n\n  // Handle data from the stream\n  stream.on('data', (chunk: Buffer | string) => {\n    if (typeof chunk === 'string') {\n      chunks.push(bufferFrom(chunk, 'utf8'));\n    } else {\n      chunks.push(chunk);\n    }\n  });\n\n  // Handle stream end events using on-one for Node 0.8 compatibility\n  oo(stream, ['error', 'end', 'close'], (err?: Error) => {\n    if (err) {\n      callback(err);\n    } else {\n      const content = Buffer.concat(chunks).toString('utf8');\n      callback(null, content);\n    }\n  });\n\n  // Ensure stream is flowing (in case it's paused)\n  if (typeof (stream as NodeJS.ReadStream).resume === 'function') {\n    (stream as NodeJS.ReadStream).resume();\n  }\n}\n"],"names":["streamToString","stream","callback","chunks","on","chunk","push","bufferFrom","oo","err","content","Buffer","concat","toString","resume"],"mappings":"AAAA;;;;;;;CAOC;;;;+BAOD;;;eAAwBA;;;4DALT;wBACY;;;;;;AAIZ,SAASA,eAAeC,MAA6B,EAAEC,QAAgC;IACpG,IAAMC,SAAmB,EAAE;IAE3B,8BAA8B;IAC9BF,OAAOG,EAAE,CAAC,QAAQ,SAACC;QACjB,IAAI,OAAOA,UAAU,UAAU;YAC7BF,OAAOG,IAAI,CAACC,IAAAA,oBAAU,EAACF,OAAO;QAChC,OAAO;YACLF,OAAOG,IAAI,CAACD;QACd;IACF;IAEA,mEAAmE;IACnEG,IAAAA,cAAE,EAACP,QAAQ;QAAC;QAAS;QAAO;KAAQ,EAAE,SAACQ;QACrC,IAAIA,KAAK;YACPP,SAASO;QACX,OAAO;YACL,IAAMC,UAAUC,OAAOC,MAAM,CAACT,QAAQU,QAAQ,CAAC;YAC/CX,SAAS,MAAMQ;QACjB;IACF;IAEA,iDAAiD;IACjD,IAAI,OAAO,AAACT,OAA6Ba,MAAM,KAAK,YAAY;QAC7Db,OAA6Ba,MAAM;IACtC;AACF"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/shared/stripPath.ts"],"sourcesContent":["import path from 'path';\n\nimport type { ExtractOptions } from '../types.ts';\n\nexport default function stripPath(relativePath: string, options: ExtractOptions): string {\n  const strip = options.strip || 0;\n  if (!strip) return relativePath;\n  const parts = relativePath.split(path.sep).filter(Boolean);\n  if (parts.length < strip) throw new Error(`You cannot strip more levels than there are directories. Strip: ${strip}. Path: ${relativePath}`);\n  return parts.slice(strip).join(path.sep);\n}\n"],"names":["stripPath","relativePath","options","strip","parts","split","path","sep","filter","Boolean","length","Error","slice","join"],"mappings":";;;;+BAIA;;;eAAwBA;;;2DAJP;;;;;;AAIF,SAASA,UAAUC,YAAoB,EAAEC,OAAuB;IAC7E,IAAMC,QAAQD,QAAQC,KAAK,IAAI;IAC/B,IAAI,CAACA,OAAO,OAAOF;IACnB,IAAMG,QAAQH,aAAaI,KAAK,CAACC,aAAI,CAACC,GAAG,EAAEC,MAAM,CAACC;IAClD,IAAIL,MAAMM,MAAM,GAAGP,OAAO,MAAM,IAAIQ,MAAM,AAAC,mEAAkFV,OAAhBE,OAAM,YAAuB,OAAbF;IAC7H,OAAOG,MAAMQ,KAAK,CAACT,OAAOU,IAAI,CAACP,aAAI,CAACC,GAAG;AACzC"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/stripPath.ts"],"sourcesContent":["import path from 'path';\n\nimport type { ExtractOptions } from '../types.ts';\n\nexport default function stripPath(relativePath: string, options: ExtractOptions): string {\n  const strip = options.strip || 0;\n  if (!strip) return relativePath;\n  const parts = relativePath.split(path.sep).filter(Boolean);\n  if (parts.length < strip) throw new Error(`You cannot strip more levels than there are directories. Strip: ${strip}. Path: ${relativePath}`);\n  return parts.slice(strip).join(path.sep);\n}\n"],"names":["stripPath","relativePath","options","strip","parts","split","path","sep","filter","Boolean","length","Error","slice","join"],"mappings":";;;;+BAIA;;;eAAwBA;;;2DAJP;;;;;;AAIF,SAASA,UAAUC,YAAoB,EAAEC,OAAuB;IAC7E,IAAMC,QAAQD,QAAQC,KAAK,IAAI;IAC/B,IAAI,CAACA,OAAO,OAAOF;IACnB,IAAMG,QAAQH,aAAaI,KAAK,CAACC,aAAI,CAACC,GAAG,EAAEC,MAAM,CAACC;IAClD,IAAIL,MAAMM,MAAM,GAAGP,OAAO,MAAM,IAAIQ,MAAM,AAAC,mEAAkFV,OAAhBE,OAAM,YAAuB,OAAbF;IAC7H,OAAOG,MAAMQ,KAAK,CAACT,OAAOU,IAAI,CAACP,aAAI,CAACC,GAAG;AACzC"}

package/dist/cjs/validateAttributes.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/validateAttributes.ts"],"sourcesContent":["export default function validateAttributes(attributes: object, keys: string[]): void {\n  for (let index = 0; index < keys.length; index++) {\n    const key = keys[index];\n    if (attributes[key] === undefined) throw new Error(`Missing attribute ${key}.Attributes ${JSON.stringify(attributes)}`);\n  }\n}\n"],"names":["validateAttributes","attributes","keys","index","length","key","undefined","Error","JSON","stringify"],"mappings":";;;;+BAAA;;;eAAwBA;;;AAAT,SAASA,mBAAmBC,UAAkB,EAAEC,IAAc;IAC3E,IAAK,IAAIC,QAAQ,GAAGA,QAAQD,KAAKE,MAAM,EAAED,QAAS;QAChD,IAAME,MAAMH,IAAI,CAACC,MAAM;QACvB,IAAIF,UAAU,CAACI,IAAI,KAAKC,WAAW,MAAM,IAAIC,MAAM,AAAC,qBAAsCC,OAAlBH,KAAI,gBAAyC,OAA3BG,KAAKC,SAAS,CAACR;IAC3G;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/validateAttributes.ts"],"sourcesContent":["export default function validateAttributes(attributes: object, keys: string[]): void {\n  for (let index = 0; index < keys.length; index++) {\n    const key = keys[index];\n    if (attributes[key] === undefined) throw new Error(`Missing attribute ${key}.Attributes ${JSON.stringify(attributes)}`);\n  }\n}\n"],"names":["validateAttributes","attributes","keys","index","length","key","undefined","Error","JSON","stringify"],"mappings":";;;;+BAAA;;;eAAwBA;;;AAAT,SAASA,mBAAmBC,UAAkB,EAAEC,IAAc;IAC3E,IAAK,IAAIC,QAAQ,GAAGA,QAAQD,KAAKE,MAAM,EAAED,QAAS;QAChD,IAAME,MAAMH,IAAI,CAACC,MAAM;QACvB,IAAIF,UAAU,CAACI,IAAI,KAAKC,WAAW,MAAM,IAAIC,MAAM,AAAC,qBAAsCC,OAAlBH,KAAI,gBAAyC,OAA3BG,KAAKC,SAAS,CAACR;IAC3G;AACF"}

package/dist/cjs/waitForAccess.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/waitForAccess.ts"],"sourcesContent":["import fs from 'graceful-fs';\n\nimport type { NoParamCallback } from './types.ts';\n\n// Backward compatible: waitForAccess(path, callback) or waitForAccess(path, noFollow, callback)\nexport default function waitForAccess(fullPath: string, noFollow: boolean | NoParamCallback, callback?: NoParamCallback | number) {\n  callback = typeof noFollow === 'function' ? noFollow : callback;\n  noFollow = typeof noFollow === 'function' ? false : (noFollow as boolean);\n\n  // Exponential backoff: 5, 10, 20, 40, 80, 160, 320, 640, 1280, 2560ms\n  // Total max wait: ~5 seconds\n  function waitSymlink(attempts, cb) {\n    fs.lstat(fullPath, (err) => {\n      if (err) {\n        if (err.code === 'ENOENT' && attempts < 10) {\n          const delay = Math.min(5 * 2 ** attempts, 2560);\n          return setTimeout(() => waitSymlink(attempts + 1, cb), delay);\n        }\n        return cb(err);\n      }\n      cb();\n    });\n  }\n  function waitOpen(attempts, cb) {\n    fs.open(fullPath, 'r', (err, fd) => {\n      if (err) {\n        if (err.code === 'ENOENT' && attempts < 10) {\n          const delay = Math.min(5 * 2 ** attempts, 2560);\n          return setTimeout(() => waitOpen(attempts + 1, cb), delay);\n        }\n        return cb(err);\n      }\n      fs.close(fd, () => cb());\n    });\n  }\n\n  // Windows: NTFS metadata may not be committed yet, verify accessibility\n  // Node 0.10: the write stream's finish/close events may fire before the file is fully flushed to disk\n  // For symlinks (noFollow=true), use lstat to check the link itself exists\n  // For files/dirs/hardlinks, use open to verify the file is accessible\n  noFollow ? waitSymlink(0, callback) : waitOpen(0, callback);\n}\n"],"names":["waitForAccess","fullPath","noFollow","callback","waitSymlink","attempts","cb","fs","lstat","err","code","delay","Math","min","setTimeout","waitOpen","open","fd","close"],"mappings":";;;;+BAIA,gGAAgG;AAChG;;;eAAwBA;;;iEALT;;;;;;AAKA,SAASA,cAAcC,QAAgB,EAAEC,QAAmC,EAAEC,QAAmC;IAC9HA,WAAW,OAAOD,aAAa,aAAaA,WAAWC;IACvDD,WAAW,OAAOA,aAAa,aAAa,QAASA;IAErD,sEAAsE;IACtE,6BAA6B;IAC7B,SAASE,YAAYC,QAAQ,EAAEC,EAAE;QAC/BC,mBAAE,CAACC,KAAK,CAACP,UAAU,SAACQ;YAClB,IAAIA,KAAK;gBACP,IAAIA,IAAIC,IAAI,KAAK,YAAYL,WAAW,IAAI;oBAC1C,IAAMM,QAAQC,KAAKC,GAAG,CAAC,aAAI,GAAKR,WAAU;oBAC1C,OAAOS,WAAW;+BAAMV,YAAYC,WAAW,GAAGC;uBAAKK;gBACzD;gBACA,OAAOL,GAAGG;YACZ;YACAH;QACF;IACF;IACA,SAASS,SAASV,QAAQ,EAAEC,EAAE;QAC5BC,mBAAE,CAACS,IAAI,CAACf,UAAU,KAAK,SAACQ,KAAKQ;YAC3B,IAAIR,KAAK;gBACP,IAAIA,IAAIC,IAAI,KAAK,YAAYL,WAAW,IAAI;oBAC1C,IAAMM,QAAQC,KAAKC,GAAG,CAAC,aAAI,GAAKR,WAAU;oBAC1C,OAAOS,WAAW;+BAAMC,SAASV,WAAW,GAAGC;uBAAKK;gBACtD;gBACA,OAAOL,GAAGG;YACZ;YACAF,mBAAE,CAACW,KAAK,CAACD,IAAI;uBAAMX;;QACrB;IACF;IAEA,wEAAwE;IACxE,sGAAsG;IACtG,0EAA0E;IAC1E,sEAAsE;IACtEJ,WAAWE,YAAY,GAAGD,YAAYY,SAAS,GAAGZ;AACpD"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/waitForAccess.ts"],"sourcesContent":["import fs from 'graceful-fs';\n\nimport type { NoParamCallback } from './types.ts';\n\n// Backward compatible: waitForAccess(path, callback) or waitForAccess(path, noFollow, callback)\nexport default function waitForAccess(fullPath: string, noFollow: boolean | NoParamCallback, callback?: NoParamCallback | number) {\n  callback = typeof noFollow === 'function' ? noFollow : callback;\n  noFollow = typeof noFollow === 'function' ? false : (noFollow as boolean);\n\n  // Exponential backoff: 5, 10, 20, 40, 80, 160, 320, 640, 1280, 2560ms\n  // Total max wait: ~5 seconds\n  function waitSymlink(attempts, cb) {\n    fs.lstat(fullPath, (err) => {\n      if (err) {\n        if (err.code === 'ENOENT' && attempts < 10) {\n          const delay = Math.min(5 * 2 ** attempts, 2560);\n          return setTimeout(() => waitSymlink(attempts + 1, cb), delay);\n        }\n        return cb(err);\n      }\n      cb();\n    });\n  }\n  function waitOpen(attempts, cb) {\n    fs.open(fullPath, 'r', (err, fd) => {\n      if (err) {\n        if (err.code === 'ENOENT' && attempts < 10) {\n          const delay = Math.min(5 * 2 ** attempts, 2560);\n          return setTimeout(() => waitOpen(attempts + 1, cb), delay);\n        }\n        return cb(err);\n      }\n      fs.close(fd, () => cb());\n    });\n  }\n\n  // Windows: NTFS metadata may not be committed yet, verify accessibility\n  // Node 0.10: the write stream's finish/close events may fire before the file is fully flushed to disk\n  // For symlinks (noFollow=true), use lstat to check the link itself exists\n  // For files/dirs/hardlinks, use open to verify the file is accessible\n  noFollow ? waitSymlink(0, callback) : waitOpen(0, callback);\n}\n"],"names":["waitForAccess","fullPath","noFollow","callback","waitSymlink","attempts","cb","fs","lstat","err","code","delay","Math","min","setTimeout","waitOpen","open","fd","close"],"mappings":";;;;+BAIA,gGAAgG;AAChG;;;eAAwBA;;;iEALT;;;;;;AAKA,SAASA,cAAcC,QAAgB,EAAEC,QAAmC,EAAEC,QAAmC;IAC9HA,WAAW,OAAOD,aAAa,aAAaA,WAAWC;IACvDD,WAAW,OAAOA,aAAa,aAAa,QAASA;IAErD,sEAAsE;IACtE,6BAA6B;IAC7B,SAASE,YAAYC,QAAQ,EAAEC,EAAE;QAC/BC,mBAAE,CAACC,KAAK,CAACP,UAAU,SAACQ;YAClB,IAAIA,KAAK;gBACP,IAAIA,IAAIC,IAAI,KAAK,YAAYL,WAAW,IAAI;oBAC1C,IAAMM,QAAQC,KAAKC,GAAG,CAAC,aAAI,GAAKR,WAAU;oBAC1C,OAAOS,WAAW;+BAAMV,YAAYC,WAAW,GAAGC;uBAAKK;gBACzD;gBACA,OAAOL,GAAGG;YACZ;YACAH;QACF;IACF;IACA,SAASS,SAASV,QAAQ,EAAEC,EAAE;QAC5BC,mBAAE,CAACS,IAAI,CAACf,UAAU,KAAK,SAACQ,KAAKQ;YAC3B,IAAIR,KAAK;gBACP,IAAIA,IAAIC,IAAI,KAAK,YAAYL,WAAW,IAAI;oBAC1C,IAAMM,QAAQC,KAAKC,GAAG,CAAC,aAAI,GAAKR,WAAU;oBAC1C,OAAOS,WAAW;+BAAMC,SAASV,WAAW,GAAGC;uBAAKK;gBACtD;gBACA,OAAOL,GAAGG;YACZ;YACAF,mBAAE,CAACW,KAAK,CAACD,IAAI;uBAAMX;;QACrB;IACF;IAEA,wEAAwE;IACxE,sGAAsG;IACtG,0EAA0E;IAC1E,sEAAsE;IACtEJ,WAAWE,YAAY,GAAGD,YAAYY,SAAS,GAAGZ;AACpD"}

package/dist/esm/DirectoryEntry.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/DirectoryEntry.ts"],"sourcesContent":["import 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'];\n\nimport type { Mode } from 'fs';\nimport type { DirectoryAttributes, ExtractOptions, NoParamCallback } from './types.ts';\n\nexport default class DirectoryEntry {\n  mode: Mode;\n  mtime: number;\n  path: string;\n  basename: string;\n  type: string;\n\n  constructor(attributes: DirectoryAttributes) {\n    validateAttributes(attributes, MANDATORY_ATTRIBUTES);\n    objectAssign(this, attributes);\n    if (this.type === undefined) this.type = 'directory';\n    if (this.basename === undefined) this.basename = path.basename(this.path);\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\n        // do not check for the existence of the directory but allow out-of-order calling\n        const queue = new Queue(1);\n        queue.defer(mkdirp.bind(null, 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":["mkdirp","path","Queue","chmod","chown","utimes","objectAssign","stripPath","validateAttributes","waitForAccess","MANDATORY_ATTRIBUTES","DirectoryEntry","create","dest","options","callback","normalizedPath","normalize","fullPath","join","queue","defer","bind","await","err","Promise","resolve","reject","done","destroy","attributes","type","undefined","basename"],"mappings":"AAAA,OAAOA,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;CAAO;AAKvC,IAAA,AAAMC,iBAAN,MAAMA;IAiBnBC,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;gBAE3D,iFAAiF;gBACjF,MAAMM,QAAQ,IAAIlB,MAAM;gBACxBkB,MAAMC,KAAK,CAACrB,OAAOsB,IAAI,CAAC,MAAMJ;gBAC9BE,MAAMC,KAAK,CAACZ,cAAca,IAAI,CAAC,MAAMJ;gBACrCE,MAAMC,KAAK,CAAClB,MAAMmB,IAAI,CAAC,MAAMJ,UAAU,IAAI,EAAEJ;gBAC7CM,MAAMC,KAAK,CAACjB,MAAMkB,IAAI,CAAC,MAAMJ,UAAU,IAAI,EAAEJ;gBAC7CM,MAAMC,KAAK,CAAChB,OAAOiB,IAAI,CAAC,MAAMJ,UAAU,IAAI,EAAEJ;gBAC9CM,MAAMG,KAAK,CAACR;gBACZ;YACF,EAAE,OAAOS,KAAK;gBACZT,SAASS;gBACT;YACF;QACF;QAEA,OAAO,IAAIC,QAAQ,CAACC,SAASC;YAC3B,IAAI,CAACf,MAAM,CAACC,MAAMC,SAAS,CAACU,KAAaI,OAAoBJ,MAAMG,OAAOH,OAAOE,QAAQE;QAC3F;IACF;IAEAC,UAAU,CAAC;IAvCX,YAAYC,UAA+B,CAAE;QAC3CtB,mBAAmBsB,YAAYpB;QAC/BJ,aAAa,IAAI,EAAEwB;QACnB,IAAI,IAAI,CAACC,IAAI,KAAKC,WAAW,IAAI,CAACD,IAAI,GAAG;QACzC,IAAI,IAAI,CAACE,QAAQ,KAAKD,WAAW,IAAI,CAACC,QAAQ,GAAGhC,KAAKgC,QAAQ,CAAC,IAAI,CAAChC,IAAI;IAC1E;AAmCF;AA/CA,SAAqBU,4BA+CpB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/DirectoryEntry.ts"],"sourcesContent":["import 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'];\n\nimport type { Mode } from 'fs';\nimport type { DirectoryAttributes, ExtractOptions, NoParamCallback } from './types.ts';\n\nexport default class DirectoryEntry {\n  mode: Mode;\n  mtime: number;\n  path: string;\n  basename: string;\n  type: string;\n\n  constructor(attributes: DirectoryAttributes) {\n    validateAttributes(attributes, MANDATORY_ATTRIBUTES);\n    objectAssign(this, attributes);\n    if (this.type === undefined) this.type = 'directory';\n    if (this.basename === undefined) this.basename = path.basename(this.path);\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\n        // do not check for the existence of the directory but allow out-of-order calling\n        const queue = new Queue(1);\n        queue.defer(mkdirp.bind(null, 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":["mkdirp","path","Queue","chmod","chown","utimes","objectAssign","stripPath","validateAttributes","waitForAccess","MANDATORY_ATTRIBUTES","DirectoryEntry","create","dest","options","callback","normalizedPath","normalize","fullPath","join","queue","defer","bind","await","err","Promise","resolve","reject","done","destroy","attributes","type","undefined","basename"],"mappings":"AAAA,OAAOA,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;CAAO;AAKvC,IAAA,AAAMC,iBAAN,MAAMA;IAiBnBC,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;gBAE3D,iFAAiF;gBACjF,MAAMM,QAAQ,IAAIlB,MAAM;gBACxBkB,MAAMC,KAAK,CAACrB,OAAOsB,IAAI,CAAC,MAAMJ;gBAC9BE,MAAMC,KAAK,CAACZ,cAAca,IAAI,CAAC,MAAMJ;gBACrCE,MAAMC,KAAK,CAAClB,MAAMmB,IAAI,CAAC,MAAMJ,UAAU,IAAI,EAAEJ;gBAC7CM,MAAMC,KAAK,CAACjB,MAAMkB,IAAI,CAAC,MAAMJ,UAAU,IAAI,EAAEJ;gBAC7CM,MAAMC,KAAK,CAAChB,OAAOiB,IAAI,CAAC,MAAMJ,UAAU,IAAI,EAAEJ;gBAC9CM,MAAMG,KAAK,CAACR;gBACZ;YACF,EAAE,OAAOS,KAAK;gBACZT,SAASS;gBACT;YACF;QACF;QAEA,OAAO,IAAIC,QAAQ,CAACC,SAASC;YAC3B,IAAI,CAACf,MAAM,CAACC,MAAMC,SAAS,CAACU,KAAaI,OAAoBJ,MAAMG,OAAOH,OAAOE,QAAQE;QAC3F;IACF;IAEAC,UAAU,CAAC;IAvCX,YAAYC,UAA+B,CAAE;QAC3CtB,mBAAmBsB,YAAYpB;QAC/BJ,aAAa,IAAI,EAAEwB;QACnB,IAAI,IAAI,CAACC,IAAI,KAAKC,WAAW,IAAI,CAACD,IAAI,GAAG;QACzC,IAAI,IAAI,CAACE,QAAQ,KAAKD,WAAW,IAAI,CAACC,QAAQ,GAAGhC,KAAKgC,QAAQ,CAAC,IAAI,CAAChC,IAAI;IAC1E;AAmCF;AA/CA,SAAqBU,4BA+CpB"}

package/dist/esm/FileEntry.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/FileEntry.ts"],"sourcesContent":["import { rm } from 'fs-remove-compat';\nimport fs from 'graceful-fs';\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'];\n\nimport type { Mode } from 'fs';\nimport type { ExtractOptions, FileAttributes, NoParamCallback, WriteFileFn } from './types.ts';\n\ninterface AbstractFileEntry {\n  _writeFile: WriteFileFn;\n}\n\nexport default class FileEntry {\n  mode: Mode;\n  mtime: number;\n  path: string;\n  basename: string;\n  type: string;\n\n  constructor(attributes: FileAttributes) {\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 = 'file';\n    if ((this as unknown as AbstractFileEntry)._writeFile === undefined) throw new Error('File this missing _writeFile. Please implement this method in your subclass');\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\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        } else {\n          // Check if file exists - throw EEXIST if it does\n          queue.defer((callback) => {\n            fs.stat(fullPath, (err) => {\n              if (!err) {\n                const existsErr = new Error(`EEXIST: file already exists, open '${fullPath}'`) as NodeJS.ErrnoException;\n                existsErr.code = 'EEXIST';\n                existsErr.path = fullPath;\n                return callback(existsErr);\n              }\n              // ENOENT means file doesn't exist - that's what we want\n              if (err.code === 'ENOENT') return callback();\n              // Other errors should be reported\n              callback(err);\n            });\n          });\n        }\n        queue.defer(mkdirp.bind(null, path.dirname(fullPath)));\n        queue.defer((this as unknown as AbstractFileEntry)._writeFile.bind(this, fullPath, options));\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":["rm","fs","mkdirp","path","Queue","chmod","chown","utimes","objectAssign","stripPath","validateAttributes","waitForAccess","MANDATORY_ATTRIBUTES","FileEntry","create","dest","options","callback","normalizedPath","normalize","fullPath","join","queue","force","defer","err","code","stat","existsErr","Error","bind","dirname","_writeFile","await","Promise","resolve","reject","done","destroy","attributes","basename","undefined","type"],"mappings":"AAAA,SAASA,EAAE,QAAQ,mBAAmB;AACtC,OAAOC,QAAQ,cAAc;AAC7B,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;CAAO;AASvC,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;gBAE3D,MAAMM,QAAQ,IAAIlB,MAAM;gBACxB,IAAIY,QAAQO,KAAK,EAAE;oBACjBD,MAAME,KAAK,CAAC,CAACP;wBACXjB,GAAGoB,UAAU,CAACK;4BACZA,OAAOA,IAAIC,IAAI,KAAK,WAAWT,SAASQ,OAAOR;wBACjD;oBACF;gBACF,OAAO;oBACL,iDAAiD;oBACjDK,MAAME,KAAK,CAAC,CAACP;wBACXhB,GAAG0B,IAAI,CAACP,UAAU,CAACK;4BACjB,IAAI,CAACA,KAAK;gCACR,MAAMG,YAAY,IAAIC,MAAM,CAAC,mCAAmC,EAAET,SAAS,CAAC,CAAC;gCAC7EQ,UAAUF,IAAI,GAAG;gCACjBE,UAAUzB,IAAI,GAAGiB;gCACjB,OAAOH,SAASW;4BAClB;4BACA,wDAAwD;4BACxD,IAAIH,IAAIC,IAAI,KAAK,UAAU,OAAOT;4BAClC,kCAAkC;4BAClCA,SAASQ;wBACX;oBACF;gBACF;gBACAH,MAAME,KAAK,CAACtB,OAAO4B,IAAI,CAAC,MAAM3B,KAAK4B,OAAO,CAACX;gBAC3CE,MAAME,KAAK,CAAC,AAAC,IAAI,CAAkCQ,UAAU,CAACF,IAAI,CAAC,IAAI,EAAEV,UAAUJ;gBACnFM,MAAME,KAAK,CAACb,cAAcmB,IAAI,CAAC,MAAMV;gBACrCE,MAAME,KAAK,CAACnB,MAAMyB,IAAI,CAAC,MAAMV,UAAU,IAAI,EAAEJ;gBAC7CM,MAAME,KAAK,CAAClB,MAAMwB,IAAI,CAAC,MAAMV,UAAU,IAAI,EAAEJ;gBAC7CM,MAAME,KAAK,CAACjB,OAAOuB,IAAI,CAAC,MAAMV,UAAU,IAAI,EAAEJ;gBAC9CM,MAAMW,KAAK,CAAChB;gBACZ;YACF,EAAE,OAAOQ,KAAK;gBACZR,SAASQ;gBACT;YACF;QACF;QAEA,OAAO,IAAIS,QAAQ,CAACC,SAASC;YAC3B,IAAI,CAACtB,MAAM,CAACC,MAAMC,SAAS,CAACS,KAAaY,OAAoBZ,MAAMW,OAAOX,OAAOU,QAAQE;QAC3F;IACF;IAEAC,UAAU,CAAC;IA/DX,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;QACzC,IAAI,AAAC,IAAI,CAAkCV,UAAU,KAAKS,WAAW,MAAM,IAAIZ,MAAM;IACvF;AA0DF;AAvEA,SAAqBhB,uBAuEpB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/FileEntry.ts"],"sourcesContent":["import { rm } from 'fs-remove-compat';\nimport fs from 'graceful-fs';\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'];\n\nimport type { Mode } from 'fs';\nimport type { ExtractOptions, FileAttributes, NoParamCallback, WriteFileFn } from './types.ts';\n\ninterface AbstractFileEntry {\n  _writeFile: WriteFileFn;\n}\n\nexport default class FileEntry {\n  mode: Mode;\n  mtime: number;\n  path: string;\n  basename: string;\n  type: string;\n\n  constructor(attributes: FileAttributes) {\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 = 'file';\n    if ((this as unknown as AbstractFileEntry)._writeFile === undefined) throw new Error('File this missing _writeFile. Please implement this method in your subclass');\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\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        } else {\n          // Check if file exists - throw EEXIST if it does\n          queue.defer((callback) => {\n            fs.stat(fullPath, (err) => {\n              if (!err) {\n                const existsErr = new Error(`EEXIST: file already exists, open '${fullPath}'`) as NodeJS.ErrnoException;\n                existsErr.code = 'EEXIST';\n                existsErr.path = fullPath;\n                return callback(existsErr);\n              }\n              // ENOENT means file doesn't exist - that's what we want\n              if (err.code === 'ENOENT') return callback();\n              // Other errors should be reported\n              callback(err);\n            });\n          });\n        }\n        queue.defer(mkdirp.bind(null, path.dirname(fullPath)));\n        queue.defer((this as unknown as AbstractFileEntry)._writeFile.bind(this, fullPath, options));\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":["rm","fs","mkdirp","path","Queue","chmod","chown","utimes","objectAssign","stripPath","validateAttributes","waitForAccess","MANDATORY_ATTRIBUTES","FileEntry","create","dest","options","callback","normalizedPath","normalize","fullPath","join","queue","force","defer","err","code","stat","existsErr","Error","bind","dirname","_writeFile","await","Promise","resolve","reject","done","destroy","attributes","basename","undefined","type"],"mappings":"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"}

package/dist/esm/LinkEntry.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/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(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"}

package/dist/esm/SymbolicLinkEntry.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/SymbolicLinkEntry.ts"],"sourcesContent":["import fs from 'fs';\nimport { rm } from 'fs-remove-compat';\nimport isAbsolute from 'is-absolute';\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 lutimes from './fs/lutimes.ts';\nimport symlinkWin32 from './fs/symlinkWin32.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 isWindows = process.platform === 'win32' || /^(msys|cygwin)$/.test(process.env.OSTYPE);\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 SymbolicLinkEntry {\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 = 'symlink';\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        let normalizedLinkpath = path.normalize(this.linkpath);\n        let linkFullPath = path.join(dest, stripPath(normalizedLinkpath, options));\n        if (!isAbsolute(normalizedLinkpath)) {\n          const linkRelativePath = path.join(path.dirname(normalizedPath), this.linkpath);\n          linkFullPath = path.join(dest, stripPath(linkRelativePath, options));\n          normalizedLinkpath = path.relative(path.dirname(fullPath), linkFullPath);\n        }\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        if (isWindows) queue.defer(symlinkWin32.bind(null, linkFullPath, normalizedLinkpath, fullPath));\n        else queue.defer(fs.symlink.bind(fs, normalizedLinkpath, fullPath));\n        queue.defer(waitForAccess.bind(null, fullPath, true)); // noFollow=true for symlinks\n        queue.defer(chmod.bind(null, fullPath, this, options));\n        queue.defer(chown.bind(null, fullPath, this, options));\n        queue.defer(lutimes.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","isAbsolute","mkdirp","path","Queue","chmod","chown","lutimes","symlinkWin32","objectAssign","stripPath","validateAttributes","waitForAccess","isWindows","process","platform","test","env","OSTYPE","MANDATORY_ATTRIBUTES","SymbolicLinkEntry","create","dest","options","callback","normalizedPath","normalize","fullPath","join","normalizedLinkpath","linkpath","linkFullPath","linkRelativePath","dirname","relative","queue","force","defer","err","code","bind","symlink","await","Promise","resolve","reject","done","destroy","attributes","basename","undefined","type"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/SymbolicLinkEntry.ts"],"sourcesContent":["import fs from 'fs';\nimport { rm } from 'fs-remove-compat';\nimport isAbsolute from 'is-absolute';\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 lutimes from './fs/lutimes.ts';\nimport symlinkWin32 from './fs/symlinkWin32.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 isWindows = process.platform === 'win32' || /^(msys|cygwin)$/.test(process.env.OSTYPE);\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 SymbolicLinkEntry {\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 = 'symlink';\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        let normalizedLinkpath = path.normalize(this.linkpath);\n        let linkFullPath = path.join(dest, stripPath(normalizedLinkpath, options));\n        if (!isAbsolute(normalizedLinkpath)) {\n          const linkRelativePath = path.join(path.dirname(normalizedPath), this.linkpath);\n          linkFullPath = path.join(dest, stripPath(linkRelativePath, options));\n          normalizedLinkpath = path.relative(path.dirname(fullPath), linkFullPath);\n        }\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        if (isWindows) queue.defer(symlinkWin32.bind(null, linkFullPath, normalizedLinkpath, fullPath));\n        else queue.defer(fs.symlink.bind(fs, normalizedLinkpath, fullPath));\n        queue.defer(waitForAccess.bind(null, fullPath, true)); // noFollow=true for symlinks\n        queue.defer(chmod.bind(null, fullPath, this, options));\n        queue.defer(chown.bind(null, fullPath, this, options));\n        queue.defer(lutimes.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","isAbsolute","mkdirp","path","Queue","chmod","chown","lutimes","symlinkWin32","objectAssign","stripPath","validateAttributes","waitForAccess","isWindows","process","platform","test","env","OSTYPE","MANDATORY_ATTRIBUTES","SymbolicLinkEntry","create","dest","options","callback","normalizedPath","normalize","fullPath","join","normalizedLinkpath","linkpath","linkFullPath","linkRelativePath","dirname","relative","queue","force","defer","err","code","bind","symlink","await","Promise","resolve","reject","done","destroy","attributes","basename","undefined","type"],"mappings":"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"}

package/dist/esm/fs/chmod.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/fs/chmod.ts"],"sourcesContent":["// adapted from https://github.com/mafintosh/tar-fs\n\nimport fs, { type NoParamCallback } from 'fs';\nimport type { AbstractEntry, ExtractOptions } from '../types.ts';\n\nconst UMASK = process.umask ? process.umask() : null;\nconst DMODE = 0o755;\nconst FMODE = 0o644;\nconst SMODE = 0o755;\nconst LMODE = 0o644;\n\nexport default function chmodFn(fullPath: string, entry: AbstractEntry, _options: ExtractOptions, callback: NoParamCallback) {\n  const chmod = entry.type === 'symlink' ? fs.lchmod : fs.chmod;\n  if (!chmod || UMASK === null) return callback(null);\n\n  let mode = entry.mode;\n  if (!mode) {\n    switch (entry.type) {\n      case 'directory':\n        mode = DMODE;\n        break;\n      case 'file':\n        mode = FMODE;\n        break;\n      case 'symlink':\n        mode = SMODE;\n        break;\n      case 'link':\n        mode = LMODE;\n        break;\n    }\n  }\n  chmod(fullPath, (mode as number) & ~UMASK, callback);\n}\n"],"names":["fs","UMASK","process","umask","DMODE","FMODE","SMODE","LMODE","chmodFn","fullPath","entry","_options","callback","chmod","type","lchmod","mode"],"mappings":"AAAA,mDAAmD;AAEnD,OAAOA,QAAkC,KAAK;AAG9C,MAAMC,QAAQC,QAAQC,KAAK,GAAGD,QAAQC,KAAK,KAAK;AAChD,MAAMC,QAAQ;AACd,MAAMC,QAAQ;AACd,MAAMC,QAAQ;AACd,MAAMC,QAAQ;AAEd,eAAe,SAASC,QAAQC,QAAgB,EAAEC,KAAoB,EAAEC,QAAwB,EAAEC,QAAyB;IACzH,MAAMC,QAAQH,MAAMI,IAAI,KAAK,YAAYd,GAAGe,MAAM,GAAGf,GAAGa,KAAK;IAC7D,IAAI,CAACA,SAASZ,UAAU,MAAM,OAAOW,SAAS;IAE9C,IAAII,OAAON,MAAMM,IAAI;IACrB,IAAI,CAACA,MAAM;QACT,OAAQN,MAAMI,IAAI;YAChB,KAAK;gBACHE,OAAOZ;gBACP;YACF,KAAK;gBACHY,OAAOX;gBACP;YACF,KAAK;gBACHW,OAAOV;gBACP;YACF,KAAK;gBACHU,OAAOT;gBACP;QACJ;IACF;IACAM,MAAMJ,UAAU,AAACO,OAAkB,CAACf,OAAOW;AAC7C"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/fs/chmod.ts"],"sourcesContent":["// adapted from https://github.com/mafintosh/tar-fs\n\nimport fs, { type NoParamCallback } from 'fs';\nimport type { AbstractEntry, ExtractOptions } from '../types.ts';\n\nconst UMASK = process.umask ? process.umask() : null;\nconst DMODE = 0o755;\nconst FMODE = 0o644;\nconst SMODE = 0o755;\nconst LMODE = 0o644;\n\nexport default function chmodFn(fullPath: string, entry: AbstractEntry, _options: ExtractOptions, callback: NoParamCallback) {\n  const chmod = entry.type === 'symlink' ? fs.lchmod : fs.chmod;\n  if (!chmod || UMASK === null) return callback(null);\n\n  let mode = entry.mode;\n  if (!mode) {\n    switch (entry.type) {\n      case 'directory':\n        mode = DMODE;\n        break;\n      case 'file':\n        mode = FMODE;\n        break;\n      case 'symlink':\n        mode = SMODE;\n        break;\n      case 'link':\n        mode = LMODE;\n        break;\n    }\n  }\n  chmod(fullPath, (mode as number) & ~UMASK, callback);\n}\n"],"names":["fs","UMASK","process","umask","DMODE","FMODE","SMODE","LMODE","chmodFn","fullPath","entry","_options","callback","chmod","type","lchmod","mode"],"mappings":"AAAA,mDAAmD;AAEnD,OAAOA,QAAkC,KAAK;AAG9C,MAAMC,QAAQC,QAAQC,KAAK,GAAGD,QAAQC,KAAK,KAAK;AAChD,MAAMC,QAAQ;AACd,MAAMC,QAAQ;AACd,MAAMC,QAAQ;AACd,MAAMC,QAAQ;AAEd,eAAe,SAASC,QAAQC,QAAgB,EAAEC,KAAoB,EAAEC,QAAwB,EAAEC,QAAyB;IACzH,MAAMC,QAAQH,MAAMI,IAAI,KAAK,YAAYd,GAAGe,MAAM,GAAGf,GAAGa,KAAK;IAC7D,IAAI,CAACA,SAASZ,UAAU,MAAM,OAAOW,SAAS;IAE9C,IAAII,OAAON,MAAMM,IAAI;IACrB,IAAI,CAACA,MAAM;QACT,OAAQN,MAAMI,IAAI;YAChB,KAAK;gBACHE,OAAOZ;gBACP;YACF,KAAK;gBACHY,OAAOX;gBACP;YACF,KAAK;gBACHW,OAAOV;gBACP;YACF,KAAK;gBACHU,OAAOT;gBACP;QACJ;IACF;IACAM,MAAMJ,UAAU,AAACO,OAAkB,CAACf,OAAOW;AAC7C"}

package/dist/esm/fs/chown.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/fs/chown.ts"],"sourcesContent":["// adapted from https://github.com/mafintosh/tar-fs\n\nimport fs, { type NoParamCallback } from 'fs';\nimport type { AbstractEntry, ExtractOptions } from '../types.ts';\n\nconst UID = process.getuid ? process.getuid() : -1;\nconst OWN = process.platform !== 'win32' && UID === 0;\n\nexport default function chownFn(fullPath: string, entry: AbstractEntry, _options: ExtractOptions, callback: NoParamCallback) {\n  const chown = entry.type === 'symlink' ? fs.lchown : fs.chown;\n  if (!chown || !OWN || !entry.uid || !entry.gid) return callback(null);\n  chown(fullPath, entry.uid, entry.gid, callback);\n}\n"],"names":["fs","UID","process","getuid","OWN","platform","chownFn","fullPath","entry","_options","callback","chown","type","lchown","uid","gid"],"mappings":"AAAA,mDAAmD;AAEnD,OAAOA,QAAkC,KAAK;AAG9C,MAAMC,MAAMC,QAAQC,MAAM,GAAGD,QAAQC,MAAM,KAAK,CAAC;AACjD,MAAMC,MAAMF,QAAQG,QAAQ,KAAK,WAAWJ,QAAQ;AAEpD,eAAe,SAASK,QAAQC,QAAgB,EAAEC,KAAoB,EAAEC,QAAwB,EAAEC,QAAyB;IACzH,MAAMC,QAAQH,MAAMI,IAAI,KAAK,YAAYZ,GAAGa,MAAM,GAAGb,GAAGW,KAAK;IAC7D,IAAI,CAACA,SAAS,CAACP,OAAO,CAACI,MAAMM,GAAG,IAAI,CAACN,MAAMO,GAAG,EAAE,OAAOL,SAAS;IAChEC,MAAMJ,UAAUC,MAAMM,GAAG,EAAEN,MAAMO,GAAG,EAAEL;AACxC"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/fs/chown.ts"],"sourcesContent":["// adapted from https://github.com/mafintosh/tar-fs\n\nimport fs, { type NoParamCallback } from 'fs';\nimport type { AbstractEntry, ExtractOptions } from '../types.ts';\n\nconst UID = process.getuid ? process.getuid() : -1;\nconst OWN = process.platform !== 'win32' && UID === 0;\n\nexport default function chownFn(fullPath: string, entry: AbstractEntry, _options: ExtractOptions, callback: NoParamCallback) {\n  const chown = entry.type === 'symlink' ? fs.lchown : fs.chown;\n  if (!chown || !OWN || !entry.uid || !entry.gid) return callback(null);\n  chown(fullPath, entry.uid, entry.gid, callback);\n}\n"],"names":["fs","UID","process","getuid","OWN","platform","chownFn","fullPath","entry","_options","callback","chown","type","lchown","uid","gid"],"mappings":"AAAA,mDAAmD;AAEnD,OAAOA,QAAkC,KAAK;AAG9C,MAAMC,MAAMC,QAAQC,MAAM,GAAGD,QAAQC,MAAM,KAAK,CAAC;AACjD,MAAMC,MAAMF,QAAQG,QAAQ,KAAK,WAAWJ,QAAQ;AAEpD,eAAe,SAASK,QAAQC,QAAgB,EAAEC,KAAoB,EAAEC,QAAwB,EAAEC,QAAyB;IACzH,MAAMC,QAAQH,MAAMI,IAAI,KAAK,YAAYZ,GAAGa,MAAM,GAAGb,GAAGW,KAAK;IAC7D,IAAI,CAACA,SAAS,CAACP,OAAO,CAACI,MAAMM,GAAG,IAAI,CAACN,MAAMO,GAAG,EAAE,OAAOL,SAAS;IAChEC,MAAMJ,UAAUC,MAAMM,GAAG,EAAEN,MAAMO,GAAG,EAAEL;AACxC"}

package/dist/esm/fs/lstatReal.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/fs/lstatReal.ts"],"sourcesContent":["import fs, { type BigIntStats, type Stats } from 'fs';\n\nexport type Callback = (err: NodeJS.ErrnoException | null, stats?: Stats | BigIntStats) => void;\n\nexport default function lstatReal(path: string, callback: Callback): void {\n  fs.realpath(path, (err, realpath) => {\n    err ? callback(err) : fs.lstat(realpath, callback);\n  });\n}\n"],"names":["fs","lstatReal","path","callback","realpath","err","lstat"],"mappings":"AAAA,OAAOA,QAA0C,KAAK;AAItD,eAAe,SAASC,UAAUC,IAAY,EAAEC,QAAkB;IAChEH,GAAGI,QAAQ,CAACF,MAAM,CAACG,KAAKD;QACtBC,MAAMF,SAASE,OAAOL,GAAGM,KAAK,CAACF,UAAUD;IAC3C;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/fs/lstatReal.ts"],"sourcesContent":["import fs, { type BigIntStats, type Stats } from 'fs';\n\nexport type Callback = (err: NodeJS.ErrnoException | null, stats?: Stats | BigIntStats) => void;\n\nexport default function lstatReal(path: string, callback: Callback): void {\n  fs.realpath(path, (err, realpath) => {\n    err ? callback(err) : fs.lstat(realpath, callback);\n  });\n}\n"],"names":["fs","lstatReal","path","callback","realpath","err","lstat"],"mappings":"AAAA,OAAOA,QAA0C,KAAK;AAItD,eAAe,SAASC,UAAUC,IAAY,EAAEC,QAAkB;IAChEH,GAAGI,QAAQ,CAACF,MAAM,CAACG,KAAKD;QACtBC,MAAMF,SAASE,OAAOL,GAAGM,KAAK,CAACF,UAAUD;IAC3C;AACF"}

package/dist/esm/fs/lutimes.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/fs/lutimes.ts"],"sourcesContent":["// lutimes - set times on symlinks without following them\n// fs.lutimes was added in Node.js 14.5.0\n// For older versions, we skip setting times on symlinks (no good alternative)\n\nimport fs, { type NoParamCallback } from 'fs';\nimport type { AbstractEntry, ExtractOptions } from '../types.ts';\n\n// biome-ignore lint/suspicious/noExplicitAny: fs.lutimes not in older @types/node\nconst HAS_LUTIMES = typeof (fs as any).lutimes === 'function';\n\nexport default function lutimes(fullPath: string, entry: AbstractEntry, options: ExtractOptions, callback: NoParamCallback): void {\n  if (HAS_LUTIMES) {\n    const now = options.now || new Date();\n    // biome-ignore lint/suspicious/noExplicitAny: fs.lutimes not in older @types/node\n    (fs as any).lutimes(fullPath, now, new Date(entry.mtime), callback);\n  } else {\n    // On older Node versions, skip setting times on symlinks\n    // fs.utimes follows symlinks and will fail with ENOENT if target doesn't exist\n    callback(null);\n  }\n}\n"],"names":["fs","HAS_LUTIMES","lutimes","fullPath","entry","options","callback","now","Date","mtime"],"mappings":"AAAA,yDAAyD;AACzD,yCAAyC;AACzC,8EAA8E;AAE9E,OAAOA,QAAkC,KAAK;AAG9C,kFAAkF;AAClF,MAAMC,cAAc,OAAO,AAACD,GAAWE,OAAO,KAAK;AAEnD,eAAe,SAASA,QAAQC,QAAgB,EAAEC,KAAoB,EAAEC,OAAuB,EAAEC,QAAyB;IACxH,IAAIL,aAAa;QACf,MAAMM,MAAMF,QAAQE,GAAG,IAAI,IAAIC;QAC/B,kFAAkF;QACjFR,GAAWE,OAAO,CAACC,UAAUI,KAAK,IAAIC,KAAKJ,MAAMK,KAAK,GAAGH;IAC5D,OAAO;QACL,yDAAyD;QACzD,+EAA+E;QAC/EA,SAAS;IACX;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/fs/lutimes.ts"],"sourcesContent":["// lutimes - set times on symlinks without following them\n// fs.lutimes was added in Node.js 14.5.0\n// For older versions, we skip setting times on symlinks (no good alternative)\n\nimport fs, { type NoParamCallback } from 'fs';\nimport type { AbstractEntry, ExtractOptions } from '../types.ts';\n\n// biome-ignore lint/suspicious/noExplicitAny: fs.lutimes not in older @types/node\nconst HAS_LUTIMES = typeof (fs as any).lutimes === 'function';\n\nexport default function lutimes(fullPath: string, entry: AbstractEntry, options: ExtractOptions, callback: NoParamCallback): void {\n  if (HAS_LUTIMES) {\n    const now = options.now || new Date();\n    // biome-ignore lint/suspicious/noExplicitAny: fs.lutimes not in older @types/node\n    (fs as any).lutimes(fullPath, now, new Date(entry.mtime), callback);\n  } else {\n    // On older Node versions, skip setting times on symlinks\n    // fs.utimes follows symlinks and will fail with ENOENT if target doesn't exist\n    callback(null);\n  }\n}\n"],"names":["fs","HAS_LUTIMES","lutimes","fullPath","entry","options","callback","now","Date","mtime"],"mappings":"AAAA,yDAAyD;AACzD,yCAAyC;AACzC,8EAA8E;AAE9E,OAAOA,QAAkC,KAAK;AAG9C,kFAAkF;AAClF,MAAMC,cAAc,OAAO,AAACD,GAAWE,OAAO,KAAK;AAEnD,eAAe,SAASA,QAAQC,QAAgB,EAAEC,KAAoB,EAAEC,OAAuB,EAAEC,QAAyB;IACxH,IAAIL,aAAa;QACf,MAAMM,MAAMF,QAAQE,GAAG,IAAI,IAAIC;QAC/B,kFAAkF;QACjFR,GAAWE,OAAO,CAACC,UAAUI,KAAK,IAAIC,KAAKJ,MAAMK,KAAK,GAAGH;IAC5D,OAAO;QACL,yDAAyD;QACzD,+EAA+E;QAC/EA,SAAS;IACX;AACF"}

package/dist/esm/fs/symlinkWin32.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/fs/symlinkWin32.ts"],"sourcesContent":["import fs, { type NoParamCallback } from 'fs';\nimport lstatReal from './lstatReal.ts';\n\nexport default function symlinkWin32(linkFullPath: string, linkpath: string, fullPath: string, callback: NoParamCallback) {\n  lstatReal(linkFullPath, (err, targetStat) => {\n    // If target doesn't exist, default to 'file' type (Windows requires a type for symlinks)\n    const type = !err && targetStat?.isDirectory() ? 'dir' : 'file';\n    fs.symlink(linkpath, fullPath, type, callback);\n  });\n}\n"],"names":["fs","lstatReal","symlinkWin32","linkFullPath","linkpath","fullPath","callback","err","targetStat","type","isDirectory","symlink"],"mappings":"AAAA,OAAOA,QAAkC,KAAK;AAC9C,OAAOC,eAAe,iBAAiB;AAEvC,eAAe,SAASC,aAAaC,YAAoB,EAAEC,QAAgB,EAAEC,QAAgB,EAAEC,QAAyB;IACtHL,UAAUE,cAAc,CAACI,KAAKC;QAC5B,yFAAyF;QACzF,MAAMC,OAAO,CAACF,QAAOC,uBAAAA,iCAAAA,WAAYE,WAAW,MAAK,QAAQ;QACzDV,GAAGW,OAAO,CAACP,UAAUC,UAAUI,MAAMH;IACvC;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/fs/symlinkWin32.ts"],"sourcesContent":["import fs, { type NoParamCallback } from 'fs';\nimport lstatReal from './lstatReal.ts';\n\nexport default function symlinkWin32(linkFullPath: string, linkpath: string, fullPath: string, callback: NoParamCallback) {\n  lstatReal(linkFullPath, (err, targetStat) => {\n    // If target doesn't exist, default to 'file' type (Windows requires a type for symlinks)\n    const type = !err && targetStat?.isDirectory() ? 'dir' : 'file';\n    fs.symlink(linkpath, fullPath, type, callback);\n  });\n}\n"],"names":["fs","lstatReal","symlinkWin32","linkFullPath","linkpath","fullPath","callback","err","targetStat","type","isDirectory","symlink"],"mappings":"AAAA,OAAOA,QAAkC,KAAK;AAC9C,OAAOC,eAAe,iBAAiB;AAEvC,eAAe,SAASC,aAAaC,YAAoB,EAAEC,QAAgB,EAAEC,QAAgB,EAAEC,QAAyB;IACtHL,UAAUE,cAAc,CAACI,KAAKC;QAC5B,yFAAyF;QACzF,MAAMC,OAAO,CAACF,QAAOC,uBAAAA,iCAAAA,WAAYE,WAAW,MAAK,QAAQ;QACzDV,GAAGW,OAAO,CAACP,UAAUC,UAAUI,MAAMH;IACvC;AACF"}

package/dist/esm/fs/utimes.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/fs/utimes.ts"],"sourcesContent":["// adapted from https://github.com/mafintosh/tar-fs\n\nimport fs, { type NoParamCallback } from 'fs';\nimport type { AbstractEntry, ExtractOptions } from '../types.ts';\n\nexport default function utimes(fullPath: string, entry: AbstractEntry, options: ExtractOptions, callback: NoParamCallback): void {\n  const now = options.now || new Date();\n  fs.utimes(fullPath, now, new Date(entry.mtime), callback);\n}\n"],"names":["fs","utimes","fullPath","entry","options","callback","now","Date","mtime"],"mappings":"AAAA,mDAAmD;AAEnD,OAAOA,QAAkC,KAAK;AAG9C,eAAe,SAASC,OAAOC,QAAgB,EAAEC,KAAoB,EAAEC,OAAuB,EAAEC,QAAyB;IACvH,MAAMC,MAAMF,QAAQE,GAAG,IAAI,IAAIC;IAC/BP,GAAGC,MAAM,CAACC,UAAUI,KAAK,IAAIC,KAAKJ,MAAMK,KAAK,GAAGH;AAClD"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/fs/utimes.ts"],"sourcesContent":["// adapted from https://github.com/mafintosh/tar-fs\n\nimport fs, { type NoParamCallback } from 'fs';\nimport type { AbstractEntry, ExtractOptions } from '../types.ts';\n\nexport default function utimes(fullPath: string, entry: AbstractEntry, options: ExtractOptions, callback: NoParamCallback): void {\n  const now = options.now || new Date();\n  fs.utimes(fullPath, now, new Date(entry.mtime), callback);\n}\n"],"names":["fs","utimes","fullPath","entry","options","callback","now","Date","mtime"],"mappings":"AAAA,mDAAmD;AAEnD,OAAOA,QAAkC,KAAK;AAG9C,eAAe,SAASC,OAAOC,QAAgB,EAAEC,KAAoB,EAAEC,OAAuB,EAAEC,QAAyB;IACvH,MAAMC,MAAMF,QAAQE,GAAG,IAAI,IAAIC;IAC/BP,GAAGC,MAAM,CAACC,UAAUI,KAAK,IAAIC,KAAKJ,MAAMK,KAAK,GAAGH;AAClD"}

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/index.ts"],"sourcesContent":["import StackBaseIterator from 'stack-base-iterator';\n\nimport type { Entry } from './types.ts';\n\nexport default class ExtractBaseIterator<T = Entry> extends StackBaseIterator<T> {}\n\nexport { default as DirectoryEntry } from './DirectoryEntry.ts';\nexport { default as FileEntry } from './FileEntry.ts';\nexport { default as LinkEntry } from './LinkEntry.ts';\nexport { default as SymbolicLinkEntry } from './SymbolicLinkEntry.ts';\n// Shared utilities for iterator libraries\nexport * from './shared/index.ts';\nexport * from './types.ts';\nexport { default as waitForAccess } from './waitForAccess.ts';\n"],"names":["StackBaseIterator","ExtractBaseIterator","default","DirectoryEntry","FileEntry","LinkEntry","SymbolicLinkEntry","waitForAccess"],"mappings":"AAAA,OAAOA,uBAAuB,sBAAsB;AAIpD,eAAe,MAAMC,4BAAuCD;AAAsB;AAElF,SAASE,WAAWC,cAAc,QAAQ,sBAAsB;AAChE,SAASD,WAAWE,SAAS,QAAQ,iBAAiB;AACtD,SAASF,WAAWG,SAAS,QAAQ,iBAAiB;AACtD,SAASH,WAAWI,iBAAiB,QAAQ,yBAAyB;AACtE,0CAA0C;AAC1C,cAAc,oBAAoB;AAClC,cAAc,aAAa;AAC3B,SAASJ,WAAWK,aAAa,QAAQ,qBAAqB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/index.ts"],"sourcesContent":["import StackBaseIterator from 'stack-base-iterator';\n\nimport type { Entry } from './types.ts';\n\nexport default class ExtractBaseIterator<T = Entry> extends StackBaseIterator<T> {}\n\nexport { default as DirectoryEntry } from './DirectoryEntry.ts';\nexport { default as FileEntry } from './FileEntry.ts';\nexport { default as LinkEntry } from './LinkEntry.ts';\nexport { default as SymbolicLinkEntry } from './SymbolicLinkEntry.ts';\n// Shared utilities for iterator libraries\nexport * from './shared/index.ts';\nexport * from './types.ts';\nexport { default as waitForAccess } from './waitForAccess.ts';\n"],"names":["StackBaseIterator","ExtractBaseIterator","default","DirectoryEntry","FileEntry","LinkEntry","SymbolicLinkEntry","waitForAccess"],"mappings":"AAAA,OAAOA,uBAAuB,sBAAsB;AAIpD,eAAe,MAAMC,4BAAuCD;AAAsB;AAElF,SAASE,WAAWC,cAAc,QAAQ,sBAAsB;AAChE,SAASD,WAAWE,SAAS,QAAQ,iBAAiB;AACtD,SAASF,WAAWG,SAAS,QAAQ,iBAAiB;AACtD,SAASH,WAAWI,iBAAiB,QAAQ,yBAAyB;AACtE,0CAA0C;AAC1C,cAAc,oBAAoB;AAClC,cAAc,aAAa;AAC3B,SAASJ,WAAWK,aAAa,QAAQ,qBAAqB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/shared/BufferList.ts"],"sourcesContent":["/**\n * Buffer List for Streaming\n *\n * Simple linked list for accumulating buffer chunks during streaming.\n * Provides efficient append, consume, and slice operations.\n */\n\nimport { allocBuffer } from 'extract-base-iterator';\n\ninterface BufferNode {\n  data: Buffer;\n  next: BufferNode | null;\n}\n\nexport default class BufferList {\n  private head: BufferNode | null = null;\n  private tail: BufferNode | null = null;\n\n  /** Total bytes in the buffer list */\n  public length = 0;\n\n  /**\n   * Append a buffer to the end of the list\n   */\n  append(buf: Buffer): void {\n    if (buf.length === 0) return;\n\n    const node: BufferNode = { data: buf, next: null };\n\n    if (this.tail) {\n      this.tail.next = node;\n      this.tail = node;\n    } else {\n      this.head = this.tail = node;\n    }\n\n    this.length += buf.length;\n  }\n\n  /**\n   * Prepend a buffer to the front of the list\n   */\n  prepend(buf: Buffer): void {\n    if (buf.length === 0) return;\n\n    const node: BufferNode = { data: buf, next: this.head };\n\n    if (!this.tail) {\n      this.tail = node;\n    }\n    this.head = node;\n\n    this.length += buf.length;\n  }\n\n  /**\n   * Consume n bytes from the front of the list\n   * Returns a new buffer containing the consumed bytes\n   */\n  consume(n: number): Buffer {\n    if (n <= 0) return allocBuffer(0);\n    if (n > this.length) n = this.length;\n\n    const result = allocBuffer(n);\n    let offset = 0;\n\n    while (offset < n && this.head) {\n      const chunk = this.head.data;\n      const needed = n - offset;\n\n      if (chunk.length <= needed) {\n        // Use entire chunk\n        chunk.copy(result, offset);\n        offset += chunk.length;\n        this.head = this.head.next;\n        if (!this.head) this.tail = null;\n      } else {\n        // Use partial chunk\n        chunk.copy(result, offset, 0, needed);\n        this.head.data = chunk.slice(needed);\n        offset = n;\n      }\n    }\n\n    this.length -= n;\n    return result;\n  }\n\n  /**\n   * Get a slice of the buffer without consuming\n   * Returns a new buffer containing the bytes\n   */\n  slice(start: number, end: number): Buffer {\n    const len = end - start;\n    if (len <= 0) return allocBuffer(0);\n    if (start >= this.length) return allocBuffer(0);\n\n    const result = allocBuffer(Math.min(len, this.length - start));\n    let resultOffset = 0;\n    let bufOffset = 0;\n    let node = this.head;\n\n    // Skip to start position\n    while (node && bufOffset + node.data.length <= start) {\n      bufOffset += node.data.length;\n      node = node.next;\n    }\n\n    // Copy data\n    while (node && resultOffset < result.length) {\n      const chunk = node.data;\n      const chunkStart = Math.max(0, start - bufOffset);\n      const chunkEnd = Math.min(chunk.length, end - bufOffset);\n      const toCopy = chunkEnd - chunkStart;\n\n      if (toCopy > 0) {\n        chunk.copy(result, resultOffset, chunkStart, chunkEnd);\n        resultOffset += toCopy;\n      }\n\n      bufOffset += chunk.length;\n      node = node.next;\n    }\n\n    return result;\n  }\n\n  /**\n   * Read a single byte at offset without consuming\n   */\n  readByte(offset: number): number {\n    if (offset < 0 || offset >= this.length) return -1;\n\n    let bufOffset = 0;\n    let node = this.head;\n\n    while (node) {\n      if (offset < bufOffset + node.data.length) {\n        return node.data[offset - bufOffset];\n      }\n      bufOffset += node.data.length;\n      node = node.next;\n    }\n\n    return -1;\n  }\n\n  /**\n   * Search for a byte sequence in the buffer\n   * Returns offset of first match, or -1 if not found\n   */\n  indexOf(signature: number[], startOffset = 0): number {\n    if (signature.length === 0) return startOffset;\n    if (startOffset + signature.length > this.length) return -1;\n\n    // Simple byte-by-byte search\n    // Could be optimized with KMP/Boyer-Moore for larger signatures\n    for (let i = startOffset; i <= this.length - signature.length; i++) {\n      let match = true;\n      for (let j = 0; j < signature.length; j++) {\n        if (this.readByte(i + j) !== signature[j]) {\n          match = false;\n          break;\n        }\n      }\n      if (match) return i;\n    }\n\n    return -1;\n  }\n\n  /**\n   * Skip (consume) n bytes without returning them\n   */\n  skip(n: number): void {\n    if (n <= 0) return;\n    if (n >= this.length) {\n      this.clear();\n      return;\n    }\n\n    let remaining = n;\n\n    while (remaining > 0 && this.head) {\n      const chunk = this.head.data;\n\n      if (chunk.length <= remaining) {\n        remaining -= chunk.length;\n        this.head = this.head.next;\n        if (!this.head) this.tail = null;\n      } else {\n        this.head.data = chunk.slice(remaining);\n        remaining = 0;\n      }\n    }\n\n    this.length -= n;\n  }\n\n  /**\n   * Clear all buffers\n   */\n  clear(): void {\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  /**\n   * Check if buffer has at least n bytes available\n   */\n  has(n: number): boolean {\n    return this.length >= n;\n  }\n\n  /**\n   * Check if the buffer starts with a signature at offset 0\n   */\n  startsWith(signature: number[]): boolean {\n    if (signature.length > this.length) return false;\n    for (let i = 0; i < signature.length; i++) {\n      if (this.readByte(i) !== signature[i]) return false;\n    }\n    return true;\n  }\n\n  /**\n   * Get a consolidated buffer of the entire contents\n   * Note: This creates a copy, so use sparingly for large buffers\n   */\n  toBuffer(): Buffer {\n    if (this.length === 0) return allocBuffer(0);\n    return this.slice(0, this.length);\n  }\n\n  /**\n   * Read UInt16 (little-endian) at offset without consuming\n   * Returns null if not enough data\n   */\n  readUInt16LEAt(offset: number): number | null {\n    if (offset < 0 || offset + 2 > this.length) return null;\n\n    const bytes = this.readBytesAt(offset, 2);\n    if (bytes.length < 2) return null;\n\n    return bytes.readUInt16LE(0);\n  }\n\n  /**\n   * Read UInt32 (little-endian) at offset without consuming\n   * Returns null if not enough data\n   */\n  readUInt32LEAt(offset: number): number | null {\n    if (offset < 0 || offset + 4 > this.length) return null;\n\n    const bytes = this.readBytesAt(offset, 4);\n    if (bytes.length < 4) return null;\n\n    return bytes.readUInt32LE(0);\n  }\n\n  /**\n   * Read bytes at offset without consuming.\n   * Returns a slice (zero-copy) when data fits within a single chunk,\n   * otherwise allocates and copies from multiple chunks.\n   */\n  readBytesAt(offset: number, length: number): Buffer {\n    if (length <= 0) return allocBuffer(0);\n    if (offset < 0 || offset >= this.length) return allocBuffer(0);\n\n    // Clamp length to available data\n    const available = this.length - offset;\n    if (length > available) length = available;\n\n    // Find the node containing the offset\n    let bufOffset = 0;\n    let node = this.head;\n    while (node && bufOffset + node.data.length <= offset) {\n      bufOffset += node.data.length;\n      node = node.next;\n    }\n\n    if (!node) return allocBuffer(0);\n\n    const startInChunk = offset - bufOffset;\n\n    // Single-buffer optimization: zero-copy slice\n    if (startInChunk + length <= node.data.length) {\n      return node.data.slice(startInChunk, startInChunk + length);\n    }\n\n    // Multi-buffer case: must allocate and copy\n    const result = allocBuffer(length);\n    let resultOffset = 0;\n\n    while (node && resultOffset < length) {\n      const chunk = node.data;\n      const chunkStart = resultOffset === 0 ? startInChunk : 0;\n      const chunkAvailable = chunk.length - chunkStart;\n      const toCopy = Math.min(chunkAvailable, length - resultOffset);\n\n      chunk.copy(result, resultOffset, chunkStart, chunkStart + toCopy);\n      resultOffset += toCopy;\n\n      node = node.next;\n    }\n\n    return result;\n  }\n}\n"],"names":["allocBuffer","BufferList","append","buf","length","node","data","next","tail","head","prepend","consume","n","result","offset","chunk","needed","copy","slice","start","end","len","Math","min","resultOffset","bufOffset","chunkStart","max","chunkEnd","toCopy","readByte","indexOf","signature","startOffset","i","match","j","skip","clear","remaining","has","startsWith","toBuffer","readUInt16LEAt","bytes","readBytesAt","readUInt16LE","readUInt32LEAt","readUInt32LE","available","startInChunk","chunkAvailable"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/BufferList.ts"],"sourcesContent":["/**\n * Buffer List for Streaming\n *\n * Simple linked list for accumulating buffer chunks during streaming.\n * Provides efficient append, consume, and slice operations.\n */\n\nimport { allocBuffer } from 'extract-base-iterator';\n\ninterface BufferNode {\n  data: Buffer;\n  next: BufferNode | null;\n}\n\nexport default class BufferList {\n  private head: BufferNode | null = null;\n  private tail: BufferNode | null = null;\n\n  /** Total bytes in the buffer list */\n  public length = 0;\n\n  /**\n   * Append a buffer to the end of the list\n   */\n  append(buf: Buffer): void {\n    if (buf.length === 0) return;\n\n    const node: BufferNode = { data: buf, next: null };\n\n    if (this.tail) {\n      this.tail.next = node;\n      this.tail = node;\n    } else {\n      this.head = this.tail = node;\n    }\n\n    this.length += buf.length;\n  }\n\n  /**\n   * Prepend a buffer to the front of the list\n   */\n  prepend(buf: Buffer): void {\n    if (buf.length === 0) return;\n\n    const node: BufferNode = { data: buf, next: this.head };\n\n    if (!this.tail) {\n      this.tail = node;\n    }\n    this.head = node;\n\n    this.length += buf.length;\n  }\n\n  /**\n   * Consume n bytes from the front of the list\n   * Returns a new buffer containing the consumed bytes\n   */\n  consume(n: number): Buffer {\n    if (n <= 0) return allocBuffer(0);\n    if (n > this.length) n = this.length;\n\n    const result = allocBuffer(n);\n    let offset = 0;\n\n    while (offset < n && this.head) {\n      const chunk = this.head.data;\n      const needed = n - offset;\n\n      if (chunk.length <= needed) {\n        // Use entire chunk\n        chunk.copy(result, offset);\n        offset += chunk.length;\n        this.head = this.head.next;\n        if (!this.head) this.tail = null;\n      } else {\n        // Use partial chunk\n        chunk.copy(result, offset, 0, needed);\n        this.head.data = chunk.slice(needed);\n        offset = n;\n      }\n    }\n\n    this.length -= n;\n    return result;\n  }\n\n  /**\n   * Get a slice of the buffer without consuming\n   * Returns a new buffer containing the bytes\n   */\n  slice(start: number, end: number): Buffer {\n    const len = end - start;\n    if (len <= 0) return allocBuffer(0);\n    if (start >= this.length) return allocBuffer(0);\n\n    const result = allocBuffer(Math.min(len, this.length - start));\n    let resultOffset = 0;\n    let bufOffset = 0;\n    let node = this.head;\n\n    // Skip to start position\n    while (node && bufOffset + node.data.length <= start) {\n      bufOffset += node.data.length;\n      node = node.next;\n    }\n\n    // Copy data\n    while (node && resultOffset < result.length) {\n      const chunk = node.data;\n      const chunkStart = Math.max(0, start - bufOffset);\n      const chunkEnd = Math.min(chunk.length, end - bufOffset);\n      const toCopy = chunkEnd - chunkStart;\n\n      if (toCopy > 0) {\n        chunk.copy(result, resultOffset, chunkStart, chunkEnd);\n        resultOffset += toCopy;\n      }\n\n      bufOffset += chunk.length;\n      node = node.next;\n    }\n\n    return result;\n  }\n\n  /**\n   * Read a single byte at offset without consuming\n   */\n  readByte(offset: number): number {\n    if (offset < 0 || offset >= this.length) return -1;\n\n    let bufOffset = 0;\n    let node = this.head;\n\n    while (node) {\n      if (offset < bufOffset + node.data.length) {\n        return node.data[offset - bufOffset];\n      }\n      bufOffset += node.data.length;\n      node = node.next;\n    }\n\n    return -1;\n  }\n\n  /**\n   * Search for a byte sequence in the buffer\n   * Returns offset of first match, or -1 if not found\n   */\n  indexOf(signature: number[], startOffset = 0): number {\n    if (signature.length === 0) return startOffset;\n    if (startOffset + signature.length > this.length) return -1;\n\n    // Simple byte-by-byte search\n    // Could be optimized with KMP/Boyer-Moore for larger signatures\n    for (let i = startOffset; i <= this.length - signature.length; i++) {\n      let match = true;\n      for (let j = 0; j < signature.length; j++) {\n        if (this.readByte(i + j) !== signature[j]) {\n          match = false;\n          break;\n        }\n      }\n      if (match) return i;\n    }\n\n    return -1;\n  }\n\n  /**\n   * Skip (consume) n bytes without returning them\n   */\n  skip(n: number): void {\n    if (n <= 0) return;\n    if (n >= this.length) {\n      this.clear();\n      return;\n    }\n\n    let remaining = n;\n\n    while (remaining > 0 && this.head) {\n      const chunk = this.head.data;\n\n      if (chunk.length <= remaining) {\n        remaining -= chunk.length;\n        this.head = this.head.next;\n        if (!this.head) this.tail = null;\n      } else {\n        this.head.data = chunk.slice(remaining);\n        remaining = 0;\n      }\n    }\n\n    this.length -= n;\n  }\n\n  /**\n   * Clear all buffers\n   */\n  clear(): void {\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  /**\n   * Check if buffer has at least n bytes available\n   */\n  has(n: number): boolean {\n    return this.length >= n;\n  }\n\n  /**\n   * Check if the buffer starts with a signature at offset 0\n   */\n  startsWith(signature: number[]): boolean {\n    if (signature.length > this.length) return false;\n    for (let i = 0; i < signature.length; i++) {\n      if (this.readByte(i) !== signature[i]) return false;\n    }\n    return true;\n  }\n\n  /**\n   * Get a consolidated buffer of the entire contents\n   * Note: This creates a copy, so use sparingly for large buffers\n   */\n  toBuffer(): Buffer {\n    if (this.length === 0) return allocBuffer(0);\n    return this.slice(0, this.length);\n  }\n\n  /**\n   * Read UInt16 (little-endian) at offset without consuming\n   * Returns null if not enough data\n   */\n  readUInt16LEAt(offset: number): number | null {\n    if (offset < 0 || offset + 2 > this.length) return null;\n\n    const bytes = this.readBytesAt(offset, 2);\n    if (bytes.length < 2) return null;\n\n    return bytes.readUInt16LE(0);\n  }\n\n  /**\n   * Read UInt32 (little-endian) at offset without consuming\n   * Returns null if not enough data\n   */\n  readUInt32LEAt(offset: number): number | null {\n    if (offset < 0 || offset + 4 > this.length) return null;\n\n    const bytes = this.readBytesAt(offset, 4);\n    if (bytes.length < 4) return null;\n\n    return bytes.readUInt32LE(0);\n  }\n\n  /**\n   * Read bytes at offset without consuming.\n   * Returns a slice (zero-copy) when data fits within a single chunk,\n   * otherwise allocates and copies from multiple chunks.\n   */\n  readBytesAt(offset: number, length: number): Buffer {\n    if (length <= 0) return allocBuffer(0);\n    if (offset < 0 || offset >= this.length) return allocBuffer(0);\n\n    // Clamp length to available data\n    const available = this.length - offset;\n    if (length > available) length = available;\n\n    // Find the node containing the offset\n    let bufOffset = 0;\n    let node = this.head;\n    while (node && bufOffset + node.data.length <= offset) {\n      bufOffset += node.data.length;\n      node = node.next;\n    }\n\n    if (!node) return allocBuffer(0);\n\n    const startInChunk = offset - bufOffset;\n\n    // Single-buffer optimization: zero-copy slice\n    if (startInChunk + length <= node.data.length) {\n      return node.data.slice(startInChunk, startInChunk + length);\n    }\n\n    // Multi-buffer case: must allocate and copy\n    const result = allocBuffer(length);\n    let resultOffset = 0;\n\n    while (node && resultOffset < length) {\n      const chunk = node.data;\n      const chunkStart = resultOffset === 0 ? startInChunk : 0;\n      const chunkAvailable = chunk.length - chunkStart;\n      const toCopy = Math.min(chunkAvailable, length - resultOffset);\n\n      chunk.copy(result, resultOffset, chunkStart, chunkStart + toCopy);\n      resultOffset += toCopy;\n\n      node = node.next;\n    }\n\n    return result;\n  }\n}\n"],"names":["allocBuffer","BufferList","append","buf","length","node","data","next","tail","head","prepend","consume","n","result","offset","chunk","needed","copy","slice","start","end","len","Math","min","resultOffset","bufOffset","chunkStart","max","chunkEnd","toCopy","readByte","indexOf","signature","startOffset","i","match","j","skip","clear","remaining","has","startsWith","toBuffer","readUInt16LEAt","bytes","readBytesAt","readUInt16LE","readUInt32LEAt","readUInt32LE","available","startInChunk","chunkAvailable"],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/shared/EntryStream.ts"],"sourcesContent":["/**\n * EntryStream - Simple readable stream for entry content\n *\n * Extends Readable to emit 'data', 'end', 'error' events.\n * Node 0.8 compatible via readable-stream polyfill.\n *\n * This base class is designed to be used by:\n * - zip-iterator\n * - 7z-iterator\n * - tar-iterator\n * - Any other archive iterator library\n */\n\nimport Stream from 'stream';\n\n// Use native streams when available, readable-stream only for Node 0.x\nconst major = +process.versions.node.split('.')[0];\nlet ReadableBase: typeof Stream.Readable;\nif (major > 0) {\n  ReadableBase = Stream.Readable;\n} else {\n  ReadableBase = require('readable-stream').Readable;\n}\n\n/**\n * Base stream class for archive entry content.\n * Can be extended for special entry types like sparse files.\n */\nexport default class EntryStream extends ReadableBase {\n  protected _ended = false;\n\n  /**\n   * Signal end of stream by pushing null\n   */\n  end(): void {\n    if (this._ended) return;\n    this._ended = true;\n    this.push(null);\n  }\n\n  /**\n   * Check if stream has ended\n   */\n  get ended(): boolean {\n    return this._ended;\n  }\n\n  /**\n   * Required by Readable - called when consumer wants data.\n   * Data is pushed externally via push(), nothing to do here.\n   */\n  _read(_size: number): void {\n    // Data is pushed externally, nothing to do here\n  }\n}\n"],"names":["Stream","major","process","versions","node","split","ReadableBase","Readable","require","EntryStream","end","_ended","push","ended","_read","_size"],"mappings":"AAAA;;;;;;;;;;;CAWC,GAED,OAAOA,YAAY,SAAS;AAE5B,uEAAuE;AACvE,MAAMC,QAAQ,CAACC,QAAQC,QAAQ,CAACC,IAAI,CAACC,KAAK,CAAC,IAAI,CAAC,EAAE;AAClD,IAAIC;AACJ,IAAIL,QAAQ,GAAG;IACbK,eAAeN,OAAOO,QAAQ;AAChC,OAAO;IACLD,eAAeE,QAAQ,mBAAmBD,QAAQ;AACpD;AAMe,IAAA,AAAME,cAAN,MAAMA,oBAAoBH;IAGvC;;GAEC,GACDI,MAAY;QACV,IAAI,IAAI,CAACC,MAAM,EAAE;QACjB,IAAI,CAACA,MAAM,GAAG;QACd,IAAI,CAACC,IAAI,CAAC;IACZ;IAEA;;GAEC,GACD,IAAIC,QAAiB;QACnB,OAAO,IAAI,CAACF,MAAM;IACpB;IAEA;;;GAGC,GACDG,MAAMC,KAAa,EAAQ;IACzB,gDAAgD;IAClD;;QAzBa,qBACHJ,SAAS;;AAyBrB;AA9BA;;;CAGC,GACD,SAAqBF,yBA0BpB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/EntryStream.ts"],"sourcesContent":["/**\n * EntryStream - Simple readable stream for entry content\n *\n * Extends Readable to emit 'data', 'end', 'error' events.\n * Node 0.8 compatible via readable-stream polyfill.\n *\n * This base class is designed to be used by:\n * - zip-iterator\n * - 7z-iterator\n * - tar-iterator\n * - Any other archive iterator library\n */\n\nimport Stream from 'stream';\n\n// Use native streams when available, readable-stream only for Node 0.x\nconst major = +process.versions.node.split('.')[0];\nlet ReadableBase: typeof Stream.Readable;\nif (major > 0) {\n  ReadableBase = Stream.Readable;\n} else {\n  ReadableBase = require('readable-stream').Readable;\n}\n\n/**\n * Base stream class for archive entry content.\n * Can be extended for special entry types like sparse files.\n */\nexport default class EntryStream extends ReadableBase {\n  protected _ended = false;\n\n  /**\n   * Signal end of stream by pushing null\n   */\n  end(): void {\n    if (this._ended) return;\n    this._ended = true;\n    this.push(null);\n  }\n\n  /**\n   * Check if stream has ended\n   */\n  get ended(): boolean {\n    return this._ended;\n  }\n\n  /**\n   * Required by Readable - called when consumer wants data.\n   * Data is pushed externally via push(), nothing to do here.\n   */\n  _read(_size: number): void {\n    // Data is pushed externally, nothing to do here\n  }\n}\n"],"names":["Stream","major","process","versions","node","split","ReadableBase","Readable","require","EntryStream","end","_ended","push","ended","_read","_size"],"mappings":"AAAA;;;;;;;;;;;CAWC,GAED,OAAOA,YAAY,SAAS;AAE5B,uEAAuE;AACvE,MAAMC,QAAQ,CAACC,QAAQC,QAAQ,CAACC,IAAI,CAACC,KAAK,CAAC,IAAI,CAAC,EAAE;AAClD,IAAIC;AACJ,IAAIL,QAAQ,GAAG;IACbK,eAAeN,OAAOO,QAAQ;AAChC,OAAO;IACLD,eAAeE,QAAQ,mBAAmBD,QAAQ;AACpD;AAMe,IAAA,AAAME,cAAN,MAAMA,oBAAoBH;IAGvC;;GAEC,GACDI,MAAY;QACV,IAAI,IAAI,CAACC,MAAM,EAAE;QACjB,IAAI,CAACA,MAAM,GAAG;QACd,IAAI,CAACC,IAAI,CAAC;IACZ;IAEA;;GAEC,GACD,IAAIC,QAAiB;QACnB,OAAO,IAAI,CAACF,MAAM;IACpB;IAEA;;;GAGC,GACDG,MAAMC,KAAa,EAAQ;IACzB,gDAAgD;IAClD;;QAzBa,qBACHJ,SAAS;;AAyBrB;AA9BA;;;CAGC,GACD,SAAqBF,yBA0BpB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/shared/Lock.ts"],"sourcesContent":["/**\n * Lock - Reference counting for iterator lifecycle\n *\n * Ensures the iterator doesn't complete until all entries have been processed.\n * Uses cleanup registration pattern so each iterator can register its specific\n * cleanup functions (e.g., close file descriptors, delete temp files, end parsers).\n *\n * Usage:\n *   const lock = new Lock();\n *   lock.onDestroy = (err) => BaseIterator.prototype.end.call(this, err);\n *   lock.registerCleanup(() => { this.extract.end(); });\n *   lock.registerCleanup(() => { fs.unlinkSync(this.tempPath); });\n *\n *   // For each entry:\n *   lock.retain();\n *   // ... when entry is consumed:\n *   lock.release();\n *\n *   // When iteration complete:\n *   lock.err = err; // optional error\n *   lock.release(); // Initial count\n */\n\nexport type CleanupFn = () => void;\n\nexport default class Lock {\n  private count = 1;\n  private cleanupFns: CleanupFn[] = [];\n\n  /** Error to pass to onDestroy callback */\n  err: Error | null = null;\n\n  /** Called after all cleanups when count reaches 0 */\n  onDestroy: ((err: Error | null) => void) | null = null;\n\n  /**\n   * Register a cleanup function to be called when the lock is destroyed.\n   * Cleanup functions are called in registration order, before onDestroy.\n   * @param fn Cleanup function (should not throw)\n   */\n  registerCleanup(fn: CleanupFn): void {\n    this.cleanupFns.push(fn);\n  }\n\n  /**\n   * Increment reference count.\n   * Call when starting to process a new entry.\n   */\n  retain(): void {\n    this.count++;\n  }\n\n  /**\n   * Decrement reference count.\n   * Call when an entry has been fully consumed.\n   * When count reaches 0, cleanup is triggered.\n   */\n  release(): void {\n    if (this.count <= 0) {\n      throw new Error('Lock count is corrupted');\n    }\n    this.count--;\n    if (this.count === 0) {\n      this._destroy();\n    }\n  }\n\n  /**\n   * Internal cleanup - called when reference count reaches 0\n   */\n  private _destroy(): void {\n    // Run all registered cleanup functions in order\n    // Note: Use traditional for loop for Node 0.8 compatibility (no Symbol.iterator)\n    const fns = this.cleanupFns;\n    for (let i = 0; i < fns.length; i++) {\n      try {\n        fns[i]();\n      } catch (_e) {\n        // Ignore cleanup errors to ensure all cleanup runs\n      }\n    }\n    this.cleanupFns = [];\n\n    // Call onDestroy callback LAST (typically calls iterator.end())\n    if (this.onDestroy) {\n      this.onDestroy(this.err);\n      this.onDestroy = null;\n    }\n  }\n}\n"],"names":["Lock","registerCleanup","fn","cleanupFns","push","retain","count","release","Error","_destroy","fns","i","length","_e","onDestroy","err"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;CAqBC,GAIc,IAAA,AAAMA,OAAN,MAAMA;IAUnB;;;;GAIC,GACDC,gBAAgBC,EAAa,EAAQ;QACnC,IAAI,CAACC,UAAU,CAACC,IAAI,CAACF;IACvB;IAEA;;;GAGC,GACDG,SAAe;QACb,IAAI,CAACC,KAAK;IACZ;IAEA;;;;GAIC,GACDC,UAAgB;QACd,IAAI,IAAI,CAACD,KAAK,IAAI,GAAG;YACnB,MAAM,IAAIE,MAAM;QAClB;QACA,IAAI,CAACF,KAAK;QACV,IAAI,IAAI,CAACA,KAAK,KAAK,GAAG;YACpB,IAAI,CAACG,QAAQ;QACf;IACF;IAEA;;GAEC,GACD,AAAQA,WAAiB;QACvB,gDAAgD;QAChD,iFAAiF;QACjF,MAAMC,MAAM,IAAI,CAACP,UAAU;QAC3B,IAAK,IAAIQ,IAAI,GAAGA,IAAID,IAAIE,MAAM,EAAED,IAAK;YACnC,IAAI;gBACFD,GAAG,CAACC,EAAE;YACR,EAAE,OAAOE,IAAI;YACX,mDAAmD;YACrD;QACF;QACA,IAAI,CAACV,UAAU,GAAG,EAAE;QAEpB,gEAAgE;QAChE,IAAI,IAAI,CAACW,SAAS,EAAE;YAClB,IAAI,CAACA,SAAS,CAAC,IAAI,CAACC,GAAG;YACvB,IAAI,CAACD,SAAS,GAAG;QACnB;IACF;;aA9DQR,QAAQ;aACRH,aAA0B,EAAE;QAEpC,wCAAwC,QACxCY,MAAoB;QAEpB,mDAAmD,QACnDD,YAAkD;;AAwDpD;AAhEA,SAAqBd,kBAgEpB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/Lock.ts"],"sourcesContent":["/**\n * Lock - Reference counting for iterator lifecycle\n *\n * Ensures the iterator doesn't complete until all entries have been processed.\n * Uses cleanup registration pattern so each iterator can register its specific\n * cleanup functions (e.g., close file descriptors, delete temp files, end parsers).\n *\n * Usage:\n *   const lock = new Lock();\n *   lock.onDestroy = (err) => BaseIterator.prototype.end.call(this, err);\n *   lock.registerCleanup(() => { this.extract.end(); });\n *   lock.registerCleanup(() => { fs.unlinkSync(this.tempPath); });\n *\n *   // For each entry:\n *   lock.retain();\n *   // ... when entry is consumed:\n *   lock.release();\n *\n *   // When iteration complete:\n *   lock.err = err; // optional error\n *   lock.release(); // Initial count\n */\n\nexport type CleanupFn = () => void;\n\nexport default class Lock {\n  private count = 1;\n  private cleanupFns: CleanupFn[] = [];\n\n  /** Error to pass to onDestroy callback */\n  err: Error | null = null;\n\n  /** Called after all cleanups when count reaches 0 */\n  onDestroy: ((err: Error | null) => void) | null = null;\n\n  /**\n   * Register a cleanup function to be called when the lock is destroyed.\n   * Cleanup functions are called in registration order, before onDestroy.\n   * @param fn Cleanup function (should not throw)\n   */\n  registerCleanup(fn: CleanupFn): void {\n    this.cleanupFns.push(fn);\n  }\n\n  /**\n   * Increment reference count.\n   * Call when starting to process a new entry.\n   */\n  retain(): void {\n    this.count++;\n  }\n\n  /**\n   * Decrement reference count.\n   * Call when an entry has been fully consumed.\n   * When count reaches 0, cleanup is triggered.\n   */\n  release(): void {\n    if (this.count <= 0) {\n      throw new Error('Lock count is corrupted');\n    }\n    this.count--;\n    if (this.count === 0) {\n      this._destroy();\n    }\n  }\n\n  /**\n   * Internal cleanup - called when reference count reaches 0\n   */\n  private _destroy(): void {\n    // Run all registered cleanup functions in order\n    // Note: Use traditional for loop for Node 0.8 compatibility (no Symbol.iterator)\n    const fns = this.cleanupFns;\n    for (let i = 0; i < fns.length; i++) {\n      try {\n        fns[i]();\n      } catch (_e) {\n        // Ignore cleanup errors to ensure all cleanup runs\n      }\n    }\n    this.cleanupFns = [];\n\n    // Call onDestroy callback LAST (typically calls iterator.end())\n    if (this.onDestroy) {\n      this.onDestroy(this.err);\n      this.onDestroy = null;\n    }\n  }\n}\n"],"names":["Lock","registerCleanup","fn","cleanupFns","push","retain","count","release","Error","_destroy","fns","i","length","_e","onDestroy","err"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;CAqBC,GAIc,IAAA,AAAMA,OAAN,MAAMA;IAUnB;;;;GAIC,GACDC,gBAAgBC,EAAa,EAAQ;QACnC,IAAI,CAACC,UAAU,CAACC,IAAI,CAACF;IACvB;IAEA;;;GAGC,GACDG,SAAe;QACb,IAAI,CAACC,KAAK;IACZ;IAEA;;;;GAIC,GACDC,UAAgB;QACd,IAAI,IAAI,CAACD,KAAK,IAAI,GAAG;YACnB,MAAM,IAAIE,MAAM;QAClB;QACA,IAAI,CAACF,KAAK;QACV,IAAI,IAAI,CAACA,KAAK,KAAK,GAAG;YACpB,IAAI,CAACG,QAAQ;QACf;IACF;IAEA;;GAEC,GACD,AAAQA,WAAiB;QACvB,gDAAgD;QAChD,iFAAiF;QACjF,MAAMC,MAAM,IAAI,CAACP,UAAU;QAC3B,IAAK,IAAIQ,IAAI,GAAGA,IAAID,IAAIE,MAAM,EAAED,IAAK;YACnC,IAAI;gBACFD,GAAG,CAACC,EAAE;YACR,EAAE,OAAOE,IAAI;YACX,mDAAmD;YACrD;QACF;QACA,IAAI,CAACV,UAAU,GAAG,EAAE;QAEpB,gEAAgE;QAChE,IAAI,IAAI,CAACW,SAAS,EAAE;YAClB,IAAI,CAACA,SAAS,CAAC,IAAI,CAACC,GAAG;YACvB,IAAI,CAACD,SAAS,GAAG;QACnB;IACF;;aA9DQR,QAAQ;aACRH,aAA0B,EAAE;QAEpC,wCAAwC,QACxCY,MAAoB;QAEpB,mDAAmD,QACnDD,YAAkD;;AAwDpD;AAhEA,SAAqBd,kBAgEpB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/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/**\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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"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/shared/crc32.ts"],"sourcesContent":["/**\n * CRC32 calculation for archive formats\n *\n * Uses IEEE polynomial 0xEDB88320 (same as ZIP, 7z, PNG, gzip, etc.)\n * All bit operations (>>>, ^, &) work correctly in Node 0.8\n *\n * This is the standard CRC-32 algorithm used by:\n * - ZIP/PKZIP\n * - 7-Zip\n * - PNG\n * - gzip\n * - Ethernet\n */\n\n// Pre-computed lookup table for performance\nconst CRC32_TABLE: number[] = [];\n\n// Initialize table at module load time\n(function initTable() {\n  for (let i = 0; i < 256; i++) {\n    let c = i;\n    for (let j = 0; j < 8; j++) {\n      if ((c & 1) !== 0) {\n        c = 0xedb88320 ^ (c >>> 1);\n      } else {\n        c = c >>> 1;\n      }\n    }\n    CRC32_TABLE[i] = c >>> 0; // Ensure unsigned\n  }\n})();\n\n/**\n * Calculate CRC32 of a buffer\n * @param buf - Buffer to calculate CRC32 for\n * @param initial - Optional initial CRC value (for streaming calculation)\n * @returns CRC32 value as unsigned 32-bit integer\n */\nexport function crc32(buf: Buffer, initial?: number): number {\n  let crc = initial === undefined ? 0xffffffff : ~initial >>> 0;\n\n  for (let i = 0; i < buf.length; i++) {\n    const index = (crc ^ buf[i]) & 0xff;\n    crc = CRC32_TABLE[index] ^ (crc >>> 8);\n  }\n\n  return ~crc >>> 0; // Return unsigned\n}\n\n/**\n * Calculate CRC32 of a buffer region\n * @param buf - Buffer containing data\n * @param offset - Start offset in buffer\n * @param length - Number of bytes to process\n * @param initial - Optional initial CRC value\n * @returns CRC32 value as unsigned 32-bit integer\n */\nexport function crc32Region(buf: Buffer, offset: number, length: number, initial?: number): number {\n  let crc = initial === undefined ? 0xffffffff : ~initial >>> 0;\n  const end = offset + length;\n\n  for (let i = offset; i < end; i++) {\n    const index = (crc ^ buf[i]) & 0xff;\n    crc = CRC32_TABLE[index] ^ (crc >>> 8);\n  }\n\n  return ~crc >>> 0; // Return unsigned\n}\n\n/**\n * Verify CRC32 matches expected value\n * @param buf - Buffer to verify\n * @param expected - Expected CRC32 value\n * @returns true if CRC matches, false otherwise\n */\nexport function verifyCrc32(buf: Buffer, expected: number): boolean {\n  return crc32(buf) === expected >>> 0;\n}\n\n/**\n * Verify CRC32 of a buffer region matches expected value\n * @param buf - Buffer containing data\n * @param offset - Start offset in buffer\n * @param length - Number of bytes to verify\n * @param expected - Expected CRC32 value\n * @returns true if CRC matches, false otherwise\n */\nexport function verifyCrc32Region(buf: Buffer, offset: number, length: number, expected: number): boolean {\n  return crc32Region(buf, offset, length) === expected >>> 0;\n}\n"],"names":["CRC32_TABLE","initTable","i","c","j","crc32","buf","initial","crc","undefined","length","index","crc32Region","offset","end","verifyCrc32","expected","verifyCrc32Region"],"mappings":"AAAA;;;;;;;;;;;;CAYC,GAED,4CAA4C;AAC5C,MAAMA,cAAwB,EAAE;AAEhC,uCAAuC;AACtC,CAAA,SAASC;IACR,IAAK,IAAIC,IAAI,GAAGA,IAAI,KAAKA,IAAK;QAC5B,IAAIC,IAAID;QACR,IAAK,IAAIE,IAAI,GAAGA,IAAI,GAAGA,IAAK;YAC1B,IAAI,AAACD,CAAAA,IAAI,CAAA,MAAO,GAAG;gBACjBA,IAAI,aAAcA,MAAM;YAC1B,OAAO;gBACLA,IAAIA,MAAM;YACZ;QACF;QACAH,WAAW,CAACE,EAAE,GAAGC,MAAM,GAAG,kBAAkB;IAC9C;AACF,CAAA;AAEA;;;;;CAKC,GACD,OAAO,SAASE,MAAMC,GAAW,EAAEC,OAAgB;IACjD,IAAIC,MAAMD,YAAYE,YAAY,aAAa,CAACF,YAAY;IAE5D,IAAK,IAAIL,IAAI,GAAGA,IAAII,IAAII,MAAM,EAAER,IAAK;QACnC,MAAMS,QAAQ,AAACH,CAAAA,MAAMF,GAAG,CAACJ,EAAE,AAAD,IAAK;QAC/BM,MAAMR,WAAW,CAACW,MAAM,GAAIH,QAAQ;IACtC;IAEA,OAAO,CAACA,QAAQ,GAAG,kBAAkB;AACvC;AAEA;;;;;;;CAOC,GACD,OAAO,SAASI,YAAYN,GAAW,EAAEO,MAAc,EAAEH,MAAc,EAAEH,OAAgB;IACvF,IAAIC,MAAMD,YAAYE,YAAY,aAAa,CAACF,YAAY;IAC5D,MAAMO,MAAMD,SAASH;IAErB,IAAK,IAAIR,IAAIW,QAAQX,IAAIY,KAAKZ,IAAK;QACjC,MAAMS,QAAQ,AAACH,CAAAA,MAAMF,GAAG,CAACJ,EAAE,AAAD,IAAK;QAC/BM,MAAMR,WAAW,CAACW,MAAM,GAAIH,QAAQ;IACtC;IAEA,OAAO,CAACA,QAAQ,GAAG,kBAAkB;AACvC;AAEA;;;;;CAKC,GACD,OAAO,SAASO,YAAYT,GAAW,EAAEU,QAAgB;IACvD,OAAOX,MAAMC,SAASU,aAAa;AACrC;AAEA;;;;;;;CAOC,GACD,OAAO,SAASC,kBAAkBX,GAAW,EAAEO,MAAc,EAAEH,MAAc,EAAEM,QAAgB;IAC7F,OAAOJ,YAAYN,KAAKO,QAAQH,YAAYM,aAAa;AAC3D"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/crc32.ts"],"sourcesContent":["/**\n * CRC32 calculation for archive formats\n *\n * Uses IEEE polynomial 0xEDB88320 (same as ZIP, 7z, PNG, gzip, etc.)\n * All bit operations (>>>, ^, &) work correctly in Node 0.8\n *\n * This is the standard CRC-32 algorithm used by:\n * - ZIP/PKZIP\n * - 7-Zip\n * - PNG\n * - gzip\n * - Ethernet\n */\n\n// Pre-computed lookup table for performance\nconst CRC32_TABLE: number[] = [];\n\n// Initialize table at module load time\n(function initTable() {\n  for (let i = 0; i < 256; i++) {\n    let c = i;\n    for (let j = 0; j < 8; j++) {\n      if ((c & 1) !== 0) {\n        c = 0xedb88320 ^ (c >>> 1);\n      } else {\n        c = c >>> 1;\n      }\n    }\n    CRC32_TABLE[i] = c >>> 0; // Ensure unsigned\n  }\n})();\n\n/**\n * Calculate CRC32 of a buffer\n * @param buf - Buffer to calculate CRC32 for\n * @param initial - Optional initial CRC value (for streaming calculation)\n * @returns CRC32 value as unsigned 32-bit integer\n */\nexport function crc32(buf: Buffer, initial?: number): number {\n  let crc = initial === undefined ? 0xffffffff : ~initial >>> 0;\n\n  for (let i = 0; i < buf.length; i++) {\n    const index = (crc ^ buf[i]) & 0xff;\n    crc = CRC32_TABLE[index] ^ (crc >>> 8);\n  }\n\n  return ~crc >>> 0; // Return unsigned\n}\n\n/**\n * Calculate CRC32 of a buffer region\n * @param buf - Buffer containing data\n * @param offset - Start offset in buffer\n * @param length - Number of bytes to process\n * @param initial - Optional initial CRC value\n * @returns CRC32 value as unsigned 32-bit integer\n */\nexport function crc32Region(buf: Buffer, offset: number, length: number, initial?: number): number {\n  let crc = initial === undefined ? 0xffffffff : ~initial >>> 0;\n  const end = offset + length;\n\n  for (let i = offset; i < end; i++) {\n    const index = (crc ^ buf[i]) & 0xff;\n    crc = CRC32_TABLE[index] ^ (crc >>> 8);\n  }\n\n  return ~crc >>> 0; // Return unsigned\n}\n\n/**\n * Verify CRC32 matches expected value\n * @param buf - Buffer to verify\n * @param expected - Expected CRC32 value\n * @returns true if CRC matches, false otherwise\n */\nexport function verifyCrc32(buf: Buffer, expected: number): boolean {\n  return crc32(buf) === expected >>> 0;\n}\n\n/**\n * Verify CRC32 of a buffer region matches expected value\n * @param buf - Buffer containing data\n * @param offset - Start offset in buffer\n * @param length - Number of bytes to verify\n * @param expected - Expected CRC32 value\n * @returns true if CRC matches, false otherwise\n */\nexport function verifyCrc32Region(buf: Buffer, offset: number, length: number, expected: number): boolean {\n  return crc32Region(buf, offset, length) === expected >>> 0;\n}\n"],"names":["CRC32_TABLE","initTable","i","c","j","crc32","buf","initial","crc","undefined","length","index","crc32Region","offset","end","verifyCrc32","expected","verifyCrc32Region"],"mappings":"AAAA;;;;;;;;;;;;CAYC,GAED,4CAA4C;AAC5C,MAAMA,cAAwB,EAAE;AAEhC,uCAAuC;AACtC,CAAA,SAASC;IACR,IAAK,IAAIC,IAAI,GAAGA,IAAI,KAAKA,IAAK;QAC5B,IAAIC,IAAID;QACR,IAAK,IAAIE,IAAI,GAAGA,IAAI,GAAGA,IAAK;YAC1B,IAAI,AAACD,CAAAA,IAAI,CAAA,MAAO,GAAG;gBACjBA,IAAI,aAAcA,MAAM;YAC1B,OAAO;gBACLA,IAAIA,MAAM;YACZ;QACF;QACAH,WAAW,CAACE,EAAE,GAAGC,MAAM,GAAG,kBAAkB;IAC9C;AACF,CAAA;AAEA;;;;;CAKC,GACD,OAAO,SAASE,MAAMC,GAAW,EAAEC,OAAgB;IACjD,IAAIC,MAAMD,YAAYE,YAAY,aAAa,CAACF,YAAY;IAE5D,IAAK,IAAIL,IAAI,GAAGA,IAAII,IAAII,MAAM,EAAER,IAAK;QACnC,MAAMS,QAAQ,AAACH,CAAAA,MAAMF,GAAG,CAACJ,EAAE,AAAD,IAAK;QAC/BM,MAAMR,WAAW,CAACW,MAAM,GAAIH,QAAQ;IACtC;IAEA,OAAO,CAACA,QAAQ,GAAG,kBAAkB;AACvC;AAEA;;;;;;;CAOC,GACD,OAAO,SAASI,YAAYN,GAAW,EAAEO,MAAc,EAAEH,MAAc,EAAEH,OAAgB;IACvF,IAAIC,MAAMD,YAAYE,YAAY,aAAa,CAACF,YAAY;IAC5D,MAAMO,MAAMD,SAASH;IAErB,IAAK,IAAIR,IAAIW,QAAQX,IAAIY,KAAKZ,IAAK;QACjC,MAAMS,QAAQ,AAACH,CAAAA,MAAMF,GAAG,CAACJ,EAAE,AAAD,IAAK;QAC/BM,MAAMR,WAAW,CAACW,MAAM,GAAIH,QAAQ;IACtC;IAEA,OAAO,CAACA,QAAQ,GAAG,kBAAkB;AACvC;AAEA;;;;;CAKC,GACD,OAAO,SAASO,YAAYT,GAAW,EAAEU,QAAgB;IACvD,OAAOX,MAAMC,SAASU,aAAa;AACrC;AAEA;;;;;;;CAOC,GACD,OAAO,SAASC,kBAAkBX,GAAW,EAAEO,MAAc,EAAEH,MAAc,EAAEM,QAAgB;IAC7F,OAAOJ,YAAYN,KAAKO,QAAQH,YAAYM,aAAa;AAC3D"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/shared/index.ts"],"sourcesContent":["/**\n * Shared utilities for iterator libraries\n *\n * These utilities are designed to be used by:\n * - zip-iterator\n * - 7z-iterator\n * - tar-iterator\n * - Any other archive iterator library\n *\n * All utilities support Node.js 0.8+\n */\n\nimport BufferList from './BufferList.ts';\n\nexport { BufferList };\n\n/**\n * Type alias for Buffer or BufferList - both can be read byte-by-byte.\n * Use this when an API should accept either contiguous data (Buffer)\n * or chunked streaming data (BufferList).\n */\nexport type BufferLike = Buffer | BufferList;\nexport {\n  allocBuffer,\n  allocBufferUnsafe,\n  bufferCompare,\n  bufferConcat,\n  bufferEquals,\n  bufferFrom,\n  bufferSliceCopy,\n  createInflateRawStream,\n  inflateRaw,\n  isNaN,\n  objectAssign,\n  PassThrough,\n  Readable,\n  readUInt64LE,\n  Transform,\n  Writable,\n  writeUInt64LE,\n} from './compat.ts';\nexport { crc32, crc32Region, verifyCrc32, verifyCrc32Region } from './crc32.ts';\nexport { default as EntryStream } from './EntryStream.ts';\nexport { type CleanupFn, default as Lock } from './Lock.ts';\nexport { default as normalizePath } from './normalizePath.ts';\nexport { default as streamToString, type StreamToStringCallback } from './streamToString.ts';\nexport { default as stripPath } from './stripPath.ts';\n"],"names":["BufferList","allocBuffer","allocBufferUnsafe","bufferCompare","bufferConcat","bufferEquals","bufferFrom","bufferSliceCopy","createInflateRawStream","inflateRaw","isNaN","objectAssign","PassThrough","Readable","readUInt64LE","Transform","Writable","writeUInt64LE","crc32","crc32Region","verifyCrc32","verifyCrc32Region","default","EntryStream","Lock","normalizePath","streamToString","stripPath"],"mappings":"AAAA;;;;;;;;;;CAUC,GAED,OAAOA,gBAAgB,kBAAkB;AAEzC,SAASA,UAAU,GAAG;AAQtB,SACEC,WAAW,EACXC,iBAAiB,EACjBC,aAAa,EACbC,YAAY,EACZC,YAAY,EACZC,UAAU,EACVC,eAAe,EACfC,sBAAsB,EACtBC,UAAU,EACVC,KAAK,EACLC,YAAY,EACZC,WAAW,EACXC,QAAQ,EACRC,YAAY,EACZC,SAAS,EACTC,QAAQ,EACRC,aAAa,QACR,cAAc;AACrB,SAASC,KAAK,EAAEC,WAAW,EAAEC,WAAW,EAAEC,iBAAiB,QAAQ,aAAa;AAChF,SAASC,WAAWC,WAAW,QAAQ,mBAAmB;AAC1D,SAAyBD,WAAWE,IAAI,QAAQ,YAAY;AAC5D,SAASF,WAAWG,aAAa,QAAQ,qBAAqB;AAC9D,SAASH,WAAWI,cAAc,QAAqC,sBAAsB;AAC7F,SAASJ,WAAWK,SAAS,QAAQ,iBAAiB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/index.ts"],"sourcesContent":["/**\n * Shared utilities for iterator libraries\n *\n * These utilities are designed to be used by:\n * - zip-iterator\n * - 7z-iterator\n * - tar-iterator\n * - Any other archive iterator library\n *\n * All utilities support Node.js 0.8+\n */\n\nimport BufferList from './BufferList.ts';\n\nexport { BufferList };\n\n/**\n * Type alias for Buffer or BufferList - both can be read byte-by-byte.\n * Use this when an API should accept either contiguous data (Buffer)\n * or chunked streaming data (BufferList).\n */\nexport type BufferLike = Buffer | BufferList;\nexport {\n  allocBuffer,\n  allocBufferUnsafe,\n  bufferCompare,\n  bufferConcat,\n  bufferEquals,\n  bufferFrom,\n  bufferSliceCopy,\n  createInflateRawStream,\n  inflateRaw,\n  isNaN,\n  objectAssign,\n  PassThrough,\n  Readable,\n  readUInt64LE,\n  Transform,\n  Writable,\n  writeUInt64LE,\n} from './compat.ts';\nexport { crc32, crc32Region, verifyCrc32, verifyCrc32Region } from './crc32.ts';\nexport { default as EntryStream } from './EntryStream.ts';\nexport { type CleanupFn, default as Lock } from './Lock.ts';\nexport { default as normalizePath } from './normalizePath.ts';\nexport { default as streamToString, type StreamToStringCallback } from './streamToString.ts';\nexport { default as stripPath } from './stripPath.ts';\n"],"names":["BufferList","allocBuffer","allocBufferUnsafe","bufferCompare","bufferConcat","bufferEquals","bufferFrom","bufferSliceCopy","createInflateRawStream","inflateRaw","isNaN","objectAssign","PassThrough","Readable","readUInt64LE","Transform","Writable","writeUInt64LE","crc32","crc32Region","verifyCrc32","verifyCrc32Region","default","EntryStream","Lock","normalizePath","streamToString","stripPath"],"mappings":"AAAA;;;;;;;;;;CAUC,GAED,OAAOA,gBAAgB,kBAAkB;AAEzC,SAASA,UAAU,GAAG;AAQtB,SACEC,WAAW,EACXC,iBAAiB,EACjBC,aAAa,EACbC,YAAY,EACZC,YAAY,EACZC,UAAU,EACVC,eAAe,EACfC,sBAAsB,EACtBC,UAAU,EACVC,KAAK,EACLC,YAAY,EACZC,WAAW,EACXC,QAAQ,EACRC,YAAY,EACZC,SAAS,EACTC,QAAQ,EACRC,aAAa,QACR,cAAc;AACrB,SAASC,KAAK,EAAEC,WAAW,EAAEC,WAAW,EAAEC,iBAAiB,QAAQ,aAAa;AAChF,SAASC,WAAWC,WAAW,QAAQ,mBAAmB;AAC1D,SAAyBD,WAAWE,IAAI,QAAQ,YAAY;AAC5D,SAASF,WAAWG,aAAa,QAAQ,qBAAqB;AAC9D,SAASH,WAAWI,cAAc,QAAqC,sBAAsB;AAC7F,SAASJ,WAAWK,SAAS,QAAQ,iBAAiB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/shared/normalizePath.ts"],"sourcesContent":["/**\n * Normalize archive entry path\n *\n * - Converts backslashes to forward slashes\n * - Removes empty segments\n * - Removes leading slashes\n *\n * Node 0.8+ compatible.\n */\n\nexport default function normalizePath(p: string): string {\n  // Split on both forward and back slashes, filter empty segments, rejoin with forward slash\n  const segments = p.split(/[/\\\\]/);\n  const result: string[] = [];\n  for (let i = 0; i < segments.length; i++) {\n    if (segments[i].length > 0) {\n      result.push(segments[i]);\n    }\n  }\n  return result.join('/');\n}\n"],"names":["normalizePath","p","segments","split","result","i","length","push","join"],"mappings":"AAAA;;;;;;;;CAQC,GAED,eAAe,SAASA,cAAcC,CAAS;IAC7C,2FAA2F;IAC3F,MAAMC,WAAWD,EAAEE,KAAK,CAAC;IACzB,MAAMC,SAAmB,EAAE;IAC3B,IAAK,IAAIC,IAAI,GAAGA,IAAIH,SAASI,MAAM,EAAED,IAAK;QACxC,IAAIH,QAAQ,CAACG,EAAE,CAACC,MAAM,GAAG,GAAG;YAC1BF,OAAOG,IAAI,CAACL,QAAQ,CAACG,EAAE;QACzB;IACF;IACA,OAAOD,OAAOI,IAAI,CAAC;AACrB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/normalizePath.ts"],"sourcesContent":["/**\n * Normalize archive entry path\n *\n * - Converts backslashes to forward slashes\n * - Removes empty segments\n * - Removes leading slashes\n *\n * Node 0.8+ compatible.\n */\n\nexport default function normalizePath(p: string): string {\n  // Split on both forward and back slashes, filter empty segments, rejoin with forward slash\n  const segments = p.split(/[/\\\\]/);\n  const result: string[] = [];\n  for (let i = 0; i < segments.length; i++) {\n    if (segments[i].length > 0) {\n      result.push(segments[i]);\n    }\n  }\n  return result.join('/');\n}\n"],"names":["normalizePath","p","segments","split","result","i","length","push","join"],"mappings":"AAAA;;;;;;;;CAQC,GAED,eAAe,SAASA,cAAcC,CAAS;IAC7C,2FAA2F;IAC3F,MAAMC,WAAWD,EAAEE,KAAK,CAAC;IACzB,MAAMC,SAAmB,EAAE;IAC3B,IAAK,IAAIC,IAAI,GAAGA,IAAIH,SAASI,MAAM,EAAED,IAAK;QACxC,IAAIH,QAAQ,CAACG,EAAE,CAACC,MAAM,GAAG,GAAG;YAC1BF,OAAOG,IAAI,CAACL,QAAQ,CAACG,EAAE;QACzB;IACF;IACA,OAAOD,OAAOI,IAAI,CAAC;AACrB"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/shared/streamToString.ts"],"sourcesContent":["/**\n * Read entire stream content as string\n *\n * Handles both flowing streams and streams that have already\n * buffered data (using readable stream semantics).\n *\n * Node 0.8+ compatible.\n */\n\nimport oo from 'on-one';\nimport { bufferFrom } from './compat.ts';\n\nexport type StreamToStringCallback = (error?: Error, result?: string) => void;\n\nexport default function streamToString(stream: NodeJS.ReadableStream, callback: StreamToStringCallback): void {\n  const chunks: Buffer[] = [];\n\n  // Handle data from the stream\n  stream.on('data', (chunk: Buffer | string) => {\n    if (typeof chunk === 'string') {\n      chunks.push(bufferFrom(chunk, 'utf8'));\n    } else {\n      chunks.push(chunk);\n    }\n  });\n\n  // Handle stream end events using on-one for Node 0.8 compatibility\n  oo(stream, ['error', 'end', 'close'], (err?: Error) => {\n    if (err) {\n      callback(err);\n    } else {\n      const content = Buffer.concat(chunks).toString('utf8');\n      callback(null, content);\n    }\n  });\n\n  // Ensure stream is flowing (in case it's paused)\n  if (typeof (stream as NodeJS.ReadStream).resume === 'function') {\n    (stream as NodeJS.ReadStream).resume();\n  }\n}\n"],"names":["oo","bufferFrom","streamToString","stream","callback","chunks","on","chunk","push","err","content","Buffer","concat","toString","resume"],"mappings":"AAAA;;;;;;;CAOC,GAED,OAAOA,QAAQ,SAAS;AACxB,SAASC,UAAU,QAAQ,cAAc;AAIzC,eAAe,SAASC,eAAeC,MAA6B,EAAEC,QAAgC;IACpG,MAAMC,SAAmB,EAAE;IAE3B,8BAA8B;IAC9BF,OAAOG,EAAE,CAAC,QAAQ,CAACC;QACjB,IAAI,OAAOA,UAAU,UAAU;YAC7BF,OAAOG,IAAI,CAACP,WAAWM,OAAO;QAChC,OAAO;YACLF,OAAOG,IAAI,CAACD;QACd;IACF;IAEA,mEAAmE;IACnEP,GAAGG,QAAQ;QAAC;QAAS;QAAO;KAAQ,EAAE,CAACM;QACrC,IAAIA,KAAK;YACPL,SAASK;QACX,OAAO;YACL,MAAMC,UAAUC,OAAOC,MAAM,CAACP,QAAQQ,QAAQ,CAAC;YAC/CT,SAAS,MAAMM;QACjB;IACF;IAEA,iDAAiD;IACjD,IAAI,OAAO,AAACP,OAA6BW,MAAM,KAAK,YAAY;QAC7DX,OAA6BW,MAAM;IACtC;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/streamToString.ts"],"sourcesContent":["/**\n * Read entire stream content as string\n *\n * Handles both flowing streams and streams that have already\n * buffered data (using readable stream semantics).\n *\n * Node 0.8+ compatible.\n */\n\nimport oo from 'on-one';\nimport { bufferFrom } from './compat.ts';\n\nexport type StreamToStringCallback = (error?: Error, result?: string) => void;\n\nexport default function streamToString(stream: NodeJS.ReadableStream, callback: StreamToStringCallback): void {\n  const chunks: Buffer[] = [];\n\n  // Handle data from the stream\n  stream.on('data', (chunk: Buffer | string) => {\n    if (typeof chunk === 'string') {\n      chunks.push(bufferFrom(chunk, 'utf8'));\n    } else {\n      chunks.push(chunk);\n    }\n  });\n\n  // Handle stream end events using on-one for Node 0.8 compatibility\n  oo(stream, ['error', 'end', 'close'], (err?: Error) => {\n    if (err) {\n      callback(err);\n    } else {\n      const content = Buffer.concat(chunks).toString('utf8');\n      callback(null, content);\n    }\n  });\n\n  // Ensure stream is flowing (in case it's paused)\n  if (typeof (stream as NodeJS.ReadStream).resume === 'function') {\n    (stream as NodeJS.ReadStream).resume();\n  }\n}\n"],"names":["oo","bufferFrom","streamToString","stream","callback","chunks","on","chunk","push","err","content","Buffer","concat","toString","resume"],"mappings":"AAAA;;;;;;;CAOC,GAED,OAAOA,QAAQ,SAAS;AACxB,SAASC,UAAU,QAAQ,cAAc;AAIzC,eAAe,SAASC,eAAeC,MAA6B,EAAEC,QAAgC;IACpG,MAAMC,SAAmB,EAAE;IAE3B,8BAA8B;IAC9BF,OAAOG,EAAE,CAAC,QAAQ,CAACC;QACjB,IAAI,OAAOA,UAAU,UAAU;YAC7BF,OAAOG,IAAI,CAACP,WAAWM,OAAO;QAChC,OAAO;YACLF,OAAOG,IAAI,CAACD;QACd;IACF;IAEA,mEAAmE;IACnEP,GAAGG,QAAQ;QAAC;QAAS;QAAO;KAAQ,EAAE,CAACM;QACrC,IAAIA,KAAK;YACPL,SAASK;QACX,OAAO;YACL,MAAMC,UAAUC,OAAOC,MAAM,CAACP,QAAQQ,QAAQ,CAAC;YAC/CT,SAAS,MAAMM;QACjB;IACF;IAEA,iDAAiD;IACjD,IAAI,OAAO,AAACP,OAA6BW,MAAM,KAAK,YAAY;QAC7DX,OAA6BW,MAAM;IACtC;AACF"}

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/shared/stripPath.ts"],"sourcesContent":["import path from 'path';\n\nimport type { ExtractOptions } from '../types.ts';\n\nexport default function stripPath(relativePath: string, options: ExtractOptions): string {\n  const strip = options.strip || 0;\n  if (!strip) return relativePath;\n  const parts = relativePath.split(path.sep).filter(Boolean);\n  if (parts.length < strip) throw new Error(`You cannot strip more levels than there are directories. Strip: ${strip}. Path: ${relativePath}`);\n  return parts.slice(strip).join(path.sep);\n}\n"],"names":["path","stripPath","relativePath","options","strip","parts","split","sep","filter","Boolean","length","Error","slice","join"],"mappings":"AAAA,OAAOA,UAAU,OAAO;AAIxB,eAAe,SAASC,UAAUC,YAAoB,EAAEC,OAAuB;IAC7E,MAAMC,QAAQD,QAAQC,KAAK,IAAI;IAC/B,IAAI,CAACA,OAAO,OAAOF;IACnB,MAAMG,QAAQH,aAAaI,KAAK,CAACN,KAAKO,GAAG,EAAEC,MAAM,CAACC;IAClD,IAAIJ,MAAMK,MAAM,GAAGN,OAAO,MAAM,IAAIO,MAAM,CAAC,gEAAgE,EAAEP,MAAM,QAAQ,EAAEF,cAAc;IAC3I,OAAOG,MAAMO,KAAK,CAACR,OAAOS,IAAI,CAACb,KAAKO,GAAG;AACzC"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/stripPath.ts"],"sourcesContent":["import path from 'path';\n\nimport type { ExtractOptions } from '../types.ts';\n\nexport default function stripPath(relativePath: string, options: ExtractOptions): string {\n  const strip = options.strip || 0;\n  if (!strip) return relativePath;\n  const parts = relativePath.split(path.sep).filter(Boolean);\n  if (parts.length < strip) throw new Error(`You cannot strip more levels than there are directories. Strip: ${strip}. Path: ${relativePath}`);\n  return parts.slice(strip).join(path.sep);\n}\n"],"names":["path","stripPath","relativePath","options","strip","parts","split","sep","filter","Boolean","length","Error","slice","join"],"mappings":"AAAA,OAAOA,UAAU,OAAO;AAIxB,eAAe,SAASC,UAAUC,YAAoB,EAAEC,OAAuB;IAC7E,MAAMC,QAAQD,QAAQC,KAAK,IAAI;IAC/B,IAAI,CAACA,OAAO,OAAOF;IACnB,MAAMG,QAAQH,aAAaI,KAAK,CAACN,KAAKO,GAAG,EAAEC,MAAM,CAACC;IAClD,IAAIJ,MAAMK,MAAM,GAAGN,OAAO,MAAM,IAAIO,MAAM,CAAC,gEAAgE,EAAEP,MAAM,QAAQ,EAAEF,cAAc;IAC3I,OAAOG,MAAMO,KAAK,CAACR,OAAOS,IAAI,CAACb,KAAKO,GAAG;AACzC"}

package/dist/esm/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/types.ts"],"sourcesContent":["import type { Mode } from 'fs';\nimport type { StackOptions } from 'stack-base-iterator';\n\nexport interface ExtractOptions extends StackOptions {\n  force?: boolean;\n  strip?: number;\n  now?: Date;\n}\n\nexport type NoParamCallback = (error?: Error) => void;\nexport type WriteFileFn = (path: string, options: object, callback: NoParamCallback) => void;\n\nexport interface FileAttributes {\n  mode: Mode;\n  mtime: number;\n  path: string;\n}\n\nexport interface DirectoryAttributes {\n  mode: Mode;\n  mtime: number | Date;\n  path: string;\n}\n\nexport interface LinkAttributes {\n  mode: Mode;\n  mtime: number;\n  path: string;\n  linkpath: string;\n}\n\nimport type { default as DirectoryEntry } from './DirectoryEntry.ts';\nimport type { default as FileEntry } from './FileEntry.ts';\nimport type { default as LinkEntry } from './LinkEntry.ts';\nimport type { default as SymbolicLinkEntry } from './SymbolicLinkEntry.ts';\n\nexport type Entry = DirectoryEntry | FileEntry | LinkEntry | SymbolicLinkEntry;\n\nexport interface AbstractEntry {\n  mode: Mode;\n  mtime: number;\n  path: string;\n  basename: string;\n  type: string;\n  linkpath?: string;\n  uid?: number;\n  gid?: number;\n}\n"],"names":[],"mappings":"AAsCA,WASC"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/types.ts"],"sourcesContent":["import type { Mode } from 'fs';\nimport type { StackOptions } from 'stack-base-iterator';\n\nexport interface ExtractOptions extends StackOptions {\n  force?: boolean;\n  strip?: number;\n  now?: Date;\n}\n\nexport type NoParamCallback = (error?: Error) => void;\nexport type WriteFileFn = (path: string, options: object, callback: NoParamCallback) => void;\n\nexport interface FileAttributes {\n  mode: Mode;\n  mtime: number;\n  path: string;\n}\n\nexport interface DirectoryAttributes {\n  mode: Mode;\n  mtime: number | Date;\n  path: string;\n}\n\nexport interface LinkAttributes {\n  mode: Mode;\n  mtime: number;\n  path: string;\n  linkpath: string;\n}\n\nimport type { default as DirectoryEntry } from './DirectoryEntry.ts';\nimport type { default as FileEntry } from './FileEntry.ts';\nimport type { default as LinkEntry } from './LinkEntry.ts';\nimport type { default as SymbolicLinkEntry } from './SymbolicLinkEntry.ts';\n\nexport type Entry = DirectoryEntry | FileEntry | LinkEntry | SymbolicLinkEntry;\n\nexport interface AbstractEntry {\n  mode: Mode;\n  mtime: number;\n  path: string;\n  basename: string;\n  type: string;\n  linkpath?: string;\n  uid?: number;\n  gid?: number;\n}\n"],"names":[],"mappings":"AAsCA,WASC"}

package/dist/esm/validateAttributes.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/validateAttributes.ts"],"sourcesContent":["export default function validateAttributes(attributes: object, keys: string[]): void {\n  for (let index = 0; index < keys.length; index++) {\n    const key = keys[index];\n    if (attributes[key] === undefined) throw new Error(`Missing attribute ${key}.Attributes ${JSON.stringify(attributes)}`);\n  }\n}\n"],"names":["validateAttributes","attributes","keys","index","length","key","undefined","Error","JSON","stringify"],"mappings":"AAAA,eAAe,SAASA,mBAAmBC,UAAkB,EAAEC,IAAc;IAC3E,IAAK,IAAIC,QAAQ,GAAGA,QAAQD,KAAKE,MAAM,EAAED,QAAS;QAChD,MAAME,MAAMH,IAAI,CAACC,MAAM;QACvB,IAAIF,UAAU,CAACI,IAAI,KAAKC,WAAW,MAAM,IAAIC,MAAM,CAAC,kBAAkB,EAAEF,IAAI,YAAY,EAAEG,KAAKC,SAAS,CAACR,aAAa;IACxH;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/validateAttributes.ts"],"sourcesContent":["export default function validateAttributes(attributes: object, keys: string[]): void {\n  for (let index = 0; index < keys.length; index++) {\n    const key = keys[index];\n    if (attributes[key] === undefined) throw new Error(`Missing attribute ${key}.Attributes ${JSON.stringify(attributes)}`);\n  }\n}\n"],"names":["validateAttributes","attributes","keys","index","length","key","undefined","Error","JSON","stringify"],"mappings":"AAAA,eAAe,SAASA,mBAAmBC,UAAkB,EAAEC,IAAc;IAC3E,IAAK,IAAIC,QAAQ,GAAGA,QAAQD,KAAKE,MAAM,EAAED,QAAS;QAChD,MAAME,MAAMH,IAAI,CAACC,MAAM;QACvB,IAAIF,UAAU,CAACI,IAAI,KAAKC,WAAW,MAAM,IAAIC,MAAM,CAAC,kBAAkB,EAAEF,IAAI,YAAY,EAAEG,KAAKC,SAAS,CAACR,aAAa;IACxH;AACF"}

package/dist/esm/waitForAccess.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/iterators/extract-base-iterator/src/waitForAccess.ts"],"sourcesContent":["import fs from 'graceful-fs';\n\nimport type { NoParamCallback } from './types.ts';\n\n// Backward compatible: waitForAccess(path, callback) or waitForAccess(path, noFollow, callback)\nexport default function waitForAccess(fullPath: string, noFollow: boolean | NoParamCallback, callback?: NoParamCallback | number) {\n  callback = typeof noFollow === 'function' ? noFollow : callback;\n  noFollow = typeof noFollow === 'function' ? false : (noFollow as boolean);\n\n  // Exponential backoff: 5, 10, 20, 40, 80, 160, 320, 640, 1280, 2560ms\n  // Total max wait: ~5 seconds\n  function waitSymlink(attempts, cb) {\n    fs.lstat(fullPath, (err) => {\n      if (err) {\n        if (err.code === 'ENOENT' && attempts < 10) {\n          const delay = Math.min(5 * 2 ** attempts, 2560);\n          return setTimeout(() => waitSymlink(attempts + 1, cb), delay);\n        }\n        return cb(err);\n      }\n      cb();\n    });\n  }\n  function waitOpen(attempts, cb) {\n    fs.open(fullPath, 'r', (err, fd) => {\n      if (err) {\n        if (err.code === 'ENOENT' && attempts < 10) {\n          const delay = Math.min(5 * 2 ** attempts, 2560);\n          return setTimeout(() => waitOpen(attempts + 1, cb), delay);\n        }\n        return cb(err);\n      }\n      fs.close(fd, () => cb());\n    });\n  }\n\n  // Windows: NTFS metadata may not be committed yet, verify accessibility\n  // Node 0.10: the write stream's finish/close events may fire before the file is fully flushed to disk\n  // For symlinks (noFollow=true), use lstat to check the link itself exists\n  // For files/dirs/hardlinks, use open to verify the file is accessible\n  noFollow ? waitSymlink(0, callback) : waitOpen(0, callback);\n}\n"],"names":["fs","waitForAccess","fullPath","noFollow","callback","waitSymlink","attempts","cb","lstat","err","code","delay","Math","min","setTimeout","waitOpen","open","fd","close"],"mappings":"AAAA,OAAOA,QAAQ,cAAc;AAI7B,gGAAgG;AAChG,eAAe,SAASC,cAAcC,QAAgB,EAAEC,QAAmC,EAAEC,QAAmC;IAC9HA,WAAW,OAAOD,aAAa,aAAaA,WAAWC;IACvDD,WAAW,OAAOA,aAAa,aAAa,QAASA;IAErD,sEAAsE;IACtE,6BAA6B;IAC7B,SAASE,YAAYC,QAAQ,EAAEC,EAAE;QAC/BP,GAAGQ,KAAK,CAACN,UAAU,CAACO;YAClB,IAAIA,KAAK;gBACP,IAAIA,IAAIC,IAAI,KAAK,YAAYJ,WAAW,IAAI;oBAC1C,MAAMK,QAAQC,KAAKC,GAAG,CAAC,IAAI,KAAKP,UAAU;oBAC1C,OAAOQ,WAAW,IAAMT,YAAYC,WAAW,GAAGC,KAAKI;gBACzD;gBACA,OAAOJ,GAAGE;YACZ;YACAF;QACF;IACF;IACA,SAASQ,SAAST,QAAQ,EAAEC,EAAE;QAC5BP,GAAGgB,IAAI,CAACd,UAAU,KAAK,CAACO,KAAKQ;YAC3B,IAAIR,KAAK;gBACP,IAAIA,IAAIC,IAAI,KAAK,YAAYJ,WAAW,IAAI;oBAC1C,MAAMK,QAAQC,KAAKC,GAAG,CAAC,IAAI,KAAKP,UAAU;oBAC1C,OAAOQ,WAAW,IAAMC,SAAST,WAAW,GAAGC,KAAKI;gBACtD;gBACA,OAAOJ,GAAGE;YACZ;YACAT,GAAGkB,KAAK,CAACD,IAAI,IAAMV;QACrB;IACF;IAEA,wEAAwE;IACxE,sGAAsG;IACtG,0EAA0E;IAC1E,sEAAsE;IACtEJ,WAAWE,YAAY,GAAGD,YAAYW,SAAS,GAAGX;AACpD"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/waitForAccess.ts"],"sourcesContent":["import fs from 'graceful-fs';\n\nimport type { NoParamCallback } from './types.ts';\n\n// Backward compatible: waitForAccess(path, callback) or waitForAccess(path, noFollow, callback)\nexport default function waitForAccess(fullPath: string, noFollow: boolean | NoParamCallback, callback?: NoParamCallback | number) {\n  callback = typeof noFollow === 'function' ? noFollow : callback;\n  noFollow = typeof noFollow === 'function' ? false : (noFollow as boolean);\n\n  // Exponential backoff: 5, 10, 20, 40, 80, 160, 320, 640, 1280, 2560ms\n  // Total max wait: ~5 seconds\n  function waitSymlink(attempts, cb) {\n    fs.lstat(fullPath, (err) => {\n      if (err) {\n        if (err.code === 'ENOENT' && attempts < 10) {\n          const delay = Math.min(5 * 2 ** attempts, 2560);\n          return setTimeout(() => waitSymlink(attempts + 1, cb), delay);\n        }\n        return cb(err);\n      }\n      cb();\n    });\n  }\n  function waitOpen(attempts, cb) {\n    fs.open(fullPath, 'r', (err, fd) => {\n      if (err) {\n        if (err.code === 'ENOENT' && attempts < 10) {\n          const delay = Math.min(5 * 2 ** attempts, 2560);\n          return setTimeout(() => waitOpen(attempts + 1, cb), delay);\n        }\n        return cb(err);\n      }\n      fs.close(fd, () => cb());\n    });\n  }\n\n  // Windows: NTFS metadata may not be committed yet, verify accessibility\n  // Node 0.10: the write stream's finish/close events may fire before the file is fully flushed to disk\n  // For symlinks (noFollow=true), use lstat to check the link itself exists\n  // For files/dirs/hardlinks, use open to verify the file is accessible\n  noFollow ? waitSymlink(0, callback) : waitOpen(0, callback);\n}\n"],"names":["fs","waitForAccess","fullPath","noFollow","callback","waitSymlink","attempts","cb","lstat","err","code","delay","Math","min","setTimeout","waitOpen","open","fd","close"],"mappings":"AAAA,OAAOA,QAAQ,cAAc;AAI7B,gGAAgG;AAChG,eAAe,SAASC,cAAcC,QAAgB,EAAEC,QAAmC,EAAEC,QAAmC;IAC9HA,WAAW,OAAOD,aAAa,aAAaA,WAAWC;IACvDD,WAAW,OAAOA,aAAa,aAAa,QAASA;IAErD,sEAAsE;IACtE,6BAA6B;IAC7B,SAASE,YAAYC,QAAQ,EAAEC,EAAE;QAC/BP,GAAGQ,KAAK,CAACN,UAAU,CAACO;YAClB,IAAIA,KAAK;gBACP,IAAIA,IAAIC,IAAI,KAAK,YAAYJ,WAAW,IAAI;oBAC1C,MAAMK,QAAQC,KAAKC,GAAG,CAAC,IAAI,KAAKP,UAAU;oBAC1C,OAAOQ,WAAW,IAAMT,YAAYC,WAAW,GAAGC,KAAKI;gBACzD;gBACA,OAAOJ,GAAGE;YACZ;YACAF;QACF;IACF;IACA,SAASQ,SAAST,QAAQ,EAAEC,EAAE;QAC5BP,GAAGgB,IAAI,CAACd,UAAU,KAAK,CAACO,KAAKQ;YAC3B,IAAIR,KAAK;gBACP,IAAIA,IAAIC,IAAI,KAAK,YAAYJ,WAAW,IAAI;oBAC1C,MAAMK,QAAQC,KAAKC,GAAG,CAAC,IAAI,KAAKP,UAAU;oBAC1C,OAAOQ,WAAW,IAAMC,SAAST,WAAW,GAAGC,KAAKI;gBACtD;gBACA,OAAOJ,GAAGE;YACZ;YACAT,GAAGkB,KAAK,CAACD,IAAI,IAAMV;QACrB;IACF;IAEA,wEAAwE;IACxE,sGAAsG;IACtG,0EAA0E;IAC1E,sEAAsE;IACtEJ,WAAWE,YAAY,GAAGD,YAAYW,SAAS,GAAGX;AACpD"}

package/package.json

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