7z-iterator 0.1.0

package/dist/cjs/sevenz/NumberCodec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/sevenz/NumberCodec.ts"],"sourcesContent":["// Variable-length integer encoding for 7z format\n// Reference: https://py7zr.readthedocs.io/en/latest/archive_format.html\n//\n// 7z uses a space-efficient encoding where the first byte determines length:\n// 0xxxxxxx                    -> 1 byte  (0-127)\n// 10xxxxxx xxxxxxxx           -> 2 bytes (0-16383)\n// 110xxxxx + 2 bytes          -> 3 bytes\n// 1110xxxx + 3 bytes          -> 4 bytes\n// 11110xxx + 4 bytes          -> 5 bytes\n// 111110xx + 5 bytes          -> 6 bytes\n// 1111110x + 6 bytes          -> 7 bytes\n// 11111110 + 7 bytes          -> 8 bytes\n// 11111111 + 8 bytes          -> 9 bytes (full 64-bit)\n//\n// NOTE: Returns JavaScript number which is accurate up to 2^53 - 1 (~9 PB).\n// This covers all practical file sizes.\n\nimport { readUInt64LE } from 'extract-base-iterator';\n\nexport interface NumberReadResult {\n  value: number;\n  bytesRead: number;\n}\n\n/**\n * Read a variable-length encoded number from a buffer\n * @param buf - Buffer containing encoded number\n * @param offset - Offset to start reading from\n * @returns Object with value and number of bytes consumed\n */\nexport function readNumber(buf: Buffer, offset: number): NumberReadResult {\n  var firstByte = buf[offset];\n\n  // Count leading 1 bits to determine extra bytes\n  var mask = 0x80;\n  var extraBytes = 0;\n\n  while ((firstByte & mask) !== 0 && extraBytes < 8) {\n    extraBytes++;\n    mask = mask >>> 1;\n  }\n\n  // Special case: all 8 bits set means 8 extra bytes\n  if (extraBytes === 8) {\n    // Full 64-bit value follows\n    return {\n      value: readUInt64LE(buf, offset + 1),\n      bytesRead: 9,\n    };\n  }\n\n  // Mask off the length bits from first byte\n  var value = firstByte & ((mask - 1) | mask);\n\n  // Add remaining bytes (big-endian order)\n  for (var i = 0; i < extraBytes; i++) {\n    value = value * 256 + buf[offset + 1 + i];\n  }\n\n  return {\n    value: value,\n    bytesRead: 1 + extraBytes,\n  };\n}\n\n/**\n * Read a raw 64-bit little-endian number (used in some fixed-size fields)\n * @param buf - Buffer containing the number\n * @param offset - Offset to start reading from\n * @returns The number value\n */\nexport function readRawNumber(buf: Buffer, offset: number): number {\n  return readUInt64LE(buf, offset);\n}\n\n/**\n * Calculate the encoded size of a number\n * @param value - The number to encode\n * @returns Number of bytes needed to encode the value\n */\nexport function encodedSize(value: number): number {\n  if (value < 0x80) return 1; // 7 bits\n  if (value < 0x4000) return 2; // 14 bits\n  if (value < 0x200000) return 3; // 21 bits\n  if (value < 0x10000000) return 4; // 28 bits\n  if (value < 0x800000000) return 5; // 35 bits\n  if (value < 0x40000000000) return 6; // 42 bits\n  if (value < 0x2000000000000) return 7; // 49 bits\n  // 2^56 = 72057594037927936 (use calculated value to avoid precision loss)\n  if (value < 72057594037927936) return 8; // 56 bits\n  return 9; // 64 bits\n}\n\n/**\n * Read a boolean encoded as a single byte\n * @param buf - Buffer to read from\n * @param offset - Offset to read from\n * @returns true if byte is non-zero\n */\nexport function readBoolean(buf: Buffer, offset: number): boolean {\n  return buf[offset] !== 0;\n}\n\n/**\n * Read a \"defined\" bitmask for an array of items.\n * Used when some items in a list have optional values.\n *\n * Format: If \"allDefined\" byte is 0, a bitmask follows indicating which items have values.\n * If \"allDefined\" byte is non-zero, all items are defined.\n *\n * @param buf - Buffer to read from\n * @param offset - Offset to start reading\n * @param count - Number of items\n * @returns Object with defined array and bytes consumed\n */\nexport function readDefinedVector(buf: Buffer, offset: number, count: number): { defined: boolean[]; bytesRead: number } {\n  var allDefined = buf[offset] !== 0;\n  var bytesRead = 1;\n  var defined: boolean[] = [];\n\n  if (allDefined) {\n    // All items are defined\n    for (var i = 0; i < count; i++) {\n      defined.push(true);\n    }\n  } else {\n    // Read bitmask\n    var bitsNeeded = count;\n    var bytesNeeded = Math.ceil(bitsNeeded / 8);\n\n    for (var byteIdx = 0; byteIdx < bytesNeeded; byteIdx++) {\n      var byte = buf[offset + 1 + byteIdx];\n      for (var bit = 7; bit >= 0 && defined.length < count; bit--) {\n        defined.push((byte & (1 << bit)) !== 0);\n      }\n    }\n    bytesRead += bytesNeeded;\n  }\n\n  return { defined: defined, bytesRead: bytesRead };\n}\n\n/**\n * Read an array of variable-length numbers\n * @param buf - Buffer to read from\n * @param offset - Offset to start reading\n * @param count - Number of items to read\n * @returns Object with values array and bytes consumed\n */\nexport function readNumberArray(buf: Buffer, offset: number, count: number): { values: number[]; bytesRead: number } {\n  var values: number[] = [];\n  var totalBytesRead = 0;\n\n  for (var i = 0; i < count; i++) {\n    var result = readNumber(buf, offset + totalBytesRead);\n    values.push(result.value);\n    totalBytesRead += result.bytesRead;\n  }\n\n  return { values: values, bytesRead: totalBytesRead };\n}\n"],"names":["encodedSize","readBoolean","readDefinedVector","readNumber","readNumberArray","readRawNumber","buf","offset","firstByte","mask","extraBytes","value","readUInt64LE","bytesRead","i","count","allDefined","defined","push","bitsNeeded","bytesNeeded","Math","ceil","byteIdx","byte","bit","length","values","totalBytesRead","result"],"mappings":"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"}

