7z-iterator 0.1.0

package/dist/esm/sevenz/headers.js

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