7z-iterator 0.1.0

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

@@ -0,0 +1,24 @@
+import type { Transform } from 'readable-stream';
+import { getPassword, setPassword } from './Aes.js';
+export { getPassword, setPassword };
+export interface Codec {
+    decode: (input: Buffer, properties?: Buffer, unpackSize?: number) => Buffer;
+    createDecoder: (properties?: Buffer, unpackSize?: number) => Transform;
+}
+/**
+ * Register a codec
+ */
+export declare function registerCodec(id: number[], codec: Codec): void;
+/**
+ * Get a codec by ID
+ * @throws Error if codec is not supported
+ */
+export declare function getCodec(id: number[]): Codec;
+/**
+ * Check if a codec is supported
+ */
+export declare function isCodecSupported(id: number[]): boolean;
+/**
+ * Get human-readable codec name
+ */
+export declare function getCodecName(id: number[]): string;

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

@@ -0,0 +1,108 @@
+// Codec registry for 7z decompression
+// Each codec provides a decode function and optionally a streaming decoder
+import { CodecId, createCodedError, ErrorCode } from '../constants.js';
+import { createAesDecoder, decodeAes, getPassword, setPassword } from './Aes.js';
+import { createBcjDecoder, decodeBcj } from './Bcj.js';
+import { createBzip2Decoder, decodeBzip2 } from './BZip2.js';
+import { createCopyDecoder, decodeCopy } from './Copy.js';
+import { createDeflateDecoder, decodeDeflate } from './Deflate.js';
+import { createDeltaDecoder, decodeDelta } from './Delta.js';
+import { createLzmaDecoder, decodeLzma } from './Lzma.js';
+import { createLzma2Decoder, decodeLzma2 } from './Lzma2.js';
+// Re-export password functions for API access
+export { getPassword, setPassword };
+// Registry of supported codecs
+var codecs = {};
+/**
+ * Convert codec ID bytes to a string key
+ */ function codecIdToKey(id) {
+    var parts = [];
+    for(var i = 0; i < id.length; i++){
+        parts.push(id[i].toString(16).toUpperCase());
+    }
+    return parts.join('-');
+}
+/**
+ * Check if two codec IDs match
+ */ function codecIdEquals(a, b) {
+    if (a.length !== b.length) return false;
+    for(var i = 0; i < a.length; i++){
+        if (a[i] !== b[i]) return false;
+    }
+    return true;
+}
+/**
+ * Register a codec
+ */ export function registerCodec(id, codec) {
+    codecs[codecIdToKey(id)] = codec;
+}
+/**
+ * Get a codec by ID
+ * @throws Error if codec is not supported
+ */ export function getCodec(id) {
+    var key = codecIdToKey(id);
+    var codec = codecs[key];
+    if (!codec) {
+        throw createCodedError(`Unsupported codec: ${key}`, ErrorCode.UNSUPPORTED_CODEC);
+    }
+    return codec;
+}
+/**
+ * Check if a codec is supported
+ */ export function isCodecSupported(id) {
+    return codecs[codecIdToKey(id)] !== undefined;
+}
+/**
+ * Get human-readable codec name
+ */ export function getCodecName(id) {
+    if (codecIdEquals(id, CodecId.COPY)) return 'Copy';
+    if (codecIdEquals(id, CodecId.LZMA)) return 'LZMA';
+    if (codecIdEquals(id, CodecId.LZMA2)) return 'LZMA2';
+    if (codecIdEquals(id, CodecId.BCJ_X86)) return 'BCJ (x86)';
+    if (codecIdEquals(id, CodecId.DELTA)) return 'Delta';
+    if (codecIdEquals(id, CodecId.DEFLATE)) return 'Deflate';
+    if (codecIdEquals(id, CodecId.BZIP2)) return 'BZip2';
+    if (codecIdEquals(id, CodecId.AES)) return 'AES-256';
+    return `Unknown (${codecIdToKey(id)})`;
+}
+// Register built-in codecs
+// Copy codec (no compression)
+registerCodec(CodecId.COPY, {
+    decode: decodeCopy,
+    createDecoder: createCopyDecoder
+});
+// LZMA codec
+registerCodec(CodecId.LZMA, {
+    decode: decodeLzma,
+    createDecoder: createLzmaDecoder
+});
+// LZMA2 codec
+registerCodec(CodecId.LZMA2, {
+    decode: decodeLzma2,
+    createDecoder: createLzma2Decoder
+});
+// BCJ (x86) filter
+registerCodec(CodecId.BCJ_X86, {
+    decode: decodeBcj,
+    createDecoder: createBcjDecoder
+});
+// Delta filter
+registerCodec(CodecId.DELTA, {
+    decode: decodeDelta,
+    createDecoder: createDeltaDecoder
+});
+// Deflate codec
+registerCodec(CodecId.DEFLATE, {
+    decode: decodeDeflate,
+    createDecoder: createDeflateDecoder
+});
+// BZip2 codec
+registerCodec(CodecId.BZIP2, {
+    decode: decodeBzip2,
+    createDecoder: createBzip2Decoder
+});
+// AES-256-CBC codec (encryption)
+registerCodec(CodecId.AES, {
+    decode: decodeAes,
+    createDecoder: createAesDecoder
+});

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