package/dist/cjs/sevenz/SevenZipParser.d.cts

@@ -0,0 +1,96 @@
+import { type Readable } from 'readable-stream';
+export interface SevenZipEntry {
+    name: string;
+    path: string;
+    type: 'file' | 'directory' | 'link';
+    size: number;
+    mtime?: Date;
+    atime?: Date;
+    ctime?: Date;
+    mode?: number;
+    isAntiFile: boolean;
+    _folderIndex: number;
+    _streamIndex: number;
+    _streamIndexInFolder: number;
+    _hasStream: boolean;
+}
+/**
+ * Archive source abstraction - allows reading from file descriptor or buffer
+ */
+export interface ArchiveSource {
+    read(position: number, length: number): Buffer;
+    getSize(): number;
+    close(): void;
+}
+/**
+ * Buffer-based archive source
+ */
+export declare class BufferSource implements ArchiveSource {
+    private buffer;
+    constructor(buffer: Buffer);
+    read(position: number, length: number): Buffer;
+    getSize(): number;
+    close(): void;
+}
+/**
+ * File descriptor based archive source
+ */
+export declare class FileSource implements ArchiveSource {
+    private fd;
+    private size;
+    constructor(fd: number, size: number);
+    read(position: number, length: number): Buffer;
+    getSize(): number;
+    close(): void;
+}
+/**
+ * SevenZipParser - parses 7z archives and provides entry iteration
+ */
+export declare class SevenZipParser {
+    private source;
+    private signature;
+    private streamsInfo;
+    private filesInfo;
+    private entries;
+    private parsed;
+    private decompressedCache;
+    constructor(source: ArchiveSource);
+    /**
+     * Parse the archive structure
+     * Must be called before iterating entries
+     */
+    parse(): void;
+    /**
+     * Handle compressed header (kEncodedHeader)
+     */
+    private handleCompressedHeader;
+    /**
+     * Parse streams info from encoded header block
+     * This is a simplified parser for the header's own compression info
+     */
+    private parseEncodedHeaderStreams;
+    /**
+     * Build the entries list from parsed file info
+     */
+    private buildEntries;
+    /**
+     * Create an entry from file info
+     */
+    private createEntry;
+    /**
+     * Get the list of entries
+     */
+    getEntries(): SevenZipEntry[];
+    /**
+     * Get a readable stream for an entry's content
+     */
+    getEntryStream(entry: SevenZipEntry): Readable;
+    /**
+     * Get decompressed data for a folder, with caching for solid archives
+     */
+    private getDecompressedFolder;
+    /**
+     * Close the parser and release resources
+     */
+    close(): void;
+}

