extract-base-iterator 2.2.6 → 2.3.0

package/dist/cjs/index.d.cts

@@ -7,5 +7,6 @@ export { default as DirectoryEntry } from './DirectoryEntry.js';
 export { default as FileEntry } from './FileEntry.js';
 export { default as LinkEntry } from './LinkEntry.js';
 export { default as SymbolicLinkEntry } from './SymbolicLinkEntry.js';
+export * from './shared/index.js';
 export * from './types.js';
 export { default as waitForAccess } from './waitForAccess.js';

package/dist/cjs/index.d.ts

@@ -7,5 +7,6 @@ export { default as DirectoryEntry } from './DirectoryEntry.js';
 export { default as FileEntry } from './FileEntry.js';
 export { default as LinkEntry } from './LinkEntry.js';
 export { default as SymbolicLinkEntry } from './SymbolicLinkEntry.js';
+export * from './shared/index.js';
 export * from './types.js';
 export { default as waitForAccess } from './waitForAccess.js';

package/dist/cjs/index.js

@@ -34,6 +34,7 @@ var _DirectoryEntryts = /*#__PURE__*/ _interop_require_default(require("./Direct
 var _FileEntryts = /*#__PURE__*/ _interop_require_default(require("./FileEntry.js"));
 var _LinkEntryts = /*#__PURE__*/ _interop_require_default(require("./LinkEntry.js"));
 var _SymbolicLinkEntryts = /*#__PURE__*/ _interop_require_default(require("./SymbolicLinkEntry.js"));
+_export_star(require("./shared/index.js"), exports);
 _export_star(require("./types.js"), exports);
 var _waitForAccessts = /*#__PURE__*/ _interop_require_default(require("./waitForAccess.js"));
 function _assert_this_initialized(self) {

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/index.ts"],"sourcesContent":["import './polyfills.ts';\nimport StackBaseIterator from 'stack-base-iterator';\n\nimport type { Entry } from './types.ts';\n\nexport default class ExtractBaseIterator extends StackBaseIterator<Entry> {}\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';\nexport * from './types.ts';\nexport { default as waitForAccess } from './waitForAccess.ts';\n"],"names":["DirectoryEntry","FileEntry","LinkEntry","SymbolicLinkEntry","ExtractBaseIterator","waitForAccess","StackBaseIterator"],"mappings":";;;;;;;;;;;QAOoBA;eAAAA,yBAAc;;QACdC;eAAAA,oBAAS;;QACTC;eAAAA,oBAAS;;QACTC;eAAAA,4BAAiB;;;eALhBC;;QAODC;eAAAA,wBAAa;;;QAZ1B;wEACuB;uEAMY;kEACL;kEACA;0EACQ;qBAC/B;sEAC2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAP1B,IAAA,AAAMD,oCAAN;;cAAMA;aAAAA;gCAAAA;QAAN,OAAA,kBAAMA;;WAAAA;EAA4BE,0BAAiB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/index.ts"],"sourcesContent":["import './polyfills.ts';\nimport StackBaseIterator from 'stack-base-iterator';\n\nimport type { Entry } from './types.ts';\n\nexport default class ExtractBaseIterator extends StackBaseIterator<Entry> {}\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":";;;;;;;;;;;QAOoBA;eAAAA,yBAAc;;QACdC;eAAAA,oBAAS;;QACTC;eAAAA,oBAAS;;QACTC;eAAAA,4BAAiB;;;eALhBC;;QASDC;eAAAA,wBAAa;;;QAd1B;wEACuB;uEAMY;kEACL;kEACA;0EACQ;qBAE/B;qBACA;sEAC2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAT1B,IAAA,AAAMD,oCAAN;;cAAMA;aAAAA;gCAAAA;QAAN,OAAA,kBAAMA;;WAAAA;EAA4BE,0BAAiB"}

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

@@ -0,0 +1,78 @@
+/**
+ * Buffer Compatibility Layer for Node.js 0.8+
+ *
+ * Provides buffer utilities that work across all Node.js versions
+ * WITHOUT modifying global Buffer object.
+ *
+ * Version history:
+ * - Node 0.8-4.4: Only has `new Buffer()`, no `Buffer.alloc/from`
+ * - Node 4.5+: Has `Buffer.alloc/from`, deprecates `new Buffer()`
+ * - Node 10+: Warns or errors on `new Buffer()`
+ *
+ * Solution: Feature detection with graceful fallback in both directions.
+ */
+/**
+ * Allocate a zero-filled buffer (safe)
+ * - Uses Buffer.alloc() on Node 4.5+
+ * - Falls back to new Buffer() + fill on Node 0.8-4.4
+ */
+export declare function allocBuffer(size: number): Buffer;
+/**
+ * Allocate a buffer without initialization (unsafe but faster)
+ * - Uses Buffer.allocUnsafe() on Node 4.5+
+ * - Falls back to new Buffer() on Node 0.8-4.4
+ *
+ * WARNING: Buffer contents are uninitialized and may contain sensitive data.
+ * Only use when you will immediately overwrite all bytes.
+ */
+export declare function allocBufferUnsafe(size: number): Buffer;
+/**
+ * Create a buffer from string, array, or existing buffer
+ * - Uses Buffer.from() on Node 4.5+
+ * - Falls back to new Buffer() on Node 0.8-4.4
+ * - Handles Uint8Array conversion for Node 0.8 (crypto output compatibility)
+ */
+export declare function bufferFrom(data: string | number[] | Buffer | Uint8Array, encoding?: BufferEncoding): Buffer;
+/**
+ * Compare two buffers or buffer regions
+ * - Uses Buffer.compare() on Node 5.10+ (with offset support)
+ * - Falls back to manual comparison on Node 0.8-5.9
+ */
+export declare function bufferCompare(source: Buffer, target: Buffer, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): number;
+/**
+ * Check if buffer region equals byte array
+ * Useful for magic number detection without Buffer.from()
+ */
+export declare function bufferEquals(buf: Buffer, offset: number, expected: number[]): boolean;
+/**
+ * Copy buffer region to new buffer
+ * Works on all Node versions
+ */
+export declare function bufferSliceCopy(buf: Buffer, start: number, end: number): Buffer;
+/**
+ * Read 64-bit unsigned integer (little-endian)
+ * Uses two 32-bit reads since BigInt not available until Node 10.4
+ *
+ * WARNING: Only accurate for values < Number.MAX_SAFE_INTEGER (2^53 - 1)
+ * This covers files up to ~9 PB which is practical for all real use cases.
+ */
+export declare function readUInt64LE(buf: Buffer, offset: number): number;
+/**
+ * Write 64-bit unsigned integer (little-endian)
+ * Same precision limitation as readUInt64LE
+ */
+export declare function writeUInt64LE(buf: Buffer, value: number, offset: number): void;
+/**
+ * Concatenate buffers - compatible with Node 0.8
+ * Handles crypto output which may not be proper Buffer instances in old Node.
+ *
+ * NOTE: This function is primarily needed for AES decryption compatibility
+ * in Node 0.8 where crypto output may not be proper Buffer instances.
+ * Libraries not using crypto can use native Buffer.concat() directly.
+ */
+export declare function bufferConcat(list: (Buffer | Uint8Array)[], totalLength?: number): Buffer;
+/**
+ * Node 0.8 compatible isNaN (Number.isNaN didn't exist until ES2015)
+ * Uses self-comparison: NaN is the only value not equal to itself
+ */
+export declare function isNaN(value: number): boolean;

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

@@ -0,0 +1,78 @@
+/**
+ * Buffer Compatibility Layer for Node.js 0.8+
+ *
+ * Provides buffer utilities that work across all Node.js versions
+ * WITHOUT modifying global Buffer object.
+ *
+ * Version history:
+ * - Node 0.8-4.4: Only has `new Buffer()`, no `Buffer.alloc/from`
+ * - Node 4.5+: Has `Buffer.alloc/from`, deprecates `new Buffer()`
+ * - Node 10+: Warns or errors on `new Buffer()`
+ *
+ * Solution: Feature detection with graceful fallback in both directions.
+ */
+/**
+ * Allocate a zero-filled buffer (safe)
+ * - Uses Buffer.alloc() on Node 4.5+
+ * - Falls back to new Buffer() + fill on Node 0.8-4.4
+ */
+export declare function allocBuffer(size: number): Buffer;
+/**
+ * Allocate a buffer without initialization (unsafe but faster)
+ * - Uses Buffer.allocUnsafe() on Node 4.5+
+ * - Falls back to new Buffer() on Node 0.8-4.4
+ *
+ * WARNING: Buffer contents are uninitialized and may contain sensitive data.
+ * Only use when you will immediately overwrite all bytes.
+ */
+export declare function allocBufferUnsafe(size: number): Buffer;
+/**
+ * Create a buffer from string, array, or existing buffer
+ * - Uses Buffer.from() on Node 4.5+
+ * - Falls back to new Buffer() on Node 0.8-4.4
+ * - Handles Uint8Array conversion for Node 0.8 (crypto output compatibility)
+ */
+export declare function bufferFrom(data: string | number[] | Buffer | Uint8Array, encoding?: BufferEncoding): Buffer;
+/**
+ * Compare two buffers or buffer regions
+ * - Uses Buffer.compare() on Node 5.10+ (with offset support)
+ * - Falls back to manual comparison on Node 0.8-5.9
+ */
+export declare function bufferCompare(source: Buffer, target: Buffer, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): number;
+/**
+ * Check if buffer region equals byte array
+ * Useful for magic number detection without Buffer.from()
+ */
+export declare function bufferEquals(buf: Buffer, offset: number, expected: number[]): boolean;
+/**
+ * Copy buffer region to new buffer
+ * Works on all Node versions
+ */
+export declare function bufferSliceCopy(buf: Buffer, start: number, end: number): Buffer;
+/**
+ * Read 64-bit unsigned integer (little-endian)
+ * Uses two 32-bit reads since BigInt not available until Node 10.4
+ *
+ * WARNING: Only accurate for values < Number.MAX_SAFE_INTEGER (2^53 - 1)
+ * This covers files up to ~9 PB which is practical for all real use cases.
+ */
+export declare function readUInt64LE(buf: Buffer, offset: number): number;
+/**
+ * Write 64-bit unsigned integer (little-endian)
+ * Same precision limitation as readUInt64LE
+ */
+export declare function writeUInt64LE(buf: Buffer, value: number, offset: number): void;
+/**
+ * Concatenate buffers - compatible with Node 0.8
+ * Handles crypto output which may not be proper Buffer instances in old Node.
+ *
+ * NOTE: This function is primarily needed for AES decryption compatibility
+ * in Node 0.8 where crypto output may not be proper Buffer instances.
+ * Libraries not using crypto can use native Buffer.concat() directly.
+ */
+export declare function bufferConcat(list: (Buffer | Uint8Array)[], totalLength?: number): Buffer;
+/**
+ * Node 0.8 compatible isNaN (Number.isNaN didn't exist until ES2015)
+ * Uses self-comparison: NaN is the only value not equal to itself
+ */
+export declare function isNaN(value: number): boolean;

package/dist/cjs/shared/compat.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get allocBuffer () {
+        return allocBuffer;
+    },
+    get allocBufferUnsafe () {
+        return allocBufferUnsafe;
+    },
+    get bufferCompare () {
+        return bufferCompare;
+    },
+    get bufferConcat () {
+        return bufferConcat;
+    },
+    get bufferEquals () {
+        return bufferEquals;
+    },
+    get bufferFrom () {
+        return bufferFrom;
+    },
+    get bufferSliceCopy () {
+        return bufferSliceCopy;
+    },
+    get isNaN () {
+        return isNaN;
+    },
+    get readUInt64LE () {
+        return readUInt64LE;
+    },
+    get writeUInt64LE () {
+        return writeUInt64LE;
+    }
+});
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+/**
+ * Buffer Compatibility Layer for Node.js 0.8+
+ *
+ * Provides buffer utilities that work across all Node.js versions
+ * WITHOUT modifying global Buffer object.
+ *
+ * Version history:
+ * - Node 0.8-4.4: Only has `new Buffer()`, no `Buffer.alloc/from`
+ * - Node 4.5+: Has `Buffer.alloc/from`, deprecates `new Buffer()`
+ * - Node 10+: Warns or errors on `new Buffer()`
+ *
+ * Solution: Feature detection with graceful fallback in both directions.
+ */ // Feature detection (runs once at module load)
+var hasBufferAlloc = typeof Buffer.alloc === 'function';
+var hasBufferAllocUnsafe = typeof Buffer.allocUnsafe === 'function';
+var hasBufferFrom = typeof Buffer.from === 'function' && Buffer.from !== Uint8Array.from;
+function allocBuffer(size) {
+    if (hasBufferAlloc) {
+        return Buffer.alloc(size);
+    }
+    // Legacy fallback: new Buffer() is uninitialized, must zero-fill
+    var buf = new Buffer(size);
+    buf.fill(0);
+    return buf;
+}
+function allocBufferUnsafe(size) {
+    if (hasBufferAllocUnsafe) {
+        return Buffer.allocUnsafe(size);
+    }
+    return new Buffer(size);
+}
+function bufferFrom(data, encoding) {
+    if (hasBufferFrom) {
+        if (typeof data === 'string') {
+            return Buffer.from(data, encoding);
+        }
+        return Buffer.from(data);
+    }
+    // Node 0.8 compatibility - deprecated Buffer constructor
+    // For Uint8Array, convert to array first (needed for crypto output in Node 0.8)
+    if (_instanceof(data, Uint8Array) && !_instanceof(data, Buffer)) {
+        var arr = [];
+        for(var i = 0; i < data.length; i++){
+            arr.push(data[i]);
+        }
+        return new Buffer(arr);
+    }
+    return new Buffer(data, encoding);
+}
+function bufferCompare(source, target, targetStart, targetEnd, sourceStart, sourceEnd) {
+    sourceStart = sourceStart || 0;
+    sourceEnd = sourceEnd || source.length;
+    targetStart = targetStart || 0;
+    targetEnd = targetEnd || target.length;
+    // Check if native compare with offset support exists (Node 5.10+)
+    if (source.compare && source.compare.length >= 5) {
+        return source.compare(target, targetStart, targetEnd, sourceStart, sourceEnd);
+    }
+    // Manual comparison for older Node versions
+    var sourceLen = sourceEnd - sourceStart;
+    var targetLen = targetEnd - targetStart;
+    var len = Math.min(sourceLen, targetLen);
+    for(var i = 0; i < len; i++){
+        var s = source[sourceStart + i];
+        var t = target[targetStart + i];
+        if (s !== t) return s < t ? -1 : 1;
+    }
+    return sourceLen - targetLen;
+}
+function bufferEquals(buf, offset, expected) {
+    if (offset + expected.length > buf.length) return false;
+    for(var i = 0; i < expected.length; i++){
+        if (buf[offset + i] !== expected[i]) return false;
+    }
+    return true;
+}
+function bufferSliceCopy(buf, start, end) {
+    var result = allocBuffer(end - start);
+    buf.copy(result, 0, start, end);
+    return result;
+}
+function readUInt64LE(buf, offset) {
+    var low = buf.readUInt32LE(offset);
+    var high = buf.readUInt32LE(offset + 4);
+    return high * 0x100000000 + low;
+}
+function writeUInt64LE(buf, value, offset) {
+    var low = value >>> 0;
+    var high = value / 0x100000000 >>> 0;
+    buf.writeUInt32LE(low, offset);
+    buf.writeUInt32LE(high, offset + 4);
+}
+function bufferConcat(list, totalLength) {
+    // Calculate actual total length first
+    var actualLength = 0;
+    for(var i = 0; i < list.length; i++){
+        actualLength += list[i].length;
+    }
+    // Use specified totalLength or actual length
+    var targetLength = totalLength !== undefined ? totalLength : actualLength;
+    // Check if all items are proper Buffers AND no truncation needed
+    // (Node 0.8's Buffer.concat doesn't handle truncation well)
+    var allBuffers = true;
+    for(var j = 0; j < list.length; j++){
+        if (!_instanceof(list[j], Buffer)) {
+            allBuffers = false;
+            break;
+        }
+    }
+    if (allBuffers && targetLength >= actualLength) {
+        return Buffer.concat(list, targetLength);
+    }
+    // Manual concat for mixed types or when truncation is needed
+    var result = allocBuffer(targetLength);
+    var offset = 0;
+    for(var k = 0; k < list.length && offset < targetLength; k++){
+        var buf = list[k];
+        for(var l = 0; l < buf.length && offset < targetLength; l++){
+            result[offset++] = buf[l];
+        }
+    }
+    return result;
+}
+function isNaN(value) {
+    // biome-ignore lint/suspicious/noSelfCompare: NaN check pattern
+    return value !== value;
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/compat.ts"],"sourcesContent":["/**\n * Buffer Compatibility Layer for Node.js 0.8+\n *\n * Provides buffer utilities that work across all Node.js versions\n * WITHOUT modifying global Buffer object.\n *\n * Version history:\n * - Node 0.8-4.4: Only has `new Buffer()`, no `Buffer.alloc/from`\n * - Node 4.5+: Has `Buffer.alloc/from`, deprecates `new Buffer()`\n * - Node 10+: Warns or errors on `new Buffer()`\n *\n * Solution: Feature detection with graceful fallback in both directions.\n */\n\n// Feature detection (runs once at module load)\nvar hasBufferAlloc = typeof Buffer.alloc === 'function';\nvar hasBufferAllocUnsafe = typeof Buffer.allocUnsafe === 'function';\nvar 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  var 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    var arr: number[] = [];\n    for (var 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  var sourceLen = sourceEnd - sourceStart;\n  var targetLen = targetEnd - targetStart;\n  var len = Math.min(sourceLen, targetLen);\n\n  for (var i = 0; i < len; i++) {\n    var s = source[sourceStart + i];\n    var 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 (var 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  var 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  var low = buf.readUInt32LE(offset);\n  var 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  var low = value >>> 0;\n  var 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  var actualLength = 0;\n  for (var i = 0; i < list.length; i++) {\n    actualLength += list[i].length;\n  }\n\n  // Use specified totalLength or actual length\n  var 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  var allBuffers = true;\n  for (var 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  var result = allocBuffer(targetLength);\n  var offset = 0;\n  for (var k = 0; k < list.length && offset < targetLength; k++) {\n    var buf = list[k];\n    for (var 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"],"names":["allocBuffer","allocBufferUnsafe","bufferCompare","bufferConcat","bufferEquals","bufferFrom","bufferSliceCopy","isNaN","readUInt64LE","writeUInt64LE","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"],"mappings":";;;;;;;;;;;QAwBgBA;eAAAA;;QAkBAC;eAAAA;;QAqCAC;eAAAA;;QA+EAC;eAAAA;;QAlDAC;eAAAA;;QArDAC;eAAAA;;QAiEAC;eAAAA;;QA8EAC;eAAAA;;QAjEAC;eAAAA;;QAUAC;eAAAA;;;;;;;;;;AA/IhB;;;;;;;;;;;;CAYC,GAED,+CAA+C;AAC/C,IAAIC,iBAAiB,OAAOC,OAAOC,KAAK,KAAK;AAC7C,IAAIC,uBAAuB,OAAOF,OAAOG,WAAW,KAAK;AACzD,IAAIC,gBAAgB,OAAOJ,OAAOK,IAAI,KAAK,cAAcL,OAAOK,IAAI,KAAKC,WAAWD,IAAI;AAOjF,SAAShB,YAAYkB,IAAY;IACtC,IAAIR,gBAAgB;QAClB,OAAOC,OAAOC,KAAK,CAACM;IACtB;IACA,iEAAiE;IACjE,IAAIC,MAAM,IAAIR,OAAOO;IACrBC,IAAIC,IAAI,CAAC;IACT,OAAOD;AACT;AAUO,SAASlB,kBAAkBiB,IAAY;IAC5C,IAAIL,sBAAsB;QACxB,OAAOF,OAAOG,WAAW,CAACI;IAC5B;IACA,OAAO,IAAIP,OAAOO;AACpB;AAQO,SAASb,WAAWgB,IAA6C,EAAEC,QAAyB;IACjG,IAAIP,eAAe;QACjB,IAAI,OAAOM,SAAS,UAAU;YAC5B,OAAOV,OAAOK,IAAI,CAACK,MAAMC;QAC3B;QACA,OAAOX,OAAOK,IAAI,CAACK;IACrB;IACA,yDAAyD;IACzD,gFAAgF;IAChF,IAAIA,AAAI,YAAJA,MAAgBJ,eAAc,CAAEI,AAAI,YAAJA,MAAgBV,SAAS;QAC3D,IAAIY,MAAgB,EAAE;QACtB,IAAK,IAAIC,IAAI,GAAGA,IAAIH,KAAKI,MAAM,EAAED,IAAK;YACpCD,IAAIG,IAAI,CAACL,IAAI,CAACG,EAAE;QAClB;QACA,OAAO,IAAIb,OAAOY;IACpB;IACA,OAAO,IAAIZ,OAAOU,MAA2BC;AAC/C;AAOO,SAASpB,cAAcyB,MAAc,EAAEC,MAAc,EAAEC,WAAoB,EAAEC,SAAkB,EAAEC,WAAoB,EAAEC,SAAkB;IAC9ID,cAAcA,eAAe;IAC7BC,YAAYA,aAAaL,OAAOF,MAAM;IACtCI,cAAcA,eAAe;IAC7BC,YAAYA,aAAaF,OAAOH,MAAM;IAEtC,kEAAkE;IAClE,IAAIE,OAAOM,OAAO,IAAIN,OAAOM,OAAO,CAACR,MAAM,IAAI,GAAG;QAChD,OAAOE,OAAOM,OAAO,CAACL,QAAQC,aAAaC,WAAWC,aAAaC;IACrE;IAEA,4CAA4C;IAC5C,IAAIE,YAAYF,YAAYD;IAC5B,IAAII,YAAYL,YAAYD;IAC5B,IAAIO,MAAMC,KAAKC,GAAG,CAACJ,WAAWC;IAE9B,IAAK,IAAIX,IAAI,GAAGA,IAAIY,KAAKZ,IAAK;QAC5B,IAAIe,IAAIZ,MAAM,CAACI,cAAcP,EAAE;QAC/B,IAAIgB,IAAIZ,MAAM,CAACC,cAAcL,EAAE;QAC/B,IAAIe,MAAMC,GAAG,OAAOD,IAAIC,IAAI,CAAC,IAAI;IACnC;IAEA,OAAON,YAAYC;AACrB;AAMO,SAAS/B,aAAae,GAAW,EAAEsB,MAAc,EAAEC,QAAkB;IAC1E,IAAID,SAASC,SAASjB,MAAM,GAAGN,IAAIM,MAAM,EAAE,OAAO;IAClD,IAAK,IAAID,IAAI,GAAGA,IAAIkB,SAASjB,MAAM,EAAED,IAAK;QACxC,IAAIL,GAAG,CAACsB,SAASjB,EAAE,KAAKkB,QAAQ,CAAClB,EAAE,EAAE,OAAO;IAC9C;IACA,OAAO;AACT;AAMO,SAASlB,gBAAgBa,GAAW,EAAEwB,KAAa,EAAEC,GAAW;IACrE,IAAIC,SAAS7C,YAAY4C,MAAMD;IAC/BxB,IAAI2B,IAAI,CAACD,QAAQ,GAAGF,OAAOC;IAC3B,OAAOC;AACT;AASO,SAASrC,aAAaW,GAAW,EAAEsB,MAAc;IACtD,IAAIM,MAAM5B,IAAI6B,YAAY,CAACP;IAC3B,IAAIQ,OAAO9B,IAAI6B,YAAY,CAACP,SAAS;IACrC,OAAOQ,OAAO,cAAcF;AAC9B;AAMO,SAAStC,cAAcU,GAAW,EAAE+B,KAAa,EAAET,MAAc;IACtE,IAAIM,MAAMG,UAAU;IACpB,IAAID,OAAO,AAACC,QAAQ,gBAAiB;IACrC/B,IAAIgC,aAAa,CAACJ,KAAKN;IACvBtB,IAAIgC,aAAa,CAACF,MAAMR,SAAS;AACnC;AAUO,SAAStC,aAAaiD,IAA6B,EAAEC,WAAoB;IAC9E,sCAAsC;IACtC,IAAIC,eAAe;IACnB,IAAK,IAAI9B,IAAI,GAAGA,IAAI4B,KAAK3B,MAAM,EAAED,IAAK;QACpC8B,gBAAgBF,IAAI,CAAC5B,EAAE,CAACC,MAAM;IAChC;IAEA,6CAA6C;IAC7C,IAAI8B,eAAeF,gBAAgBG,YAAYH,cAAcC;IAE7D,iEAAiE;IACjE,4DAA4D;IAC5D,IAAIG,aAAa;IACjB,IAAK,IAAIC,IAAI,GAAGA,IAAIN,KAAK3B,MAAM,EAAEiC,IAAK;QACpC,IAAI,CAAEN,AAAO,YAAPA,IAAI,CAACM,EAAE,EAAY/C,SAAS;YAChC8C,aAAa;YACb;QACF;IACF;IACA,IAAIA,cAAcF,gBAAgBD,cAAc;QAC9C,OAAO3C,OAAOgD,MAAM,CAACP,MAAkBG;IACzC;IAEA,6DAA6D;IAC7D,IAAIV,SAAS7C,YAAYuD;IACzB,IAAId,SAAS;IACb,IAAK,IAAImB,IAAI,GAAGA,IAAIR,KAAK3B,MAAM,IAAIgB,SAASc,cAAcK,IAAK;QAC7D,IAAIzC,MAAMiC,IAAI,CAACQ,EAAE;QACjB,IAAK,IAAIC,IAAI,GAAGA,IAAI1C,IAAIM,MAAM,IAAIgB,SAASc,cAAcM,IAAK;YAC5DhB,MAAM,CAACJ,SAAS,GAAGtB,GAAG,CAAC0C,EAAE;QAC3B;IACF;IACA,OAAOhB;AACT;AAOO,SAAStC,MAAM2C,KAAa;IACjC,gEAAgE;IAChE,OAAOA,UAAUA;AACnB"}

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

@@ -0,0 +1,45 @@
+/**
+ * CRC32 calculation for archive formats
+ *
+ * Uses IEEE polynomial 0xEDB88320 (same as ZIP, 7z, PNG, gzip, etc.)
+ * All bit operations (>>>, ^, &) work correctly in Node 0.8
+ *
+ * This is the standard CRC-32 algorithm used by:
+ * - ZIP/PKZIP
+ * - 7-Zip
+ * - PNG
+ * - gzip
+ * - Ethernet
+ */
+/**
+ * Calculate CRC32 of a buffer
+ * @param buf - Buffer to calculate CRC32 for
+ * @param initial - Optional initial CRC value (for streaming calculation)
+ * @returns CRC32 value as unsigned 32-bit integer
+ */
+export declare function crc32(buf: Buffer, initial?: number): number;
+/**
+ * Calculate CRC32 of a buffer region
+ * @param buf - Buffer containing data
+ * @param offset - Start offset in buffer
+ * @param length - Number of bytes to process
+ * @param initial - Optional initial CRC value
+ * @returns CRC32 value as unsigned 32-bit integer
+ */
+export declare function crc32Region(buf: Buffer, offset: number, length: number, initial?: number): number;
+/**
+ * Verify CRC32 matches expected value
+ * @param buf - Buffer to verify
+ * @param expected - Expected CRC32 value
+ * @returns true if CRC matches, false otherwise
+ */
+export declare function verifyCrc32(buf: Buffer, expected: number): boolean;
+/**
+ * Verify CRC32 of a buffer region matches expected value
+ * @param buf - Buffer containing data
+ * @param offset - Start offset in buffer
+ * @param length - Number of bytes to verify
+ * @param expected - Expected CRC32 value
+ * @returns true if CRC matches, false otherwise
+ */
+export declare function verifyCrc32Region(buf: Buffer, offset: number, length: number, expected: number): boolean;

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

@@ -0,0 +1,45 @@
+/**
+ * CRC32 calculation for archive formats
+ *
+ * Uses IEEE polynomial 0xEDB88320 (same as ZIP, 7z, PNG, gzip, etc.)
+ * All bit operations (>>>, ^, &) work correctly in Node 0.8
+ *
+ * This is the standard CRC-32 algorithm used by:
+ * - ZIP/PKZIP
+ * - 7-Zip
+ * - PNG
+ * - gzip
+ * - Ethernet
+ */
+/**
+ * Calculate CRC32 of a buffer
+ * @param buf - Buffer to calculate CRC32 for
+ * @param initial - Optional initial CRC value (for streaming calculation)
+ * @returns CRC32 value as unsigned 32-bit integer
+ */
+export declare function crc32(buf: Buffer, initial?: number): number;
+/**
+ * Calculate CRC32 of a buffer region
+ * @param buf - Buffer containing data
+ * @param offset - Start offset in buffer
+ * @param length - Number of bytes to process
+ * @param initial - Optional initial CRC value
+ * @returns CRC32 value as unsigned 32-bit integer
+ */
+export declare function crc32Region(buf: Buffer, offset: number, length: number, initial?: number): number;
+/**
+ * Verify CRC32 matches expected value
+ * @param buf - Buffer to verify
+ * @param expected - Expected CRC32 value
+ * @returns true if CRC matches, false otherwise
+ */
+export declare function verifyCrc32(buf: Buffer, expected: number): boolean;
+/**
+ * Verify CRC32 of a buffer region matches expected value
+ * @param buf - Buffer containing data
+ * @param offset - Start offset in buffer
+ * @param length - Number of bytes to verify
+ * @param expected - Expected CRC32 value
+ * @returns true if CRC matches, false otherwise
+ */
+export declare function verifyCrc32Region(buf: Buffer, offset: number, length: number, expected: number): boolean;

package/dist/cjs/shared/crc32.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get crc32 () {
+        return crc32;
+    },
+    get crc32Region () {
+        return crc32Region;
+    },
+    get verifyCrc32 () {
+        return verifyCrc32;
+    },
+    get verifyCrc32Region () {
+        return verifyCrc32Region;
+    }
+});
+/**
+ * CRC32 calculation for archive formats
+ *
+ * Uses IEEE polynomial 0xEDB88320 (same as ZIP, 7z, PNG, gzip, etc.)
+ * All bit operations (>>>, ^, &) work correctly in Node 0.8
+ *
+ * This is the standard CRC-32 algorithm used by:
+ * - ZIP/PKZIP
+ * - 7-Zip
+ * - PNG
+ * - gzip
+ * - Ethernet
+ */ // Pre-computed lookup table for performance
+var CRC32_TABLE = [];
+// Initialize table at module load time
+(function initTable() {
+    for(var i = 0; i < 256; i++){
+        var c = i;
+        for(var j = 0; j < 8; j++){
+            if ((c & 1) !== 0) {
+                c = 0xedb88320 ^ c >>> 1;
+            } else {
+                c = c >>> 1;
+            }
+        }
+        CRC32_TABLE[i] = c >>> 0; // Ensure unsigned
+    }
+})();
+function crc32(buf, initial) {
+    var crc = initial === undefined ? 0xffffffff : ~initial >>> 0;
+    for(var i = 0; i < buf.length; i++){
+        var index = (crc ^ buf[i]) & 0xff;
+        crc = CRC32_TABLE[index] ^ crc >>> 8;
+    }
+    return ~crc >>> 0; // Return unsigned
+}
+function crc32Region(buf, offset, length, initial) {
+    var crc = initial === undefined ? 0xffffffff : ~initial >>> 0;
+    var end = offset + length;
+    for(var i = offset; i < end; i++){
+        var index = (crc ^ buf[i]) & 0xff;
+        crc = CRC32_TABLE[index] ^ crc >>> 8;
+    }
+    return ~crc >>> 0; // Return unsigned
+}
+function verifyCrc32(buf, expected) {
+    return crc32(buf) === expected >>> 0;
+}
+function verifyCrc32Region(buf, offset, length, expected) {
+    return crc32Region(buf, offset, length) === expected >>> 0;
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

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

@@ -0,0 +1 @@
+{"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\nvar CRC32_TABLE: number[] = [];\n\n// Initialize table at module load time\n(function initTable() {\n  for (var i = 0; i < 256; i++) {\n    var c = i;\n    for (var 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  var crc = initial === undefined ? 0xffffffff : ~initial >>> 0;\n\n  for (var i = 0; i < buf.length; i++) {\n    var 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  var crc = initial === undefined ? 0xffffffff : ~initial >>> 0;\n  var end = offset + length;\n\n  for (var i = offset; i < end; i++) {\n    var 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,IAAIC,cAAwB,EAAE;AAE9B,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,IAAIQ,QAAQ,AAACH,CAAAA,MAAMF,GAAG,CAACH,EAAE,AAAD,IAAK;QAC7BK,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,IAAIM,MAAMD,SAASF;IAEnB,IAAK,IAAIP,IAAIS,QAAQT,IAAIU,KAAKV,IAAK;QACjC,IAAIQ,QAAQ,AAACH,CAAAA,MAAMF,GAAG,CAACH,EAAE,AAAD,IAAK;QAC7BK,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.d.cts

@@ -0,0 +1,13 @@
+/**
+ * Shared utilities for iterator libraries
+ *
+ * These utilities are designed to be used by:
+ * - zip-iterator
+ * - 7z-iterator
+ * - tar-iterator
+ * - Any other archive iterator library
+ *
+ * All utilities support Node.js 0.8+
+ */
+export { allocBuffer, allocBufferUnsafe, bufferCompare, bufferConcat, bufferEquals, bufferFrom, bufferSliceCopy, isNaN, readUInt64LE, writeUInt64LE, } from './compat.js';
+export { crc32, crc32Region, verifyCrc32, verifyCrc32Region } from './crc32.js';

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

@@ -0,0 +1,13 @@
+/**
+ * Shared utilities for iterator libraries
+ *
+ * These utilities are designed to be used by:
+ * - zip-iterator
+ * - 7z-iterator
+ * - tar-iterator
+ * - Any other archive iterator library
+ *
+ * All utilities support Node.js 0.8+
+ */
+export { allocBuffer, allocBufferUnsafe, bufferCompare, bufferConcat, bufferEquals, bufferFrom, bufferSliceCopy, isNaN, readUInt64LE, writeUInt64LE, } from './compat.js';
+export { crc32, crc32Region, verifyCrc32, verifyCrc32Region } from './crc32.js';

package/dist/cjs/shared/index.js

@@ -0,0 +1,67 @@
+/**
+ * Shared utilities for iterator libraries
+ *
+ * These utilities are designed to be used by:
+ * - zip-iterator
+ * - 7z-iterator
+ * - tar-iterator
+ * - Any other archive iterator library
+ *
+ * All utilities support Node.js 0.8+
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get allocBuffer () {
+        return _compatts.allocBuffer;
+    },
+    get allocBufferUnsafe () {
+        return _compatts.allocBufferUnsafe;
+    },
+    get bufferCompare () {
+        return _compatts.bufferCompare;
+    },
+    get bufferConcat () {
+        return _compatts.bufferConcat;
+    },
+    get bufferEquals () {
+        return _compatts.bufferEquals;
+    },
+    get bufferFrom () {
+        return _compatts.bufferFrom;
+    },
+    get bufferSliceCopy () {
+        return _compatts.bufferSliceCopy;
+    },
+    get crc32 () {
+        return _crc32ts.crc32;
+    },
+    get crc32Region () {
+        return _crc32ts.crc32Region;
+    },
+    get isNaN () {
+        return _compatts.isNaN;
+    },
+    get readUInt64LE () {
+        return _compatts.readUInt64LE;
+    },
+    get verifyCrc32 () {
+        return _crc32ts.verifyCrc32;
+    },
+    get verifyCrc32Region () {
+        return _crc32ts.verifyCrc32Region;
+    },
+    get writeUInt64LE () {
+        return _compatts.writeUInt64LE;
+    }
+});
+var _compatts = require("./compat.js");
+var _crc32ts = require("./crc32.js");
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

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

@@ -0,0 +1 @@
+{"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\nexport {\n  allocBuffer,\n  allocBufferUnsafe,\n  bufferCompare,\n  bufferConcat,\n  bufferEquals,\n  bufferFrom,\n  bufferSliceCopy,\n  isNaN,\n  readUInt64LE,\n  writeUInt64LE,\n} from './compat.ts';\n\nexport { crc32, crc32Region, verifyCrc32, verifyCrc32Region } from './crc32.ts';\n"],"names":["allocBuffer","allocBufferUnsafe","bufferCompare","bufferConcat","bufferEquals","bufferFrom","bufferSliceCopy","crc32","crc32Region","isNaN","readUInt64LE","verifyCrc32","verifyCrc32Region","writeUInt64LE"],"mappings":"AAAA;;;;;;;;;;CAUC;;;;;;;;;;;QAGCA;eAAAA,qBAAW;;QACXC;eAAAA,2BAAiB;;QACjBC;eAAAA,uBAAa;;QACbC;eAAAA,sBAAY;;QACZC;eAAAA,sBAAY;;QACZC;eAAAA,oBAAU;;QACVC;eAAAA,yBAAe;;QAMRC;eAAAA,cAAK;;QAAEC;eAAAA,oBAAW;;QALzBC;eAAAA,eAAK;;QACLC;eAAAA,sBAAY;;QAIeC;eAAAA,oBAAW;;QAAEC;eAAAA,0BAAiB;;QAHzDC;eAAAA,uBAAa;;;wBACR;uBAE4D"}

package/dist/esm/index.d.ts

@@ -7,5 +7,6 @@ export { default as DirectoryEntry } from './DirectoryEntry.js';
 export { default as FileEntry } from './FileEntry.js';
 export { default as LinkEntry } from './LinkEntry.js';
 export { default as SymbolicLinkEntry } from './SymbolicLinkEntry.js';
+export * from './shared/index.js';
 export * from './types.js';
 export { default as waitForAccess } from './waitForAccess.js';

package/dist/esm/index.js

@@ -6,5 +6,7 @@ export { default as DirectoryEntry } from './DirectoryEntry.js';
 export { default as FileEntry } from './FileEntry.js';
 export { default as LinkEntry } from './LinkEntry.js';
 export { default as SymbolicLinkEntry } from './SymbolicLinkEntry.js';
+// Shared utilities for iterator libraries
+export * from './shared/index.js';
 export * from './types.js';
 export { default as waitForAccess } from './waitForAccess.js';

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/index.ts"],"sourcesContent":["import './polyfills.ts';\nimport StackBaseIterator from 'stack-base-iterator';\n\nimport type { Entry } from './types.ts';\n\nexport default class ExtractBaseIterator extends StackBaseIterator<Entry> {}\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';\nexport * from './types.ts';\nexport { default as waitForAccess } from './waitForAccess.ts';\n"],"names":["StackBaseIterator","ExtractBaseIterator","default","DirectoryEntry","FileEntry","LinkEntry","SymbolicLinkEntry","waitForAccess"],"mappings":"AAAA,OAAO,iBAAiB;AACxB,OAAOA,uBAAuB,sBAAsB;AAIpD,eAAe,MAAMC,4BAA4BD;AAA0B;AAE3E,SAASE,WAAWC,cAAc,QAAQ,sBAAsB;AAChE,SAASD,WAAWE,SAAS,QAAQ,iBAAiB;AACtD,SAASF,WAAWG,SAAS,QAAQ,iBAAiB;AACtD,SAASH,WAAWI,iBAAiB,QAAQ,yBAAyB;AACtE,cAAc,aAAa;AAC3B,SAASJ,WAAWK,aAAa,QAAQ,qBAAqB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/index.ts"],"sourcesContent":["import './polyfills.ts';\nimport StackBaseIterator from 'stack-base-iterator';\n\nimport type { Entry } from './types.ts';\n\nexport default class ExtractBaseIterator extends StackBaseIterator<Entry> {}\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,OAAO,iBAAiB;AACxB,OAAOA,uBAAuB,sBAAsB;AAIpD,eAAe,MAAMC,4BAA4BD;AAA0B;AAE3E,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/compat.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Buffer Compatibility Layer for Node.js 0.8+
+ *
+ * Provides buffer utilities that work across all Node.js versions
+ * WITHOUT modifying global Buffer object.
+ *
+ * Version history:
+ * - Node 0.8-4.4: Only has `new Buffer()`, no `Buffer.alloc/from`
+ * - Node 4.5+: Has `Buffer.alloc/from`, deprecates `new Buffer()`
+ * - Node 10+: Warns or errors on `new Buffer()`
+ *
+ * Solution: Feature detection with graceful fallback in both directions.
+ */
+/**
+ * Allocate a zero-filled buffer (safe)
+ * - Uses Buffer.alloc() on Node 4.5+
+ * - Falls back to new Buffer() + fill on Node 0.8-4.4
+ */
+export declare function allocBuffer(size: number): Buffer;
+/**
+ * Allocate a buffer without initialization (unsafe but faster)
+ * - Uses Buffer.allocUnsafe() on Node 4.5+
+ * - Falls back to new Buffer() on Node 0.8-4.4
+ *
+ * WARNING: Buffer contents are uninitialized and may contain sensitive data.
+ * Only use when you will immediately overwrite all bytes.
+ */
+export declare function allocBufferUnsafe(size: number): Buffer;
+/**
+ * Create a buffer from string, array, or existing buffer
+ * - Uses Buffer.from() on Node 4.5+
+ * - Falls back to new Buffer() on Node 0.8-4.4
+ * - Handles Uint8Array conversion for Node 0.8 (crypto output compatibility)
+ */
+export declare function bufferFrom(data: string | number[] | Buffer | Uint8Array, encoding?: BufferEncoding): Buffer;
+/**
+ * Compare two buffers or buffer regions
+ * - Uses Buffer.compare() on Node 5.10+ (with offset support)
+ * - Falls back to manual comparison on Node 0.8-5.9
+ */
+export declare function bufferCompare(source: Buffer, target: Buffer, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): number;
+/**
+ * Check if buffer region equals byte array
+ * Useful for magic number detection without Buffer.from()
+ */
+export declare function bufferEquals(buf: Buffer, offset: number, expected: number[]): boolean;
+/**
+ * Copy buffer region to new buffer
+ * Works on all Node versions
+ */
+export declare function bufferSliceCopy(buf: Buffer, start: number, end: number): Buffer;
+/**
+ * Read 64-bit unsigned integer (little-endian)
+ * Uses two 32-bit reads since BigInt not available until Node 10.4
+ *
+ * WARNING: Only accurate for values < Number.MAX_SAFE_INTEGER (2^53 - 1)
+ * This covers files up to ~9 PB which is practical for all real use cases.
+ */
+export declare function readUInt64LE(buf: Buffer, offset: number): number;
+/**
+ * Write 64-bit unsigned integer (little-endian)
+ * Same precision limitation as readUInt64LE
+ */
+export declare function writeUInt64LE(buf: Buffer, value: number, offset: number): void;
+/**
+ * Concatenate buffers - compatible with Node 0.8
+ * Handles crypto output which may not be proper Buffer instances in old Node.
+ *
+ * NOTE: This function is primarily needed for AES decryption compatibility
+ * in Node 0.8 where crypto output may not be proper Buffer instances.
+ * Libraries not using crypto can use native Buffer.concat() directly.
+ */
+export declare function bufferConcat(list: (Buffer | Uint8Array)[], totalLength?: number): Buffer;
+/**
+ * Node 0.8 compatible isNaN (Number.isNaN didn't exist until ES2015)
+ * Uses self-comparison: NaN is the only value not equal to itself
+ */
+export declare function isNaN(value: number): boolean;

package/dist/esm/shared/compat.js

@@ -0,0 +1,173 @@
+/**
+ * Buffer Compatibility Layer for Node.js 0.8+
+ *
+ * Provides buffer utilities that work across all Node.js versions
+ * WITHOUT modifying global Buffer object.
+ *
+ * Version history:
+ * - Node 0.8-4.4: Only has `new Buffer()`, no `Buffer.alloc/from`
+ * - Node 4.5+: Has `Buffer.alloc/from`, deprecates `new Buffer()`
+ * - Node 10+: Warns or errors on `new Buffer()`
+ *
+ * Solution: Feature detection with graceful fallback in both directions.
+ */ // Feature detection (runs once at module load)
+var hasBufferAlloc = typeof Buffer.alloc === 'function';
+var hasBufferAllocUnsafe = typeof Buffer.allocUnsafe === 'function';
+var hasBufferFrom = typeof Buffer.from === 'function' && Buffer.from !== Uint8Array.from;
+/**
+ * Allocate a zero-filled buffer (safe)
+ * - Uses Buffer.alloc() on Node 4.5+
+ * - Falls back to new Buffer() + fill on Node 0.8-4.4
+ */ export function allocBuffer(size) {
+    if (hasBufferAlloc) {
+        return Buffer.alloc(size);
+    }
+    // Legacy fallback: new Buffer() is uninitialized, must zero-fill
+    var buf = new Buffer(size);
+    buf.fill(0);
+    return buf;
+}
+/**
+ * Allocate a buffer without initialization (unsafe but faster)
+ * - Uses Buffer.allocUnsafe() on Node 4.5+
+ * - Falls back to new Buffer() on Node 0.8-4.4
+ *
+ * WARNING: Buffer contents are uninitialized and may contain sensitive data.
+ * Only use when you will immediately overwrite all bytes.
+ */ export function allocBufferUnsafe(size) {
+    if (hasBufferAllocUnsafe) {
+        return Buffer.allocUnsafe(size);
+    }
+    return new Buffer(size);
+}
+/**
+ * Create a buffer from string, array, or existing buffer
+ * - Uses Buffer.from() on Node 4.5+
+ * - Falls back to new Buffer() on Node 0.8-4.4
+ * - Handles Uint8Array conversion for Node 0.8 (crypto output compatibility)
+ */ export function bufferFrom(data, encoding) {
+    if (hasBufferFrom) {
+        if (typeof data === 'string') {
+            return Buffer.from(data, encoding);
+        }
+        return Buffer.from(data);
+    }
+    // Node 0.8 compatibility - deprecated Buffer constructor
+    // For Uint8Array, convert to array first (needed for crypto output in Node 0.8)
+    if (data instanceof Uint8Array && !(data instanceof Buffer)) {
+        var arr = [];
+        for(var i = 0; i < data.length; i++){
+            arr.push(data[i]);
+        }
+        return new Buffer(arr);
+    }
+    return new Buffer(data, encoding);
+}
+/**
+ * Compare two buffers or buffer regions
+ * - Uses Buffer.compare() on Node 5.10+ (with offset support)
+ * - Falls back to manual comparison on Node 0.8-5.9
+ */ export function bufferCompare(source, target, targetStart, targetEnd, sourceStart, sourceEnd) {
+    sourceStart = sourceStart || 0;
+    sourceEnd = sourceEnd || source.length;
+    targetStart = targetStart || 0;
+    targetEnd = targetEnd || target.length;
+    // Check if native compare with offset support exists (Node 5.10+)
+    if (source.compare && source.compare.length >= 5) {
+        return source.compare(target, targetStart, targetEnd, sourceStart, sourceEnd);
+    }
+    // Manual comparison for older Node versions
+    var sourceLen = sourceEnd - sourceStart;
+    var targetLen = targetEnd - targetStart;
+    var len = Math.min(sourceLen, targetLen);
+    for(var i = 0; i < len; i++){
+        var s = source[sourceStart + i];
+        var t = target[targetStart + i];
+        if (s !== t) return s < t ? -1 : 1;
+    }
+    return sourceLen - targetLen;
+}
+/**
+ * Check if buffer region equals byte array
+ * Useful for magic number detection without Buffer.from()
+ */ export function bufferEquals(buf, offset, expected) {
+    if (offset + expected.length > buf.length) return false;
+    for(var i = 0; i < expected.length; i++){
+        if (buf[offset + i] !== expected[i]) return false;
+    }
+    return true;
+}
+/**
+ * Copy buffer region to new buffer
+ * Works on all Node versions
+ */ export function bufferSliceCopy(buf, start, end) {
+    var result = allocBuffer(end - start);
+    buf.copy(result, 0, start, end);
+    return result;
+}
+/**
+ * Read 64-bit unsigned integer (little-endian)
+ * Uses two 32-bit reads since BigInt not available until Node 10.4
+ *
+ * WARNING: Only accurate for values < Number.MAX_SAFE_INTEGER (2^53 - 1)
+ * This covers files up to ~9 PB which is practical for all real use cases.
+ */ export function readUInt64LE(buf, offset) {
+    var low = buf.readUInt32LE(offset);
+    var high = buf.readUInt32LE(offset + 4);
+    return high * 0x100000000 + low;
+}
+/**
+ * Write 64-bit unsigned integer (little-endian)
+ * Same precision limitation as readUInt64LE
+ */ export function writeUInt64LE(buf, value, offset) {
+    var low = value >>> 0;
+    var high = value / 0x100000000 >>> 0;
+    buf.writeUInt32LE(low, offset);
+    buf.writeUInt32LE(high, offset + 4);
+}
+/**
+ * Concatenate buffers - compatible with Node 0.8
+ * Handles crypto output which may not be proper Buffer instances in old Node.
+ *
+ * NOTE: This function is primarily needed for AES decryption compatibility
+ * in Node 0.8 where crypto output may not be proper Buffer instances.
+ * Libraries not using crypto can use native Buffer.concat() directly.
+ */ export function bufferConcat(list, totalLength) {
+    // Calculate actual total length first
+    var actualLength = 0;
+    for(var i = 0; i < list.length; i++){
+        actualLength += list[i].length;
+    }
+    // Use specified totalLength or actual length
+    var targetLength = totalLength !== undefined ? totalLength : actualLength;
+    // Check if all items are proper Buffers AND no truncation needed
+    // (Node 0.8's Buffer.concat doesn't handle truncation well)
+    var allBuffers = true;
+    for(var j = 0; j < list.length; j++){
+        if (!(list[j] instanceof Buffer)) {
+            allBuffers = false;
+            break;
+        }
+    }
+    if (allBuffers && targetLength >= actualLength) {
+        return Buffer.concat(list, targetLength);
+    }
+    // Manual concat for mixed types or when truncation is needed
+    var result = allocBuffer(targetLength);
+    var offset = 0;
+    for(var k = 0; k < list.length && offset < targetLength; k++){
+        var buf = list[k];
+        for(var l = 0; l < buf.length && offset < targetLength; l++){
+            result[offset++] = buf[l];
+        }
+    }
+    return result;
+}
+/**
+ * Node 0.8 compatible isNaN (Number.isNaN didn't exist until ES2015)
+ * Uses self-comparison: NaN is the only value not equal to itself
+ */ // biome-ignore lint/suspicious/noShadowRestrictedNames: Legacy compatibility
+export function isNaN(value) {
+    // biome-ignore lint/suspicious/noSelfCompare: NaN check pattern
+    return value !== value;
+}

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/compat.ts"],"sourcesContent":["/**\n * Buffer Compatibility Layer for Node.js 0.8+\n *\n * Provides buffer utilities that work across all Node.js versions\n * WITHOUT modifying global Buffer object.\n *\n * Version history:\n * - Node 0.8-4.4: Only has `new Buffer()`, no `Buffer.alloc/from`\n * - Node 4.5+: Has `Buffer.alloc/from`, deprecates `new Buffer()`\n * - Node 10+: Warns or errors on `new Buffer()`\n *\n * Solution: Feature detection with graceful fallback in both directions.\n */\n\n// Feature detection (runs once at module load)\nvar hasBufferAlloc = typeof Buffer.alloc === 'function';\nvar hasBufferAllocUnsafe = typeof Buffer.allocUnsafe === 'function';\nvar 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  var 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    var arr: number[] = [];\n    for (var 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  var sourceLen = sourceEnd - sourceStart;\n  var targetLen = targetEnd - targetStart;\n  var len = Math.min(sourceLen, targetLen);\n\n  for (var i = 0; i < len; i++) {\n    var s = source[sourceStart + i];\n    var 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 (var 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  var 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  var low = buf.readUInt32LE(offset);\n  var 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  var low = value >>> 0;\n  var 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  var actualLength = 0;\n  for (var i = 0; i < list.length; i++) {\n    actualLength += list[i].length;\n  }\n\n  // Use specified totalLength or actual length\n  var 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  var allBuffers = true;\n  for (var 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  var result = allocBuffer(targetLength);\n  var offset = 0;\n  for (var k = 0; k < list.length && offset < targetLength; k++) {\n    var buf = list[k];\n    for (var 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"],"names":["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"],"mappings":"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"}

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

@@ -0,0 +1,45 @@
+/**
+ * CRC32 calculation for archive formats
+ *
+ * Uses IEEE polynomial 0xEDB88320 (same as ZIP, 7z, PNG, gzip, etc.)
+ * All bit operations (>>>, ^, &) work correctly in Node 0.8
+ *
+ * This is the standard CRC-32 algorithm used by:
+ * - ZIP/PKZIP
+ * - 7-Zip
+ * - PNG
+ * - gzip
+ * - Ethernet
+ */
+/**
+ * Calculate CRC32 of a buffer
+ * @param buf - Buffer to calculate CRC32 for
+ * @param initial - Optional initial CRC value (for streaming calculation)
+ * @returns CRC32 value as unsigned 32-bit integer
+ */
+export declare function crc32(buf: Buffer, initial?: number): number;
+/**
+ * Calculate CRC32 of a buffer region
+ * @param buf - Buffer containing data
+ * @param offset - Start offset in buffer
+ * @param length - Number of bytes to process
+ * @param initial - Optional initial CRC value
+ * @returns CRC32 value as unsigned 32-bit integer
+ */
+export declare function crc32Region(buf: Buffer, offset: number, length: number, initial?: number): number;
+/**
+ * Verify CRC32 matches expected value
+ * @param buf - Buffer to verify
+ * @param expected - Expected CRC32 value
+ * @returns true if CRC matches, false otherwise
+ */
+export declare function verifyCrc32(buf: Buffer, expected: number): boolean;
+/**
+ * Verify CRC32 of a buffer region matches expected value
+ * @param buf - Buffer containing data
+ * @param offset - Start offset in buffer
+ * @param length - Number of bytes to verify
+ * @param expected - Expected CRC32 value
+ * @returns true if CRC matches, false otherwise
+ */
+export declare function verifyCrc32Region(buf: Buffer, offset: number, length: number, expected: number): boolean;

package/dist/esm/shared/crc32.js

@@ -0,0 +1,75 @@
+/**
+ * CRC32 calculation for archive formats
+ *
+ * Uses IEEE polynomial 0xEDB88320 (same as ZIP, 7z, PNG, gzip, etc.)
+ * All bit operations (>>>, ^, &) work correctly in Node 0.8
+ *
+ * This is the standard CRC-32 algorithm used by:
+ * - ZIP/PKZIP
+ * - 7-Zip
+ * - PNG
+ * - gzip
+ * - Ethernet
+ */ // Pre-computed lookup table for performance
+var CRC32_TABLE = [];
+// Initialize table at module load time
+(function initTable() {
+    for(var i = 0; i < 256; i++){
+        var c = i;
+        for(var j = 0; j < 8; j++){
+            if ((c & 1) !== 0) {
+                c = 0xedb88320 ^ c >>> 1;
+            } else {
+                c = c >>> 1;
+            }
+        }
+        CRC32_TABLE[i] = c >>> 0; // Ensure unsigned
+    }
+})();
+/**
+ * Calculate CRC32 of a buffer
+ * @param buf - Buffer to calculate CRC32 for
+ * @param initial - Optional initial CRC value (for streaming calculation)
+ * @returns CRC32 value as unsigned 32-bit integer
+ */ export function crc32(buf, initial) {
+    var crc = initial === undefined ? 0xffffffff : ~initial >>> 0;
+    for(var i = 0; i < buf.length; i++){
+        var index = (crc ^ buf[i]) & 0xff;
+        crc = CRC32_TABLE[index] ^ crc >>> 8;
+    }
+    return ~crc >>> 0; // Return unsigned
+}
+/**
+ * Calculate CRC32 of a buffer region
+ * @param buf - Buffer containing data
+ * @param offset - Start offset in buffer
+ * @param length - Number of bytes to process
+ * @param initial - Optional initial CRC value
+ * @returns CRC32 value as unsigned 32-bit integer
+ */ export function crc32Region(buf, offset, length, initial) {
+    var crc = initial === undefined ? 0xffffffff : ~initial >>> 0;
+    var end = offset + length;
+    for(var i = offset; i < end; i++){
+        var index = (crc ^ buf[i]) & 0xff;
+        crc = CRC32_TABLE[index] ^ crc >>> 8;
+    }
+    return ~crc >>> 0; // Return unsigned
+}
+/**
+ * Verify CRC32 matches expected value
+ * @param buf - Buffer to verify
+ * @param expected - Expected CRC32 value
+ * @returns true if CRC matches, false otherwise
+ */ export function verifyCrc32(buf, expected) {
+    return crc32(buf) === expected >>> 0;
+}
+/**
+ * Verify CRC32 of a buffer region matches expected value
+ * @param buf - Buffer containing data
+ * @param offset - Start offset in buffer
+ * @param length - Number of bytes to verify
+ * @param expected - Expected CRC32 value
+ * @returns true if CRC matches, false otherwise
+ */ export function verifyCrc32Region(buf, offset, length, expected) {
+    return crc32Region(buf, offset, length) === expected >>> 0;
+}

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

@@ -0,0 +1 @@
+{"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\nvar CRC32_TABLE: number[] = [];\n\n// Initialize table at module load time\n(function initTable() {\n  for (var i = 0; i < 256; i++) {\n    var c = i;\n    for (var 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  var crc = initial === undefined ? 0xffffffff : ~initial >>> 0;\n\n  for (var i = 0; i < buf.length; i++) {\n    var 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  var crc = initial === undefined ? 0xffffffff : ~initial >>> 0;\n  var end = offset + length;\n\n  for (var i = offset; i < end; i++) {\n    var 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,IAAIA,cAAwB,EAAE;AAE9B,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,IAAIS,QAAQ,AAACH,CAAAA,MAAMF,GAAG,CAACJ,EAAE,AAAD,IAAK;QAC7BM,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,IAAIO,MAAMD,SAASH;IAEnB,IAAK,IAAIR,IAAIW,QAAQX,IAAIY,KAAKZ,IAAK;QACjC,IAAIS,QAAQ,AAACH,CAAAA,MAAMF,GAAG,CAACJ,EAAE,AAAD,IAAK;QAC7BM,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.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Shared utilities for iterator libraries
+ *
+ * These utilities are designed to be used by:
+ * - zip-iterator
+ * - 7z-iterator
+ * - tar-iterator
+ * - Any other archive iterator library
+ *
+ * All utilities support Node.js 0.8+
+ */
+export { allocBuffer, allocBufferUnsafe, bufferCompare, bufferConcat, bufferEquals, bufferFrom, bufferSliceCopy, isNaN, readUInt64LE, writeUInt64LE, } from './compat.js';
+export { crc32, crc32Region, verifyCrc32, verifyCrc32Region } from './crc32.js';

package/dist/esm/shared/index.js

@@ -0,0 +1,12 @@
+/**
+ * Shared utilities for iterator libraries
+ *
+ * These utilities are designed to be used by:
+ * - zip-iterator
+ * - 7z-iterator
+ * - tar-iterator
+ * - Any other archive iterator library
+ *
+ * All utilities support Node.js 0.8+
+ */ export { allocBuffer, allocBufferUnsafe, bufferCompare, bufferConcat, bufferEquals, bufferFrom, bufferSliceCopy, isNaN, readUInt64LE, writeUInt64LE } from './compat.js';
+export { crc32, crc32Region, verifyCrc32, verifyCrc32Region } from './crc32.js';

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

@@ -0,0 +1 @@
+{"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\nexport {\n  allocBuffer,\n  allocBufferUnsafe,\n  bufferCompare,\n  bufferConcat,\n  bufferEquals,\n  bufferFrom,\n  bufferSliceCopy,\n  isNaN,\n  readUInt64LE,\n  writeUInt64LE,\n} from './compat.ts';\n\nexport { crc32, crc32Region, verifyCrc32, verifyCrc32Region } from './crc32.ts';\n"],"names":["allocBuffer","allocBufferUnsafe","bufferCompare","bufferConcat","bufferEquals","bufferFrom","bufferSliceCopy","isNaN","readUInt64LE","writeUInt64LE","crc32","crc32Region","verifyCrc32","verifyCrc32Region"],"mappings":"AAAA;;;;;;;;;;CAUC,GAED,SACEA,WAAW,EACXC,iBAAiB,EACjBC,aAAa,EACbC,YAAY,EACZC,YAAY,EACZC,UAAU,EACVC,eAAe,EACfC,KAAK,EACLC,YAAY,EACZC,aAAa,QACR,cAAc;AAErB,SAASC,KAAK,EAAEC,WAAW,EAAEC,WAAW,EAAEC,iBAAiB,QAAQ,aAAa"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "extract-base-iterator",
-  "version": "2.2.6",
+  "version": "2.3.0",
   "description": "Base iterator for extract iterators like tar-iterator and zip-iterator",
   "keywords": [
     "extract",
@@ -36,6 +36,7 @@
   "scripts": {
     "build": "tsds build",
     "format": "biome check --write --unsafe",
+    "prepublishOnly": "tsds validate",
     "test": "mocha --no-timeouts test/**/*.test.*",
     "test:engines": "nvu engines tsds test:node --no-timeouts",
     "version": "tsds version"