@@ -0,0 +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 'readable-stream';\nimport { CodecId, createCodedError, ErrorCode } from '../constants.ts';\nimport { createAesDecoder, decodeAes, getPassword, setPassword } from './Aes.ts';\nimport { createBcjDecoder, decodeBcj } from './Bcj.ts';\nimport { createBzip2Decoder, decodeBzip2 } from './BZip2.ts';\nimport { createCopyDecoder, decodeCopy } from './Copy.ts';\nimport { createDeflateDecoder, decodeDeflate } from './Deflate.ts';\nimport { createDeltaDecoder, decodeDelta } from './Delta.ts';\nimport { createLzmaDecoder, decodeLzma } from './Lzma.ts';\nimport { createLzma2Decoder, decodeLzma2 } from './Lzma2.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// Registry of supported codecs\nvar codecs: { [key: string]: Codec } = {};\n\n/**\n * Convert codec ID bytes to a string key\n */\nfunction codecIdToKey(id: number[]): string {\n  var parts: string[] = [];\n  for (var 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 (var 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  var key = codecIdToKey(id);\n  var 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.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// 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// 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"],"names":["CodecId","createCodedError","ErrorCode","createAesDecoder","decodeAes","getPassword","setPassword","createBcjDecoder","decodeBcj","createBzip2Decoder","decodeBzip2","createCopyDecoder","decodeCopy","createDeflateDecoder","decodeDeflate","createDeltaDecoder","decodeDelta","createLzmaDecoder","decodeLzma","createLzma2Decoder","decodeLzma2","codecs","codecIdToKey","id","parts","i","length","push","toString","toUpperCase","join","codecIdEquals","a","b","registerCodec","codec","getCodec","key","UNSUPPORTED_CODEC","isCodecSupported","undefined","getCodecName","COPY","LZMA","LZMA2","BCJ_X86","DELTA","DEFLATE","BZIP2","AES","decode","createDecoder"],"mappings":"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"}

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

@@ -0,0 +1,18 @@
+/**
+ * Input stream wrapper for lzma-purejs
+ * Wraps a Buffer region as a readable stream interface
+ */
+export declare function createInputStream(buffer: Buffer, offset: number, length: number): {
+    readByte: () => number;
+    read: (buf: number[], bufOffset: number, len: number) => number;
+};
+/**
+ * Output stream wrapper for lzma-purejs
+ * Collects output bytes into Buffer chunks
+ */
+export declare function createOutputStream(): {
+    writeByte: (b: number) => void;
+    write: (buf: number[], bufOffset: number, len: number) => number;
+    flush: () => void;
+    toBuffer: () => Buffer;
+};

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

@@ -0,0 +1,66 @@
+// Shared stream wrappers for lzma-purejs codec interface
+// These adapters convert between Buffer/lzma-purejs stream interfaces
+import { allocBufferUnsafe } from 'extract-base-iterator';
+/**
+ * Input stream wrapper for lzma-purejs
+ * Wraps a Buffer region as a readable stream interface
+ */ export function createInputStream(buffer, offset, length) {
+    var pos = 0;
+    var end = Math.min(offset + length, buffer.length);
+    var start = offset;
+    return {
+        readByte: ()=>{
+            if (start + pos >= end) return -1;
+            return buffer[start + pos++];
+        },
+        read: (buf, bufOffset, len)=>{
+            var bytesRead = 0;
+            while(bytesRead < len && start + pos < end){
+                buf[bufOffset + bytesRead] = buffer[start + pos];
+                pos++;
+                bytesRead++;
+            }
+            return bytesRead === 0 ? -1 : bytesRead;
+        }
+    };
+}
+/**
+ * Output stream wrapper for lzma-purejs
+ * Collects output bytes into Buffer chunks
+ */ export function createOutputStream() {
+    var chunks = [];
+    var currentChunk = [];
+    var CHUNK_SIZE = 16384;
+    return {
+        writeByte: (b)=>{
+            currentChunk.push(b);
+            if (currentChunk.length >= CHUNK_SIZE) {
+                chunks.push(allocBufferUnsafe(currentChunk.length));
+                for(var i = 0; i < currentChunk.length; i++){
+                    chunks[chunks.length - 1][i] = currentChunk[i];
+                }
+                currentChunk = [];
+            }
+        },
+        write: function(buf, bufOffset, len) {
+            for(var i = 0; i < len; i++){
+                this.writeByte(buf[bufOffset + i]);
+            }
+            return len;
+        },
+        flush: ()=>{
+            if (currentChunk.length > 0) {
+                var finalChunk = allocBufferUnsafe(currentChunk.length);
+                for(var i = 0; i < currentChunk.length; i++){
+                    finalChunk[i] = currentChunk[i];
+                }
+                chunks.push(finalChunk);
+                currentChunk = [];
+            }
+        },
+        toBuffer: function() {
+            this.flush();
+            return Buffer.concat(chunks);
+        }
+    };
+}

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

@@ -0,0 +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  var pos = 0;\n  var end = Math.min(offset + length, buffer.length);\n  var 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      var 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 */\nexport function createOutputStream() {\n  var chunks: Buffer[] = [];\n  var currentChunk: number[] = [];\n  var CHUNK_SIZE = 16384;\n\n  return {\n    writeByte: (b: number): void => {\n      currentChunk.push(b);\n      if (currentChunk.length >= CHUNK_SIZE) {\n        chunks.push(allocBufferUnsafe(currentChunk.length));\n        for (var i = 0; i < currentChunk.length; i++) {\n          chunks[chunks.length - 1][i] = currentChunk[i];\n        }\n        currentChunk = [];\n      }\n    },\n    write: function (buf: number[], bufOffset: number, len: number): number {\n      for (var i = 0; i < len; i++) {\n        this.writeByte(buf[bufOffset + i]);\n      }\n      return len;\n    },\n    flush: (): void => {\n      if (currentChunk.length > 0) {\n        var finalChunk = allocBufferUnsafe(currentChunk.length);\n        for (var i = 0; i < currentChunk.length; i++) {\n          finalChunk[i] = currentChunk[i];\n        }\n        chunks.push(finalChunk);\n        currentChunk = [];\n      }\n    },\n    toBuffer: function (): Buffer {\n      this.flush();\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","chunks","currentChunk","CHUNK_SIZE","writeByte","b","push","i","write","flush","finalChunk","toBuffer","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,IAAIC,MAAMC,KAAKC,GAAG,CAACL,SAASC,QAAQF,OAAOE,MAAM;IACjD,IAAIK,QAAQN;IAEZ,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;;;CAGC,GACD,OAAO,SAASC;IACd,IAAIC,SAAmB,EAAE;IACzB,IAAIC,eAAyB,EAAE;IAC/B,IAAIC,aAAa;IAEjB,OAAO;QACLC,WAAW,CAACC;YACVH,aAAaI,IAAI,CAACD;YAClB,IAAIH,aAAad,MAAM,IAAIe,YAAY;gBACrCF,OAAOK,IAAI,CAACtB,kBAAkBkB,aAAad,MAAM;gBACjD,IAAK,IAAImB,IAAI,GAAGA,IAAIL,aAAad,MAAM,EAAEmB,IAAK;oBAC5CN,MAAM,CAACA,OAAOb,MAAM,GAAG,EAAE,CAACmB,EAAE,GAAGL,YAAY,CAACK,EAAE;gBAChD;gBACAL,eAAe,EAAE;YACnB;QACF;QACAM,OAAO,SAAUZ,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;QACAW,OAAO;YACL,IAAIP,aAAad,MAAM,GAAG,GAAG;gBAC3B,IAAIsB,aAAa1B,kBAAkBkB,aAAad,MAAM;gBACtD,IAAK,IAAImB,IAAI,GAAGA,IAAIL,aAAad,MAAM,EAAEmB,IAAK;oBAC5CG,UAAU,CAACH,EAAE,GAAGL,YAAY,CAACK,EAAE;gBACjC;gBACAN,OAAOK,IAAI,CAACI;gBACZR,eAAe,EAAE;YACnB;QACF;QACAS,UAAU;YACR,IAAI,CAACF,KAAK;YACV,OAAOG,OAAOC,MAAM,CAACZ;QACvB;IACF;AACF"}

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

@@ -0,0 +1,86 @@
+export declare var SEVENZ_MAGIC: number[];
+export declare var SIGNATURE_HEADER_SIZE: number;
+export declare var START_HEADER_SIZE: number;
+export declare var PropertyId: {
+    kEnd: number;
+    kHeader: number;
+    kArchiveProperties: number;
+    kAdditionalStreamsInfo: number;
+    kMainStreamsInfo: number;
+    kFilesInfo: number;
+    kPackInfo: number;
+    kUnpackInfo: number;
+    kSubStreamsInfo: number;
+    kSize: number;
+    kCRC: number;
+    kFolder: number;
+    kCodersUnpackSize: number;
+    kNumUnpackStream: number;
+    kEmptyStream: number;
+    kEmptyFile: number;
+    kAnti: number;
+    kName: number;
+    kCTime: number;
+    kATime: number;
+    kMTime: number;
+    kWinAttributes: number;
+    kComment: number;
+    kEncodedHeader: number;
+    kStartPos: number;
+    kDummy: number;
+};
+export declare var CodecId: {
+    COPY: number[];
+    DELTA: number[];
+    LZMA: number[];
+    LZMA2: number[];
+    BCJ_X86: number[];
+    DEFLATE: number[];
+    BZIP2: number[];
+    AES: number[];
+};
+export declare var FileAttribute: {
+    READONLY: number;
+    HIDDEN: number;
+    SYSTEM: number;
+    DIRECTORY: number;
+    ARCHIVE: number;
+    DEVICE: number;
+    NORMAL: number;
+    TEMPORARY: number;
+    SPARSE_FILE: number;
+    REPARSE_POINT: number;
+    COMPRESSED: number;
+    OFFLINE: number;
+    NOT_CONTENT_INDEXED: number;
+    ENCRYPTED: number;
+    UNIX_EXTENSION: number;
+};
+export declare var UnixMode: {
+    DIR: number;
+    FILE: number;
+    SYMLINK: number;
+    RWXRWXRWX: number;
+    RWXRXRX: number;
+    RWRR: number;
+    DEFAULT_DIR: number;
+    DEFAULT_FILE: number;
+};
+export declare var ErrorCode: {
+    INVALID_SIGNATURE: string;
+    CRC_MISMATCH: string;
+    UNSUPPORTED_CODEC: string;
+    UNSUPPORTED_VERSION: string;
+    UNSUPPORTED_FEATURE: string;
+    TRUNCATED_ARCHIVE: string;
+    CORRUPT_HEADER: string;
+    ENCRYPTED_ARCHIVE: string;
+    COMPRESSED_HEADER: string;
+};
+export interface CodedError extends Error {
+    code: string;
+}
+/**
+ * Create an error with a code property
+ */
+export declare function createCodedError(message: string, code: string): CodedError;

package/dist/esm/sevenz/constants.js

@@ -0,0 +1,131 @@
+// 7z format constants
+// Reference: https://py7zr.readthedocs.io/en/latest/archive_format.html
+// 7z signature: '7z' + magic bytes
+export var SEVENZ_MAGIC = [
+    0x37,
+    0x7a,
+    0xbc,
+    0xaf,
+    0x27,
+    0x1c
+];
+// Header sizes
+export var SIGNATURE_HEADER_SIZE = 32;
+export var START_HEADER_SIZE = 20; // Part of signature header after magic + version
+// Property IDs for encoded header
+export var PropertyId = {
+    kEnd: 0x00,
+    kHeader: 0x01,
+    kArchiveProperties: 0x02,
+    kAdditionalStreamsInfo: 0x03,
+    kMainStreamsInfo: 0x04,
+    kFilesInfo: 0x05,
+    kPackInfo: 0x06,
+    kUnpackInfo: 0x07,
+    kSubStreamsInfo: 0x08,
+    kSize: 0x09,
+    kCRC: 0x0a,
+    kFolder: 0x0b,
+    kCodersUnpackSize: 0x0c,
+    kNumUnpackStream: 0x0d,
+    kEmptyStream: 0x0e,
+    kEmptyFile: 0x0f,
+    kAnti: 0x10,
+    kName: 0x11,
+    kCTime: 0x12,
+    kATime: 0x13,
+    kMTime: 0x14,
+    kWinAttributes: 0x15,
+    kComment: 0x16,
+    kEncodedHeader: 0x17,
+    kStartPos: 0x18,
+    kDummy: 0x19
+};
+// Codec IDs
+// 7z uses variable-length codec IDs
+export var CodecId = {
+    COPY: [
+        0x00
+    ],
+    DELTA: [
+        0x03
+    ],
+    LZMA: [
+        0x03,
+        0x01,
+        0x01
+    ],
+    LZMA2: [
+        0x21
+    ],
+    BCJ_X86: [
+        0x03,
+        0x03,
+        0x01,
+        0x03
+    ],
+    DEFLATE: [
+        0x04,
+        0x01,
+        0x08
+    ],
+    BZIP2: [
+        0x04,
+        0x02,
+        0x02
+    ],
+    AES: [
+        0x06,
+        0xf1,
+        0x07,
+        0x01
+    ]
+};
+// File attribute flags (Windows style, stored in FilesInfo)
+export var FileAttribute = {
+    READONLY: 0x01,
+    HIDDEN: 0x02,
+    SYSTEM: 0x04,
+    DIRECTORY: 0x10,
+    ARCHIVE: 0x20,
+    DEVICE: 0x40,
+    NORMAL: 0x80,
+    TEMPORARY: 0x100,
+    SPARSE_FILE: 0x200,
+    REPARSE_POINT: 0x400,
+    COMPRESSED: 0x800,
+    OFFLINE: 0x1000,
+    NOT_CONTENT_INDEXED: 0x2000,
+    ENCRYPTED: 0x4000,
+    UNIX_EXTENSION: 0x8000
+};
+// Unix permission modes (decimal values for Node 0.8 compatibility)
+export var UnixMode = {
+    DIR: 16384,
+    FILE: 32768,
+    SYMLINK: 40960,
+    RWXRWXRWX: 511,
+    RWXRXRX: 493,
+    RWRR: 420,
+    DEFAULT_DIR: 493,
+    DEFAULT_FILE: 420
+};
+// Error codes
+export var ErrorCode = {
+    INVALID_SIGNATURE: 'INVALID_SIGNATURE',
+    CRC_MISMATCH: 'CRC_MISMATCH',
+    UNSUPPORTED_CODEC: 'UNSUPPORTED_CODEC',
+    UNSUPPORTED_VERSION: 'UNSUPPORTED_VERSION',
+    UNSUPPORTED_FEATURE: 'UNSUPPORTED_FEATURE',
+    TRUNCATED_ARCHIVE: 'TRUNCATED_ARCHIVE',
+    CORRUPT_HEADER: 'CORRUPT_HEADER',
+    ENCRYPTED_ARCHIVE: 'ENCRYPTED_ARCHIVE',
+    COMPRESSED_HEADER: 'COMPRESSED_HEADER'
+};
+/**
+ * Create an error with a code property
+ */ export function createCodedError(message, code) {
+    var err = new Error(message);
+    err.code = code;
+    return err;
+}

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

@@ -0,0 +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 var SEVENZ_MAGIC = [0x37, 0x7a, 0xbc, 0xaf, 0x27, 0x1c];\n\n// Header sizes\nexport var SIGNATURE_HEADER_SIZE = 32;\nexport var START_HEADER_SIZE = 20; // Part of signature header after magic + version\n\n// Property IDs for encoded header\nexport var 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\nexport var CodecId = {\n  COPY: [0x00],\n  DELTA: [0x03],\n  LZMA: [0x03, 0x01, 0x01],\n  LZMA2: [0x21],\n  BCJ_X86: [0x03, 0x03, 0x01, 0x03],\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 var 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 var 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 var 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_HEADER: 'CORRUPT_HEADER',\n  ENCRYPTED_ARCHIVE: 'ENCRYPTED_ARCHIVE',\n  COMPRESSED_HEADER: 'COMPRESSED_HEADER',\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  var 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","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_HEADER","ENCRYPTED_ARCHIVE","COMPRESSED_HEADER","createCodedError","message","code","err","Error"],"mappings":"AAAA,sBAAsB;AACtB,wEAAwE;AAExE,mCAAmC;AACnC,OAAO,IAAIA,eAAe;IAAC;IAAM;IAAM;IAAM;IAAM;IAAM;CAAK,CAAC;AAE/D,eAAe;AACf,OAAO,IAAIC,wBAAwB,GAAG;AACtC,OAAO,IAAIC,oBAAoB,GAAG,CAAC,iDAAiD;AAEpF,kCAAkC;AAClC,OAAO,IAAIC,aAAa;IACtBC,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,OAAO,IAAIC,UAAU;IACnBC,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;KAAK;IAC3BC,OAAO;QAAC;QAAM;QAAM;KAAK;IACzBC,KAAK;QAAC;QAAM;QAAM;QAAM;KAAK;AAC/B,EAAE;AAEF,4DAA4D;AAC5D,OAAO,IAAIC,gBAAgB;IACzBC,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,IAAIC,WAAW;IACpBC,KAAK;IACLC,MAAM;IACNC,SAAS;IACTC,WAAW;IACXC,SAAS;IACTC,MAAM;IACNC,aAAa;IACbC,cAAc;AAChB,EAAE;AAEF,cAAc;AACd,OAAO,IAAIC,YAAY;IACrBC,mBAAmB;IACnBC,cAAc;IACdC,mBAAmB;IACnBC,qBAAqB;IACrBC,qBAAqB;IACrBC,mBAAmB;IACnBC,gBAAgB;IAChBC,mBAAmB;IACnBC,mBAAmB;AACrB,EAAE;AAOF;;CAEC,GACD,OAAO,SAASC,iBAAiBC,OAAe,EAAEC,IAAY;IAC5D,IAAIC,MAAM,IAAIC,MAAMH;IACpBE,IAAID,IAAI,GAAGA;IACX,OAAOC;AACT"}

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

@@ -0,0 +1,70 @@
+export interface SignatureHeader {
+    majorVersion: number;
+    minorVersion: number;
+    startHeaderCRC: number;
+    nextHeaderOffset: number;
+    nextHeaderSize: number;
+    nextHeaderCRC: number;
+}
+export interface Coder {
+    id: number[];
+    numInStreams: number;
+    numOutStreams: number;
+    properties?: Buffer;
+}
+export interface Folder {
+    coders: Coder[];
+    bindPairs: {
+        inIndex: number;
+        outIndex: number;
+    }[];
+    packedStreams: number[];
+    unpackSizes: number[];
+    unpackCRC?: number;
+    hasCRC: boolean;
+}
+export interface StreamsInfo {
+    packPos: number;
+    packSizes: number[];
+    packCRCs?: number[];
+    folders: Folder[];
+    numUnpackStreamsPerFolder: number[];
+    unpackSizes: number[];
+    unpackCRCs?: number[];
+}
+export interface FileInfo {
+    name: string;
+    size: number;
+    isDirectory: boolean;
+    isAntiFile: boolean;
+    hasStream: boolean;
+    crc?: number;
+    ctime?: Date;
+    atime?: Date;
+    mtime?: Date;
+    attributes?: number;
+}
+export interface ArchiveHeader {
+    signature: SignatureHeader;
+    streamsInfo?: StreamsInfo;
+    filesInfo: FileInfo[];
+}
+/**
+ * Parse the signature header (first 32 bytes)
+ */
+export declare function parseSignatureHeader(buf: Buffer): SignatureHeader;
+/**
+ * Parse the encoded header (metadata block at end of archive)
+ */
+export declare function parseEncodedHeader(buf: Buffer, expectedCRC: number): {
+    streamsInfo?: StreamsInfo;
+    filesInfo: FileInfo[];
+};
+/**
+ * Parse header content (after kHeader byte has been read)
+ * Used by parseEncodedHeader and for decompressed headers
+ */
+export declare function parseHeaderContent(buf: Buffer, offset: number): {
+    streamsInfo?: StreamsInfo;
+    filesInfo: FileInfo[];
+};