package/dist/cjs/sevenz/SevenZipParser.d.ts

@@ -0,0 +1,96 @@
+import { type Readable } from 'readable-stream';
+export interface SevenZipEntry {
+    name: string;
+    path: string;
+    type: 'file' | 'directory' | 'link';
+    size: number;
+    mtime?: Date;
+    atime?: Date;
+    ctime?: Date;
+    mode?: number;
+    isAntiFile: boolean;
+    _folderIndex: number;
+    _streamIndex: number;
+    _streamIndexInFolder: number;
+    _hasStream: boolean;
+}
+/**
+ * Archive source abstraction - allows reading from file descriptor or buffer
+ */
+export interface ArchiveSource {
+    read(position: number, length: number): Buffer;
+    getSize(): number;
+    close(): void;
+}
+/**
+ * Buffer-based archive source
+ */
+export declare class BufferSource implements ArchiveSource {
+    private buffer;
+    constructor(buffer: Buffer);
+    read(position: number, length: number): Buffer;
+    getSize(): number;
+    close(): void;
+}
+/**
+ * File descriptor based archive source
+ */
+export declare class FileSource implements ArchiveSource {
+    private fd;
+    private size;
+    constructor(fd: number, size: number);
+    read(position: number, length: number): Buffer;
+    getSize(): number;
+    close(): void;
+}
+/**
+ * SevenZipParser - parses 7z archives and provides entry iteration
+ */
+export declare class SevenZipParser {
+    private source;
+    private signature;
+    private streamsInfo;
+    private filesInfo;
+    private entries;
+    private parsed;
+    private decompressedCache;
+    constructor(source: ArchiveSource);
+    /**
+     * Parse the archive structure
+     * Must be called before iterating entries
+     */
+    parse(): void;
+    /**
+     * Handle compressed header (kEncodedHeader)
+     */
+    private handleCompressedHeader;
+    /**
+     * Parse streams info from encoded header block
+     * This is a simplified parser for the header's own compression info
+     */
+    private parseEncodedHeaderStreams;
+    /**
+     * Build the entries list from parsed file info
+     */
+    private buildEntries;
+    /**
+     * Create an entry from file info
+     */
+    private createEntry;
+    /**
+     * Get the list of entries
+     */
+    getEntries(): SevenZipEntry[];
+    /**
+     * Get a readable stream for an entry's content
+     */
+    getEntryStream(entry: SevenZipEntry): Readable;
+    /**
+     * Get decompressed data for a folder, with caching for solid archives
+     */
+    private getDecompressedFolder;
+    /**
+     * Close the parser and release resources
+     */
+    close(): void;
+}

package/dist/cjs/sevenz/SevenZipParser.js

