7z-iterator 2.0.3 → 2.1.0

package/dist/esm/sevenz/codecs/createBufferingDecoder.js

@@ -12,11 +12,26 @@ import { Transform } from 'extract-base-iterator';
             callback();
         },
         flush: function(callback) {
-            try {
-                const input = Buffer.concat(chunks);
-                const output = decodeFn(input, properties, unpackSize);
-                this.push(output);
+            const input = Buffer.concat(chunks);
+            const finish = (err, output)=>{
+                if (err) {
+                    callback(err);
+                    return;
+                }
+                if (output) {
+                    this.push(output);
+                }
                 callback();
+            };
+            try {
+                const maybeResult = decodeFn(input, properties, unpackSize, finish);
+                if (maybeResult && typeof maybeResult.then === 'function') {
+                    maybeResult.then((value)=>finish(null, value), (err)=>finish(err));
+                    return;
+                }
+                if (Buffer.isBuffer(maybeResult)) {
+                    finish(null, maybeResult);
+                }
             } catch (err) {
                 callback(err);
             }

package/dist/esm/sevenz/codecs/createBufferingDecoder.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/createBufferingDecoder.ts"],"sourcesContent":["// Helper to create a Transform stream that buffers all input before decoding\n// Used by codecs that need the full input before decompression (LZMA, LZMA2, BZip2, etc.)\n\nimport { Transform } from 'extract-base-iterator';\n\ntype TransformCallback = (error?: Error | null, data?: Buffer) => void;\n\nexport type DecodeFn = (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;\n\n/**\n * Create a Transform stream that buffers all input, then decodes in flush\n * This is the common pattern for codecs that can't stream (need full input)\n */\nexport default function createBufferingDecoder(decodeFn: DecodeFn, properties?: Buffer, unpackSize?: number): InstanceType<typeof Transform> {\n  const chunks: Buffer[] = [];\n\n  return new Transform({\n    transform: (chunk: Buffer, _encoding: string, callback: TransformCallback) => {\n      chunks.push(chunk);\n      callback();\n    },\n    flush: function (callback: TransformCallback) {\n      try {\n        const input = Buffer.concat(chunks);\n        const output = decodeFn(input, properties, unpackSize);\n        this.push(output);\n        callback();\n      } catch (err) {\n        callback(err as Error);\n      }\n    },\n  });\n}\n"],"names":["Transform","createBufferingDecoder","decodeFn","properties","unpackSize","chunks","transform","chunk","_encoding","callback","push","flush","input","Buffer","concat","output","err"],"mappings":"AAAA,6EAA6E;AAC7E,0FAA0F;AAE1F,SAASA,SAAS,QAAQ,wBAAwB;AAMlD;;;CAGC,GACD,eAAe,SAASC,uBAAuBC,QAAkB,EAAEC,UAAmB,EAAEC,UAAmB;IACzG,MAAMC,SAAmB,EAAE;IAE3B,OAAO,IAAIL,UAAU;QACnBM,WAAW,CAACC,OAAeC,WAAmBC;YAC5CJ,OAAOK,IAAI,CAACH;YACZE;QACF;QACAE,OAAO,SAAUF,QAA2B;YAC1C,IAAI;gBACF,MAAMG,QAAQC,OAAOC,MAAM,CAACT;gBAC5B,MAAMU,SAASb,SAASU,OAAOT,YAAYC;gBAC3C,IAAI,CAACM,IAAI,CAACK;gBACVN;YACF,EAAE,OAAOO,KAAK;gBACZP,SAASO;YACX;QACF;IACF;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/iterators/7z-iterator/src/sevenz/codecs/createBufferingDecoder.ts"],"sourcesContent":["// Helper to create a Transform stream that buffers all input before decoding\n// Used by codecs that need the full input before decompression (LZMA, LZMA2, BZip2, etc.)\n\nimport { Transform } from 'extract-base-iterator';\nimport type { DecodeCallback } from '../../lib/runDecode.ts';\n\ntype TransformCallback = (error?: Error | null, data?: Buffer) => void;\n\nexport type DecodeFn = (input: Buffer, properties?: Buffer, unpackSize?: number, callback?: DecodeCallback<Buffer>) => Buffer | Promise<Buffer> | void;\n\n/**\n * Create a Transform stream that buffers all input, then decodes in flush\n * This is the common pattern for codecs that can't stream (need full input)\n */\nexport default function createBufferingDecoder(decodeFn: DecodeFn, properties?: Buffer, unpackSize?: number): InstanceType<typeof Transform> {\n  const chunks: Buffer[] = [];\n\n  return new Transform({\n    transform: (chunk: Buffer, _encoding: string, callback: TransformCallback) => {\n      chunks.push(chunk);\n      callback();\n    },\n    flush: function (callback: TransformCallback) {\n      const input = Buffer.concat(chunks);\n      const finish = (err?: Error | null, output?: Buffer) => {\n        if (err) {\n          callback(err);\n          return;\n        }\n        if (output) {\n          this.push(output);\n        }\n        callback();\n      };\n\n      try {\n        const maybeResult = decodeFn(input, properties, unpackSize, finish);\n        if (maybeResult && typeof (maybeResult as Promise<Buffer>).then === 'function') {\n          (maybeResult as Promise<Buffer>).then(\n            (value) => finish(null, value),\n            (err) => finish(err as Error)\n          );\n          return;\n        }\n        if (Buffer.isBuffer(maybeResult)) {\n          finish(null, maybeResult);\n        }\n      } catch (err) {\n        callback(err as Error);\n      }\n    },\n  });\n}\n"],"names":["Transform","createBufferingDecoder","decodeFn","properties","unpackSize","chunks","transform","chunk","_encoding","callback","push","flush","input","Buffer","concat","finish","err","output","maybeResult","then","value","isBuffer"],"mappings":"AAAA,6EAA6E;AAC7E,0FAA0F;AAE1F,SAASA,SAAS,QAAQ,wBAAwB;AAOlD;;;CAGC,GACD,eAAe,SAASC,uBAAuBC,QAAkB,EAAEC,UAAmB,EAAEC,UAAmB;IACzG,MAAMC,SAAmB,EAAE;IAE3B,OAAO,IAAIL,UAAU;QACnBM,WAAW,CAACC,OAAeC,WAAmBC;YAC5CJ,OAAOK,IAAI,CAACH;YACZE;QACF;QACAE,OAAO,SAAUF,QAA2B;YAC1C,MAAMG,QAAQC,OAAOC,MAAM,CAACT;YAC5B,MAAMU,SAAS,CAACC,KAAoBC;gBAClC,IAAID,KAAK;oBACPP,SAASO;oBACT;gBACF;gBACA,IAAIC,QAAQ;oBACV,IAAI,CAACP,IAAI,CAACO;gBACZ;gBACAR;YACF;YAEA,IAAI;gBACF,MAAMS,cAAchB,SAASU,OAAOT,YAAYC,YAAYW;gBAC5D,IAAIG,eAAe,OAAO,AAACA,YAAgCC,IAAI,KAAK,YAAY;oBAC7ED,YAAgCC,IAAI,CACnC,CAACC,QAAUL,OAAO,MAAMK,QACxB,CAACJ,MAAQD,OAAOC;oBAElB;gBACF;gBACA,IAAIH,OAAOQ,QAAQ,CAACH,cAAc;oBAChCH,OAAO,MAAMG;gBACf;YACF,EAAE,OAAOF,KAAK;gBACZP,SAASO;YACX;QACF;IACF;AACF"}

package/dist/esm/sevenz/codecs/index.d.ts

@@ -1,9 +1,10 @@
 import type { Transform } from 'stream';
+import { type DecodeCallback as CodecDecodeCallback } from '../../lib/runDecode.js';
 import { getPassword, setPassword } from './Aes.js';
 import { decodeBcj2Multi } from './Bcj2.js';
 export { getPassword, setPassword };
 export interface Codec {
-    decode: (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;
+    decode: (input: Buffer, properties: Buffer | undefined, unpackSize: number | undefined, callback: CodecDecodeCallback<Buffer>) => void;
     createDecoder: (properties?: Buffer, unpackSize?: number) => Transform;
 }
 /**

package/dist/esm/sevenz/codecs/index.js

@@ -1,6 +1,7 @@
 // Codec registry for 7z decompression
 // Each codec provides a decode function and optionally a streaming decoder
 import { createLzma2Decoder as _createLzma2Decoder, createLzmaDecoder as _createLzmaDecoder, createBcjArm64Decoder, createBcjArmDecoder, createBcjArmtDecoder, createBcjDecoder, createBcjIa64Decoder, createBcjPpcDecoder, createBcjSparcDecoder, createDeltaDecoder, decode7zLzma, decode7zLzma2, decodeBcj, decodeBcjArm, decodeBcjArm64, decodeBcjArmt, decodeBcjIa64, decodeBcjPpc, decodeBcjSparc, decodeDelta } from 'xz-compat';
+import { runDecode } from '../../lib/runDecode.js';
 import { CodecId, createCodedError, ErrorCode } from '../constants.js';
 import { createAesDecoder, decodeAes, getPassword, setPassword } from './Aes.js';
 import { createBcj2Decoder, decodeBcj2, decodeBcj2Multi } from './Bcj2.js';
@@ -9,15 +10,24 @@ import { createCopyDecoder, decodeCopy } from './Copy.js';
 import { createDeflateDecoder, decodeDeflate } from './Deflate.js';
 // Re-export password functions for API access
 export { getPassword, setPassword };
+function wrapSyncDecode(fn) {
+    return (input, properties, unpackSize, callback)=>{
+        runDecode((done)=>{
+            done(null, fn(input, properties, unpackSize));
+        }, callback);
+    };
+}
 // Simple wrappers with validation that use xz-compat's optimized decode7zLjma/decode7zLzma2
-function decodeLzma(input, properties, unpackSize) {
+function decodeLzma(input, properties, unpackSize, callback) {
     if (!properties || properties.length < 5) {
         throw new Error('LZMA requires 5-byte properties');
     }
     if (typeof unpackSize !== 'number' || unpackSize < 0) {
         throw new Error('LZMA requires known unpack size');
     }
-    return decode7zLzma(input, properties, unpackSize);
+    runDecode((done)=>{
+        decode7zLzma(input, properties, unpackSize, done);
+    }, callback);
 }
 function createLzmaDecoder(properties, unpackSize) {
     if (!properties || properties.length < 5) {
@@ -28,11 +38,13 @@ function createLzmaDecoder(properties, unpackSize) {
     }
     return _createLzmaDecoder(properties, unpackSize);
 }
-function decodeLzma2(input, properties, unpackSize) {
+function decodeLzma2(input, properties, unpackSize, callback) {
     if (!properties || properties.length < 1) {
         throw new Error('LZMA2 requires properties byte');
     }
-    return decode7zLzma2(input, properties, unpackSize);
+    runDecode((done)=>{
+        decode7zLzma2(input, properties, unpackSize, done);
+    }, callback);
 }
 function createLzma2Decoder(properties, _unpackSize) {
     if (!properties || properties.length < 1) {
@@ -112,7 +124,7 @@ export { decodeBcj2Multi };
 // Register built-in codecs
 // Copy codec (no compression)
 registerCodec(CodecId.COPY, {
-    decode: decodeCopy,
+    decode: wrapSyncDecode(decodeCopy),
     createDecoder: createCopyDecoder
 });
 // LZMA codec
@@ -127,57 +139,57 @@ registerCodec(CodecId.LZMA2, {
 });
 // BCJ (x86) filter
 registerCodec(CodecId.BCJ_X86, {
-    decode: decodeBcj,
+    decode: wrapSyncDecode(decodeBcj),
     createDecoder: createBcjDecoder
 });
 // BCJ (ARM) filter
 registerCodec(CodecId.BCJ_ARM, {
-    decode: decodeBcjArm,
+    decode: wrapSyncDecode(decodeBcjArm),
     createDecoder: createBcjArmDecoder
 });
 // BCJ (ARM Thumb) filter
 registerCodec(CodecId.BCJ_ARMT, {
-    decode: decodeBcjArmt,
+    decode: wrapSyncDecode(decodeBcjArmt),
     createDecoder: createBcjArmtDecoder
 });
 // BCJ (ARM64) filter
 registerCodec(CodecId.BCJ_ARM64, {
-    decode: decodeBcjArm64,
+    decode: wrapSyncDecode(decodeBcjArm64),
     createDecoder: createBcjArm64Decoder
 });
 // BCJ (PowerPC) filter
 registerCodec(CodecId.BCJ_PPC, {
-    decode: decodeBcjPpc,
+    decode: wrapSyncDecode(decodeBcjPpc),
     createDecoder: createBcjPpcDecoder
 });
 // BCJ (IA64) filter
 registerCodec(CodecId.BCJ_IA64, {
-    decode: decodeBcjIa64,
+    decode: wrapSyncDecode(decodeBcjIa64),
     createDecoder: createBcjIa64Decoder
 });
 // BCJ (SPARC) filter
 registerCodec(CodecId.BCJ_SPARC, {
-    decode: decodeBcjSparc,
+    decode: wrapSyncDecode(decodeBcjSparc),
     createDecoder: createBcjSparcDecoder
 });
 // Delta filter
 registerCodec(CodecId.DELTA, {
-    decode: decodeDelta,
+    decode: wrapSyncDecode(decodeDelta),
     createDecoder: createDeltaDecoder
 });
 // Deflate codec
 registerCodec(CodecId.DEFLATE, {
-    decode: decodeDeflate,
+    decode: wrapSyncDecode(decodeDeflate),
     createDecoder: createDeflateDecoder
 });
 // BZip2 codec
 registerCodec(CodecId.BZIP2, {
-    decode: decodeBzip2,
+    decode: wrapSyncDecode(decodeBzip2),
     createDecoder: createBzip2Decoder
 });
 // AES-256-CBC codec (encryption)
 registerCodec(CodecId.AES, {
-    decode: decodeAes,
+    decode: wrapSyncDecode(decodeAes),
     createDecoder: createAesDecoder
 });
 // BCJ2 (x86-64) filter - multi-stream

package/dist/esm/sevenz/codecs/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/index.ts"],"sourcesContent":["// Codec registry for 7z decompression\n// Each codec provides a decode function and optionally a streaming decoder\n\nimport type { Transform } from 'stream';\nimport {\n  createLzma2Decoder as _createLzma2Decoder,\n  createLzmaDecoder as _createLzmaDecoder,\n  createBcjArm64Decoder,\n  createBcjArmDecoder,\n  createBcjArmtDecoder,\n  createBcjDecoder,\n  createBcjIa64Decoder,\n  createBcjPpcDecoder,\n  createBcjSparcDecoder,\n  createDeltaDecoder,\n  decode7zLzma,\n  decode7zLzma2,\n  decodeBcj,\n  decodeBcjArm,\n  decodeBcjArm64,\n  decodeBcjArmt,\n  decodeBcjIa64,\n  decodeBcjPpc,\n  decodeBcjSparc,\n  decodeDelta,\n} from 'xz-compat';\nimport { CodecId, createCodedError, ErrorCode } from '../constants.ts';\nimport { createAesDecoder, decodeAes, getPassword, setPassword } from './Aes.ts';\nimport { createBcj2Decoder, decodeBcj2, decodeBcj2Multi } from './Bcj2.ts';\nimport { createBzip2Decoder, decodeBzip2 } from './BZip2.ts';\nimport { createCopyDecoder, decodeCopy } from './Copy.ts';\nimport { createDeflateDecoder, decodeDeflate } from './Deflate.ts';\n\n// Re-export password functions for API access\nexport { getPassword, setPassword };\n\nexport interface Codec {\n  decode: (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;\n  createDecoder: (properties?: Buffer, unpackSize?: number) => Transform;\n}\n\n// Simple wrappers with validation that use xz-compat's optimized decode7zLjma/decode7zLzma2\nfunction decodeLzma(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer {\n  if (!properties || properties.length < 5) {\n    throw new Error('LZMA requires 5-byte properties');\n  }\n  if (typeof unpackSize !== 'number' || unpackSize < 0) {\n    throw new Error('LZMA requires known unpack size');\n  }\n  return decode7zLzma(input, properties, unpackSize);\n}\n\nfunction createLzmaDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  if (!properties || properties.length < 5) {\n    throw new Error('LZMA requires 5-byte properties');\n  }\n  if (typeof unpackSize !== 'number' || unpackSize < 0) {\n    throw new Error('LZMA requires known unpack size');\n  }\n  return _createLzmaDecoder(properties, unpackSize) as Transform;\n}\n\nfunction decodeLzma2(input: Buffer, properties?: Buffer, unpackSize?: number): Buffer {\n  if (!properties || properties.length < 1) {\n    throw new Error('LZMA2 requires properties byte');\n  }\n  return decode7zLzma2(input, properties, unpackSize);\n}\n\nfunction createLzma2Decoder(properties?: Buffer, _unpackSize?: number): Transform {\n  if (!properties || properties.length < 1) {\n    throw new Error('LZMA2 requires properties byte');\n  }\n  return _createLzma2Decoder(properties) as Transform;\n}\n\n// Registry of supported codecs\nconst codecs: { [key: string]: Codec } = {};\n\n/**\n * Convert codec ID bytes to a string key\n */\nfunction codecIdToKey(id: number[]): string {\n  const parts: string[] = [];\n  for (let i = 0; i < id.length; i++) {\n    parts.push(id[i].toString(16).toUpperCase());\n  }\n  return parts.join('-');\n}\n\n/**\n * Check if two codec IDs match\n */\nfunction codecIdEquals(a: number[], b: number[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) return false;\n  }\n  return true;\n}\n\n/**\n * Register a codec\n */\nexport function registerCodec(id: number[], codec: Codec): void {\n  codecs[codecIdToKey(id)] = codec;\n}\n\n/**\n * Get a codec by ID\n * @throws Error if codec is not supported\n */\nexport function getCodec(id: number[]): Codec {\n  const key = codecIdToKey(id);\n  const codec = codecs[key];\n  if (!codec) {\n    throw createCodedError(`Unsupported codec: ${key}`, ErrorCode.UNSUPPORTED_CODEC);\n  }\n  return codec;\n}\n\n/**\n * Check if a codec is supported\n */\nexport function isCodecSupported(id: number[]): boolean {\n  return codecs[codecIdToKey(id)] !== undefined;\n}\n\n/**\n * Get human-readable codec name\n */\nexport function getCodecName(id: number[]): string {\n  if (codecIdEquals(id, CodecId.COPY)) return 'Copy';\n  if (codecIdEquals(id, CodecId.LZMA)) return 'LZMA';\n  if (codecIdEquals(id, CodecId.LZMA2)) return 'LZMA2';\n  if (codecIdEquals(id, CodecId.BCJ_X86)) return 'BCJ (x86)';\n  if (codecIdEquals(id, CodecId.BCJ_ARM)) return 'BCJ (ARM)';\n  if (codecIdEquals(id, CodecId.BCJ_ARMT)) return 'BCJ (ARM Thumb)';\n  if (codecIdEquals(id, CodecId.BCJ_ARM64)) return 'BCJ (ARM64)';\n  if (codecIdEquals(id, CodecId.BCJ_PPC)) return 'BCJ (PowerPC)';\n  if (codecIdEquals(id, CodecId.BCJ_IA64)) return 'BCJ (IA64)';\n  if (codecIdEquals(id, CodecId.BCJ_SPARC)) return 'BCJ (SPARC)';\n  if (codecIdEquals(id, CodecId.BCJ2)) return 'BCJ2';\n  if (codecIdEquals(id, CodecId.PPMD)) return 'PPMd';\n  if (codecIdEquals(id, CodecId.DELTA)) return 'Delta';\n  if (codecIdEquals(id, CodecId.DEFLATE)) return 'Deflate';\n  if (codecIdEquals(id, CodecId.BZIP2)) return 'BZip2';\n  if (codecIdEquals(id, CodecId.AES)) return 'AES-256';\n  return `Unknown (${codecIdToKey(id)})`;\n}\n\n/**\n * Check if a codec ID matches BCJ2\n */\nexport function isBcj2Codec(id: number[]): boolean {\n  return codecIdEquals(id, CodecId.BCJ2);\n}\n\n// Re-export BCJ2 multi-stream decoder for special handling\nexport { decodeBcj2Multi };\n\n// Register built-in codecs\n\n// Copy codec (no compression)\nregisterCodec(CodecId.COPY, {\n  decode: decodeCopy,\n  createDecoder: createCopyDecoder,\n});\n\n// LZMA codec\nregisterCodec(CodecId.LZMA, {\n  decode: decodeLzma,\n  createDecoder: createLzmaDecoder,\n});\n\n// LZMA2 codec\nregisterCodec(CodecId.LZMA2, {\n  decode: decodeLzma2,\n  createDecoder: createLzma2Decoder,\n});\n\n// BCJ (x86) filter\nregisterCodec(CodecId.BCJ_X86, {\n  decode: decodeBcj,\n  createDecoder: createBcjDecoder,\n});\n\n// BCJ (ARM) filter\nregisterCodec(CodecId.BCJ_ARM, {\n  decode: decodeBcjArm,\n  createDecoder: createBcjArmDecoder,\n});\n\n// BCJ (ARM Thumb) filter\nregisterCodec(CodecId.BCJ_ARMT, {\n  decode: decodeBcjArmt,\n  createDecoder: createBcjArmtDecoder,\n});\n\n// BCJ (ARM64) filter\nregisterCodec(CodecId.BCJ_ARM64, {\n  decode: decodeBcjArm64,\n  createDecoder: createBcjArm64Decoder,\n});\n\n// BCJ (PowerPC) filter\nregisterCodec(CodecId.BCJ_PPC, {\n  decode: decodeBcjPpc,\n  createDecoder: createBcjPpcDecoder,\n});\n\n// BCJ (IA64) filter\nregisterCodec(CodecId.BCJ_IA64, {\n  decode: decodeBcjIa64,\n  createDecoder: createBcjIa64Decoder,\n});\n\n// BCJ (SPARC) filter\nregisterCodec(CodecId.BCJ_SPARC, {\n  decode: decodeBcjSparc,\n  createDecoder: createBcjSparcDecoder,\n});\n\n// Delta filter\nregisterCodec(CodecId.DELTA, {\n  decode: decodeDelta,\n  createDecoder: createDeltaDecoder,\n});\n\n// Deflate codec\nregisterCodec(CodecId.DEFLATE, {\n  decode: decodeDeflate,\n  createDecoder: createDeflateDecoder,\n});\n\n// BZip2 codec\nregisterCodec(CodecId.BZIP2, {\n  decode: decodeBzip2,\n  createDecoder: createBzip2Decoder,\n});\n\n// AES-256-CBC codec (encryption)\nregisterCodec(CodecId.AES, {\n  decode: decodeAes,\n  createDecoder: createAesDecoder,\n});\n\n// BCJ2 (x86-64) filter - multi-stream\n// Note: BCJ2 requires special handling in SevenZipParser due to 4-stream architecture\nregisterCodec(CodecId.BCJ2, {\n  decode: decodeBcj2,\n  createDecoder: createBcj2Decoder,\n});\n\n// Note: PPMd codec is not implemented. See FUTURE_ENHANCEMENTS.md\n"],"names":["createLzma2Decoder","_createLzma2Decoder","createLzmaDecoder","_createLzmaDecoder","createBcjArm64Decoder","createBcjArmDecoder","createBcjArmtDecoder","createBcjDecoder","createBcjIa64Decoder","createBcjPpcDecoder","createBcjSparcDecoder","createDeltaDecoder","decode7zLzma","decode7zLzma2","decodeBcj","decodeBcjArm","decodeBcjArm64","decodeBcjArmt","decodeBcjIa64","decodeBcjPpc","decodeBcjSparc","decodeDelta","CodecId","createCodedError","ErrorCode","createAesDecoder","decodeAes","getPassword","setPassword","createBcj2Decoder","decodeBcj2","decodeBcj2Multi","createBzip2Decoder","decodeBzip2","createCopyDecoder","decodeCopy","createDeflateDecoder","decodeDeflate","decodeLzma","input","properties","unpackSize","length","Error","decodeLzma2","_unpackSize","codecs","codecIdToKey","id","parts","i","push","toString","toUpperCase","join","codecIdEquals","a","b","registerCodec","codec","getCodec","key","UNSUPPORTED_CODEC","isCodecSupported","undefined","getCodecName","COPY","LZMA","LZMA2","BCJ_X86","BCJ_ARM","BCJ_ARMT","BCJ_ARM64","BCJ_PPC","BCJ_IA64","BCJ_SPARC","BCJ2","PPMD","DELTA","DEFLATE","BZIP2","AES","isBcj2Codec","decode","createDecoder"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/iterators/7z-iterator/src/sevenz/codecs/index.ts"],"sourcesContent":["// Codec registry for 7z decompression\n// Each codec provides a decode function and optionally a streaming decoder\n\nimport type { Transform } from 'stream';\nimport {\n  createLzma2Decoder as _createLzma2Decoder,\n  createLzmaDecoder as _createLzmaDecoder,\n  createBcjArm64Decoder,\n  createBcjArmDecoder,\n  createBcjArmtDecoder,\n  createBcjDecoder,\n  createBcjIa64Decoder,\n  createBcjPpcDecoder,\n  createBcjSparcDecoder,\n  createDeltaDecoder,\n  decode7zLzma,\n  decode7zLzma2,\n  decodeBcj,\n  decodeBcjArm,\n  decodeBcjArm64,\n  decodeBcjArmt,\n  decodeBcjIa64,\n  decodeBcjPpc,\n  decodeBcjSparc,\n  decodeDelta,\n} from 'xz-compat';\nimport { type DecodeCallback as CodecDecodeCallback, runDecode } from '../../lib/runDecode.ts';\nimport { CodecId, createCodedError, ErrorCode } from '../constants.ts';\nimport { createAesDecoder, decodeAes, getPassword, setPassword } from './Aes.ts';\nimport { createBcj2Decoder, decodeBcj2, decodeBcj2Multi } from './Bcj2.ts';\nimport { createBzip2Decoder, decodeBzip2 } from './BZip2.ts';\nimport { createCopyDecoder, decodeCopy } from './Copy.ts';\nimport { createDeflateDecoder, decodeDeflate } from './Deflate.ts';\n\n// Re-export password functions for API access\nexport { getPassword, setPassword };\n\nfunction wrapSyncDecode(fn: (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer): Codec['decode'] {\n  return (input, properties, unpackSize, callback) => {\n    runDecode((done) => {\n      done(null, fn(input, properties, unpackSize));\n    }, callback);\n  };\n}\n\nexport interface Codec {\n  decode: (input: Buffer, properties: Buffer | undefined, unpackSize: number | undefined, callback: CodecDecodeCallback<Buffer>) => void;\n  createDecoder: (properties?: Buffer, unpackSize?: number) => Transform;\n}\n\n// Simple wrappers with validation that use xz-compat's optimized decode7zLjma/decode7zLzma2\nfunction decodeLzma(input: Buffer, properties?: Buffer, unpackSize?: number, callback?: CodecDecodeCallback<Buffer>): void {\n  if (!properties || properties.length < 5) {\n    throw new Error('LZMA requires 5-byte properties');\n  }\n  if (typeof unpackSize !== 'number' || unpackSize < 0) {\n    throw new Error('LZMA requires known unpack size');\n  }\n  runDecode((done) => {\n    decode7zLzma(input, properties, unpackSize, done);\n  }, callback);\n}\n\nfunction createLzmaDecoder(properties?: Buffer, unpackSize?: number): Transform {\n  if (!properties || properties.length < 5) {\n    throw new Error('LZMA requires 5-byte properties');\n  }\n  if (typeof unpackSize !== 'number' || unpackSize < 0) {\n    throw new Error('LZMA requires known unpack size');\n  }\n  return _createLzmaDecoder(properties, unpackSize) as Transform;\n}\n\nfunction decodeLzma2(input: Buffer, properties?: Buffer, unpackSize?: number, callback?: CodecDecodeCallback<Buffer>): void {\n  if (!properties || properties.length < 1) {\n    throw new Error('LZMA2 requires properties byte');\n  }\n  runDecode((done) => {\n    decode7zLzma2(input, properties, unpackSize, done);\n  }, callback);\n}\n\nfunction createLzma2Decoder(properties?: Buffer, _unpackSize?: number): Transform {\n  if (!properties || properties.length < 1) {\n    throw new Error('LZMA2 requires properties byte');\n  }\n  return _createLzma2Decoder(properties) as Transform;\n}\n\n// Registry of supported codecs\nconst codecs: { [key: string]: Codec } = {};\n\n/**\n * Convert codec ID bytes to a string key\n */\nfunction codecIdToKey(id: number[]): string {\n  const parts: string[] = [];\n  for (let i = 0; i < id.length; i++) {\n    parts.push(id[i].toString(16).toUpperCase());\n  }\n  return parts.join('-');\n}\n\n/**\n * Check if two codec IDs match\n */\nfunction codecIdEquals(a: number[], b: number[]): boolean {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) return false;\n  }\n  return true;\n}\n\n/**\n * Register a codec\n */\nexport function registerCodec(id: number[], codec: Codec): void {\n  codecs[codecIdToKey(id)] = codec;\n}\n\n/**\n * Get a codec by ID\n * @throws Error if codec is not supported\n */\nexport function getCodec(id: number[]): Codec {\n  const key = codecIdToKey(id);\n  const codec = codecs[key];\n  if (!codec) {\n    throw createCodedError(`Unsupported codec: ${key}`, ErrorCode.UNSUPPORTED_CODEC);\n  }\n  return codec;\n}\n\n/**\n * Check if a codec is supported\n */\nexport function isCodecSupported(id: number[]): boolean {\n  return codecs[codecIdToKey(id)] !== undefined;\n}\n\n/**\n * Get human-readable codec name\n */\nexport function getCodecName(id: number[]): string {\n  if (codecIdEquals(id, CodecId.COPY)) return 'Copy';\n  if (codecIdEquals(id, CodecId.LZMA)) return 'LZMA';\n  if (codecIdEquals(id, CodecId.LZMA2)) return 'LZMA2';\n  if (codecIdEquals(id, CodecId.BCJ_X86)) return 'BCJ (x86)';\n  if (codecIdEquals(id, CodecId.BCJ_ARM)) return 'BCJ (ARM)';\n  if (codecIdEquals(id, CodecId.BCJ_ARMT)) return 'BCJ (ARM Thumb)';\n  if (codecIdEquals(id, CodecId.BCJ_ARM64)) return 'BCJ (ARM64)';\n  if (codecIdEquals(id, CodecId.BCJ_PPC)) return 'BCJ (PowerPC)';\n  if (codecIdEquals(id, CodecId.BCJ_IA64)) return 'BCJ (IA64)';\n  if (codecIdEquals(id, CodecId.BCJ_SPARC)) return 'BCJ (SPARC)';\n  if (codecIdEquals(id, CodecId.BCJ2)) return 'BCJ2';\n  if (codecIdEquals(id, CodecId.PPMD)) return 'PPMd';\n  if (codecIdEquals(id, CodecId.DELTA)) return 'Delta';\n  if (codecIdEquals(id, CodecId.DEFLATE)) return 'Deflate';\n  if (codecIdEquals(id, CodecId.BZIP2)) return 'BZip2';\n  if (codecIdEquals(id, CodecId.AES)) return 'AES-256';\n  return `Unknown (${codecIdToKey(id)})`;\n}\n\n/**\n * Check if a codec ID matches BCJ2\n */\nexport function isBcj2Codec(id: number[]): boolean {\n  return codecIdEquals(id, CodecId.BCJ2);\n}\n\n// Re-export BCJ2 multi-stream decoder for special handling\nexport { decodeBcj2Multi };\n\n// Register built-in codecs\n\n// Copy codec (no compression)\nregisterCodec(CodecId.COPY, {\n  decode: wrapSyncDecode(decodeCopy),\n  createDecoder: createCopyDecoder,\n});\n\n// LZMA codec\nregisterCodec(CodecId.LZMA, {\n  decode: decodeLzma,\n  createDecoder: createLzmaDecoder,\n});\n\n// LZMA2 codec\nregisterCodec(CodecId.LZMA2, {\n  decode: decodeLzma2,\n  createDecoder: createLzma2Decoder,\n});\n\n// BCJ (x86) filter\nregisterCodec(CodecId.BCJ_X86, {\n  decode: wrapSyncDecode(decodeBcj),\n  createDecoder: createBcjDecoder,\n});\n\n// BCJ (ARM) filter\nregisterCodec(CodecId.BCJ_ARM, {\n  decode: wrapSyncDecode(decodeBcjArm),\n  createDecoder: createBcjArmDecoder,\n});\n\n// BCJ (ARM Thumb) filter\nregisterCodec(CodecId.BCJ_ARMT, {\n  decode: wrapSyncDecode(decodeBcjArmt),\n  createDecoder: createBcjArmtDecoder,\n});\n\n// BCJ (ARM64) filter\nregisterCodec(CodecId.BCJ_ARM64, {\n  decode: wrapSyncDecode(decodeBcjArm64),\n  createDecoder: createBcjArm64Decoder,\n});\n\n// BCJ (PowerPC) filter\nregisterCodec(CodecId.BCJ_PPC, {\n  decode: wrapSyncDecode(decodeBcjPpc),\n  createDecoder: createBcjPpcDecoder,\n});\n\n// BCJ (IA64) filter\nregisterCodec(CodecId.BCJ_IA64, {\n  decode: wrapSyncDecode(decodeBcjIa64),\n  createDecoder: createBcjIa64Decoder,\n});\n\n// BCJ (SPARC) filter\nregisterCodec(CodecId.BCJ_SPARC, {\n  decode: wrapSyncDecode(decodeBcjSparc),\n  createDecoder: createBcjSparcDecoder,\n});\n\n// Delta filter\nregisterCodec(CodecId.DELTA, {\n  decode: wrapSyncDecode(decodeDelta),\n  createDecoder: createDeltaDecoder,\n});\n\n// Deflate codec\nregisterCodec(CodecId.DEFLATE, {\n  decode: wrapSyncDecode(decodeDeflate),\n  createDecoder: createDeflateDecoder,\n});\n\n// BZip2 codec\nregisterCodec(CodecId.BZIP2, {\n  decode: wrapSyncDecode(decodeBzip2),\n  createDecoder: createBzip2Decoder,\n});\n\n// AES-256-CBC codec (encryption)\nregisterCodec(CodecId.AES, {\n  decode: wrapSyncDecode(decodeAes),\n  createDecoder: createAesDecoder,\n});\n\n// BCJ2 (x86-64) filter - multi-stream\n// Note: BCJ2 requires special handling in SevenZipParser due to 4-stream architecture\nregisterCodec(CodecId.BCJ2, {\n  decode: decodeBcj2,\n  createDecoder: createBcj2Decoder,\n});\n\n// Note: PPMd codec is not implemented. See FUTURE_ENHANCEMENTS.md\n"],"names":["createLzma2Decoder","_createLzma2Decoder","createLzmaDecoder","_createLzmaDecoder","createBcjArm64Decoder","createBcjArmDecoder","createBcjArmtDecoder","createBcjDecoder","createBcjIa64Decoder","createBcjPpcDecoder","createBcjSparcDecoder","createDeltaDecoder","decode7zLzma","decode7zLzma2","decodeBcj","decodeBcjArm","decodeBcjArm64","decodeBcjArmt","decodeBcjIa64","decodeBcjPpc","decodeBcjSparc","decodeDelta","runDecode","CodecId","createCodedError","ErrorCode","createAesDecoder","decodeAes","getPassword","setPassword","createBcj2Decoder","decodeBcj2","decodeBcj2Multi","createBzip2Decoder","decodeBzip2","createCopyDecoder","decodeCopy","createDeflateDecoder","decodeDeflate","wrapSyncDecode","fn","input","properties","unpackSize","callback","done","decodeLzma","length","Error","decodeLzma2","_unpackSize","codecs","codecIdToKey","id","parts","i","push","toString","toUpperCase","join","codecIdEquals","a","b","registerCodec","codec","getCodec","key","UNSUPPORTED_CODEC","isCodecSupported","undefined","getCodecName","COPY","LZMA","LZMA2","BCJ_X86","BCJ_ARM","BCJ_ARMT","BCJ_ARM64","BCJ_PPC","BCJ_IA64","BCJ_SPARC","BCJ2","PPMD","DELTA","DEFLATE","BZIP2","AES","isBcj2Codec","decode","createDecoder"],"mappings":"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"}

package/dist/esm/sevenz/codecs/streams.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/codecs/streams.ts"],"sourcesContent":["// Shared stream wrappers for lzma-purejs codec interface\n// These adapters convert between Buffer/lzma-purejs stream interfaces\n\nimport { allocBufferUnsafe } from 'extract-base-iterator';\n\n/**\n * Input stream wrapper for lzma-purejs\n * Wraps a Buffer region as a readable stream interface\n */\nexport function createInputStream(buffer: Buffer, offset: number, length: number) {\n  let pos = 0;\n  const end = Math.min(offset + length, buffer.length);\n  const start = offset;\n\n  return {\n    readByte: (): number => {\n      if (start + pos >= end) return -1;\n      return buffer[start + pos++];\n    },\n    read: (buf: number[], bufOffset: number, len: number): number => {\n      let bytesRead = 0;\n      while (bytesRead < len && start + pos < end) {\n        buf[bufOffset + bytesRead] = buffer[start + pos];\n        pos++;\n        bytesRead++;\n      }\n      return bytesRead === 0 ? -1 : bytesRead;\n    },\n  };\n}\n\n/**\n * Output stream wrapper for lzma-purejs\n * Collects output bytes into Buffer chunks\n * Uses typed arrays for memory efficiency (1 byte per element instead of 8)\n *\n * Memory optimization: If expectedSize is provided, pre-allocates a single buffer\n * to avoid double-memory during Buffer.concat.\n *\n * @param expectedSize - Optional expected output size for pre-allocation\n */\nexport function createOutputStream(expectedSize?: number) {\n  // Pre-allocation mode: single buffer, no concat needed\n  // Includes bounds checking for safety on older Node.js versions\n  if (expectedSize && expectedSize > 0) {\n    const buffer = allocBufferUnsafe(expectedSize);\n    let bufPos = 0;\n    const bufLen = buffer.length;\n\n    return {\n      writeByte: (b: number): void => {\n        if (bufPos < bufLen) {\n          buffer[bufPos++] = b;\n        }\n        // Silently ignore overflow (should not happen with correct size)\n      },\n      write: (buf: number[], bufOffset: number, len: number): number => {\n        for (let i = 0; i < len && bufPos < bufLen; i++) {\n          buffer[bufPos++] = buf[bufOffset + i];\n        }\n        return len;\n      },\n      flush: (): void => {\n        // No-op for pre-allocated buffer\n      },\n      toBuffer: (): Buffer => {\n        // Return only the used portion\n        return bufPos < buffer.length ? buffer.slice(0, bufPos) : buffer;\n      },\n    };\n  }\n\n  // Chunked mode: accumulate in 64KB chunks (fallback for unknown size)\n  const chunks: Buffer[] = [];\n  const CHUNK_SIZE = 65536; // 64KB chunks for better memory efficiency\n  let currentChunk: Buffer = allocBufferUnsafe(CHUNK_SIZE);\n  let pos = 0;\n\n  return {\n    writeByte: (b: number): void => {\n      currentChunk[pos++] = b;\n      if (pos >= CHUNK_SIZE) {\n        chunks.push(currentChunk);\n        currentChunk = allocBufferUnsafe(CHUNK_SIZE);\n        pos = 0;\n      }\n    },\n    write: function (buf: number[], bufOffset: number, len: number): number {\n      for (let i = 0; i < len; i++) {\n        this.writeByte(buf[bufOffset + i]);\n      }\n      return len;\n    },\n    flush: (): void => {\n      if (pos > 0) {\n        // Only keep the used portion of the current chunk\n        chunks.push(currentChunk.slice(0, pos));\n        currentChunk = allocBufferUnsafe(CHUNK_SIZE);\n        pos = 0;\n      }\n    },\n    toBuffer: function (): Buffer {\n      this.flush();\n      // Optimization: if single chunk, return it directly\n      if (chunks.length === 1) {\n        return chunks[0];\n      }\n      return Buffer.concat(chunks);\n    },\n  };\n}\n"],"names":["allocBufferUnsafe","createInputStream","buffer","offset","length","pos","end","Math","min","start","readByte","read","buf","bufOffset","len","bytesRead","createOutputStream","expectedSize","bufPos","bufLen","writeByte","b","write","i","flush","toBuffer","slice","chunks","CHUNK_SIZE","currentChunk","push","Buffer","concat"],"mappings":"AAAA,yDAAyD;AACzD,sEAAsE;AAEtE,SAASA,iBAAiB,QAAQ,wBAAwB;AAE1D;;;CAGC,GACD,OAAO,SAASC,kBAAkBC,MAAc,EAAEC,MAAc,EAAEC,MAAc;IAC9E,IAAIC,MAAM;IACV,MAAMC,MAAMC,KAAKC,GAAG,CAACL,SAASC,QAAQF,OAAOE,MAAM;IACnD,MAAMK,QAAQN;IAEd,OAAO;QACLO,UAAU;YACR,IAAID,QAAQJ,OAAOC,KAAK,OAAO,CAAC;YAChC,OAAOJ,MAAM,CAACO,QAAQJ,MAAM;QAC9B;QACAM,MAAM,CAACC,KAAeC,WAAmBC;YACvC,IAAIC,YAAY;YAChB,MAAOA,YAAYD,OAAOL,QAAQJ,MAAMC,IAAK;gBAC3CM,GAAG,CAACC,YAAYE,UAAU,GAAGb,MAAM,CAACO,QAAQJ,IAAI;gBAChDA;gBACAU;YACF;YACA,OAAOA,cAAc,IAAI,CAAC,IAAIA;QAChC;IACF;AACF;AAEA;;;;;;;;;CASC,GACD,OAAO,SAASC,mBAAmBC,YAAqB;IACtD,uDAAuD;IACvD,gEAAgE;IAChE,IAAIA,gBAAgBA,eAAe,GAAG;QACpC,MAAMf,SAASF,kBAAkBiB;QACjC,IAAIC,SAAS;QACb,MAAMC,SAASjB,OAAOE,MAAM;QAE5B,OAAO;YACLgB,WAAW,CAACC;gBACV,IAAIH,SAASC,QAAQ;oBACnBjB,MAAM,CAACgB,SAAS,GAAGG;gBACrB;YACA,iEAAiE;YACnE;YACAC,OAAO,CAACV,KAAeC,WAAmBC;gBACxC,IAAK,IAAIS,IAAI,GAAGA,IAAIT,OAAOI,SAASC,QAAQI,IAAK;oBAC/CrB,MAAM,CAACgB,SAAS,GAAGN,GAAG,CAACC,YAAYU,EAAE;gBACvC;gBACA,OAAOT;YACT;YACAU,OAAO;YACL,iCAAiC;YACnC;YACAC,UAAU;gBACR,+BAA+B;gBAC/B,OAAOP,SAAShB,OAAOE,MAAM,GAAGF,OAAOwB,KAAK,CAAC,GAAGR,UAAUhB;YAC5D;QACF;IACF;IAEA,sEAAsE;IACtE,MAAMyB,SAAmB,EAAE;IAC3B,MAAMC,aAAa,OAAO,2CAA2C;IACrE,IAAIC,eAAuB7B,kBAAkB4B;IAC7C,IAAIvB,MAAM;IAEV,OAAO;QACLe,WAAW,CAACC;YACVQ,YAAY,CAACxB,MAAM,GAAGgB;YACtB,IAAIhB,OAAOuB,YAAY;gBACrBD,OAAOG,IAAI,CAACD;gBACZA,eAAe7B,kBAAkB4B;gBACjCvB,MAAM;YACR;QACF;QACAiB,OAAO,SAAUV,GAAa,EAAEC,SAAiB,EAAEC,GAAW;YAC5D,IAAK,IAAIS,IAAI,GAAGA,IAAIT,KAAKS,IAAK;gBAC5B,IAAI,CAACH,SAAS,CAACR,GAAG,CAACC,YAAYU,EAAE;YACnC;YACA,OAAOT;QACT;QACAU,OAAO;YACL,IAAInB,MAAM,GAAG;gBACX,kDAAkD;gBAClDsB,OAAOG,IAAI,CAACD,aAAaH,KAAK,CAAC,GAAGrB;gBAClCwB,eAAe7B,kBAAkB4B;gBACjCvB,MAAM;YACR;QACF;QACAoB,UAAU;YACR,IAAI,CAACD,KAAK;YACV,oDAAoD;YACpD,IAAIG,OAAOvB,MAAM,KAAK,GAAG;gBACvB,OAAOuB,MAAM,CAAC,EAAE;YAClB;YACA,OAAOI,OAAOC,MAAM,CAACL;QACvB;IACF;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/iterators/7z-iterator/src/sevenz/codecs/streams.ts"],"sourcesContent":["// Shared stream wrappers for lzma-purejs codec interface\n// These adapters convert between Buffer/lzma-purejs stream interfaces\n\nimport { allocBufferUnsafe } from 'extract-base-iterator';\n\n/**\n * Input stream wrapper for lzma-purejs\n * Wraps a Buffer region as a readable stream interface\n */\nexport function createInputStream(buffer: Buffer, offset: number, length: number) {\n  let pos = 0;\n  const end = Math.min(offset + length, buffer.length);\n  const start = offset;\n\n  return {\n    readByte: (): number => {\n      if (start + pos >= end) return -1;\n      return buffer[start + pos++];\n    },\n    read: (buf: number[], bufOffset: number, len: number): number => {\n      let bytesRead = 0;\n      while (bytesRead < len && start + pos < end) {\n        buf[bufOffset + bytesRead] = buffer[start + pos];\n        pos++;\n        bytesRead++;\n      }\n      return bytesRead === 0 ? -1 : bytesRead;\n    },\n  };\n}\n\n/**\n * Output stream wrapper for lzma-purejs\n * Collects output bytes into Buffer chunks\n * Uses typed arrays for memory efficiency (1 byte per element instead of 8)\n *\n * Memory optimization: If expectedSize is provided, pre-allocates a single buffer\n * to avoid double-memory during Buffer.concat.\n *\n * @param expectedSize - Optional expected output size for pre-allocation\n */\nexport function createOutputStream(expectedSize?: number) {\n  // Pre-allocation mode: single buffer, no concat needed\n  // Includes bounds checking for safety on older Node.js versions\n  if (expectedSize && expectedSize > 0) {\n    const buffer = allocBufferUnsafe(expectedSize);\n    let bufPos = 0;\n    const bufLen = buffer.length;\n\n    return {\n      writeByte: (b: number): void => {\n        if (bufPos < bufLen) {\n          buffer[bufPos++] = b;\n        }\n        // Silently ignore overflow (should not happen with correct size)\n      },\n      write: (buf: number[], bufOffset: number, len: number): number => {\n        for (let i = 0; i < len && bufPos < bufLen; i++) {\n          buffer[bufPos++] = buf[bufOffset + i];\n        }\n        return len;\n      },\n      flush: (): void => {\n        // No-op for pre-allocated buffer\n      },\n      toBuffer: (): Buffer => {\n        // Return only the used portion\n        return bufPos < buffer.length ? buffer.slice(0, bufPos) : buffer;\n      },\n    };\n  }\n\n  // Chunked mode: accumulate in 64KB chunks (fallback for unknown size)\n  const chunks: Buffer[] = [];\n  const CHUNK_SIZE = 65536; // 64KB chunks for better memory efficiency\n  let currentChunk: Buffer = allocBufferUnsafe(CHUNK_SIZE);\n  let pos = 0;\n\n  return {\n    writeByte: (b: number): void => {\n      currentChunk[pos++] = b;\n      if (pos >= CHUNK_SIZE) {\n        chunks.push(currentChunk);\n        currentChunk = allocBufferUnsafe(CHUNK_SIZE);\n        pos = 0;\n      }\n    },\n    write: function (buf: number[], bufOffset: number, len: number): number {\n      for (let i = 0; i < len; i++) {\n        this.writeByte(buf[bufOffset + i]);\n      }\n      return len;\n    },\n    flush: (): void => {\n      if (pos > 0) {\n        // Only keep the used portion of the current chunk\n        chunks.push(currentChunk.slice(0, pos));\n        currentChunk = allocBufferUnsafe(CHUNK_SIZE);\n        pos = 0;\n      }\n    },\n    toBuffer: function (): Buffer {\n      this.flush();\n      // Optimization: if single chunk, return it directly\n      if (chunks.length === 1) {\n        return chunks[0];\n      }\n      return Buffer.concat(chunks);\n    },\n  };\n}\n"],"names":["allocBufferUnsafe","createInputStream","buffer","offset","length","pos","end","Math","min","start","readByte","read","buf","bufOffset","len","bytesRead","createOutputStream","expectedSize","bufPos","bufLen","writeByte","b","write","i","flush","toBuffer","slice","chunks","CHUNK_SIZE","currentChunk","push","Buffer","concat"],"mappings":"AAAA,yDAAyD;AACzD,sEAAsE;AAEtE,SAASA,iBAAiB,QAAQ,wBAAwB;AAE1D;;;CAGC,GACD,OAAO,SAASC,kBAAkBC,MAAc,EAAEC,MAAc,EAAEC,MAAc;IAC9E,IAAIC,MAAM;IACV,MAAMC,MAAMC,KAAKC,GAAG,CAACL,SAASC,QAAQF,OAAOE,MAAM;IACnD,MAAMK,QAAQN;IAEd,OAAO;QACLO,UAAU;YACR,IAAID,QAAQJ,OAAOC,KAAK,OAAO,CAAC;YAChC,OAAOJ,MAAM,CAACO,QAAQJ,MAAM;QAC9B;QACAM,MAAM,CAACC,KAAeC,WAAmBC;YACvC,IAAIC,YAAY;YAChB,MAAOA,YAAYD,OAAOL,QAAQJ,MAAMC,IAAK;gBAC3CM,GAAG,CAACC,YAAYE,UAAU,GAAGb,MAAM,CAACO,QAAQJ,IAAI;gBAChDA;gBACAU;YACF;YACA,OAAOA,cAAc,IAAI,CAAC,IAAIA;QAChC;IACF;AACF;AAEA;;;;;;;;;CASC,GACD,OAAO,SAASC,mBAAmBC,YAAqB;IACtD,uDAAuD;IACvD,gEAAgE;IAChE,IAAIA,gBAAgBA,eAAe,GAAG;QACpC,MAAMf,SAASF,kBAAkBiB;QACjC,IAAIC,SAAS;QACb,MAAMC,SAASjB,OAAOE,MAAM;QAE5B,OAAO;YACLgB,WAAW,CAACC;gBACV,IAAIH,SAASC,QAAQ;oBACnBjB,MAAM,CAACgB,SAAS,GAAGG;gBACrB;YACA,iEAAiE;YACnE;YACAC,OAAO,CAACV,KAAeC,WAAmBC;gBACxC,IAAK,IAAIS,IAAI,GAAGA,IAAIT,OAAOI,SAASC,QAAQI,IAAK;oBAC/CrB,MAAM,CAACgB,SAAS,GAAGN,GAAG,CAACC,YAAYU,EAAE;gBACvC;gBACA,OAAOT;YACT;YACAU,OAAO;YACL,iCAAiC;YACnC;YACAC,UAAU;gBACR,+BAA+B;gBAC/B,OAAOP,SAAShB,OAAOE,MAAM,GAAGF,OAAOwB,KAAK,CAAC,GAAGR,UAAUhB;YAC5D;QACF;IACF;IAEA,sEAAsE;IACtE,MAAMyB,SAAmB,EAAE;IAC3B,MAAMC,aAAa,OAAO,2CAA2C;IACrE,IAAIC,eAAuB7B,kBAAkB4B;IAC7C,IAAIvB,MAAM;IAEV,OAAO;QACLe,WAAW,CAACC;YACVQ,YAAY,CAACxB,MAAM,GAAGgB;YACtB,IAAIhB,OAAOuB,YAAY;gBACrBD,OAAOG,IAAI,CAACD;gBACZA,eAAe7B,kBAAkB4B;gBACjCvB,MAAM;YACR;QACF;QACAiB,OAAO,SAAUV,GAAa,EAAEC,SAAiB,EAAEC,GAAW;YAC5D,IAAK,IAAIS,IAAI,GAAGA,IAAIT,KAAKS,IAAK;gBAC5B,IAAI,CAACH,SAAS,CAACR,GAAG,CAACC,YAAYU,EAAE;YACnC;YACA,OAAOT;QACT;QACAU,OAAO;YACL,IAAInB,MAAM,GAAG;gBACX,kDAAkD;gBAClDsB,OAAOG,IAAI,CAACD,aAAaH,KAAK,CAAC,GAAGrB;gBAClCwB,eAAe7B,kBAAkB4B;gBACjCvB,MAAM;YACR;QACF;QACAoB,UAAU;YACR,IAAI,CAACD,KAAK;YACV,oDAAoD;YACpD,IAAIG,OAAOvB,MAAM,KAAK,GAAG;gBACvB,OAAOuB,MAAM,CAAC,EAAE;YAClB;YACA,OAAOI,OAAOC,MAAM,CAACL;QACvB;IACF;AACF"}

package/dist/esm/sevenz/constants.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/constants.ts"],"sourcesContent":["// 7z format constants\n// Reference: https://py7zr.readthedocs.io/en/latest/archive_format.html\n\n// 7z signature: '7z' + magic bytes\nexport const SEVENZ_MAGIC = [0x37, 0x7a, 0xbc, 0xaf, 0x27, 0x1c];\n\n// Header sizes\nexport const SIGNATURE_HEADER_SIZE = 32;\nexport const START_HEADER_SIZE = 20; // Part of signature header after magic + version\n\n// Property IDs for encoded header\nexport const PropertyId = {\n  kEnd: 0x00,\n  kHeader: 0x01,\n  kArchiveProperties: 0x02,\n  kAdditionalStreamsInfo: 0x03,\n  kMainStreamsInfo: 0x04,\n  kFilesInfo: 0x05,\n  kPackInfo: 0x06,\n  kUnpackInfo: 0x07,\n  kSubStreamsInfo: 0x08,\n  kSize: 0x09,\n  kCRC: 0x0a,\n  kFolder: 0x0b,\n  kCodersUnpackSize: 0x0c,\n  kNumUnpackStream: 0x0d,\n  kEmptyStream: 0x0e,\n  kEmptyFile: 0x0f,\n  kAnti: 0x10,\n  kName: 0x11,\n  kCTime: 0x12,\n  kATime: 0x13,\n  kMTime: 0x14,\n  kWinAttributes: 0x15,\n  kComment: 0x16,\n  kEncodedHeader: 0x17,\n  kStartPos: 0x18,\n  kDummy: 0x19,\n};\n\n// Codec IDs\n// 7z uses variable-length codec IDs\n// Reference: 7za i output shows hex codec IDs (e.g., 3030501 = ARM)\nexport const CodecId = {\n  COPY: [0x00],\n  DELTA: [0x03],\n  LZMA: [0x03, 0x01, 0x01],\n  LZMA2: [0x21],\n  BCJ_X86: [0x03, 0x03, 0x01, 0x03],\n  BCJ_PPC: [0x03, 0x03, 0x02, 0x05],\n  BCJ_IA64: [0x03, 0x03, 0x04, 0x01],\n  BCJ_ARM: [0x03, 0x03, 0x05, 0x01],\n  BCJ_ARMT: [0x03, 0x03, 0x07, 0x01],\n  BCJ_SPARC: [0x03, 0x03, 0x08, 0x05],\n  BCJ_ARM64: [0x03, 0x03, 0x0a, 0x01],\n  BCJ2: [0x03, 0x03, 0x01, 0x1b],\n  PPMD: [0x03, 0x04, 0x01],\n  DEFLATE: [0x04, 0x01, 0x08],\n  BZIP2: [0x04, 0x02, 0x02],\n  AES: [0x06, 0xf1, 0x07, 0x01],\n};\n\n// File attribute flags (Windows style, stored in FilesInfo)\nexport const FileAttribute = {\n  READONLY: 0x01,\n  HIDDEN: 0x02,\n  SYSTEM: 0x04,\n  DIRECTORY: 0x10,\n  ARCHIVE: 0x20,\n  DEVICE: 0x40,\n  NORMAL: 0x80,\n  TEMPORARY: 0x100,\n  SPARSE_FILE: 0x200,\n  REPARSE_POINT: 0x400,\n  COMPRESSED: 0x800,\n  OFFLINE: 0x1000,\n  NOT_CONTENT_INDEXED: 0x2000,\n  ENCRYPTED: 0x4000,\n  UNIX_EXTENSION: 0x8000,\n};\n\n// Unix permission modes (decimal values for Node 0.8 compatibility)\nexport const UnixMode = {\n  DIR: 16384, // 0o40000 - directory\n  FILE: 32768, // 0o100000 - regular file\n  SYMLINK: 40960, // 0o120000 - symbolic link\n  RWXRWXRWX: 511, // 0o777\n  RWXRXRX: 493, // 0o755\n  RWRR: 420, // 0o644\n  DEFAULT_DIR: 493, // 0o755 - rwxr-xr-x\n  DEFAULT_FILE: 420, // 0o644 - rw-r--r--\n};\n\n// Error codes\nexport const ErrorCode = {\n  INVALID_SIGNATURE: 'INVALID_SIGNATURE',\n  CRC_MISMATCH: 'CRC_MISMATCH',\n  UNSUPPORTED_CODEC: 'UNSUPPORTED_CODEC',\n  UNSUPPORTED_VERSION: 'UNSUPPORTED_VERSION',\n  UNSUPPORTED_FEATURE: 'UNSUPPORTED_FEATURE',\n  TRUNCATED_ARCHIVE: 'TRUNCATED_ARCHIVE',\n  CORRUPT_ARCHIVE: 'CORRUPT_ARCHIVE',\n  CORRUPT_HEADER: 'CORRUPT_HEADER',\n  ENCRYPTED_ARCHIVE: 'ENCRYPTED_ARCHIVE',\n  COMPRESSED_HEADER: 'COMPRESSED_HEADER',\n  DECOMPRESSION_FAILED: 'DECOMPRESSION_FAILED',\n};\n\n// Error with code property\nexport interface CodedError extends Error {\n  code: string;\n}\n\n/**\n * Create an error with a code property\n */\nexport function createCodedError(message: string, code: string): CodedError {\n  const err = new Error(message) as CodedError;\n  err.code = code;\n  return err;\n}\n"],"names":["SEVENZ_MAGIC","SIGNATURE_HEADER_SIZE","START_HEADER_SIZE","PropertyId","kEnd","kHeader","kArchiveProperties","kAdditionalStreamsInfo","kMainStreamsInfo","kFilesInfo","kPackInfo","kUnpackInfo","kSubStreamsInfo","kSize","kCRC","kFolder","kCodersUnpackSize","kNumUnpackStream","kEmptyStream","kEmptyFile","kAnti","kName","kCTime","kATime","kMTime","kWinAttributes","kComment","kEncodedHeader","kStartPos","kDummy","CodecId","COPY","DELTA","LZMA","LZMA2","BCJ_X86","BCJ_PPC","BCJ_IA64","BCJ_ARM","BCJ_ARMT","BCJ_SPARC","BCJ_ARM64","BCJ2","PPMD","DEFLATE","BZIP2","AES","FileAttribute","READONLY","HIDDEN","SYSTEM","DIRECTORY","ARCHIVE","DEVICE","NORMAL","TEMPORARY","SPARSE_FILE","REPARSE_POINT","COMPRESSED","OFFLINE","NOT_CONTENT_INDEXED","ENCRYPTED","UNIX_EXTENSION","UnixMode","DIR","FILE","SYMLINK","RWXRWXRWX","RWXRXRX","RWRR","DEFAULT_DIR","DEFAULT_FILE","ErrorCode","INVALID_SIGNATURE","CRC_MISMATCH","UNSUPPORTED_CODEC","UNSUPPORTED_VERSION","UNSUPPORTED_FEATURE","TRUNCATED_ARCHIVE","CORRUPT_ARCHIVE","CORRUPT_HEADER","ENCRYPTED_ARCHIVE","COMPRESSED_HEADER","DECOMPRESSION_FAILED","createCodedError","message","code","err","Error"],"mappings":"AAAA,sBAAsB;AACtB,wEAAwE;AAExE,mCAAmC;AACnC,OAAO,MAAMA,eAAe;IAAC;IAAM;IAAM;IAAM;IAAM;IAAM;CAAK,CAAC;AAEjE,eAAe;AACf,OAAO,MAAMC,wBAAwB,GAAG;AACxC,OAAO,MAAMC,oBAAoB,GAAG,CAAC,iDAAiD;AAEtF,kCAAkC;AAClC,OAAO,MAAMC,aAAa;IACxBC,MAAM;IACNC,SAAS;IACTC,oBAAoB;IACpBC,wBAAwB;IACxBC,kBAAkB;IAClBC,YAAY;IACZC,WAAW;IACXC,aAAa;IACbC,iBAAiB;IACjBC,OAAO;IACPC,MAAM;IACNC,SAAS;IACTC,mBAAmB;IACnBC,kBAAkB;IAClBC,cAAc;IACdC,YAAY;IACZC,OAAO;IACPC,OAAO;IACPC,QAAQ;IACRC,QAAQ;IACRC,QAAQ;IACRC,gBAAgB;IAChBC,UAAU;IACVC,gBAAgB;IAChBC,WAAW;IACXC,QAAQ;AACV,EAAE;AAEF,YAAY;AACZ,oCAAoC;AACpC,oEAAoE;AACpE,OAAO,MAAMC,UAAU;IACrBC,MAAM;QAAC;KAAK;IACZC,OAAO;QAAC;KAAK;IACbC,MAAM;QAAC;QAAM;QAAM;KAAK;IACxBC,OAAO;QAAC;KAAK;IACbC,SAAS;QAAC;QAAM;QAAM;QAAM;KAAK;IACjCC,SAAS;QAAC;QAAM;QAAM;QAAM;KAAK;IACjCC,UAAU;QAAC;QAAM;QAAM;QAAM;KAAK;IAClCC,SAAS;QAAC;QAAM;QAAM;QAAM;KAAK;IACjCC,UAAU;QAAC;QAAM;QAAM;QAAM;KAAK;IAClCC,WAAW;QAAC;QAAM;QAAM;QAAM;KAAK;IACnCC,WAAW;QAAC;QAAM;QAAM;QAAM;KAAK;IACnCC,MAAM;QAAC;QAAM;QAAM;QAAM;KAAK;IAC9BC,MAAM;QAAC;QAAM;QAAM;KAAK;IACxBC,SAAS;QAAC;QAAM;QAAM;KAAK;IAC3BC,OAAO;QAAC;QAAM;QAAM;KAAK;IACzBC,KAAK;QAAC;QAAM;QAAM;QAAM;KAAK;AAC/B,EAAE;AAEF,4DAA4D;AAC5D,OAAO,MAAMC,gBAAgB;IAC3BC,UAAU;IACVC,QAAQ;IACRC,QAAQ;IACRC,WAAW;IACXC,SAAS;IACTC,QAAQ;IACRC,QAAQ;IACRC,WAAW;IACXC,aAAa;IACbC,eAAe;IACfC,YAAY;IACZC,SAAS;IACTC,qBAAqB;IACrBC,WAAW;IACXC,gBAAgB;AAClB,EAAE;AAEF,oEAAoE;AACpE,OAAO,MAAMC,WAAW;IACtBC,KAAK;IACLC,MAAM;IACNC,SAAS;IACTC,WAAW;IACXC,SAAS;IACTC,MAAM;IACNC,aAAa;IACbC,cAAc;AAChB,EAAE;AAEF,cAAc;AACd,OAAO,MAAMC,YAAY;IACvBC,mBAAmB;IACnBC,cAAc;IACdC,mBAAmB;IACnBC,qBAAqB;IACrBC,qBAAqB;IACrBC,mBAAmB;IACnBC,iBAAiB;IACjBC,gBAAgB;IAChBC,mBAAmB;IACnBC,mBAAmB;IACnBC,sBAAsB;AACxB,EAAE;AAOF;;CAEC,GACD,OAAO,SAASC,iBAAiBC,OAAe,EAAEC,IAAY;IAC5D,MAAMC,MAAM,IAAIC,MAAMH;IACtBE,IAAID,IAAI,GAAGA;IACX,OAAOC;AACT"}
+{"version":3,"sources":["/Users/kevin/Dev/iterators/7z-iterator/src/sevenz/constants.ts"],"sourcesContent":["// 7z format constants\n// Reference: https://py7zr.readthedocs.io/en/latest/archive_format.html\n\n// 7z signature: '7z' + magic bytes\nexport const SEVENZ_MAGIC = [0x37, 0x7a, 0xbc, 0xaf, 0x27, 0x1c];\n\n// Header sizes\nexport const SIGNATURE_HEADER_SIZE = 32;\nexport const START_HEADER_SIZE = 20; // Part of signature header after magic + version\n\n// Property IDs for encoded header\nexport const PropertyId = {\n  kEnd: 0x00,\n  kHeader: 0x01,\n  kArchiveProperties: 0x02,\n  kAdditionalStreamsInfo: 0x03,\n  kMainStreamsInfo: 0x04,\n  kFilesInfo: 0x05,\n  kPackInfo: 0x06,\n  kUnpackInfo: 0x07,\n  kSubStreamsInfo: 0x08,\n  kSize: 0x09,\n  kCRC: 0x0a,\n  kFolder: 0x0b,\n  kCodersUnpackSize: 0x0c,\n  kNumUnpackStream: 0x0d,\n  kEmptyStream: 0x0e,\n  kEmptyFile: 0x0f,\n  kAnti: 0x10,\n  kName: 0x11,\n  kCTime: 0x12,\n  kATime: 0x13,\n  kMTime: 0x14,\n  kWinAttributes: 0x15,\n  kComment: 0x16,\n  kEncodedHeader: 0x17,\n  kStartPos: 0x18,\n  kDummy: 0x19,\n};\n\n// Codec IDs\n// 7z uses variable-length codec IDs\n// Reference: 7za i output shows hex codec IDs (e.g., 3030501 = ARM)\nexport const CodecId = {\n  COPY: [0x00],\n  DELTA: [0x03],\n  LZMA: [0x03, 0x01, 0x01],\n  LZMA2: [0x21],\n  BCJ_X86: [0x03, 0x03, 0x01, 0x03],\n  BCJ_PPC: [0x03, 0x03, 0x02, 0x05],\n  BCJ_IA64: [0x03, 0x03, 0x04, 0x01],\n  BCJ_ARM: [0x03, 0x03, 0x05, 0x01],\n  BCJ_ARMT: [0x03, 0x03, 0x07, 0x01],\n  BCJ_SPARC: [0x03, 0x03, 0x08, 0x05],\n  BCJ_ARM64: [0x03, 0x03, 0x0a, 0x01],\n  BCJ2: [0x03, 0x03, 0x01, 0x1b],\n  PPMD: [0x03, 0x04, 0x01],\n  DEFLATE: [0x04, 0x01, 0x08],\n  BZIP2: [0x04, 0x02, 0x02],\n  AES: [0x06, 0xf1, 0x07, 0x01],\n};\n\n// File attribute flags (Windows style, stored in FilesInfo)\nexport const FileAttribute = {\n  READONLY: 0x01,\n  HIDDEN: 0x02,\n  SYSTEM: 0x04,\n  DIRECTORY: 0x10,\n  ARCHIVE: 0x20,\n  DEVICE: 0x40,\n  NORMAL: 0x80,\n  TEMPORARY: 0x100,\n  SPARSE_FILE: 0x200,\n  REPARSE_POINT: 0x400,\n  COMPRESSED: 0x800,\n  OFFLINE: 0x1000,\n  NOT_CONTENT_INDEXED: 0x2000,\n  ENCRYPTED: 0x4000,\n  UNIX_EXTENSION: 0x8000,\n};\n\n// Unix permission modes (decimal values for Node 0.8 compatibility)\nexport const UnixMode = {\n  DIR: 16384, // 0o40000 - directory\n  FILE: 32768, // 0o100000 - regular file\n  SYMLINK: 40960, // 0o120000 - symbolic link\n  RWXRWXRWX: 511, // 0o777\n  RWXRXRX: 493, // 0o755\n  RWRR: 420, // 0o644\n  DEFAULT_DIR: 493, // 0o755 - rwxr-xr-x\n  DEFAULT_FILE: 420, // 0o644 - rw-r--r--\n};\n\n// Error codes\nexport const ErrorCode = {\n  INVALID_SIGNATURE: 'INVALID_SIGNATURE',\n  CRC_MISMATCH: 'CRC_MISMATCH',\n  UNSUPPORTED_CODEC: 'UNSUPPORTED_CODEC',\n  UNSUPPORTED_VERSION: 'UNSUPPORTED_VERSION',\n  UNSUPPORTED_FEATURE: 'UNSUPPORTED_FEATURE',\n  TRUNCATED_ARCHIVE: 'TRUNCATED_ARCHIVE',\n  CORRUPT_ARCHIVE: 'CORRUPT_ARCHIVE',\n  CORRUPT_HEADER: 'CORRUPT_HEADER',\n  ENCRYPTED_ARCHIVE: 'ENCRYPTED_ARCHIVE',\n  COMPRESSED_HEADER: 'COMPRESSED_HEADER',\n  DECOMPRESSION_FAILED: 'DECOMPRESSION_FAILED',\n};\n\n// Error with code property\nexport interface CodedError extends Error {\n  code: string;\n}\n\n/**\n * Create an error with a code property\n */\nexport function createCodedError(message: string, code: string): CodedError {\n  const err = new Error(message) as CodedError;\n  err.code = code;\n  return err;\n}\n"],"names":["SEVENZ_MAGIC","SIGNATURE_HEADER_SIZE","START_HEADER_SIZE","PropertyId","kEnd","kHeader","kArchiveProperties","kAdditionalStreamsInfo","kMainStreamsInfo","kFilesInfo","kPackInfo","kUnpackInfo","kSubStreamsInfo","kSize","kCRC","kFolder","kCodersUnpackSize","kNumUnpackStream","kEmptyStream","kEmptyFile","kAnti","kName","kCTime","kATime","kMTime","kWinAttributes","kComment","kEncodedHeader","kStartPos","kDummy","CodecId","COPY","DELTA","LZMA","LZMA2","BCJ_X86","BCJ_PPC","BCJ_IA64","BCJ_ARM","BCJ_ARMT","BCJ_SPARC","BCJ_ARM64","BCJ2","PPMD","DEFLATE","BZIP2","AES","FileAttribute","READONLY","HIDDEN","SYSTEM","DIRECTORY","ARCHIVE","DEVICE","NORMAL","TEMPORARY","SPARSE_FILE","REPARSE_POINT","COMPRESSED","OFFLINE","NOT_CONTENT_INDEXED","ENCRYPTED","UNIX_EXTENSION","UnixMode","DIR","FILE","SYMLINK","RWXRWXRWX","RWXRXRX","RWRR","DEFAULT_DIR","DEFAULT_FILE","ErrorCode","INVALID_SIGNATURE","CRC_MISMATCH","UNSUPPORTED_CODEC","UNSUPPORTED_VERSION","UNSUPPORTED_FEATURE","TRUNCATED_ARCHIVE","CORRUPT_ARCHIVE","CORRUPT_HEADER","ENCRYPTED_ARCHIVE","COMPRESSED_HEADER","DECOMPRESSION_FAILED","createCodedError","message","code","err","Error"],"mappings":"AAAA,sBAAsB;AACtB,wEAAwE;AAExE,mCAAmC;AACnC,OAAO,MAAMA,eAAe;IAAC;IAAM;IAAM;IAAM;IAAM;IAAM;CAAK,CAAC;AAEjE,eAAe;AACf,OAAO,MAAMC,wBAAwB,GAAG;AACxC,OAAO,MAAMC,oBAAoB,GAAG,CAAC,iDAAiD;AAEtF,kCAAkC;AAClC,OAAO,MAAMC,aAAa;IACxBC,MAAM;IACNC,SAAS;IACTC,oBAAoB;IACpBC,wBAAwB;IACxBC,kBAAkB;IAClBC,YAAY;IACZC,WAAW;IACXC,aAAa;IACbC,iBAAiB;IACjBC,OAAO;IACPC,MAAM;IACNC,SAAS;IACTC,mBAAmB;IACnBC,kBAAkB;IAClBC,cAAc;IACdC,YAAY;IACZC,OAAO;IACPC,OAAO;IACPC,QAAQ;IACRC,QAAQ;IACRC,QAAQ;IACRC,gBAAgB;IAChBC,UAAU;IACVC,gBAAgB;IAChBC,WAAW;IACXC,QAAQ;AACV,EAAE;AAEF,YAAY;AACZ,oCAAoC;AACpC,oEAAoE;AACpE,OAAO,MAAMC,UAAU;IACrBC,MAAM;QAAC;KAAK;IACZC,OAAO;QAAC;KAAK;IACbC,MAAM;QAAC;QAAM;QAAM;KAAK;IACxBC,OAAO;QAAC;KAAK;IACbC,SAAS;QAAC;QAAM;QAAM;QAAM;KAAK;IACjCC,SAAS;QAAC;QAAM;QAAM;QAAM;KAAK;IACjCC,UAAU;QAAC;QAAM;QAAM;QAAM;KAAK;IAClCC,SAAS;QAAC;QAAM;QAAM;QAAM;KAAK;IACjCC,UAAU;QAAC;QAAM;QAAM;QAAM;KAAK;IAClCC,WAAW;QAAC;QAAM;QAAM;QAAM;KAAK;IACnCC,WAAW;QAAC;QAAM;QAAM;QAAM;KAAK;IACnCC,MAAM;QAAC;QAAM;QAAM;QAAM;KAAK;IAC9BC,MAAM;QAAC;QAAM;QAAM;KAAK;IACxBC,SAAS;QAAC;QAAM;QAAM;KAAK;IAC3BC,OAAO;QAAC;QAAM;QAAM;KAAK;IACzBC,KAAK;QAAC;QAAM;QAAM;QAAM;KAAK;AAC/B,EAAE;AAEF,4DAA4D;AAC5D,OAAO,MAAMC,gBAAgB;IAC3BC,UAAU;IACVC,QAAQ;IACRC,QAAQ;IACRC,WAAW;IACXC,SAAS;IACTC,QAAQ;IACRC,QAAQ;IACRC,WAAW;IACXC,aAAa;IACbC,eAAe;IACfC,YAAY;IACZC,SAAS;IACTC,qBAAqB;IACrBC,WAAW;IACXC,gBAAgB;AAClB,EAAE;AAEF,oEAAoE;AACpE,OAAO,MAAMC,WAAW;IACtBC,KAAK;IACLC,MAAM;IACNC,SAAS;IACTC,WAAW;IACXC,SAAS;IACTC,MAAM;IACNC,aAAa;IACbC,cAAc;AAChB,EAAE;AAEF,cAAc;AACd,OAAO,MAAMC,YAAY;IACvBC,mBAAmB;IACnBC,cAAc;IACdC,mBAAmB;IACnBC,qBAAqB;IACrBC,qBAAqB;IACrBC,mBAAmB;IACnBC,iBAAiB;IACjBC,gBAAgB;IAChBC,mBAAmB;IACnBC,mBAAmB;IACnBC,sBAAsB;AACxB,EAAE;AAOF;;CAEC,GACD,OAAO,SAASC,iBAAiBC,OAAe,EAAEC,IAAY;IAC5D,MAAMC,MAAM,IAAIC,MAAMH;IACtBE,IAAID,IAAI,GAAGA;IACX,OAAOC;AACT"}

package/dist/esm/sevenz/headers.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/headers.ts"],"sourcesContent":["// 7z header parsing\n// Reference: https://py7zr.readthedocs.io/en/latest/archive_format.html\n\nimport { bufferEquals, readUInt64LE, verifyCrc32Region } from 'extract-base-iterator';\nimport { createCodedError, ErrorCode, PropertyId, SEVENZ_MAGIC } from './constants.ts';\nimport { readDefinedVector, readNumber } from './NumberCodec.ts';\n\n// Type definitions\nexport interface SignatureHeader {\n  majorVersion: number;\n  minorVersion: number;\n  startHeaderCRC: number;\n  nextHeaderOffset: number;\n  nextHeaderSize: number;\n  nextHeaderCRC: number;\n}\n\nexport interface Coder {\n  id: number[]; // Codec ID bytes\n  numInStreams: number; // Number of input streams\n  numOutStreams: number; // Number of output streams\n  properties?: Buffer; // Optional codec properties\n}\n\nexport interface Folder {\n  coders: Coder[];\n  bindPairs: { inIndex: number; outIndex: number }[];\n  packedStreams: number[]; // Indices of packed streams\n  unpackSizes: number[]; // Unpack size for each coder output\n  unpackCRC?: number; // CRC of final unpacked data\n  hasCRC: boolean;\n}\n\nexport interface StreamsInfo {\n  packPos: number; // Position of packed data (relative to end of signature header)\n  packSizes: number[]; // Sizes of packed streams\n  packCRCs?: number[]; // Optional CRCs for packed streams\n  folders: Folder[]; // Decompression info\n  numUnpackStreamsPerFolder: number[]; // Number of files in each folder (for solid archives)\n  unpackSizes: number[]; // Size of each unpacked file\n  unpackCRCs?: number[]; // Optional CRCs for unpacked files\n}\n\nexport interface FileInfo {\n  name: string;\n  size: number;\n  isDirectory: boolean;\n  isAntiFile: boolean; // \"Anti\" items mark files to delete in delta archives\n  hasStream: boolean; // False for empty files/directories\n  crc?: number;\n  ctime?: Date;\n  atime?: Date;\n  mtime?: Date;\n  attributes?: number;\n}\n\nexport interface ArchiveHeader {\n  signature: SignatureHeader;\n  streamsInfo?: StreamsInfo;\n  filesInfo: FileInfo[];\n}\n\n/**\n * Parse the signature header (first 32 bytes)\n */\nexport function parseSignatureHeader(buf: Buffer): SignatureHeader {\n  // Verify magic bytes\n  if (!bufferEquals(buf, 0, SEVENZ_MAGIC)) {\n    throw createCodedError('Not a valid 7z archive', ErrorCode.INVALID_SIGNATURE);\n  }\n\n  // Read version\n  const majorVersion = buf[6];\n  const minorVersion = buf[7];\n\n  // Version check - we support 0.x (current is 0.4)\n  if (majorVersion > 0) {\n    throw createCodedError(`Unsupported 7z version: ${majorVersion}.${minorVersion}`, ErrorCode.UNSUPPORTED_VERSION);\n  }\n\n  // Read start header CRC (CRC of the next 20 bytes)\n  const startHeaderCRC = buf.readUInt32LE(8);\n\n  // Verify start header CRC\n  if (!verifyCrc32Region(buf, 12, 20, startHeaderCRC)) {\n    throw createCodedError('Start header CRC mismatch', ErrorCode.CRC_MISMATCH);\n  }\n\n  // Read next header location\n  const nextHeaderOffset = readUInt64LE(buf, 12);\n  const nextHeaderSize = readUInt64LE(buf, 20);\n  const nextHeaderCRC = buf.readUInt32LE(28);\n\n  return {\n    majorVersion: majorVersion,\n    minorVersion: minorVersion,\n    startHeaderCRC: startHeaderCRC,\n    nextHeaderOffset: nextHeaderOffset,\n    nextHeaderSize: nextHeaderSize,\n    nextHeaderCRC: nextHeaderCRC,\n  };\n}\n\n/**\n * Parse the encoded header (metadata block at end of archive)\n */\nexport function parseEncodedHeader(buf: Buffer, expectedCRC: number): { streamsInfo?: StreamsInfo; filesInfo: FileInfo[] } {\n  // Verify CRC\n  if (!verifyCrc32Region(buf, 0, buf.length, expectedCRC)) {\n    throw createCodedError('Encoded header CRC mismatch', ErrorCode.CRC_MISMATCH);\n  }\n\n  let offset = 0;\n\n  // Read property ID\n  const propertyId = buf[offset++];\n\n  // Handle kEncodedHeader - means the header itself is compressed\n  if (propertyId === PropertyId.kEncodedHeader) {\n    // Return indicator that we need to decompress\n    throw createCodedError('Compressed header - needs decompression first', ErrorCode.COMPRESSED_HEADER);\n  }\n\n  // Should be kHeader\n  if (propertyId !== PropertyId.kHeader) {\n    throw createCodedError(`Expected kHeader, got ${propertyId}`, ErrorCode.CORRUPT_HEADER);\n  }\n\n  // Parse header contents (after kHeader byte)\n  return parseHeaderContent(buf, offset);\n}\n\n/**\n * Parse header content (after kHeader byte has been read)\n * Used by parseEncodedHeader and for decompressed headers\n */\nexport function parseHeaderContent(buf: Buffer, offset: number): { streamsInfo?: StreamsInfo; filesInfo: FileInfo[] } {\n  const result: { streamsInfo?: StreamsInfo; filesInfo: FileInfo[] } = {\n    filesInfo: [],\n  };\n\n  // Parse header contents\n  while (offset < buf.length) {\n    const propertyId = buf[offset++];\n\n    if (propertyId === PropertyId.kEnd) {\n      break;\n    }\n\n    switch (propertyId) {\n      case PropertyId.kArchiveProperties:\n        offset = skipArchiveProperties(buf, offset);\n        break;\n      case PropertyId.kAdditionalStreamsInfo:\n        // Additional streams - skip for now\n        offset = skipStreamsInfo(buf, offset);\n        break;\n      case PropertyId.kMainStreamsInfo: {\n        const streamsResult = parseStreamsInfo(buf, offset);\n        result.streamsInfo = streamsResult.info;\n        offset = streamsResult.offset;\n        break;\n      }\n      case PropertyId.kFilesInfo: {\n        const filesResult = parseFilesInfo(buf, offset);\n        result.filesInfo = filesResult.files;\n        offset = filesResult.offset;\n        break;\n      }\n      default:\n        throw createCodedError(`Unknown property ID in header: ${propertyId}`, ErrorCode.CORRUPT_HEADER);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Parse StreamsInfo block\n */\nfunction parseStreamsInfo(buf: Buffer, offset: number): { info: StreamsInfo; offset: number } {\n  const info: StreamsInfo = {\n    packPos: 0,\n    packSizes: [],\n    folders: [],\n    numUnpackStreamsPerFolder: [],\n    unpackSizes: [],\n  };\n\n  while (offset < buf.length) {\n    const propertyId = buf[offset++];\n\n    if (propertyId === PropertyId.kEnd) {\n      break;\n    }\n\n    switch (propertyId) {\n      case PropertyId.kPackInfo: {\n        const packResult = parsePackInfo(buf, offset);\n        info.packPos = packResult.packPos;\n        info.packSizes = packResult.packSizes;\n        info.packCRCs = packResult.packCRCs;\n        offset = packResult.offset;\n        break;\n      }\n      case PropertyId.kUnpackInfo: {\n        const unpackResult = parseUnpackInfo(buf, offset);\n        info.folders = unpackResult.folders;\n        offset = unpackResult.offset;\n        break;\n      }\n      case PropertyId.kSubStreamsInfo: {\n        const subResult = parseSubStreamsInfo(buf, offset, info.folders);\n        info.numUnpackStreamsPerFolder = subResult.numUnpackStreamsPerFolder;\n        info.unpackSizes = subResult.unpackSizes;\n        info.unpackCRCs = subResult.unpackCRCs;\n        offset = subResult.offset;\n        break;\n      }\n      default:\n        throw createCodedError(`Unknown property ID in StreamsInfo: ${propertyId}`, ErrorCode.CORRUPT_HEADER);\n    }\n  }\n\n  // If no SubStreamsInfo, each folder produces one file\n  if (info.unpackSizes.length === 0 && info.folders.length > 0) {\n    for (let i = 0; i < info.folders.length; i++) {\n      const folder = info.folders[i];\n      // Get the final unpack size (last coder's output)\n      const finalSize = folder.unpackSizes[folder.unpackSizes.length - 1];\n      info.unpackSizes.push(finalSize);\n      info.numUnpackStreamsPerFolder.push(1);\n    }\n  }\n\n  return { info: info, offset: offset };\n}\n\n/**\n * Parse PackInfo block\n */\nfunction parsePackInfo(buf: Buffer, offset: number): { packPos: number; packSizes: number[]; packCRCs?: number[]; offset: number } {\n  // Pack position\n  const packPosResult = readNumber(buf, offset);\n  const packPos = packPosResult.value;\n  offset += packPosResult.bytesRead;\n\n  // Number of pack streams\n  const numPackResult = readNumber(buf, offset);\n  const numPackStreams = numPackResult.value;\n  offset += numPackResult.bytesRead;\n\n  const packSizes: number[] = [];\n  let packCRCs: number[] | undefined;\n\n  while (offset < buf.length) {\n    const propertyId = buf[offset++];\n\n    if (propertyId === PropertyId.kEnd) {\n      break;\n    }\n\n    if (propertyId === PropertyId.kSize) {\n      for (let i = 0; i < numPackStreams; i++) {\n        const sizeResult = readNumber(buf, offset);\n        packSizes.push(sizeResult.value);\n        offset += sizeResult.bytesRead;\n      }\n    } else if (propertyId === PropertyId.kCRC) {\n      packCRCs = [];\n      const definedResult = readDefinedVector(buf, offset, numPackStreams);\n      offset += definedResult.bytesRead;\n      for (let j = 0; j < numPackStreams; j++) {\n        if (definedResult.defined[j]) {\n          packCRCs.push(buf.readUInt32LE(offset));\n          offset += 4;\n        } else {\n          packCRCs.push(0);\n        }\n      }\n    }\n  }\n\n  return { packPos: packPos, packSizes: packSizes, packCRCs: packCRCs, offset: offset };\n}\n\n/**\n * Parse UnpackInfo block\n */\nfunction parseUnpackInfo(buf: Buffer, offset: number): { folders: Folder[]; offset: number } {\n  const folders: Folder[] = [];\n\n  while (offset < buf.length) {\n    const propertyId = buf[offset++];\n\n    if (propertyId === PropertyId.kEnd) {\n      break;\n    }\n\n    if (propertyId === PropertyId.kFolder) {\n      // Number of folders\n      const numFoldersResult = readNumber(buf, offset);\n      const numFolders = numFoldersResult.value;\n      offset += numFoldersResult.bytesRead;\n\n      // External flag\n      const external = buf[offset++];\n      if (external !== 0) {\n        throw createCodedError('External folders not supported', ErrorCode.CORRUPT_HEADER);\n      }\n\n      // Parse each folder\n      for (let i = 0; i < numFolders; i++) {\n        const folderResult = parseFolder(buf, offset);\n        folders.push(folderResult.folder);\n        offset = folderResult.offset;\n      }\n    } else if (propertyId === PropertyId.kCodersUnpackSize) {\n      // Unpack sizes for each coder output\n      for (let j = 0; j < folders.length; j++) {\n        const folder = folders[j];\n        folder.unpackSizes = [];\n        // One unpack size per coder output stream\n        let numOutputs = 0;\n        for (let k = 0; k < folder.coders.length; k++) {\n          numOutputs += folder.coders[k].numOutStreams;\n        }\n        for (let l = 0; l < numOutputs; l++) {\n          const sizeResult = readNumber(buf, offset);\n          folder.unpackSizes.push(sizeResult.value);\n          offset += sizeResult.bytesRead;\n        }\n      }\n    } else if (propertyId === PropertyId.kCRC) {\n      // CRCs for folders\n      const definedResult = readDefinedVector(buf, offset, folders.length);\n      offset += definedResult.bytesRead;\n      for (let m = 0; m < folders.length; m++) {\n        folders[m].hasCRC = definedResult.defined[m];\n        if (definedResult.defined[m]) {\n          folders[m].unpackCRC = buf.readUInt32LE(offset);\n          offset += 4;\n        }\n      }\n    }\n  }\n\n  return { folders: folders, offset: offset };\n}\n\n/**\n * Parse a single Folder structure\n */\nfunction parseFolder(buf: Buffer, offset: number): { folder: Folder; offset: number } {\n  // Number of coders\n  const numCodersResult = readNumber(buf, offset);\n  const numCoders = numCodersResult.value;\n  offset += numCodersResult.bytesRead;\n\n  const coders: Coder[] = [];\n  let numInStreamsTotal = 0;\n  let numOutStreamsTotal = 0;\n\n  for (let i = 0; i < numCoders; i++) {\n    const flags = buf[offset++];\n    const idSize = flags & 0x0f;\n    const isComplex = (flags & 0x10) !== 0;\n    const hasAttributes = (flags & 0x20) !== 0;\n\n    // Read codec ID\n    const id: number[] = [];\n    for (let j = 0; j < idSize; j++) {\n      id.push(buf[offset++]);\n    }\n\n    let numInStreams = 1;\n    let numOutStreams = 1;\n\n    if (isComplex) {\n      const inResult = readNumber(buf, offset);\n      numInStreams = inResult.value;\n      offset += inResult.bytesRead;\n\n      const outResult = readNumber(buf, offset);\n      numOutStreams = outResult.value;\n      offset += outResult.bytesRead;\n    }\n\n    let properties: Buffer | undefined;\n    if (hasAttributes) {\n      const propsLenResult = readNumber(buf, offset);\n      offset += propsLenResult.bytesRead;\n      properties = buf.slice(offset, offset + propsLenResult.value);\n      offset += propsLenResult.value;\n    }\n\n    coders.push({\n      id: id,\n      numInStreams: numInStreams,\n      numOutStreams: numOutStreams,\n      properties: properties,\n    });\n\n    numInStreamsTotal += numInStreams;\n    numOutStreamsTotal += numOutStreams;\n  }\n\n  // Bind pairs\n  const numBindPairs = numOutStreamsTotal - 1;\n  const bindPairs: { inIndex: number; outIndex: number }[] = [];\n\n  for (let k = 0; k < numBindPairs; k++) {\n    const inIndexResult = readNumber(buf, offset);\n    offset += inIndexResult.bytesRead;\n\n    const outIndexResult = readNumber(buf, offset);\n    offset += outIndexResult.bytesRead;\n\n    bindPairs.push({\n      inIndex: inIndexResult.value,\n      outIndex: outIndexResult.value,\n    });\n  }\n\n  // Packed stream indices\n  const numPackedStreams = numInStreamsTotal - numBindPairs;\n  const packedStreams: number[] = [];\n\n  if (numPackedStreams === 1) {\n    // Find the unbound input stream\n    for (let m = 0; m < numInStreamsTotal; m++) {\n      let isBound = false;\n      for (let n = 0; n < bindPairs.length; n++) {\n        if (bindPairs[n].inIndex === m) {\n          isBound = true;\n          break;\n        }\n      }\n      if (!isBound) {\n        packedStreams.push(m);\n        break;\n      }\n    }\n  } else {\n    for (let p = 0; p < numPackedStreams; p++) {\n      const indexResult = readNumber(buf, offset);\n      packedStreams.push(indexResult.value);\n      offset += indexResult.bytesRead;\n    }\n  }\n\n  return {\n    folder: {\n      coders: coders,\n      bindPairs: bindPairs,\n      packedStreams: packedStreams,\n      unpackSizes: [],\n      hasCRC: false,\n    },\n    offset: offset,\n  };\n}\n\n/**\n * Parse SubStreamsInfo block\n */\nfunction parseSubStreamsInfo(buf: Buffer, offset: number, folders: Folder[]): { numUnpackStreamsPerFolder: number[]; unpackSizes: number[]; unpackCRCs?: number[]; offset: number } {\n  const numUnpackStreamsPerFolder: number[] = [];\n  const unpackSizes: number[] = [];\n  let unpackCRCs: number[] | undefined;\n\n  // Default: 1 file per folder\n  for (let i = 0; i < folders.length; i++) {\n    numUnpackStreamsPerFolder.push(1);\n  }\n\n  while (offset < buf.length) {\n    const propertyId = buf[offset++];\n\n    if (propertyId === PropertyId.kEnd) {\n      break;\n    }\n\n    if (propertyId === PropertyId.kNumUnpackStream) {\n      for (let j = 0; j < folders.length; j++) {\n        const numResult = readNumber(buf, offset);\n        numUnpackStreamsPerFolder[j] = numResult.value;\n        offset += numResult.bytesRead;\n      }\n    } else if (propertyId === PropertyId.kSize) {\n      for (let k = 0; k < folders.length; k++) {\n        const numStreams = numUnpackStreamsPerFolder[k];\n        if (numStreams === 0) continue;\n\n        // Read sizes for all but last stream in folder (last is calculated)\n        let remaining = folders[k].unpackSizes[folders[k].unpackSizes.length - 1];\n        for (let l = 0; l < numStreams - 1; l++) {\n          const sizeResult = readNumber(buf, offset);\n          unpackSizes.push(sizeResult.value);\n          remaining -= sizeResult.value;\n          offset += sizeResult.bytesRead;\n        }\n        // Last stream size is remainder\n        unpackSizes.push(remaining);\n      }\n    } else if (propertyId === PropertyId.kCRC) {\n      // Count files that need CRC\n      let numFiles = 0;\n      for (let m = 0; m < folders.length; m++) {\n        const numStreamsInFolder = numUnpackStreamsPerFolder[m];\n        // Only count if folder doesn't have CRC or has multiple streams\n        if (!folders[m].hasCRC || numStreamsInFolder > 1) {\n          numFiles += numStreamsInFolder;\n        }\n      }\n\n      unpackCRCs = [];\n      const definedResult = readDefinedVector(buf, offset, numFiles);\n      offset += definedResult.bytesRead;\n      for (let n = 0; n < numFiles; n++) {\n        if (definedResult.defined[n]) {\n          unpackCRCs.push(buf.readUInt32LE(offset));\n          offset += 4;\n        } else {\n          unpackCRCs.push(0);\n        }\n      }\n    }\n  }\n\n  // If no sizes specified, use folder unpack sizes\n  if (unpackSizes.length === 0) {\n    for (let p = 0; p < folders.length; p++) {\n      const folder = folders[p];\n      unpackSizes.push(folder.unpackSizes[folder.unpackSizes.length - 1]);\n    }\n  }\n\n  return { numUnpackStreamsPerFolder: numUnpackStreamsPerFolder, unpackSizes: unpackSizes, unpackCRCs: unpackCRCs, offset: offset };\n}\n\n/**\n * Parse FilesInfo block\n */\nfunction parseFilesInfo(buf: Buffer, offset: number): { files: FileInfo[]; offset: number } {\n  // Number of files\n  const numFilesResult = readNumber(buf, offset);\n  const numFiles = numFilesResult.value;\n  offset += numFilesResult.bytesRead;\n\n  // Initialize files array\n  const files: FileInfo[] = [];\n  for (let i = 0; i < numFiles; i++) {\n    files.push({\n      name: '',\n      size: 0,\n      isDirectory: false,\n      isAntiFile: false,\n      hasStream: true,\n    });\n  }\n\n  let emptyStreamFlags: boolean[] = [];\n  let emptyFileFlags: boolean[] = [];\n\n  while (offset < buf.length) {\n    const propertyId = buf[offset++];\n\n    if (propertyId === PropertyId.kEnd) {\n      break;\n    }\n\n    // Read property size\n    const propSizeResult = readNumber(buf, offset);\n    const propSize = propSizeResult.value;\n    offset += propSizeResult.bytesRead;\n\n    const propEnd = offset + propSize;\n\n    switch (propertyId) {\n      case PropertyId.kEmptyStream:\n        emptyStreamFlags = readBoolVector(buf, offset, numFiles);\n        // Mark files that don't have streams\n        for (let j = 0; j < numFiles; j++) {\n          files[j].hasStream = !emptyStreamFlags[j];\n        }\n        break;\n\n      case PropertyId.kEmptyFile: {\n        let numEmptyStreams = 0;\n        for (let k = 0; k < emptyStreamFlags.length; k++) {\n          if (emptyStreamFlags[k]) numEmptyStreams++;\n        }\n        emptyFileFlags = readBoolVector(buf, offset, numEmptyStreams);\n        break;\n      }\n\n      case PropertyId.kAnti: {\n        let numAnti = 0;\n        for (let l = 0; l < emptyStreamFlags.length; l++) {\n          if (emptyStreamFlags[l]) numAnti++;\n        }\n        const antiFlags = readBoolVector(buf, offset, numAnti);\n        let antiIdx = 0;\n        for (let m = 0; m < numFiles; m++) {\n          if (emptyStreamFlags[m]) {\n            files[m].isAntiFile = antiFlags[antiIdx++];\n          }\n        }\n        break;\n      }\n\n      case PropertyId.kName:\n        offset = parseFileNames(buf, offset, files);\n        break;\n\n      case PropertyId.kCTime:\n        offset = parseFileTimes(buf, offset, files, 'ctime');\n        break;\n\n      case PropertyId.kATime:\n        offset = parseFileTimes(buf, offset, files, 'atime');\n        break;\n\n      case PropertyId.kMTime:\n        offset = parseFileTimes(buf, offset, files, 'mtime');\n        break;\n\n      case PropertyId.kWinAttributes:\n        offset = parseAttributes(buf, offset, files);\n        break;\n\n      case PropertyId.kDummy:\n        // Skip dummy bytes\n        break;\n\n      default:\n        // Skip unknown properties\n        break;\n    }\n\n    offset = propEnd;\n  }\n\n  // Determine directories from empty stream + not empty file\n  let emptyIdx = 0;\n  for (let n = 0; n < numFiles; n++) {\n    if (emptyStreamFlags[n]) {\n      // Empty stream - could be directory or empty file\n      if (emptyIdx < emptyFileFlags.length && emptyFileFlags[emptyIdx]) {\n        files[n].isDirectory = false; // Empty file\n      } else {\n        files[n].isDirectory = true; // Directory\n      }\n      emptyIdx++;\n    }\n  }\n\n  return { files: files, offset: offset };\n}\n\n/**\n * Read a boolean vector (bit-packed)\n */\nfunction readBoolVector(buf: Buffer, offset: number, count: number): boolean[] {\n  const result: boolean[] = [];\n  let byteIdx = 0;\n  let bitMask = 0x80;\n\n  for (let i = 0; i < count; i++) {\n    result.push((buf[offset + byteIdx] & bitMask) !== 0);\n    bitMask = bitMask >>> 1;\n    if (bitMask === 0) {\n      bitMask = 0x80;\n      byteIdx++;\n    }\n  }\n\n  return result;\n}\n\n/**\n * Parse file names (UTF-16LE encoded)\n */\nfunction parseFileNames(buf: Buffer, offset: number, files: FileInfo[]): number {\n  // External flag\n  const external = buf[offset++];\n  if (external !== 0) {\n    throw createCodedError('External file names not supported', ErrorCode.CORRUPT_HEADER);\n  }\n\n  // Names are UTF-16LE, null-terminated\n  for (let i = 0; i < files.length; i++) {\n    const nameChars: number[] = [];\n    while (offset < buf.length) {\n      const charCode = buf.readUInt16LE(offset);\n      offset += 2;\n      if (charCode === 0) break;\n      nameChars.push(charCode);\n    }\n    files[i].name = String.fromCharCode.apply(null, nameChars);\n  }\n\n  return offset;\n}\n\n/**\n * Parse file times (Windows FILETIME format)\n */\nfunction parseFileTimes(buf: Buffer, offset: number, files: FileInfo[], timeType: 'ctime' | 'atime' | 'mtime'): number {\n  // Read defined vector (allDefined byte + optional bitmask)\n  const definedResult = readDefinedVector(buf, offset, files.length);\n  offset += definedResult.bytesRead;\n\n  // External flag - 0x00 means data follows inline, non-zero means external stream\n  const external = buf[offset++];\n  if (external !== 0) {\n    throw createCodedError('External file times not supported', ErrorCode.UNSUPPORTED_FEATURE);\n  }\n\n  // Read times\n  for (let i = 0; i < files.length; i++) {\n    if (definedResult.defined[i]) {\n      const filetime = readUInt64LE(buf, offset);\n      offset += 8;\n      // Convert FILETIME (100ns since 1601) to JavaScript Date\n      // FILETIME epoch: 1601-01-01\n      // JS Date epoch: 1970-01-01\n      // Difference: 11644473600 seconds\n      const ms = filetime / 10000 - 11644473600000;\n      files[i][timeType] = new Date(ms);\n    }\n  }\n\n  return offset;\n}\n\n/**\n * Parse Windows file attributes\n */\nfunction parseAttributes(buf: Buffer, offset: number, files: FileInfo[]): number {\n  // Read defined vector (allDefined byte + optional bitmask)\n  const definedResult = readDefinedVector(buf, offset, files.length);\n  offset += definedResult.bytesRead;\n\n  // External flag - 0x00 means data follows inline, non-zero means external stream\n  const external = buf[offset++];\n  if (external !== 0) {\n    throw createCodedError('External file attributes not supported', ErrorCode.UNSUPPORTED_FEATURE);\n  }\n\n  // Read attributes\n  for (let i = 0; i < files.length; i++) {\n    if (definedResult.defined[i]) {\n      files[i].attributes = buf.readUInt32LE(offset);\n      offset += 4;\n    }\n  }\n\n  return offset;\n}\n\n/**\n * Skip archive properties block\n */\nfunction skipArchiveProperties(buf: Buffer, offset: number): number {\n  while (offset < buf.length) {\n    const propertyId = buf[offset++];\n    if (propertyId === PropertyId.kEnd) {\n      break;\n    }\n    const sizeResult = readNumber(buf, offset);\n    offset += sizeResult.bytesRead + sizeResult.value;\n  }\n  return offset;\n}\n\n/**\n * Skip streams info block (for additional streams)\n */\nfunction skipStreamsInfo(buf: Buffer, offset: number): number {\n  while (offset < buf.length) {\n    const propertyId = buf[offset++];\n    if (propertyId === PropertyId.kEnd) {\n      break;\n    }\n    // For nested structures, recurse\n    if (propertyId === PropertyId.kPackInfo || propertyId === PropertyId.kUnpackInfo || propertyId === PropertyId.kSubStreamsInfo) {\n      offset = skipStreamsInfo(buf, offset);\n    }\n  }\n  return offset;\n}\n"],"names":["bufferEquals","readUInt64LE","verifyCrc32Region","createCodedError","ErrorCode","PropertyId","SEVENZ_MAGIC","readDefinedVector","readNumber","parseSignatureHeader","buf","INVALID_SIGNATURE","majorVersion","minorVersion","UNSUPPORTED_VERSION","startHeaderCRC","readUInt32LE","CRC_MISMATCH","nextHeaderOffset","nextHeaderSize","nextHeaderCRC","parseEncodedHeader","expectedCRC","length","offset","propertyId","kEncodedHeader","COMPRESSED_HEADER","kHeader","CORRUPT_HEADER","parseHeaderContent","result","filesInfo","kEnd","kArchiveProperties","skipArchiveProperties","kAdditionalStreamsInfo","skipStreamsInfo","kMainStreamsInfo","streamsResult","parseStreamsInfo","streamsInfo","info","kFilesInfo","filesResult","parseFilesInfo","files","packPos","packSizes","folders","numUnpackStreamsPerFolder","unpackSizes","kPackInfo","packResult","parsePackInfo","packCRCs","kUnpackInfo","unpackResult","parseUnpackInfo","kSubStreamsInfo","subResult","parseSubStreamsInfo","unpackCRCs","i","folder","finalSize","push","packPosResult","value","bytesRead","numPackResult","numPackStreams","kSize","sizeResult","kCRC","definedResult","j","defined","kFolder","numFoldersResult","numFolders","external","folderResult","parseFolder","kCodersUnpackSize","numOutputs","k","coders","numOutStreams","l","m","hasCRC","unpackCRC","numCodersResult","numCoders","numInStreamsTotal","numOutStreamsTotal","flags","idSize","isComplex","hasAttributes","id","numInStreams","inResult","outResult","properties","propsLenResult","slice","numBindPairs","bindPairs","inIndexResult","outIndexResult","inIndex","outIndex","numPackedStreams","packedStreams","isBound","n","p","indexResult","kNumUnpackStream","numResult","numStreams","remaining","numFiles","numStreamsInFolder","numFilesResult","name","size","isDirectory","isAntiFile","hasStream","emptyStreamFlags","emptyFileFlags","propSizeResult","propSize","propEnd","kEmptyStream","readBoolVector","kEmptyFile","numEmptyStreams","kAnti","numAnti","antiFlags","antiIdx","kName","parseFileNames","kCTime","parseFileTimes","kATime","kMTime","kWinAttributes","parseAttributes","kDummy","emptyIdx","count","byteIdx","bitMask","nameChars","charCode","readUInt16LE","String","fromCharCode","apply","timeType","UNSUPPORTED_FEATURE","filetime","ms","Date","attributes"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/iterators/7z-iterator/src/sevenz/headers.ts"],"sourcesContent":["// 7z header parsing\n// Reference: https://py7zr.readthedocs.io/en/latest/archive_format.html\n\nimport { bufferEquals, readUInt64LE, verifyCrc32Region } from 'extract-base-iterator';\nimport { createCodedError, ErrorCode, PropertyId, SEVENZ_MAGIC } from './constants.ts';\nimport { readDefinedVector, readNumber } from './NumberCodec.ts';\n\n// Type definitions\nexport interface SignatureHeader {\n  majorVersion: number;\n  minorVersion: number;\n  startHeaderCRC: number;\n  nextHeaderOffset: number;\n  nextHeaderSize: number;\n  nextHeaderCRC: number;\n}\n\nexport interface Coder {\n  id: number[]; // Codec ID bytes\n  numInStreams: number; // Number of input streams\n  numOutStreams: number; // Number of output streams\n  properties?: Buffer; // Optional codec properties\n}\n\nexport interface Folder {\n  coders: Coder[];\n  bindPairs: { inIndex: number; outIndex: number }[];\n  packedStreams: number[]; // Indices of packed streams\n  unpackSizes: number[]; // Unpack size for each coder output\n  unpackCRC?: number; // CRC of final unpacked data\n  hasCRC: boolean;\n}\n\nexport interface StreamsInfo {\n  packPos: number; // Position of packed data (relative to end of signature header)\n  packSizes: number[]; // Sizes of packed streams\n  packCRCs?: number[]; // Optional CRCs for packed streams\n  folders: Folder[]; // Decompression info\n  numUnpackStreamsPerFolder: number[]; // Number of files in each folder (for solid archives)\n  unpackSizes: number[]; // Size of each unpacked file\n  unpackCRCs?: number[]; // Optional CRCs for unpacked files\n}\n\nexport interface FileInfo {\n  name: string;\n  size: number;\n  isDirectory: boolean;\n  isAntiFile: boolean; // \"Anti\" items mark files to delete in delta archives\n  hasStream: boolean; // False for empty files/directories\n  crc?: number;\n  ctime?: Date;\n  atime?: Date;\n  mtime?: Date;\n  attributes?: number;\n}\n\nexport interface ArchiveHeader {\n  signature: SignatureHeader;\n  streamsInfo?: StreamsInfo;\n  filesInfo: FileInfo[];\n}\n\n/**\n * Parse the signature header (first 32 bytes)\n */\nexport function parseSignatureHeader(buf: Buffer): SignatureHeader {\n  // Verify magic bytes\n  if (!bufferEquals(buf, 0, SEVENZ_MAGIC)) {\n    throw createCodedError('Not a valid 7z archive', ErrorCode.INVALID_SIGNATURE);\n  }\n\n  // Read version\n  const majorVersion = buf[6];\n  const minorVersion = buf[7];\n\n  // Version check - we support 0.x (current is 0.4)\n  if (majorVersion > 0) {\n    throw createCodedError(`Unsupported 7z version: ${majorVersion}.${minorVersion}`, ErrorCode.UNSUPPORTED_VERSION);\n  }\n\n  // Read start header CRC (CRC of the next 20 bytes)\n  const startHeaderCRC = buf.readUInt32LE(8);\n\n  // Verify start header CRC\n  if (!verifyCrc32Region(buf, 12, 20, startHeaderCRC)) {\n    throw createCodedError('Start header CRC mismatch', ErrorCode.CRC_MISMATCH);\n  }\n\n  // Read next header location\n  const nextHeaderOffset = readUInt64LE(buf, 12);\n  const nextHeaderSize = readUInt64LE(buf, 20);\n  const nextHeaderCRC = buf.readUInt32LE(28);\n\n  return {\n    majorVersion: majorVersion,\n    minorVersion: minorVersion,\n    startHeaderCRC: startHeaderCRC,\n    nextHeaderOffset: nextHeaderOffset,\n    nextHeaderSize: nextHeaderSize,\n    nextHeaderCRC: nextHeaderCRC,\n  };\n}\n\n/**\n * Parse the encoded header (metadata block at end of archive)\n */\nexport function parseEncodedHeader(buf: Buffer, expectedCRC: number): { streamsInfo?: StreamsInfo; filesInfo: FileInfo[] } {\n  // Verify CRC\n  if (!verifyCrc32Region(buf, 0, buf.length, expectedCRC)) {\n    throw createCodedError('Encoded header CRC mismatch', ErrorCode.CRC_MISMATCH);\n  }\n\n  let offset = 0;\n\n  // Read property ID\n  const propertyId = buf[offset++];\n\n  // Handle kEncodedHeader - means the header itself is compressed\n  if (propertyId === PropertyId.kEncodedHeader) {\n    // Return indicator that we need to decompress\n    throw createCodedError('Compressed header - needs decompression first', ErrorCode.COMPRESSED_HEADER);\n  }\n\n  // Should be kHeader\n  if (propertyId !== PropertyId.kHeader) {\n    throw createCodedError(`Expected kHeader, got ${propertyId}`, ErrorCode.CORRUPT_HEADER);\n  }\n\n  // Parse header contents (after kHeader byte)\n  return parseHeaderContent(buf, offset);\n}\n\n/**\n * Parse header content (after kHeader byte has been read)\n * Used by parseEncodedHeader and for decompressed headers\n */\nexport function parseHeaderContent(buf: Buffer, offset: number): { streamsInfo?: StreamsInfo; filesInfo: FileInfo[] } {\n  const result: { streamsInfo?: StreamsInfo; filesInfo: FileInfo[] } = {\n    filesInfo: [],\n  };\n\n  // Parse header contents\n  while (offset < buf.length) {\n    const propertyId = buf[offset++];\n\n    if (propertyId === PropertyId.kEnd) {\n      break;\n    }\n\n    switch (propertyId) {\n      case PropertyId.kArchiveProperties:\n        offset = skipArchiveProperties(buf, offset);\n        break;\n      case PropertyId.kAdditionalStreamsInfo:\n        // Additional streams - skip for now\n        offset = skipStreamsInfo(buf, offset);\n        break;\n      case PropertyId.kMainStreamsInfo: {\n        const streamsResult = parseStreamsInfo(buf, offset);\n        result.streamsInfo = streamsResult.info;\n        offset = streamsResult.offset;\n        break;\n      }\n      case PropertyId.kFilesInfo: {\n        const filesResult = parseFilesInfo(buf, offset);\n        result.filesInfo = filesResult.files;\n        offset = filesResult.offset;\n        break;\n      }\n      default:\n        throw createCodedError(`Unknown property ID in header: ${propertyId}`, ErrorCode.CORRUPT_HEADER);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Parse StreamsInfo block\n */\nfunction parseStreamsInfo(buf: Buffer, offset: number): { info: StreamsInfo; offset: number } {\n  const info: StreamsInfo = {\n    packPos: 0,\n    packSizes: [],\n    folders: [],\n    numUnpackStreamsPerFolder: [],\n    unpackSizes: [],\n  };\n\n  while (offset < buf.length) {\n    const propertyId = buf[offset++];\n\n    if (propertyId === PropertyId.kEnd) {\n      break;\n    }\n\n    switch (propertyId) {\n      case PropertyId.kPackInfo: {\n        const packResult = parsePackInfo(buf, offset);\n        info.packPos = packResult.packPos;\n        info.packSizes = packResult.packSizes;\n        info.packCRCs = packResult.packCRCs;\n        offset = packResult.offset;\n        break;\n      }\n      case PropertyId.kUnpackInfo: {\n        const unpackResult = parseUnpackInfo(buf, offset);\n        info.folders = unpackResult.folders;\n        offset = unpackResult.offset;\n        break;\n      }\n      case PropertyId.kSubStreamsInfo: {\n        const subResult = parseSubStreamsInfo(buf, offset, info.folders);\n        info.numUnpackStreamsPerFolder = subResult.numUnpackStreamsPerFolder;\n        info.unpackSizes = subResult.unpackSizes;\n        info.unpackCRCs = subResult.unpackCRCs;\n        offset = subResult.offset;\n        break;\n      }\n      default:\n        throw createCodedError(`Unknown property ID in StreamsInfo: ${propertyId}`, ErrorCode.CORRUPT_HEADER);\n    }\n  }\n\n  // If no SubStreamsInfo, each folder produces one file\n  if (info.unpackSizes.length === 0 && info.folders.length > 0) {\n    for (let i = 0; i < info.folders.length; i++) {\n      const folder = info.folders[i];\n      // Get the final unpack size (last coder's output)\n      const finalSize = folder.unpackSizes[folder.unpackSizes.length - 1];\n      info.unpackSizes.push(finalSize);\n      info.numUnpackStreamsPerFolder.push(1);\n    }\n  }\n\n  return { info: info, offset: offset };\n}\n\n/**\n * Parse PackInfo block\n */\nfunction parsePackInfo(buf: Buffer, offset: number): { packPos: number; packSizes: number[]; packCRCs?: number[]; offset: number } {\n  // Pack position\n  const packPosResult = readNumber(buf, offset);\n  const packPos = packPosResult.value;\n  offset += packPosResult.bytesRead;\n\n  // Number of pack streams\n  const numPackResult = readNumber(buf, offset);\n  const numPackStreams = numPackResult.value;\n  offset += numPackResult.bytesRead;\n\n  const packSizes: number[] = [];\n  let packCRCs: number[] | undefined;\n\n  while (offset < buf.length) {\n    const propertyId = buf[offset++];\n\n    if (propertyId === PropertyId.kEnd) {\n      break;\n    }\n\n    if (propertyId === PropertyId.kSize) {\n      for (let i = 0; i < numPackStreams; i++) {\n        const sizeResult = readNumber(buf, offset);\n        packSizes.push(sizeResult.value);\n        offset += sizeResult.bytesRead;\n      }\n    } else if (propertyId === PropertyId.kCRC) {\n      packCRCs = [];\n      const definedResult = readDefinedVector(buf, offset, numPackStreams);\n      offset += definedResult.bytesRead;\n      for (let j = 0; j < numPackStreams; j++) {\n        if (definedResult.defined[j]) {\n          packCRCs.push(buf.readUInt32LE(offset));\n          offset += 4;\n        } else {\n          packCRCs.push(0);\n        }\n      }\n    }\n  }\n\n  return { packPos: packPos, packSizes: packSizes, packCRCs: packCRCs, offset: offset };\n}\n\n/**\n * Parse UnpackInfo block\n */\nfunction parseUnpackInfo(buf: Buffer, offset: number): { folders: Folder[]; offset: number } {\n  const folders: Folder[] = [];\n\n  while (offset < buf.length) {\n    const propertyId = buf[offset++];\n\n    if (propertyId === PropertyId.kEnd) {\n      break;\n    }\n\n    if (propertyId === PropertyId.kFolder) {\n      // Number of folders\n      const numFoldersResult = readNumber(buf, offset);\n      const numFolders = numFoldersResult.value;\n      offset += numFoldersResult.bytesRead;\n\n      // External flag\n      const external = buf[offset++];\n      if (external !== 0) {\n        throw createCodedError('External folders not supported', ErrorCode.CORRUPT_HEADER);\n      }\n\n      // Parse each folder\n      for (let i = 0; i < numFolders; i++) {\n        const folderResult = parseFolder(buf, offset);\n        folders.push(folderResult.folder);\n        offset = folderResult.offset;\n      }\n    } else if (propertyId === PropertyId.kCodersUnpackSize) {\n      // Unpack sizes for each coder output\n      for (let j = 0; j < folders.length; j++) {\n        const folder = folders[j];\n        folder.unpackSizes = [];\n        // One unpack size per coder output stream\n        let numOutputs = 0;\n        for (let k = 0; k < folder.coders.length; k++) {\n          numOutputs += folder.coders[k].numOutStreams;\n        }\n        for (let l = 0; l < numOutputs; l++) {\n          const sizeResult = readNumber(buf, offset);\n          folder.unpackSizes.push(sizeResult.value);\n          offset += sizeResult.bytesRead;\n        }\n      }\n    } else if (propertyId === PropertyId.kCRC) {\n      // CRCs for folders\n      const definedResult = readDefinedVector(buf, offset, folders.length);\n      offset += definedResult.bytesRead;\n      for (let m = 0; m < folders.length; m++) {\n        folders[m].hasCRC = definedResult.defined[m];\n        if (definedResult.defined[m]) {\n          folders[m].unpackCRC = buf.readUInt32LE(offset);\n          offset += 4;\n        }\n      }\n    }\n  }\n\n  return { folders: folders, offset: offset };\n}\n\n/**\n * Parse a single Folder structure\n */\nfunction parseFolder(buf: Buffer, offset: number): { folder: Folder; offset: number } {\n  // Number of coders\n  const numCodersResult = readNumber(buf, offset);\n  const numCoders = numCodersResult.value;\n  offset += numCodersResult.bytesRead;\n\n  const coders: Coder[] = [];\n  let numInStreamsTotal = 0;\n  let numOutStreamsTotal = 0;\n\n  for (let i = 0; i < numCoders; i++) {\n    const flags = buf[offset++];\n    const idSize = flags & 0x0f;\n    const isComplex = (flags & 0x10) !== 0;\n    const hasAttributes = (flags & 0x20) !== 0;\n\n    // Read codec ID\n    const id: number[] = [];\n    for (let j = 0; j < idSize; j++) {\n      id.push(buf[offset++]);\n    }\n\n    let numInStreams = 1;\n    let numOutStreams = 1;\n\n    if (isComplex) {\n      const inResult = readNumber(buf, offset);\n      numInStreams = inResult.value;\n      offset += inResult.bytesRead;\n\n      const outResult = readNumber(buf, offset);\n      numOutStreams = outResult.value;\n      offset += outResult.bytesRead;\n    }\n\n    let properties: Buffer | undefined;\n    if (hasAttributes) {\n      const propsLenResult = readNumber(buf, offset);\n      offset += propsLenResult.bytesRead;\n      properties = buf.slice(offset, offset + propsLenResult.value);\n      offset += propsLenResult.value;\n    }\n\n    coders.push({\n      id: id,\n      numInStreams: numInStreams,\n      numOutStreams: numOutStreams,\n      properties: properties,\n    });\n\n    numInStreamsTotal += numInStreams;\n    numOutStreamsTotal += numOutStreams;\n  }\n\n  // Bind pairs\n  const numBindPairs = numOutStreamsTotal - 1;\n  const bindPairs: { inIndex: number; outIndex: number }[] = [];\n\n  for (let k = 0; k < numBindPairs; k++) {\n    const inIndexResult = readNumber(buf, offset);\n    offset += inIndexResult.bytesRead;\n\n    const outIndexResult = readNumber(buf, offset);\n    offset += outIndexResult.bytesRead;\n\n    bindPairs.push({\n      inIndex: inIndexResult.value,\n      outIndex: outIndexResult.value,\n    });\n  }\n\n  // Packed stream indices\n  const numPackedStreams = numInStreamsTotal - numBindPairs;\n  const packedStreams: number[] = [];\n\n  if (numPackedStreams === 1) {\n    // Find the unbound input stream\n    for (let m = 0; m < numInStreamsTotal; m++) {\n      let isBound = false;\n      for (let n = 0; n < bindPairs.length; n++) {\n        if (bindPairs[n].inIndex === m) {\n          isBound = true;\n          break;\n        }\n      }\n      if (!isBound) {\n        packedStreams.push(m);\n        break;\n      }\n    }\n  } else {\n    for (let p = 0; p < numPackedStreams; p++) {\n      const indexResult = readNumber(buf, offset);\n      packedStreams.push(indexResult.value);\n      offset += indexResult.bytesRead;\n    }\n  }\n\n  return {\n    folder: {\n      coders: coders,\n      bindPairs: bindPairs,\n      packedStreams: packedStreams,\n      unpackSizes: [],\n      hasCRC: false,\n    },\n    offset: offset,\n  };\n}\n\n/**\n * Parse SubStreamsInfo block\n */\nfunction parseSubStreamsInfo(buf: Buffer, offset: number, folders: Folder[]): { numUnpackStreamsPerFolder: number[]; unpackSizes: number[]; unpackCRCs?: number[]; offset: number } {\n  const numUnpackStreamsPerFolder: number[] = [];\n  const unpackSizes: number[] = [];\n  let unpackCRCs: number[] | undefined;\n\n  // Default: 1 file per folder\n  for (let i = 0; i < folders.length; i++) {\n    numUnpackStreamsPerFolder.push(1);\n  }\n\n  while (offset < buf.length) {\n    const propertyId = buf[offset++];\n\n    if (propertyId === PropertyId.kEnd) {\n      break;\n    }\n\n    if (propertyId === PropertyId.kNumUnpackStream) {\n      for (let j = 0; j < folders.length; j++) {\n        const numResult = readNumber(buf, offset);\n        numUnpackStreamsPerFolder[j] = numResult.value;\n        offset += numResult.bytesRead;\n      }\n    } else if (propertyId === PropertyId.kSize) {\n      for (let k = 0; k < folders.length; k++) {\n        const numStreams = numUnpackStreamsPerFolder[k];\n        if (numStreams === 0) continue;\n\n        // Read sizes for all but last stream in folder (last is calculated)\n        let remaining = folders[k].unpackSizes[folders[k].unpackSizes.length - 1];\n        for (let l = 0; l < numStreams - 1; l++) {\n          const sizeResult = readNumber(buf, offset);\n          unpackSizes.push(sizeResult.value);\n          remaining -= sizeResult.value;\n          offset += sizeResult.bytesRead;\n        }\n        // Last stream size is remainder\n        unpackSizes.push(remaining);\n      }\n    } else if (propertyId === PropertyId.kCRC) {\n      // Count files that need CRC\n      let numFiles = 0;\n      for (let m = 0; m < folders.length; m++) {\n        const numStreamsInFolder = numUnpackStreamsPerFolder[m];\n        // Only count if folder doesn't have CRC or has multiple streams\n        if (!folders[m].hasCRC || numStreamsInFolder > 1) {\n          numFiles += numStreamsInFolder;\n        }\n      }\n\n      unpackCRCs = [];\n      const definedResult = readDefinedVector(buf, offset, numFiles);\n      offset += definedResult.bytesRead;\n      for (let n = 0; n < numFiles; n++) {\n        if (definedResult.defined[n]) {\n          unpackCRCs.push(buf.readUInt32LE(offset));\n          offset += 4;\n        } else {\n          unpackCRCs.push(0);\n        }\n      }\n    }\n  }\n\n  // If no sizes specified, use folder unpack sizes\n  if (unpackSizes.length === 0) {\n    for (let p = 0; p < folders.length; p++) {\n      const folder = folders[p];\n      unpackSizes.push(folder.unpackSizes[folder.unpackSizes.length - 1]);\n    }\n  }\n\n  return { numUnpackStreamsPerFolder: numUnpackStreamsPerFolder, unpackSizes: unpackSizes, unpackCRCs: unpackCRCs, offset: offset };\n}\n\n/**\n * Parse FilesInfo block\n */\nfunction parseFilesInfo(buf: Buffer, offset: number): { files: FileInfo[]; offset: number } {\n  // Number of files\n  const numFilesResult = readNumber(buf, offset);\n  const numFiles = numFilesResult.value;\n  offset += numFilesResult.bytesRead;\n\n  // Initialize files array\n  const files: FileInfo[] = [];\n  for (let i = 0; i < numFiles; i++) {\n    files.push({\n      name: '',\n      size: 0,\n      isDirectory: false,\n      isAntiFile: false,\n      hasStream: true,\n    });\n  }\n\n  let emptyStreamFlags: boolean[] = [];\n  let emptyFileFlags: boolean[] = [];\n\n  while (offset < buf.length) {\n    const propertyId = buf[offset++];\n\n    if (propertyId === PropertyId.kEnd) {\n      break;\n    }\n\n    // Read property size\n    const propSizeResult = readNumber(buf, offset);\n    const propSize = propSizeResult.value;\n    offset += propSizeResult.bytesRead;\n\n    const propEnd = offset + propSize;\n\n    switch (propertyId) {\n      case PropertyId.kEmptyStream:\n        emptyStreamFlags = readBoolVector(buf, offset, numFiles);\n        // Mark files that don't have streams\n        for (let j = 0; j < numFiles; j++) {\n          files[j].hasStream = !emptyStreamFlags[j];\n        }\n        break;\n\n      case PropertyId.kEmptyFile: {\n        let numEmptyStreams = 0;\n        for (let k = 0; k < emptyStreamFlags.length; k++) {\n          if (emptyStreamFlags[k]) numEmptyStreams++;\n        }\n        emptyFileFlags = readBoolVector(buf, offset, numEmptyStreams);\n        break;\n      }\n\n      case PropertyId.kAnti: {\n        let numAnti = 0;\n        for (let l = 0; l < emptyStreamFlags.length; l++) {\n          if (emptyStreamFlags[l]) numAnti++;\n        }\n        const antiFlags = readBoolVector(buf, offset, numAnti);\n        let antiIdx = 0;\n        for (let m = 0; m < numFiles; m++) {\n          if (emptyStreamFlags[m]) {\n            files[m].isAntiFile = antiFlags[antiIdx++];\n          }\n        }\n        break;\n      }\n\n      case PropertyId.kName:\n        offset = parseFileNames(buf, offset, files);\n        break;\n\n      case PropertyId.kCTime:\n        offset = parseFileTimes(buf, offset, files, 'ctime');\n        break;\n\n      case PropertyId.kATime:\n        offset = parseFileTimes(buf, offset, files, 'atime');\n        break;\n\n      case PropertyId.kMTime:\n        offset = parseFileTimes(buf, offset, files, 'mtime');\n        break;\n\n      case PropertyId.kWinAttributes:\n        offset = parseAttributes(buf, offset, files);\n        break;\n\n      case PropertyId.kDummy:\n        // Skip dummy bytes\n        break;\n\n      default:\n        // Skip unknown properties\n        break;\n    }\n\n    offset = propEnd;\n  }\n\n  // Determine directories from empty stream + not empty file\n  let emptyIdx = 0;\n  for (let n = 0; n < numFiles; n++) {\n    if (emptyStreamFlags[n]) {\n      // Empty stream - could be directory or empty file\n      if (emptyIdx < emptyFileFlags.length && emptyFileFlags[emptyIdx]) {\n        files[n].isDirectory = false; // Empty file\n      } else {\n        files[n].isDirectory = true; // Directory\n      }\n      emptyIdx++;\n    }\n  }\n\n  return { files: files, offset: offset };\n}\n\n/**\n * Read a boolean vector (bit-packed)\n */\nfunction readBoolVector(buf: Buffer, offset: number, count: number): boolean[] {\n  const result: boolean[] = [];\n  let byteIdx = 0;\n  let bitMask = 0x80;\n\n  for (let i = 0; i < count; i++) {\n    result.push((buf[offset + byteIdx] & bitMask) !== 0);\n    bitMask = bitMask >>> 1;\n    if (bitMask === 0) {\n      bitMask = 0x80;\n      byteIdx++;\n    }\n  }\n\n  return result;\n}\n\n/**\n * Parse file names (UTF-16LE encoded)\n */\nfunction parseFileNames(buf: Buffer, offset: number, files: FileInfo[]): number {\n  // External flag\n  const external = buf[offset++];\n  if (external !== 0) {\n    throw createCodedError('External file names not supported', ErrorCode.CORRUPT_HEADER);\n  }\n\n  // Names are UTF-16LE, null-terminated\n  for (let i = 0; i < files.length; i++) {\n    const nameChars: number[] = [];\n    while (offset < buf.length) {\n      const charCode = buf.readUInt16LE(offset);\n      offset += 2;\n      if (charCode === 0) break;\n      nameChars.push(charCode);\n    }\n    files[i].name = String.fromCharCode.apply(null, nameChars);\n  }\n\n  return offset;\n}\n\n/**\n * Parse file times (Windows FILETIME format)\n */\nfunction parseFileTimes(buf: Buffer, offset: number, files: FileInfo[], timeType: 'ctime' | 'atime' | 'mtime'): number {\n  // Read defined vector (allDefined byte + optional bitmask)\n  const definedResult = readDefinedVector(buf, offset, files.length);\n  offset += definedResult.bytesRead;\n\n  // External flag - 0x00 means data follows inline, non-zero means external stream\n  const external = buf[offset++];\n  if (external !== 0) {\n    throw createCodedError('External file times not supported', ErrorCode.UNSUPPORTED_FEATURE);\n  }\n\n  // Read times\n  for (let i = 0; i < files.length; i++) {\n    if (definedResult.defined[i]) {\n      const filetime = readUInt64LE(buf, offset);\n      offset += 8;\n      // Convert FILETIME (100ns since 1601) to JavaScript Date\n      // FILETIME epoch: 1601-01-01\n      // JS Date epoch: 1970-01-01\n      // Difference: 11644473600 seconds\n      const ms = filetime / 10000 - 11644473600000;\n      files[i][timeType] = new Date(ms);\n    }\n  }\n\n  return offset;\n}\n\n/**\n * Parse Windows file attributes\n */\nfunction parseAttributes(buf: Buffer, offset: number, files: FileInfo[]): number {\n  // Read defined vector (allDefined byte + optional bitmask)\n  const definedResult = readDefinedVector(buf, offset, files.length);\n  offset += definedResult.bytesRead;\n\n  // External flag - 0x00 means data follows inline, non-zero means external stream\n  const external = buf[offset++];\n  if (external !== 0) {\n    throw createCodedError('External file attributes not supported', ErrorCode.UNSUPPORTED_FEATURE);\n  }\n\n  // Read attributes\n  for (let i = 0; i < files.length; i++) {\n    if (definedResult.defined[i]) {\n      files[i].attributes = buf.readUInt32LE(offset);\n      offset += 4;\n    }\n  }\n\n  return offset;\n}\n\n/**\n * Skip archive properties block\n */\nfunction skipArchiveProperties(buf: Buffer, offset: number): number {\n  while (offset < buf.length) {\n    const propertyId = buf[offset++];\n    if (propertyId === PropertyId.kEnd) {\n      break;\n    }\n    const sizeResult = readNumber(buf, offset);\n    offset += sizeResult.bytesRead + sizeResult.value;\n  }\n  return offset;\n}\n\n/**\n * Skip streams info block (for additional streams)\n */\nfunction skipStreamsInfo(buf: Buffer, offset: number): number {\n  while (offset < buf.length) {\n    const propertyId = buf[offset++];\n    if (propertyId === PropertyId.kEnd) {\n      break;\n    }\n    // For nested structures, recurse\n    if (propertyId === PropertyId.kPackInfo || propertyId === PropertyId.kUnpackInfo || propertyId === PropertyId.kSubStreamsInfo) {\n      offset = skipStreamsInfo(buf, offset);\n    }\n  }\n  return offset;\n}\n"],"names":["bufferEquals","readUInt64LE","verifyCrc32Region","createCodedError","ErrorCode","PropertyId","SEVENZ_MAGIC","readDefinedVector","readNumber","parseSignatureHeader","buf","INVALID_SIGNATURE","majorVersion","minorVersion","UNSUPPORTED_VERSION","startHeaderCRC","readUInt32LE","CRC_MISMATCH","nextHeaderOffset","nextHeaderSize","nextHeaderCRC","parseEncodedHeader","expectedCRC","length","offset","propertyId","kEncodedHeader","COMPRESSED_HEADER","kHeader","CORRUPT_HEADER","parseHeaderContent","result","filesInfo","kEnd","kArchiveProperties","skipArchiveProperties","kAdditionalStreamsInfo","skipStreamsInfo","kMainStreamsInfo","streamsResult","parseStreamsInfo","streamsInfo","info","kFilesInfo","filesResult","parseFilesInfo","files","packPos","packSizes","folders","numUnpackStreamsPerFolder","unpackSizes","kPackInfo","packResult","parsePackInfo","packCRCs","kUnpackInfo","unpackResult","parseUnpackInfo","kSubStreamsInfo","subResult","parseSubStreamsInfo","unpackCRCs","i","folder","finalSize","push","packPosResult","value","bytesRead","numPackResult","numPackStreams","kSize","sizeResult","kCRC","definedResult","j","defined","kFolder","numFoldersResult","numFolders","external","folderResult","parseFolder","kCodersUnpackSize","numOutputs","k","coders","numOutStreams","l","m","hasCRC","unpackCRC","numCodersResult","numCoders","numInStreamsTotal","numOutStreamsTotal","flags","idSize","isComplex","hasAttributes","id","numInStreams","inResult","outResult","properties","propsLenResult","slice","numBindPairs","bindPairs","inIndexResult","outIndexResult","inIndex","outIndex","numPackedStreams","packedStreams","isBound","n","p","indexResult","kNumUnpackStream","numResult","numStreams","remaining","numFiles","numStreamsInFolder","numFilesResult","name","size","isDirectory","isAntiFile","hasStream","emptyStreamFlags","emptyFileFlags","propSizeResult","propSize","propEnd","kEmptyStream","readBoolVector","kEmptyFile","numEmptyStreams","kAnti","numAnti","antiFlags","antiIdx","kName","parseFileNames","kCTime","parseFileTimes","kATime","kMTime","kWinAttributes","parseAttributes","kDummy","emptyIdx","count","byteIdx","bitMask","nameChars","charCode","readUInt16LE","String","fromCharCode","apply","timeType","UNSUPPORTED_FEATURE","filetime","ms","Date","attributes"],"mappings":"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"}

package/dist/esm/sevenz/index.d.ts

@@ -1,4 +1,4 @@
 export type { CodedError } from './constants.js';
 export { createCodedError, ErrorCode } from './constants.js';
-export type { ArchiveSource, SevenZipEntry } from './SevenZipParser.js';
+export type { ArchiveSource, SevenZipEntry, VoidCallback } from './SevenZipParser.js';
 export { BufferSource, FileSource, SevenZipParser } from './SevenZipParser.js';

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

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/index.ts"],"sourcesContent":["// 7z format parser exports\n// Only exports needed for public API - internal functions remain internal\n\n// Error types for handling specific error conditions\nexport type { CodedError } from './constants.ts';\nexport { createCodedError, ErrorCode } from './constants.ts';\n// Parser and sources for advanced users\nexport type { ArchiveSource, SevenZipEntry } from './SevenZipParser.ts';\nexport { BufferSource, FileSource, SevenZipParser } from './SevenZipParser.ts';\n"],"names":["createCodedError","ErrorCode","BufferSource","FileSource","SevenZipParser"],"mappings":"AAAA,2BAA2B;AAC3B,0EAA0E;AAE1E,qDAAqD;AAErD,SAASA,gBAAgB,EAAEC,SAAS,QAAQ,iBAAiB;AAG7D,SAASC,YAAY,EAAEC,UAAU,EAAEC,cAAc,QAAQ,sBAAsB"}
+{"version":3,"sources":["/Users/kevin/Dev/iterators/7z-iterator/src/sevenz/index.ts"],"sourcesContent":["// 7z format parser exports\n// Only exports needed for public API - internal functions remain internal\n\n// Error types for handling specific error conditions\nexport type { CodedError } from './constants.ts';\nexport { createCodedError, ErrorCode } from './constants.ts';\n// Parser and sources for advanced users\nexport type { ArchiveSource, SevenZipEntry, VoidCallback } from './SevenZipParser.ts';\nexport { BufferSource, FileSource, SevenZipParser } from './SevenZipParser.ts';\n"],"names":["createCodedError","ErrorCode","BufferSource","FileSource","SevenZipParser"],"mappings":"AAAA,2BAA2B;AAC3B,0EAA0E;AAE1E,qDAAqD;AAErD,SAASA,gBAAgB,EAAEC,SAAS,QAAQ,iBAAiB;AAG7D,SAASC,YAAY,EAAEC,UAAU,EAAEC,cAAc,QAAQ,sBAAsB"}

package/dist/esm/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/types.ts"],"sourcesContent":["export { DirectoryEntry, LinkEntry, Lock, SymbolicLinkEntry } from 'extract-base-iterator';\nexport { default as FileEntry } from './FileEntry.ts';\nexport type { SevenZipEntry } from './sevenz/SevenZipParser.ts';\n\nimport type { ExtractOptions as BaseExtractOptions, DirectoryEntry, LinkEntry, SymbolicLinkEntry } from 'extract-base-iterator';\nimport type FileEntry from './FileEntry.ts';\n\n// 7z-specific Entry union type with 7z-specific FileEntry\nexport type Entry = DirectoryEntry | FileEntry | LinkEntry | SymbolicLinkEntry;\n\n/**\n * Options for SevenZipIterator\n */\nexport interface ExtractOptions extends BaseExtractOptions {\n  /**\n   * Password for encrypted archives\n   */\n  password?: string;\n}\n\nexport type EntryCallback = (error?: Error, result?: IteratorResult<Entry>) => void;\n"],"names":["DirectoryEntry","LinkEntry","Lock","SymbolicLinkEntry","default","FileEntry"],"mappings":"AAAA,SAASA,cAAc,EAAEC,SAAS,EAAEC,IAAI,EAAEC,iBAAiB,QAAQ,wBAAwB;AAC3F,SAASC,WAAWC,SAAS,QAAQ,iBAAiB"}
+{"version":3,"sources":["/Users/kevin/Dev/iterators/7z-iterator/src/types.ts"],"sourcesContent":["export { DirectoryEntry, LinkEntry, Lock, SymbolicLinkEntry } from 'extract-base-iterator';\nexport { default as FileEntry } from './FileEntry.ts';\nexport type { SevenZipEntry } from './sevenz/SevenZipParser.ts';\n\nimport type { ExtractOptions as BaseExtractOptions, DirectoryEntry, LinkEntry, SymbolicLinkEntry } from 'extract-base-iterator';\nimport type FileEntry from './FileEntry.ts';\n\n// 7z-specific Entry union type with 7z-specific FileEntry\nexport type Entry = DirectoryEntry | FileEntry | LinkEntry | SymbolicLinkEntry;\n\n/**\n * Options for SevenZipIterator\n */\nexport interface ExtractOptions extends BaseExtractOptions {\n  /**\n   * Password for encrypted archives\n   */\n  password?: string;\n}\n\nexport type EntryCallback = (error?: Error, result?: IteratorResult<Entry>) => void;\n"],"names":["DirectoryEntry","LinkEntry","Lock","SymbolicLinkEntry","default","FileEntry"],"mappings":"AAAA,SAASA,cAAc,EAAEC,SAAS,EAAEC,IAAI,EAAEC,iBAAiB,QAAQ,wBAAwB;AAC3F,SAASC,WAAWC,SAAS,QAAQ,iBAAiB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "7z-iterator",
-  "version": "2.0.3",
+  "version": "2.1.0",
   "description": "Extract contents from 7z archives using an iterator API. Pure JavaScript, works on Node.js 0.8+",
   "keywords": [
     "extract",
@@ -63,7 +63,7 @@
     "short-hash": "^1.0.0",
     "temp-suffix": "^1.0.10",
     "unbzip2-stream": "1.0.8",
-    "xz-compat": "^0.2.0"
+    "xz-compat": "^1.0.0"
   },
   "devDependencies": {
     "@types/mocha": "*",