7z-iterator 0.1.0

package/dist/esm/sevenz/SevenZipParser.js

@@ -0,0 +1,419 @@
+// SevenZipParser - Main 7z archive parser
+// Handles reading archive structure and providing file streams
+import { allocBuffer, crc32 } from 'extract-base-iterator';
+import fs from 'fs';
+import { PassThrough } from 'readable-stream';
+import { getCodec, getCodecName, isCodecSupported } from './codecs/index.js';
+import { createCodedError, ErrorCode, FileAttribute, PropertyId, SIGNATURE_HEADER_SIZE } from './constants.js';
+import { parseEncodedHeader, parseHeaderContent, parseSignatureHeader } from './headers.js';
+import { readNumber } from './NumberCodec.js';
+/**
+ * Buffer-based archive source
+ */ export class BufferSource {
+    read(position, length) {
+        return this.buffer.slice(position, position + length);
+    }
+    getSize() {
+        return this.buffer.length;
+    }
+    close() {
+    // Nothing to close for buffer
+    }
+    constructor(buffer){
+        this.buffer = buffer;
+    }
+}
+/**
+ * File descriptor based archive source
+ */ export class FileSource {
+    read(position, length) {
+        var buf = allocBuffer(length);
+        var bytesRead = fs.readSync(this.fd, buf, 0, length, position);
+        if (bytesRead < length) {
+            return buf.slice(0, bytesRead);
+        }
+        return buf;
+    }
+    getSize() {
+        return this.size;
+    }
+    close() {
+        try {
+            fs.closeSync(this.fd);
+        } catch (_e) {
+        // Ignore close errors
+        }
+    }
+    constructor(fd, size){
+        this.fd = fd;
+        this.size = size;
+    }
+}
+/**
+ * SevenZipParser - parses 7z archives and provides entry iteration
+ */ export class SevenZipParser {
+    /**
+   * Parse the archive structure
+   * Must be called before iterating entries
+   */ parse() {
+        if (this.parsed) return;
+        // Read signature header
+        var sigBuf = this.source.read(0, SIGNATURE_HEADER_SIZE);
+        if (sigBuf.length < SIGNATURE_HEADER_SIZE) {
+            throw createCodedError('Archive too small', ErrorCode.TRUNCATED_ARCHIVE);
+        }
+        this.signature = parseSignatureHeader(sigBuf);
+        // Read encoded header
+        var headerOffset = SIGNATURE_HEADER_SIZE + this.signature.nextHeaderOffset;
+        var headerBuf = this.source.read(headerOffset, this.signature.nextHeaderSize);
+        if (headerBuf.length < this.signature.nextHeaderSize) {
+            throw createCodedError('Truncated header', ErrorCode.TRUNCATED_ARCHIVE);
+        }
+        // Parse encoded header (may need decompression)
+        try {
+            var headerResult = parseEncodedHeader(headerBuf, this.signature.nextHeaderCRC);
+            this.streamsInfo = headerResult.streamsInfo || null;
+            this.filesInfo = headerResult.filesInfo;
+        } catch (err) {
+            var codedErr = err;
+            if (codedErr && codedErr.code === ErrorCode.COMPRESSED_HEADER) {
+                // Header is compressed - need to decompress first
+                this.handleCompressedHeader(headerBuf);
+            } else {
+                throw err;
+            }
+        }
+        // Build entries list
+        this.buildEntries();
+        this.parsed = true;
+    }
+    /**
+   * Handle compressed header (kEncodedHeader)
+   */ handleCompressedHeader(headerBuf) {
+        // Parse the encoded header info to get decompression parameters
+        var offset = 1; // Skip kEncodedHeader byte
+        // Should have StreamsInfo for the header itself
+        var propertyId = headerBuf[offset++];
+        if (propertyId !== PropertyId.kMainStreamsInfo && propertyId !== PropertyId.kPackInfo) {
+            throw createCodedError('Expected StreamsInfo in encoded header', ErrorCode.CORRUPT_HEADER);
+        }
+        // For now, we parse the streams info from the encoded header block
+        // This tells us how to decompress the actual header
+        // Read pack info from the encoded header structure
+        var packInfoResult = this.parseEncodedHeaderStreams(headerBuf, 1);
+        // Read the compressed header data
+        var compressedStart = SIGNATURE_HEADER_SIZE + packInfoResult.packPos;
+        var compressedData = this.source.read(compressedStart, packInfoResult.packSize);
+        // Decompress using the specified codec
+        var codec = getCodec(packInfoResult.codecId);
+        var decompressedHeader = codec.decode(compressedData, packInfoResult.properties, packInfoResult.unpackSize);
+        // Verify CRC if present
+        if (packInfoResult.unpackCRC !== undefined) {
+            var actualCRC = crc32(decompressedHeader);
+            if (actualCRC !== packInfoResult.unpackCRC) {
+                throw createCodedError('Decompressed header CRC mismatch', ErrorCode.CRC_MISMATCH);
+            }
+        }
+        // Now parse the decompressed header
+        // It should start with kHeader
+        var decompOffset = 0;
+        var headerId = decompressedHeader[decompOffset++];
+        if (headerId !== PropertyId.kHeader) {
+            throw createCodedError('Expected kHeader in decompressed header', ErrorCode.CORRUPT_HEADER);
+        }
+        // Parse the decompressed header using shared function from headers.ts
+        var result = parseHeaderContent(decompressedHeader, decompOffset);
+        this.streamsInfo = result.streamsInfo || null;
+        this.filesInfo = result.filesInfo;
+    }
+    /**
+   * Parse streams info from encoded header block
+   * This is a simplified parser for the header's own compression info
+   */ parseEncodedHeaderStreams(buf, offset) {
+        // This is a simplified parser for the encoded header's own streams info
+        var packPos = 0;
+        var packSize = 0;
+        var unpackSize = 0;
+        var codecId = [];
+        var properties;
+        var unpackCRC;
+        while(offset < buf.length){
+            var propertyId = buf[offset++];
+            if (propertyId === PropertyId.kEnd) {
+                break;
+            }
+            switch(propertyId){
+                case PropertyId.kPackInfo:
+                    {
+                        var packPosResult = readNumber(buf, offset);
+                        packPos = packPosResult.value;
+                        offset += packPosResult.bytesRead;
+                        var numPackResult = readNumber(buf, offset);
+                        offset += numPackResult.bytesRead;
+                        // Read until kEnd
+                        while(buf[offset] !== PropertyId.kEnd){
+                            if (buf[offset] === PropertyId.kSize) {
+                                offset++;
+                                var sizeResult = readNumber(buf, offset);
+                                packSize = sizeResult.value;
+                                offset += sizeResult.bytesRead;
+                            } else {
+                                offset++;
+                            }
+                        }
+                        offset++; // Skip kEnd
+                        break;
+                    }
+                case PropertyId.kUnpackInfo:
+                    // Find folder/coder info
+                    while(offset < buf.length && buf[offset] !== PropertyId.kEnd){
+                        if (buf[offset] === PropertyId.kFolder) {
+                            offset++;
+                            var numFoldersResult = readNumber(buf, offset);
+                            offset += numFoldersResult.bytesRead;
+                            offset++; // external flag
+                            // Parse coder
+                            var numCodersResult = readNumber(buf, offset);
+                            offset += numCodersResult.bytesRead;
+                            var flags = buf[offset++];
+                            var idSize = flags & 0x0f;
+                            var hasAttributes = (flags & 0x20) !== 0;
+                            codecId = [];
+                            for(var i = 0; i < idSize; i++){
+                                codecId.push(buf[offset++]);
+                            }
+                            if (hasAttributes) {
+                                var propsLenResult = readNumber(buf, offset);
+                                offset += propsLenResult.bytesRead;
+                                properties = buf.slice(offset, offset + propsLenResult.value);
+                                offset += propsLenResult.value;
+                            }
+                        } else if (buf[offset] === PropertyId.kCodersUnpackSize) {
+                            offset++;
+                            // Read unpack size - needed for LZMA decoder
+                            var unpackSizeResult = readNumber(buf, offset);
+                            unpackSize = unpackSizeResult.value;
+                            offset += unpackSizeResult.bytesRead;
+                        } else if (buf[offset] === PropertyId.kCRC) {
+                            offset++;
+                            var allDefined = buf[offset++];
+                            if (allDefined) {
+                                unpackCRC = buf.readUInt32LE(offset);
+                                offset += 4;
+                            }
+                        } else {
+                            offset++;
+                        }
+                    }
+                    if (buf[offset] === PropertyId.kEnd) offset++;
+                    break;
+            }
+        }
+        return {
+            packPos: packPos,
+            packSize: packSize,
+            unpackSize: unpackSize,
+            codecId: codecId,
+            properties: properties,
+            unpackCRC: unpackCRC
+        };
+    }
+    /**
+   * Build the entries list from parsed file info
+   */ buildEntries() {
+        this.entries = [];
+        if (!this.streamsInfo) {
+            // No streams info - just create entries from file info
+            for(var i = 0; i < this.filesInfo.length; i++){
+                var file = this.filesInfo[i];
+                this.entries.push(this.createEntry(file, 0, 0, 0));
+            }
+            return;
+        }
+        // Use the properly parsed numUnpackStreamsPerFolder from the archive header
+        var streamsPerFolder = this.streamsInfo.numUnpackStreamsPerFolder;
+        // Now build entries with proper folder/stream tracking
+        var streamIndex = 0;
+        var folderIndex = 0;
+        var streamInFolder = 0;
+        var folderStreamCount = streamsPerFolder[0] || 0;
+        for(var j = 0; j < this.filesInfo.length; j++){
+            var fileInfo = this.filesInfo[j];
+            // Get size from unpackSizes for files with streams
+            var size = 0;
+            if (fileInfo.hasStream && streamIndex < this.streamsInfo.unpackSizes.length) {
+                size = this.streamsInfo.unpackSizes[streamIndex];
+            }
+            var entry = this.createEntry(fileInfo, size, folderIndex, streamInFolder);
+            entry._streamIndex = streamIndex;
+            this.entries.push(entry);
+            // Advance stream tracking for files with streams
+            if (fileInfo.hasStream) {
+                streamIndex++;
+                streamInFolder++;
+                // Check if we've exhausted streams in this folder
+                if (streamInFolder >= folderStreamCount) {
+                    folderIndex++;
+                    streamInFolder = 0;
+                    folderStreamCount = streamsPerFolder[folderIndex] || 0;
+                }
+            }
+        }
+    }
+    /**
+   * Create an entry from file info
+   */ createEntry(file, size, folderIndex, streamInFolder) {
+        // Determine entry type
+        // Note: 7z format doesn't natively support symlinks. p7zip with -snl stores
+        // symlinks as regular files with the target path as content.
+        var type = 'file';
+        if (file.isDirectory) {
+            type = 'directory';
+        }
+        // Calculate mode from Windows attributes
+        var mode;
+        if (file.attributes !== undefined) {
+            // Check for Unix extension bit
+            if ((file.attributes & FileAttribute.UNIX_EXTENSION) !== 0) {
+                mode = file.attributes >>> 16 & 0xffff;
+                // Check for symlink (S_IFLNK = 0xA000)
+                // Note: Most 7z implementations don't preserve symlink mode bits
+                if ((mode & 0xf000) === 0xa000) {
+                    type = 'link';
+                }
+            } else if (file.isDirectory) {
+                mode = 493; // 0o755
+            } else {
+                mode = 420; // 0o644
+            }
+        }
+        return {
+            name: getBaseName(file.name),
+            path: file.name,
+            type: type,
+            size: size,
+            mtime: file.mtime,
+            atime: file.atime,
+            ctime: file.ctime,
+            mode: mode,
+            isAntiFile: file.isAntiFile,
+            _folderIndex: folderIndex,
+            _streamIndex: 0,
+            _streamIndexInFolder: streamInFolder,
+            _hasStream: file.hasStream
+        };
+    }
+    /**
+   * Get the list of entries
+   */ getEntries() {
+        if (!this.parsed) {
+            this.parse();
+        }
+        return this.entries;
+    }
+    /**
+   * Get a readable stream for an entry's content
+   */ getEntryStream(entry) {
+        if (!entry._hasStream || entry.type === 'directory') {
+            // Return empty stream for directories and empty files
+            var emptyStream = new PassThrough();
+            emptyStream.end();
+            return emptyStream;
+        }
+        if (!this.streamsInfo) {
+            throw createCodedError('No streams info available', ErrorCode.CORRUPT_HEADER);
+        }
+        // Get folder info
+        var folder = this.streamsInfo.folders[entry._folderIndex];
+        if (!folder) {
+            throw createCodedError('Invalid folder index', ErrorCode.CORRUPT_HEADER);
+        }
+        // Check codec support
+        for(var i = 0; i < folder.coders.length; i++){
+            var coder = folder.coders[i];
+            if (!isCodecSupported(coder.id)) {
+                var codecName = getCodecName(coder.id);
+                throw createCodedError(`Unsupported codec: ${codecName}`, ErrorCode.UNSUPPORTED_CODEC);
+            }
+        }
+        // Get decompressed data for this folder (with caching for solid archives)
+        var data = this.getDecompressedFolder(entry._folderIndex);
+        // Calculate file offset within the decompressed block
+        // For solid archives, multiple files are concatenated in the block
+        var fileStart = 0;
+        for(var m = 0; m < entry._streamIndexInFolder; m++){
+            // Sum sizes of all streams before this one in the folder
+            var prevStreamGlobalIndex = entry._streamIndex - entry._streamIndexInFolder + m;
+            fileStart += this.streamsInfo.unpackSizes[prevStreamGlobalIndex];
+        }
+        var fileSize = entry.size;
+        // Create a PassThrough stream with the file data
+        var outputStream = new PassThrough();
+        var fileData = data.slice(fileStart, fileStart + fileSize);
+        outputStream.end(fileData);
+        return outputStream;
+    }
+    /**
+   * Get decompressed data for a folder, with caching for solid archives
+   */ getDecompressedFolder(folderIndex) {
+        // Check cache first
+        if (this.decompressedCache[folderIndex]) {
+            return this.decompressedCache[folderIndex];
+        }
+        if (!this.streamsInfo) {
+            throw createCodedError('No streams info available', ErrorCode.CORRUPT_HEADER);
+        }
+        var folder = this.streamsInfo.folders[folderIndex];
+        // Calculate packed data position
+        var packPos = SIGNATURE_HEADER_SIZE + this.streamsInfo.packPos;
+        // Find which pack stream this folder uses
+        var packStreamIndex = 0;
+        for(var j = 0; j < folderIndex; j++){
+            packStreamIndex += this.streamsInfo.folders[j].packedStreams.length;
+        }
+        // Calculate position of this pack stream
+        for(var k = 0; k < packStreamIndex; k++){
+            packPos += this.streamsInfo.packSizes[k];
+        }
+        var packSize = this.streamsInfo.packSizes[packStreamIndex];
+        // Read packed data
+        var packedData = this.source.read(packPos, packSize);
+        // Decompress through codec chain
+        var data = packedData;
+        for(var l = 0; l < folder.coders.length; l++){
+            var coderInfo = folder.coders[l];
+            var codec = getCodec(coderInfo.id);
+            // Get unpack size for this coder (needed by LZMA)
+            var unpackSize = folder.unpackSizes[l];
+            data = codec.decode(data, coderInfo.properties, unpackSize);
+        }
+        // Cache for solid archives (when multiple files share a folder)
+        this.decompressedCache[folderIndex] = data;
+        return data;
+    }
+    /**
+   * Close the parser and release resources
+   */ close() {
+        if (this.source) {
+            this.source.close();
+        }
+    }
+    constructor(source){
+        this.signature = null;
+        this.streamsInfo = null;
+        this.filesInfo = [];
+        this.entries = [];
+        this.parsed = false;
+        // Cache for decompressed solid blocks (folderIndex -> decompressed data)
+        this.decompressedCache = {};
+        this.source = source;
+    }
+}
+/**
+ * Get base name from a path
+ */ function getBaseName(path) {
+    var lastSlash = path.lastIndexOf('/');
+    var lastBackslash = path.lastIndexOf('\\');
+    var lastSep = Math.max(lastSlash, lastBackslash);
+    return lastSep >= 0 ? path.slice(lastSep + 1) : path;
+}

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

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/SevenZipParser.ts"],"sourcesContent":["// SevenZipParser - Main 7z archive parser\n// Handles reading archive structure and providing file streams\n\nimport { allocBuffer, crc32 } from 'extract-base-iterator';\nimport fs from 'fs';\nimport { PassThrough, type Readable } from 'readable-stream';\nimport { getCodec, getCodecName, isCodecSupported } from './codecs/index.ts';\nimport { type CodedError, createCodedError, ErrorCode, FileAttribute, PropertyId, SIGNATURE_HEADER_SIZE } from './constants.ts';\nimport { type FileInfo, parseEncodedHeader, parseHeaderContent, parseSignatureHeader, type SignatureHeader, type StreamsInfo } from './headers.ts';\nimport { readNumber } from './NumberCodec.ts';\n\n// Entry type for iteration\nexport interface SevenZipEntry {\n  name: string;\n  path: string;\n  type: 'file' | 'directory' | 'link';\n  size: number;\n  mtime?: Date;\n  atime?: Date;\n  ctime?: Date;\n  mode?: number;\n  isAntiFile: boolean;\n  // Internal tracking\n  _folderIndex: number;\n  _streamIndex: number; // Global stream index\n  _streamIndexInFolder: number; // Stream index within folder (for solid archives)\n  _hasStream: boolean;\n}\n\n/**\n * Archive source abstraction - allows reading from file descriptor or buffer\n */\nexport interface ArchiveSource {\n  read(position: number, length: number): Buffer;\n  getSize(): number;\n  close(): void;\n}\n\n/**\n * Buffer-based archive source\n */\nexport class BufferSource implements ArchiveSource {\n  private buffer: Buffer;\n\n  constructor(buffer: Buffer) {\n    this.buffer = buffer;\n  }\n\n  read(position: number, length: number): Buffer {\n    return this.buffer.slice(position, position + length);\n  }\n\n  getSize(): number {\n    return this.buffer.length;\n  }\n\n  close(): void {\n    // Nothing to close for buffer\n  }\n}\n\n/**\n * File descriptor based archive source\n */\nexport class FileSource implements ArchiveSource {\n  private fd: number;\n  private size: number;\n\n  constructor(fd: number, size: number) {\n    this.fd = fd;\n    this.size = size;\n  }\n\n  read(position: number, length: number): Buffer {\n    var buf = allocBuffer(length);\n    var bytesRead = fs.readSync(this.fd, buf, 0, length, position);\n    if (bytesRead < length) {\n      return buf.slice(0, bytesRead);\n    }\n    return buf;\n  }\n\n  getSize(): number {\n    return this.size;\n  }\n\n  close(): void {\n    try {\n      fs.closeSync(this.fd);\n    } catch (_e) {\n      // Ignore close errors\n    }\n  }\n}\n\n/**\n * SevenZipParser - parses 7z archives and provides entry iteration\n */\nexport class SevenZipParser {\n  private source: ArchiveSource;\n  private signature: SignatureHeader | null = null;\n  private streamsInfo: StreamsInfo | null = null;\n  private filesInfo: FileInfo[] = [];\n  private entries: SevenZipEntry[] = [];\n  private parsed = false;\n  // Cache for decompressed solid blocks (folderIndex -> decompressed data)\n  private decompressedCache: { [key: number]: Buffer } = {};\n\n  constructor(source: ArchiveSource) {\n    this.source = source;\n  }\n\n  /**\n   * Parse the archive structure\n   * Must be called before iterating entries\n   */\n  parse(): void {\n    if (this.parsed) return;\n\n    // Read signature header\n    var sigBuf = this.source.read(0, SIGNATURE_HEADER_SIZE);\n    if (sigBuf.length < SIGNATURE_HEADER_SIZE) {\n      throw createCodedError('Archive too small', ErrorCode.TRUNCATED_ARCHIVE);\n    }\n\n    this.signature = parseSignatureHeader(sigBuf);\n\n    // Read encoded header\n    var headerOffset = SIGNATURE_HEADER_SIZE + this.signature.nextHeaderOffset;\n    var headerBuf = this.source.read(headerOffset, this.signature.nextHeaderSize);\n\n    if (headerBuf.length < this.signature.nextHeaderSize) {\n      throw createCodedError('Truncated header', ErrorCode.TRUNCATED_ARCHIVE);\n    }\n\n    // Parse encoded header (may need decompression)\n    try {\n      var headerResult = parseEncodedHeader(headerBuf, this.signature.nextHeaderCRC);\n      this.streamsInfo = headerResult.streamsInfo || null;\n      this.filesInfo = headerResult.filesInfo;\n    } catch (err: unknown) {\n      var codedErr = err as CodedError;\n      if (codedErr && codedErr.code === ErrorCode.COMPRESSED_HEADER) {\n        // Header is compressed - need to decompress first\n        this.handleCompressedHeader(headerBuf);\n      } else {\n        throw err;\n      }\n    }\n\n    // Build entries list\n    this.buildEntries();\n    this.parsed = true;\n  }\n\n  /**\n   * Handle compressed header (kEncodedHeader)\n   */\n  private handleCompressedHeader(headerBuf: Buffer): void {\n    // Parse the encoded header info to get decompression parameters\n    var offset = 1; // Skip kEncodedHeader byte\n\n    // Should have StreamsInfo for the header itself\n    var propertyId = headerBuf[offset++];\n    if (propertyId !== PropertyId.kMainStreamsInfo && propertyId !== PropertyId.kPackInfo) {\n      throw createCodedError('Expected StreamsInfo in encoded header', ErrorCode.CORRUPT_HEADER);\n    }\n\n    // For now, we parse the streams info from the encoded header block\n    // This tells us how to decompress the actual header\n\n    // Read pack info from the encoded header structure\n    var packInfoResult = this.parseEncodedHeaderStreams(headerBuf, 1);\n\n    // Read the compressed header data\n    var compressedStart = SIGNATURE_HEADER_SIZE + packInfoResult.packPos;\n    var compressedData = this.source.read(compressedStart, packInfoResult.packSize);\n\n    // Decompress using the specified codec\n    var codec = getCodec(packInfoResult.codecId);\n    var decompressedHeader = codec.decode(compressedData, packInfoResult.properties, packInfoResult.unpackSize);\n\n    // Verify CRC if present\n    if (packInfoResult.unpackCRC !== undefined) {\n      var actualCRC = crc32(decompressedHeader);\n      if (actualCRC !== packInfoResult.unpackCRC) {\n        throw createCodedError('Decompressed header CRC mismatch', ErrorCode.CRC_MISMATCH);\n      }\n    }\n\n    // Now parse the decompressed header\n    // It should start with kHeader\n    var decompOffset = 0;\n    var headerId = decompressedHeader[decompOffset++];\n    if (headerId !== PropertyId.kHeader) {\n      throw createCodedError('Expected kHeader in decompressed header', ErrorCode.CORRUPT_HEADER);\n    }\n\n    // Parse the decompressed header using shared function from headers.ts\n    var result = parseHeaderContent(decompressedHeader, decompOffset);\n    this.streamsInfo = result.streamsInfo || null;\n    this.filesInfo = result.filesInfo;\n  }\n\n  /**\n   * Parse streams info from encoded header block\n   * This is a simplified parser for the header's own compression info\n   */\n  private parseEncodedHeaderStreams(\n    buf: Buffer,\n    offset: number\n  ): {\n    packPos: number;\n    packSize: number;\n    unpackSize: number;\n    codecId: number[];\n    properties?: Buffer;\n    unpackCRC?: number;\n  } {\n    // This is a simplified parser for the encoded header's own streams info\n    var packPos = 0;\n    var packSize = 0;\n    var unpackSize = 0;\n    var codecId: number[] = [];\n    var properties: Buffer | undefined;\n    var unpackCRC: number | undefined;\n\n    while (offset < buf.length) {\n      var propertyId = buf[offset++];\n\n      if (propertyId === PropertyId.kEnd) {\n        break;\n      }\n\n      switch (propertyId) {\n        case PropertyId.kPackInfo: {\n          var packPosResult = readNumber(buf, offset);\n          packPos = packPosResult.value;\n          offset += packPosResult.bytesRead;\n\n          var numPackResult = readNumber(buf, offset);\n          offset += numPackResult.bytesRead;\n\n          // Read until kEnd\n          while (buf[offset] !== PropertyId.kEnd) {\n            if (buf[offset] === PropertyId.kSize) {\n              offset++;\n              var sizeResult = readNumber(buf, offset);\n              packSize = sizeResult.value;\n              offset += sizeResult.bytesRead;\n            } else {\n              offset++;\n            }\n          }\n          offset++; // Skip kEnd\n          break;\n        }\n\n        case PropertyId.kUnpackInfo:\n          // Find folder/coder info\n          while (offset < buf.length && buf[offset] !== PropertyId.kEnd) {\n            if (buf[offset] === PropertyId.kFolder) {\n              offset++;\n              var numFoldersResult = readNumber(buf, offset);\n              offset += numFoldersResult.bytesRead;\n              offset++; // external flag\n\n              // Parse coder\n              var numCodersResult = readNumber(buf, offset);\n              offset += numCodersResult.bytesRead;\n\n              var flags = buf[offset++];\n              var idSize = flags & 0x0f;\n              var hasAttributes = (flags & 0x20) !== 0;\n\n              codecId = [];\n              for (var i = 0; i < idSize; i++) {\n                codecId.push(buf[offset++]);\n              }\n\n              if (hasAttributes) {\n                var propsLenResult = readNumber(buf, offset);\n                offset += propsLenResult.bytesRead;\n                properties = buf.slice(offset, offset + propsLenResult.value);\n                offset += propsLenResult.value;\n              }\n            } else if (buf[offset] === PropertyId.kCodersUnpackSize) {\n              offset++;\n              // Read unpack size - needed for LZMA decoder\n              var unpackSizeResult = readNumber(buf, offset);\n              unpackSize = unpackSizeResult.value;\n              offset += unpackSizeResult.bytesRead;\n            } else if (buf[offset] === PropertyId.kCRC) {\n              offset++;\n              var allDefined = buf[offset++];\n              if (allDefined) {\n                unpackCRC = buf.readUInt32LE(offset);\n                offset += 4;\n              }\n            } else {\n              offset++;\n            }\n          }\n          if (buf[offset] === PropertyId.kEnd) offset++;\n          break;\n      }\n    }\n\n    return { packPos: packPos, packSize: packSize, unpackSize: unpackSize, codecId: codecId, properties: properties, unpackCRC: unpackCRC };\n  }\n\n  /**\n   * Build the entries list from parsed file info\n   */\n  private buildEntries(): void {\n    this.entries = [];\n\n    if (!this.streamsInfo) {\n      // No streams info - just create entries from file info\n      for (var i = 0; i < this.filesInfo.length; i++) {\n        var file = this.filesInfo[i];\n        this.entries.push(this.createEntry(file, 0, 0, 0));\n      }\n      return;\n    }\n\n    // Use the properly parsed numUnpackStreamsPerFolder from the archive header\n    var streamsPerFolder = this.streamsInfo.numUnpackStreamsPerFolder;\n\n    // Now build entries with proper folder/stream tracking\n    var streamIndex = 0;\n    var folderIndex = 0;\n    var streamInFolder = 0;\n    var folderStreamCount = streamsPerFolder[0] || 0;\n\n    for (var j = 0; j < this.filesInfo.length; j++) {\n      var fileInfo = this.filesInfo[j];\n\n      // Get size from unpackSizes for files with streams\n      var size = 0;\n      if (fileInfo.hasStream && streamIndex < this.streamsInfo.unpackSizes.length) {\n        size = this.streamsInfo.unpackSizes[streamIndex];\n      }\n\n      var entry = this.createEntry(fileInfo, size, folderIndex, streamInFolder);\n      entry._streamIndex = streamIndex;\n      this.entries.push(entry);\n\n      // Advance stream tracking for files with streams\n      if (fileInfo.hasStream) {\n        streamIndex++;\n        streamInFolder++;\n\n        // Check if we've exhausted streams in this folder\n        if (streamInFolder >= folderStreamCount) {\n          folderIndex++;\n          streamInFolder = 0;\n          folderStreamCount = streamsPerFolder[folderIndex] || 0;\n        }\n      }\n    }\n  }\n\n  /**\n   * Create an entry from file info\n   */\n  private createEntry(file: FileInfo, size: number, folderIndex: number, streamInFolder: number): SevenZipEntry {\n    // Determine entry type\n    // Note: 7z format doesn't natively support symlinks. p7zip with -snl stores\n    // symlinks as regular files with the target path as content.\n    var type: 'file' | 'directory' | 'link' = 'file';\n    if (file.isDirectory) {\n      type = 'directory';\n    }\n\n    // Calculate mode from Windows attributes\n    var mode: number | undefined;\n    if (file.attributes !== undefined) {\n      // Check for Unix extension bit\n      if ((file.attributes & FileAttribute.UNIX_EXTENSION) !== 0) {\n        mode = (file.attributes >>> 16) & 0xffff;\n        // Check for symlink (S_IFLNK = 0xA000)\n        // Note: Most 7z implementations don't preserve symlink mode bits\n        if ((mode & 0xf000) === 0xa000) {\n          type = 'link';\n        }\n      } else if (file.isDirectory) {\n        mode = 493; // 0o755\n      } else {\n        mode = 420; // 0o644\n      }\n    }\n\n    return {\n      name: getBaseName(file.name),\n      path: file.name,\n      type: type,\n      size: size,\n      mtime: file.mtime,\n      atime: file.atime,\n      ctime: file.ctime,\n      mode: mode,\n      isAntiFile: file.isAntiFile,\n      _folderIndex: folderIndex,\n      _streamIndex: 0, // Set by caller\n      _streamIndexInFolder: streamInFolder,\n      _hasStream: file.hasStream,\n    };\n  }\n\n  /**\n   * Get the list of entries\n   */\n  getEntries(): SevenZipEntry[] {\n    if (!this.parsed) {\n      this.parse();\n    }\n    return this.entries;\n  }\n\n  /**\n   * Get a readable stream for an entry's content\n   */\n  getEntryStream(entry: SevenZipEntry): Readable {\n    if (!entry._hasStream || entry.type === 'directory') {\n      // Return empty stream for directories and empty files\n      var emptyStream = new PassThrough();\n      emptyStream.end();\n      return emptyStream;\n    }\n\n    if (!this.streamsInfo) {\n      throw createCodedError('No streams info available', ErrorCode.CORRUPT_HEADER);\n    }\n\n    // Get folder info\n    var folder = this.streamsInfo.folders[entry._folderIndex];\n    if (!folder) {\n      throw createCodedError('Invalid folder index', ErrorCode.CORRUPT_HEADER);\n    }\n\n    // Check codec support\n    for (var i = 0; i < folder.coders.length; i++) {\n      var coder = folder.coders[i];\n      if (!isCodecSupported(coder.id)) {\n        var codecName = getCodecName(coder.id);\n        throw createCodedError(`Unsupported codec: ${codecName}`, ErrorCode.UNSUPPORTED_CODEC);\n      }\n    }\n\n    // Get decompressed data for this folder (with caching for solid archives)\n    var data = this.getDecompressedFolder(entry._folderIndex);\n\n    // Calculate file offset within the decompressed block\n    // For solid archives, multiple files are concatenated in the block\n    var fileStart = 0;\n    for (var m = 0; m < entry._streamIndexInFolder; m++) {\n      // Sum sizes of all streams before this one in the folder\n      var prevStreamGlobalIndex = entry._streamIndex - entry._streamIndexInFolder + m;\n      fileStart += this.streamsInfo.unpackSizes[prevStreamGlobalIndex];\n    }\n\n    var fileSize = entry.size;\n\n    // Create a PassThrough stream with the file data\n    var outputStream = new PassThrough();\n    var fileData = data.slice(fileStart, fileStart + fileSize);\n    outputStream.end(fileData);\n\n    return outputStream;\n  }\n\n  /**\n   * Get decompressed data for a folder, with caching for solid archives\n   */\n  private getDecompressedFolder(folderIndex: number): Buffer {\n    // Check cache first\n    if (this.decompressedCache[folderIndex]) {\n      return this.decompressedCache[folderIndex];\n    }\n\n    if (!this.streamsInfo) {\n      throw createCodedError('No streams info available', ErrorCode.CORRUPT_HEADER);\n    }\n\n    var folder = this.streamsInfo.folders[folderIndex];\n\n    // Calculate packed data position\n    var packPos = SIGNATURE_HEADER_SIZE + this.streamsInfo.packPos;\n\n    // Find which pack stream this folder uses\n    var packStreamIndex = 0;\n    for (var j = 0; j < folderIndex; j++) {\n      packStreamIndex += this.streamsInfo.folders[j].packedStreams.length;\n    }\n\n    // Calculate position of this pack stream\n    for (var k = 0; k < packStreamIndex; k++) {\n      packPos += this.streamsInfo.packSizes[k];\n    }\n\n    var packSize = this.streamsInfo.packSizes[packStreamIndex];\n\n    // Read packed data\n    var packedData = this.source.read(packPos, packSize);\n\n    // Decompress through codec chain\n    var data = packedData;\n    for (var l = 0; l < folder.coders.length; l++) {\n      var coderInfo = folder.coders[l];\n      var codec = getCodec(coderInfo.id);\n      // Get unpack size for this coder (needed by LZMA)\n      var unpackSize = folder.unpackSizes[l];\n      data = codec.decode(data, coderInfo.properties, unpackSize);\n    }\n\n    // Cache for solid archives (when multiple files share a folder)\n    this.decompressedCache[folderIndex] = data;\n\n    return data;\n  }\n\n  /**\n   * Close the parser and release resources\n   */\n  close(): void {\n    if (this.source) {\n      this.source.close();\n    }\n  }\n}\n\n/**\n * Get base name from a path\n */\nfunction getBaseName(path: string): string {\n  var lastSlash = path.lastIndexOf('/');\n  var lastBackslash = path.lastIndexOf('\\\\');\n  var lastSep = Math.max(lastSlash, lastBackslash);\n  return lastSep >= 0 ? path.slice(lastSep + 1) : path;\n}\n"],"names":["allocBuffer","crc32","fs","PassThrough","getCodec","getCodecName","isCodecSupported","createCodedError","ErrorCode","FileAttribute","PropertyId","SIGNATURE_HEADER_SIZE","parseEncodedHeader","parseHeaderContent","parseSignatureHeader","readNumber","BufferSource","read","position","length","buffer","slice","getSize","close","FileSource","buf","bytesRead","readSync","fd","size","closeSync","_e","SevenZipParser","parse","parsed","sigBuf","source","TRUNCATED_ARCHIVE","signature","headerOffset","nextHeaderOffset","headerBuf","nextHeaderSize","headerResult","nextHeaderCRC","streamsInfo","filesInfo","err","codedErr","code","COMPRESSED_HEADER","handleCompressedHeader","buildEntries","offset","propertyId","kMainStreamsInfo","kPackInfo","CORRUPT_HEADER","packInfoResult","parseEncodedHeaderStreams","compressedStart","packPos","compressedData","packSize","codec","codecId","decompressedHeader","decode","properties","unpackSize","unpackCRC","undefined","actualCRC","CRC_MISMATCH","decompOffset","headerId","kHeader","result","kEnd","packPosResult","value","numPackResult","kSize","sizeResult","kUnpackInfo","kFolder","numFoldersResult","numCodersResult","flags","idSize","hasAttributes","i","push","propsLenResult","kCodersUnpackSize","unpackSizeResult","kCRC","allDefined","readUInt32LE","entries","file","createEntry","streamsPerFolder","numUnpackStreamsPerFolder","streamIndex","folderIndex","streamInFolder","folderStreamCount","j","fileInfo","hasStream","unpackSizes","entry","_streamIndex","type","isDirectory","mode","attributes","UNIX_EXTENSION","name","getBaseName","path","mtime","atime","ctime","isAntiFile","_folderIndex","_streamIndexInFolder","_hasStream","getEntries","getEntryStream","emptyStream","end","folder","folders","coders","coder","id","codecName","UNSUPPORTED_CODEC","data","getDecompressedFolder","fileStart","m","prevStreamGlobalIndex","fileSize","outputStream","fileData","decompressedCache","packStreamIndex","packedStreams","k","packSizes","packedData","l","coderInfo","lastSlash","lastIndexOf","lastBackslash","lastSep","Math","max"],"mappings":"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"}

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

@@ -0,0 +1,22 @@
+import type { Transform } from 'readable-stream';
+/**
+ * Set the password for AES decryption
+ */
+export declare function setPassword(password: string | null): void;
+/**
+ * Get the current password
+ */
+export declare function getPassword(): string | null;
+/**
+ * Decode AES-256-CBC encrypted data
+ *
+ * @param input - Encrypted data
+ * @param properties - AES properties (numCyclesPower, salt, IV)
+ * @param _unpackSize - Unused
+ * @returns Decrypted data
+ */
+export declare function decodeAes(input: Buffer, properties?: Buffer, _unpackSize?: number): Buffer;
+/**
+ * Create an AES decoder Transform stream
+ */
+export declare function createAesDecoder(properties?: Buffer, unpackSize?: number): Transform;

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

@@ -0,0 +1,162 @@
+// 7z AES-256-CBC codec with SHA-256 key derivation
+// Implements password-based decryption for encrypted 7z archives
+//
+// Properties format:
+//   Byte 0: bits 0-5 = NumCyclesPower (iterations = 2^NumCyclesPower)
+//           bit 6 = IV present flag
+//           bit 7 = Salt present flag
+//   Byte 1: upper nibble = salt size extension
+//           lower nibble = IV size extension
+//   Following bytes: salt data, then IV data
+//
+// Key derivation:
+//   For each round (2^NumCyclesPower times):
+//     hash = SHA256(salt + password_utf16le + round_counter_8bytes)
+//   Final key = first 32 bytes of accumulated hash
+import crypto from 'crypto';
+import { allocBuffer, bufferFrom } from 'extract-base-iterator';
+import createBufferingDecoder from './createBufferingDecoder.js';
+// Global password storage - set before decryption
+var _password = null;
+/**
+ * Set the password for AES decryption
+ */ export function setPassword(password) {
+    _password = password;
+}
+/**
+ * Get the current password
+ */ export function getPassword() {
+    return _password;
+}
+/**
+ * Parse AES properties to extract key derivation parameters
+ */ function parseProperties(properties) {
+    if (!properties || properties.length < 1) {
+        throw new Error('AES: missing properties');
+    }
+    var b0 = properties[0];
+    var numCyclesPower = b0 & 0x3f;
+    // Check for special case: no salt/IV flags
+    if ((b0 & 0xc0) === 0) {
+        // No salt, no IV - use zeros
+        return {
+            numCyclesPower: numCyclesPower,
+            salt: allocBuffer(0),
+            iv: allocBuffer(16)
+        };
+    }
+    if (properties.length < 2) {
+        throw new Error('AES: properties too short');
+    }
+    var b1 = properties[1];
+    // Calculate sizes
+    // saltSize = ((b0 >> 7) & 1) + (b1 >> 4)
+    // ivSize = ((b0 >> 6) & 1) + (b1 & 0x0F)
+    var saltSize = (b0 >>> 7 & 1) + (b1 >>> 4);
+    var ivSize = (b0 >>> 6 & 1) + (b1 & 0x0f);
+    var expectedSize = 2 + saltSize + ivSize;
+    if (properties.length < expectedSize) {
+        throw new Error('AES: properties too short for salt/IV');
+    }
+    var salt = properties.slice(2, 2 + saltSize);
+    var iv = allocBuffer(16);
+    // Copy IV data (may be less than 16 bytes, rest is zeros)
+    var ivData = properties.slice(2 + saltSize, 2 + saltSize + ivSize);
+    for(var i = 0; i < ivData.length && i < 16; i++){
+        iv[i] = ivData[i];
+    }
+    return {
+        numCyclesPower: numCyclesPower,
+        salt: salt,
+        iv: iv
+    };
+}
+/**
+ * Convert password string to UTF-16LE buffer
+ */ function passwordToUtf16LE(password) {
+    var buf = allocBuffer(password.length * 2);
+    for(var i = 0; i < password.length; i++){
+        var code = password.charCodeAt(i);
+        buf[i * 2] = code & 0xff;
+        buf[i * 2 + 1] = code >>> 8 & 0xff;
+    }
+    return buf;
+}
+/**
+ * Derive AES-256 key from password using 7z's SHA-256 iteration scheme
+ *
+ * Algorithm:
+ *   For round = 0 to 2^numCyclesPower - 1:
+ *     hash.update(salt)
+ *     hash.update(password_utf16le)
+ *     hash.update(round as 8-byte little-endian)
+ *   key = hash.digest()
+ */ function deriveKey(password, salt, numCyclesPower) {
+    var passwordBuf = passwordToUtf16LE(password);
+    var numRounds = 2 ** numCyclesPower;
+    // For special case 0x3F, don't iterate
+    if (numCyclesPower === 0x3f) {
+        // Direct concatenation mode
+        var key = allocBuffer(32);
+        var offset = 0;
+        for(var j = 0; j < salt.length && offset < 32; j++){
+            key[offset++] = salt[j];
+        }
+        for(var k = 0; k < passwordBuf.length && offset < 32; k++){
+            key[offset++] = passwordBuf[k];
+        }
+        return key;
+    }
+    // Counter buffer (8 bytes, little-endian)
+    var counter = allocBuffer(8);
+    // Create hash and iterate
+    var hash = crypto.createHash('sha256');
+    for(var round = 0; round < numRounds; round++){
+        // Write round counter as little-endian 64-bit
+        counter[0] = round & 0xff;
+        counter[1] = round >>> 8 & 0xff;
+        counter[2] = round >>> 16 & 0xff;
+        counter[3] = round >>> 24 & 0xff;
+        // Upper 32 bits - for large round counts
+        var high = Math.floor(round / 0x100000000);
+        counter[4] = high & 0xff;
+        counter[5] = high >>> 8 & 0xff;
+        counter[6] = high >>> 16 & 0xff;
+        counter[7] = high >>> 24 & 0xff;
+        hash.update(salt);
+        hash.update(passwordBuf);
+        hash.update(counter);
+    }
+    return hash.digest();
+}
+/**
+ * Decode AES-256-CBC encrypted data
+ *
+ * @param input - Encrypted data
+ * @param properties - AES properties (numCyclesPower, salt, IV)
+ * @param _unpackSize - Unused
+ * @returns Decrypted data
+ */ export function decodeAes(input, properties, _unpackSize) {
+    if (!_password) {
+        throw new Error('AES: password required but not set');
+    }
+    if (!properties) {
+        throw new Error('AES: properties required');
+    }
+    var params = parseProperties(properties);
+    var key = deriveKey(_password, params.salt, params.numCyclesPower);
+    // Create AES-256-CBC decipher
+    var decipher = crypto.createDecipheriv('aes-256-cbc', key, params.iv);
+    decipher.setAutoPadding(false); // 7z doesn't use PKCS7 padding
+    // Node 0.8 returns binary strings, newer Node returns Buffers
+    // Use 'binary' encoding for compatibility
+    // @ts-expect-error - 'binary' encoding is deprecated but required for Node 0.8 compatibility
+    var decStr = decipher.update(input, 'binary', 'binary') + decipher.final('binary');
+    var decrypted = bufferFrom(decStr, 'binary');
+    return decrypted;
+}
+/**
+ * Create an AES decoder Transform stream
+ */ export function createAesDecoder(properties, unpackSize) {
+    return createBufferingDecoder(decodeAes, properties, unpackSize);
+}