@@ -0,0 +1,457 @@
+// SevenZipParser - Main 7z archive parser
+// Handles reading archive structure and providing file streams
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get BufferSource () {
+        return BufferSource;
+    },
+    get FileSource () {
+        return FileSource;
+    },
+    get SevenZipParser () {
+        return SevenZipParser;
+    }
+});
+var _extractbaseiterator = require("extract-base-iterator");
+var _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+var _readablestream = require("readable-stream");
+var _indexts = require("./codecs/index.js");
+var _constantsts = require("./constants.js");
+var _headersts = require("./headers.js");
+var _NumberCodects = require("./NumberCodec.js");
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var BufferSource = /*#__PURE__*/ function() {
+    "use strict";
+    function BufferSource(buffer) {
+        _class_call_check(this, BufferSource);
+        this.buffer = buffer;
+    }
+    var _proto = BufferSource.prototype;
+    _proto.read = function read(position, length) {
+        return this.buffer.slice(position, position + length);
+    };
+    _proto.getSize = function getSize() {
+        return this.buffer.length;
+    };
+    _proto.close = function close() {
+    // Nothing to close for buffer
+    };
+    return BufferSource;
+}();
+var FileSource = /*#__PURE__*/ function() {
+    "use strict";
+    function FileSource(fd, size) {
+        _class_call_check(this, FileSource);
+        this.fd = fd;
+        this.size = size;
+    }
+    var _proto = FileSource.prototype;
+    _proto.read = function read(position, length) {
+        var buf = (0, _extractbaseiterator.allocBuffer)(length);
+        var bytesRead = _fs.default.readSync(this.fd, buf, 0, length, position);
+        if (bytesRead < length) {
+            return buf.slice(0, bytesRead);
+        }
+        return buf;
+    };
+    _proto.getSize = function getSize() {
+        return this.size;
+    };
+    _proto.close = function close() {
+        try {
+            _fs.default.closeSync(this.fd);
+        } catch (_e) {
+        // Ignore close errors
+        }
+    };
+    return FileSource;
+}();
+var SevenZipParser = /*#__PURE__*/ function() {
+    "use strict";
+    function SevenZipParser(source) {
+        _class_call_check(this, SevenZipParser);
+        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;
+    }
+    var _proto = SevenZipParser.prototype;
+    /**
+   * Parse the archive structure
+   * Must be called before iterating entries
+   */ _proto.parse = function parse() {
+        if (this.parsed) return;
+        // Read signature header
+        var sigBuf = this.source.read(0, _constantsts.SIGNATURE_HEADER_SIZE);
+        if (sigBuf.length < _constantsts.SIGNATURE_HEADER_SIZE) {
+            throw (0, _constantsts.createCodedError)('Archive too small', _constantsts.ErrorCode.TRUNCATED_ARCHIVE);
+        }
+        this.signature = (0, _headersts.parseSignatureHeader)(sigBuf);
+        // Read encoded header
+        var headerOffset = _constantsts.SIGNATURE_HEADER_SIZE + this.signature.nextHeaderOffset;
+        var headerBuf = this.source.read(headerOffset, this.signature.nextHeaderSize);
+        if (headerBuf.length < this.signature.nextHeaderSize) {
+            throw (0, _constantsts.createCodedError)('Truncated header', _constantsts.ErrorCode.TRUNCATED_ARCHIVE);
+        }
+        // Parse encoded header (may need decompression)
+        try {
+            var headerResult = (0, _headersts.parseEncodedHeader)(headerBuf, this.signature.nextHeaderCRC);
+            this.streamsInfo = headerResult.streamsInfo || null;
+            this.filesInfo = headerResult.filesInfo;
+        } catch (err) {
+            var codedErr = err;
+            if (codedErr && codedErr.code === _constantsts.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)
+   */ _proto.handleCompressedHeader = function 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 !== _constantsts.PropertyId.kMainStreamsInfo && propertyId !== _constantsts.PropertyId.kPackInfo) {
+            throw (0, _constantsts.createCodedError)('Expected StreamsInfo in encoded header', _constantsts.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 = _constantsts.SIGNATURE_HEADER_SIZE + packInfoResult.packPos;
+        var compressedData = this.source.read(compressedStart, packInfoResult.packSize);
+        // Decompress using the specified codec
+        var codec = (0, _indexts.getCodec)(packInfoResult.codecId);
+        var decompressedHeader = codec.decode(compressedData, packInfoResult.properties, packInfoResult.unpackSize);
+        // Verify CRC if present
+        if (packInfoResult.unpackCRC !== undefined) {
+            var actualCRC = (0, _extractbaseiterator.crc32)(decompressedHeader);
+            if (actualCRC !== packInfoResult.unpackCRC) {
+                throw (0, _constantsts.createCodedError)('Decompressed header CRC mismatch', _constantsts.ErrorCode.CRC_MISMATCH);
+            }
+        }
+        // Now parse the decompressed header
+        // It should start with kHeader
+        var decompOffset = 0;
+        var headerId = decompressedHeader[decompOffset++];
+        if (headerId !== _constantsts.PropertyId.kHeader) {
+            throw (0, _constantsts.createCodedError)('Expected kHeader in decompressed header', _constantsts.ErrorCode.CORRUPT_HEADER);
+        }
+        // Parse the decompressed header using shared function from headers.ts
+        var result = (0, _headersts.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
+   */ _proto.parseEncodedHeaderStreams = function 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 === _constantsts.PropertyId.kEnd) {
+                break;
+            }
+            switch(propertyId){
+                case _constantsts.PropertyId.kPackInfo:
+                    {
+                        var packPosResult = (0, _NumberCodects.readNumber)(buf, offset);
+                        packPos = packPosResult.value;
+                        offset += packPosResult.bytesRead;
+                        var numPackResult = (0, _NumberCodects.readNumber)(buf, offset);
+                        offset += numPackResult.bytesRead;
+                        // Read until kEnd
+                        while(buf[offset] !== _constantsts.PropertyId.kEnd){
+                            if (buf[offset] === _constantsts.PropertyId.kSize) {
+                                offset++;
+                                var sizeResult = (0, _NumberCodects.readNumber)(buf, offset);
+                                packSize = sizeResult.value;
+                                offset += sizeResult.bytesRead;
+                            } else {
+                                offset++;
+                            }
+                        }
+                        offset++; // Skip kEnd
+                        break;
+                    }
+                case _constantsts.PropertyId.kUnpackInfo:
+                    // Find folder/coder info
+                    while(offset < buf.length && buf[offset] !== _constantsts.PropertyId.kEnd){
+                        if (buf[offset] === _constantsts.PropertyId.kFolder) {
+                            offset++;
+                            var numFoldersResult = (0, _NumberCodects.readNumber)(buf, offset);
+                            offset += numFoldersResult.bytesRead;
+                            offset++; // external flag
+                            // Parse coder
+                            var numCodersResult = (0, _NumberCodects.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 = (0, _NumberCodects.readNumber)(buf, offset);
+                                offset += propsLenResult.bytesRead;
+                                properties = buf.slice(offset, offset + propsLenResult.value);
+                                offset += propsLenResult.value;
+                            }
+                        } else if (buf[offset] === _constantsts.PropertyId.kCodersUnpackSize) {
+                            offset++;
+                            // Read unpack size - needed for LZMA decoder
+                            var unpackSizeResult = (0, _NumberCodects.readNumber)(buf, offset);
+                            unpackSize = unpackSizeResult.value;
+                            offset += unpackSizeResult.bytesRead;
+                        } else if (buf[offset] === _constantsts.PropertyId.kCRC) {
+                            offset++;
+                            var allDefined = buf[offset++];
+                            if (allDefined) {
+                                unpackCRC = buf.readUInt32LE(offset);
+                                offset += 4;
+                            }
+                        } else {
+                            offset++;
+                        }
+                    }
+                    if (buf[offset] === _constantsts.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
+   */ _proto.buildEntries = function 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
+   */ _proto.createEntry = function 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 & _constantsts.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
+   */ _proto.getEntries = function getEntries() {
+        if (!this.parsed) {
+            this.parse();
+        }
+        return this.entries;
+    };
+    /**
+   * Get a readable stream for an entry's content
+   */ _proto.getEntryStream = function getEntryStream(entry) {
+        if (!entry._hasStream || entry.type === 'directory') {
+            // Return empty stream for directories and empty files
+            var emptyStream = new _readablestream.PassThrough();
+            emptyStream.end();
+            return emptyStream;
+        }
+        if (!this.streamsInfo) {
+            throw (0, _constantsts.createCodedError)('No streams info available', _constantsts.ErrorCode.CORRUPT_HEADER);
+        }
+        // Get folder info
+        var folder = this.streamsInfo.folders[entry._folderIndex];
+        if (!folder) {
+            throw (0, _constantsts.createCodedError)('Invalid folder index', _constantsts.ErrorCode.CORRUPT_HEADER);
+        }
+        // Check codec support
+        for(var i = 0; i < folder.coders.length; i++){
+            var coder = folder.coders[i];
+            if (!(0, _indexts.isCodecSupported)(coder.id)) {
+                var codecName = (0, _indexts.getCodecName)(coder.id);
+                throw (0, _constantsts.createCodedError)("Unsupported codec: ".concat(codecName), _constantsts.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 _readablestream.PassThrough();
+        var fileData = data.slice(fileStart, fileStart + fileSize);
+        outputStream.end(fileData);
+        return outputStream;
+    };
+    /**
+   * Get decompressed data for a folder, with caching for solid archives
+   */ _proto.getDecompressedFolder = function getDecompressedFolder(folderIndex) {
+        // Check cache first
+        if (this.decompressedCache[folderIndex]) {
+            return this.decompressedCache[folderIndex];
+        }
+        if (!this.streamsInfo) {
+            throw (0, _constantsts.createCodedError)('No streams info available', _constantsts.ErrorCode.CORRUPT_HEADER);
+        }
+        var folder = this.streamsInfo.folders[folderIndex];
+        // Calculate packed data position
+        var packPos = _constantsts.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 = (0, _indexts.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
+   */ _proto.close = function close() {
+        if (this.source) {
+            this.source.close();
+        }
+    };
+    return SevenZipParser;
+}();
+/**
+ * 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;
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }