@push.rocks/smartarchive 5.2.3 → 5.3.0

package/dist_ts_shared/classes.ziptools.js

@@ -1,57 +1,521 @@
-import * as plugins from './plugins.js';
-/**
- * Transform stream for ZIP decompression using fflate
- * Emits StreamFile objects for each file in the archive
- */
-export class ZipDecompressionTransform extends plugins.smartstream.SmartDuplex {
-    constructor() {
-        super({
-            objectMode: true,
-            writeFunction: async (chunkArg, streamtoolsArg) => {
-                this.streamtools ? null : (this.streamtools = streamtoolsArg);
-                const chunk = chunkArg instanceof Uint8Array ? chunkArg : new Uint8Array(chunkArg);
-                this.unzipper.push(chunk, false);
-                return null;
-            },
-            finalFunction: async () => {
-                this.unzipper.push(new Uint8Array(0), true);
-                await plugins.smartdelay.delayFor(0);
-                await this.streamtools.push(null);
-                return null;
-            },
-        });
-        this.unzipper = new plugins.fflate.Unzip(async (fileArg) => {
-            let resultBuffer;
-            fileArg.ondata = async (_flateError, dat, final) => {
-                if (resultBuffer) {
-                    const combined = new Uint8Array(resultBuffer.length + dat.length);
-                    combined.set(resultBuffer);
-                    combined.set(dat, resultBuffer.length);
-                    resultBuffer = combined;
-                }
-                else {
-                    resultBuffer = new Uint8Array(dat);
-                }
-                if (final) {
-                    const streamFile = plugins.smartfile.StreamFile.fromBuffer(Buffer.from(resultBuffer));
-                    streamFile.relativeFilePath = fileArg.name;
-                    this.streamtools.push(streamFile);
-                }
-            };
-            fileArg.start();
+import * as plugins from './plugins.ziptools.js';
+import { ZIP_ERROR_CODES, ZipError } from './errors.js';
+const ZIP_LOCAL_FILE_HEADER_SIGNATURE = 0x04034b50;
+const ZIP_CENTRAL_DIRECTORY_SIGNATURE = 0x02014b50;
+const ZIP_END_OF_CENTRAL_DIRECTORY_SIGNATURE = 0x06054b50;
+const ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIGNATURE = 0x07064b50;
+const ZIP_DATA_DESCRIPTOR_SIGNATURE = 0x08074b50;
+const ZIP64_EXTRA_FIELD_ID = 0x0001;
+const ZIP_UNICODE_PATH_EXTRA_FIELD_ID = 0x7075;
+const ZIP_ALLOWED_GENERAL_PURPOSE_FLAGS = 0x080e;
+const PAKO_INPUT_CHUNK_BYTES = 16 * 1024;
+const PAKO_OUTPUT_CHUNK_BYTES = 16 * 1024;
+const crc32Table = (() => {
+    const table = new Uint32Array(256);
+    for (let index = 0; index < table.length; index++) {
+        let value = index;
+        for (let bit = 0; bit < 8; bit++) {
+            value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+        }
+        table[index] = value >>> 0;
+    }
+    return table;
+})();
+function throwInvalidZip(message) {
+    throw new ZipError(message, ZIP_ERROR_CODES.INVALID_ARCHIVE);
+}
+function throwUnsupportedZip(message) {
+    throw new ZipError(message, ZIP_ERROR_CODES.UNSUPPORTED_FEATURE);
+}
+function checkedEnd(data, offset, length) {
+    const end = offset + length;
+    if (!Number.isSafeInteger(offset) ||
+        !Number.isSafeInteger(length) ||
+        offset < 0 ||
+        length < 0 ||
+        !Number.isSafeInteger(end) ||
+        end > data.length) {
+        throwInvalidZip('ZIP record extends beyond the archive');
+    }
+    return end;
+}
+function readUint16(data, offset) {
+    checkedEnd(data, offset, 2);
+    return data[offset] | (data[offset + 1] << 8);
+}
+function readUint32(data, offset) {
+    checkedEnd(data, offset, 4);
+    return (data[offset] |
+        (data[offset + 1] << 8) |
+        (data[offset + 2] << 16) |
+        (data[offset + 3] << 24)) >>> 0;
+}
+function equalBytes(first, second) {
+    if (first.length !== second.length)
+        return false;
+    for (let index = 0; index < first.length; index++) {
+        if (first[index] !== second[index])
+            return false;
+    }
+    return true;
+}
+function validateExtraFields(data, offset, length) {
+    const end = checkedEnd(data, offset, length);
+    let cursor = offset;
+    while (cursor < end) {
+        if (cursor + 4 > end) {
+            throwInvalidZip('ZIP extra field header is truncated');
+        }
+        const fieldId = readUint16(data, cursor);
+        const fieldLength = readUint16(data, cursor + 2);
+        cursor += 4;
+        if (cursor + fieldLength > end) {
+            throwInvalidZip('ZIP extra field data is truncated');
+        }
+        if (fieldId === ZIP64_EXTRA_FIELD_ID) {
+            throwUnsupportedZip('ZIP64 entries are not supported by bounded extraction');
+        }
+        if (fieldId === ZIP_UNICODE_PATH_EXTRA_FIELD_ID) {
+            throwUnsupportedZip('ZIP Unicode path extra fields are not supported by bounded extraction');
+        }
+        cursor += fieldLength;
+    }
+}
+function decodeZipPath(rawPath, flags) {
+    if (!rawPath.length) {
+        throwInvalidZip('ZIP entry path is empty');
+    }
+    let path;
+    if (flags & 0x0800) {
+        try {
+            path = new TextDecoder('utf-8', { fatal: true }).decode(rawPath);
+        }
+        catch {
+            throwInvalidZip('ZIP entry path is not valid UTF-8');
+        }
+    }
+    else {
+        if (rawPath.some(byte => byte > 0x7f)) {
+            throwUnsupportedZip('ZIP entry paths without the UTF-8 flag must be ASCII');
+        }
+        path = new TextDecoder().decode(rawPath);
+    }
+    if (path.includes('\0')) {
+        throwInvalidZip('ZIP entry path contains a NUL byte');
+    }
+    if (path.includes('\\') || path.startsWith('/') || /^[A-Za-z]:/.test(path)) {
+        throwInvalidZip('ZIP entry path is not relative');
+    }
+    const isDirectory = path.endsWith('/');
+    const pathSegments = path.split('/');
+    if (isDirectory)
+        pathSegments.pop();
+    if (!pathSegments.length ||
+        pathSegments.some(segment => !segment || segment === '.' || segment === '..')) {
+        throwInvalidZip('ZIP entry path contains an invalid segment');
+    }
+    return path;
+}
+function findZipEndRecord(data, maxEntries) {
+    if (data.length < 22) {
+        throwInvalidZip('ZIP end record is missing');
+    }
+    const candidates = [];
+    const earliestOffset = Math.max(0, data.length - 22 - 0xffff);
+    for (let offset = data.length - 22; offset >= earliestOffset; offset--) {
+        if (readUint32(data, offset) !== ZIP_END_OF_CENTRAL_DIRECTORY_SIGNATURE)
+            continue;
+        const commentLength = readUint16(data, offset + 20);
+        if (offset + 22 + commentLength === data.length) {
+            candidates.push(offset);
+        }
+    }
+    if (candidates.length !== 1) {
+        throwInvalidZip(candidates.length ? 'ZIP end record is ambiguous' : 'ZIP end record is missing');
+    }
+    const offset = candidates[0];
+    const diskNumber = readUint16(data, offset + 4);
+    const centralDirectoryDisk = readUint16(data, offset + 6);
+    const entriesOnDisk = readUint16(data, offset + 8);
+    const entryCount = readUint16(data, offset + 10);
+    const centralDirectorySize = readUint32(data, offset + 12);
+    const centralDirectoryOffset = readUint32(data, offset + 16);
+    if (diskNumber === 0xffff ||
+        centralDirectoryDisk === 0xffff ||
+        entriesOnDisk === 0xffff ||
+        entryCount === 0xffff ||
+        centralDirectorySize === 0xffffffff ||
+        centralDirectoryOffset === 0xffffffff) {
+        throwUnsupportedZip('ZIP64 archives are not supported by bounded extraction');
+    }
+    if (diskNumber !== 0 || centralDirectoryDisk !== 0 || entriesOnDisk !== entryCount) {
+        throwUnsupportedZip('Split ZIP archives are not supported by bounded extraction');
+    }
+    if (offset >= 20 &&
+        readUint32(data, offset - 20) === ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIGNATURE) {
+        throwUnsupportedZip('ZIP64 archives are not supported by bounded extraction');
+    }
+    if (entryCount > maxEntries) {
+        throw new ZipError(`ZIP contains ${entryCount} entries, exceeding the configured limit`, ZIP_ERROR_CODES.ENTRY_COUNT_LIMIT);
+    }
+    const centralDirectoryEnd = checkedEnd(data, centralDirectoryOffset, centralDirectorySize);
+    if (centralDirectoryEnd !== offset) {
+        throwInvalidZip('ZIP central directory range is inconsistent');
+    }
+    return {
+        offset,
+        entryCount,
+        centralDirectoryOffset,
+        centralDirectorySize,
+    };
+}
+function validateGeneralPurposeFlags(flags, compressionMethod) {
+    if (flags & ~ZIP_ALLOWED_GENERAL_PURPOSE_FLAGS) {
+        throwUnsupportedZip('ZIP entry uses unsupported general-purpose flags');
+    }
+    if (compressionMethod !== 8 && flags & 0x0006) {
+        throwUnsupportedZip('ZIP compression flags are only supported for DEFLATE entries');
+    }
+}
+function parseDataDescriptor(data, dataEnd, centralDirectoryOffset, entry) {
+    const candidates = [];
+    const matchesDescriptorAt = (offset) => {
+        if (offset + 12 > centralDirectoryOffset)
+            return null;
+        if (readUint32(data, offset) !== entry.crc32 ||
+            readUint32(data, offset + 4) !== entry.compressedSize ||
+            readUint32(data, offset + 8) !== entry.uncompressedSize) {
+            return null;
+        }
+        return offset + 12;
+    };
+    const unsignedEnd = matchesDescriptorAt(dataEnd);
+    if (unsignedEnd !== null)
+        candidates.push(unsignedEnd);
+    if (dataEnd + 4 <= centralDirectoryOffset &&
+        readUint32(data, dataEnd) === ZIP_DATA_DESCRIPTOR_SIGNATURE) {
+        const signedEnd = matchesDescriptorAt(dataEnd + 4);
+        if (signedEnd !== null)
+            candidates.push(signedEnd);
+    }
+    if (candidates.length !== 1) {
+        throwInvalidZip(candidates.length
+            ? 'ZIP data descriptor is ambiguous'
+            : 'ZIP data descriptor does not match the central directory');
+    }
+    return candidates[0];
+}
+function parseZipEntries(data, maxEntries) {
+    const endRecord = findZipEndRecord(data, maxEntries);
+    const centralDirectoryEnd = endRecord.centralDirectoryOffset + endRecord.centralDirectorySize;
+    const entries = [];
+    const localOffsets = new Set();
+    let cursor = endRecord.centralDirectoryOffset;
+    for (let entryIndex = 0; entryIndex < endRecord.entryCount; entryIndex++) {
+        if (readUint32(data, cursor) !== ZIP_CENTRAL_DIRECTORY_SIGNATURE) {
+            throwInvalidZip('ZIP central directory entry signature is invalid');
+        }
+        checkedEnd(data, cursor, 46);
+        const versionNeeded = readUint16(data, cursor + 6);
+        const flags = readUint16(data, cursor + 8);
+        const compressionMethod = readUint16(data, cursor + 10);
+        const modificationTime = readUint16(data, cursor + 12);
+        const modificationDate = readUint16(data, cursor + 14);
+        const crc32 = readUint32(data, cursor + 16);
+        const compressedSize = readUint32(data, cursor + 20);
+        const uncompressedSize = readUint32(data, cursor + 24);
+        const pathLength = readUint16(data, cursor + 28);
+        const extraLength = readUint16(data, cursor + 30);
+        const commentLength = readUint16(data, cursor + 32);
+        const diskNumberStart = readUint16(data, cursor + 34);
+        const localHeaderOffset = readUint32(data, cursor + 42);
+        if (compressedSize === 0xffffffff ||
+            uncompressedSize === 0xffffffff ||
+            diskNumberStart === 0xffff ||
+            localHeaderOffset === 0xffffffff) {
+            throwUnsupportedZip('ZIP64 entries are not supported by bounded extraction');
+        }
+        if (diskNumberStart !== 0) {
+            throwUnsupportedZip('Split ZIP entries are not supported by bounded extraction');
+        }
+        validateGeneralPurposeFlags(flags, compressionMethod);
+        if (compressionMethod === 0 || compressionMethod === 8) {
+            const minimumVersion = compressionMethod === 8 || (flags & 0x0008) !== 0 ? 20 : 10;
+            if (versionNeeded < minimumVersion) {
+                throwInvalidZip('ZIP entry declares an insufficient extraction version');
+            }
+            if (versionNeeded > 20) {
+                throwUnsupportedZip('ZIP entry requires features outside the bounded subset');
+            }
+        }
+        if (compressionMethod === 0 && compressedSize !== uncompressedSize) {
+            throwInvalidZip('ZIP stored entry has inconsistent sizes');
+        }
+        const pathOffset = cursor + 46;
+        const extraOffset = checkedEnd(data, pathOffset, pathLength);
+        const commentOffset = checkedEnd(data, extraOffset, extraLength);
+        const nextCursor = checkedEnd(data, commentOffset, commentLength);
+        if (nextCursor > centralDirectoryEnd) {
+            throwInvalidZip('ZIP central directory entry exceeds the central directory');
+        }
+        const rawPath = data.subarray(pathOffset, extraOffset);
+        const path = decodeZipPath(rawPath, flags);
+        validateExtraFields(data, extraOffset, extraLength);
+        if (localOffsets.has(localHeaderOffset)) {
+            throwInvalidZip('ZIP entries reference the same local header');
+        }
+        localOffsets.add(localHeaderOffset);
+        if (localHeaderOffset >= endRecord.centralDirectoryOffset) {
+            throwInvalidZip('ZIP local header intersects the central directory');
+        }
+        if (readUint32(data, localHeaderOffset) !== ZIP_LOCAL_FILE_HEADER_SIGNATURE) {
+            throwInvalidZip('ZIP local file header signature is invalid');
+        }
+        checkedEnd(data, localHeaderOffset, 30);
+        const localVersionNeeded = readUint16(data, localHeaderOffset + 4);
+        const localFlags = readUint16(data, localHeaderOffset + 6);
+        const localCompressionMethod = readUint16(data, localHeaderOffset + 8);
+        const localModificationTime = readUint16(data, localHeaderOffset + 10);
+        const localModificationDate = readUint16(data, localHeaderOffset + 12);
+        const localCrc32 = readUint32(data, localHeaderOffset + 14);
+        const localCompressedSize = readUint32(data, localHeaderOffset + 18);
+        const localUncompressedSize = readUint32(data, localHeaderOffset + 22);
+        const localPathLength = readUint16(data, localHeaderOffset + 26);
+        const localExtraLength = readUint16(data, localHeaderOffset + 28);
+        const localPathOffset = localHeaderOffset + 30;
+        const localExtraOffset = checkedEnd(data, localPathOffset, localPathLength);
+        const dataStart = checkedEnd(data, localExtraOffset, localExtraLength);
+        const dataEnd = checkedEnd(data, dataStart, compressedSize);
+        if (dataEnd > endRecord.centralDirectoryOffset) {
+            throwInvalidZip('ZIP local file data intersects the central directory');
+        }
+        if (localVersionNeeded !== versionNeeded ||
+            localFlags !== flags ||
+            localCompressionMethod !== compressionMethod ||
+            localModificationTime !== modificationTime ||
+            localModificationDate !== modificationDate) {
+            throwInvalidZip('ZIP local and central entry metadata differ');
+        }
+        const localRawPath = data.subarray(localPathOffset, localExtraOffset);
+        if (!equalBytes(localRawPath, rawPath)) {
+            throwInvalidZip('ZIP local and central entry paths differ');
+        }
+        validateExtraFields(data, localExtraOffset, localExtraLength);
+        let localRecordEnd = dataEnd;
+        if (flags & 0x0008) {
+            if (localCrc32 !== 0 || localCompressedSize !== 0 || localUncompressedSize !== 0) {
+                throwInvalidZip('ZIP data-descriptor entry has non-zero local size metadata');
+            }
+            localRecordEnd = parseDataDescriptor(data, dataEnd, endRecord.centralDirectoryOffset, {
+                crc32,
+                compressedSize,
+                uncompressedSize,
+            });
+        }
+        else if (localCrc32 !== crc32 ||
+            localCompressedSize !== compressedSize ||
+            localUncompressedSize !== uncompressedSize) {
+            throwInvalidZip('ZIP local sizes or CRC differ from the central directory');
+        }
+        entries.push({
+            path,
+            rawPath,
+            flags,
+            compressionMethod,
+            crc32,
+            compressedSize,
+            uncompressedSize,
+            localHeaderOffset,
+            dataStart,
+            dataEnd,
+            localRecordEnd,
+            isDirectory: path.endsWith('/'),
         });
-        this.unzipper.register(plugins.fflate.UnzipInflate);
+        cursor = nextCursor;
+    }
+    if (cursor !== centralDirectoryEnd) {
+        throwUnsupportedZip('ZIP central directory signatures are not supported by bounded extraction');
+    }
+    const entriesByLocalOffset = [...entries].sort((first, second) => first.localHeaderOffset - second.localHeaderOffset);
+    for (let index = 1; index < entriesByLocalOffset.length; index++) {
+        if (entriesByLocalOffset[index - 1].localRecordEnd >
+            entriesByLocalOffset[index].localHeaderOffset) {
+            throwInvalidZip('ZIP local file records overlap');
+        }
+    }
+    return entries;
+}
+function validateSelectiveOptions(options) {
+    if (!options || typeof options.filter !== 'function') {
+        throw new ZipError('ZIP extraction filter must be a function', ZIP_ERROR_CODES.INVALID_LIMIT);
+    }
+    const limits = [
+        options.maxArchiveBytes,
+        options.maxEntries,
+        options.maxSelectedEntries,
+        options.maxCompressedEntryBytes,
+        options.maxUncompressedEntryBytes,
+        options.maxTotalUncompressedBytes,
+    ];
+    if (limits.some(limit => !Number.isSafeInteger(limit) || limit < 1)) {
+        throw new ZipError('ZIP extraction limits must be positive safe integers', ZIP_ERROR_CODES.INVALID_LIMIT);
+    }
+}
+function updateCrc32(crc, data) {
+    let nextCrc = crc;
+    for (const byte of data) {
+        nextCrc = crc32Table[(nextCrc ^ byte) & 0xff] ^ (nextCrc >>> 8);
+    }
+    return nextCrc >>> 0;
+}
+function combineChunks(chunks, byteLength) {
+    const result = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
     }
+    return result;
 }
 /**
  * ZIP compression and decompression utilities
  */
 export class ZipTools {
     /**
-     * Get a streaming decompression transform for extracting ZIP archives
+     * Extract selected entries from a strict, bounded ZIP subset.
+     *
+     * This security-focused API accepts single-disk, non-ZIP64 archives and
+     * decompresses only entries selected from validated central-directory metadata.
      */
-    getDecompressionStream() {
-        return new ZipDecompressionTransform();
+    async extractSelectedZipEntries(data, options) {
+        validateSelectiveOptions(options);
+        if (!(data instanceof Uint8Array)) {
+            throw new ZipError('ZIP archive must be a Uint8Array', ZIP_ERROR_CODES.INVALID_ARCHIVE);
+        }
+        if (data.length > options.maxArchiveBytes) {
+            throw new ZipError(`ZIP archive has ${data.length} bytes, exceeding the configured limit`, ZIP_ERROR_CODES.ARCHIVE_SIZE_LIMIT);
+        }
+        const entries = parseZipEntries(data, options.maxEntries);
+        const selectedEntries = [];
+        const selectedPaths = new Set();
+        let declaredTotalUncompressedBytes = 0;
+        for (const entry of entries) {
+            const entryInfo = {
+                path: entry.path,
+                size: entry.uncompressedSize,
+                compressedSize: entry.compressedSize,
+                compressionMethod: entry.compressionMethod,
+                isDirectory: entry.isDirectory,
+                isFile: !entry.isDirectory,
+            };
+            if (!options.filter(entryInfo))
+                continue;
+            if (selectedPaths.has(entry.path)) {
+                throw new ZipError(`ZIP contains duplicate selected path: ${entry.path}`, ZIP_ERROR_CODES.DUPLICATE_SELECTED_PATH);
+            }
+            selectedPaths.add(entry.path);
+            if (selectedEntries.length >= options.maxSelectedEntries) {
+                throw new ZipError('ZIP selected entry count exceeds the configured limit', ZIP_ERROR_CODES.SELECTED_ENTRY_COUNT_LIMIT);
+            }
+            if (entry.compressedSize > options.maxCompressedEntryBytes) {
+                throw new ZipError(`ZIP selected entry ${entry.path} exceeds the compressed-size limit`, ZIP_ERROR_CODES.COMPRESSED_SIZE_LIMIT);
+            }
+            if (entry.uncompressedSize > options.maxUncompressedEntryBytes) {
+                throw new ZipError(`ZIP selected entry ${entry.path} exceeds the uncompressed-size limit`, ZIP_ERROR_CODES.UNCOMPRESSED_SIZE_LIMIT);
+            }
+            if (entry.uncompressedSize >
+                options.maxTotalUncompressedBytes - declaredTotalUncompressedBytes) {
+                throw new ZipError('ZIP selected entries exceed the total uncompressed-size limit', ZIP_ERROR_CODES.TOTAL_UNCOMPRESSED_SIZE_LIMIT);
+            }
+            if (entry.compressionMethod !== 0 && entry.compressionMethod !== 8) {
+                throw new ZipError(`ZIP selected entry ${entry.path} uses unsupported compression method ${entry.compressionMethod}`, ZIP_ERROR_CODES.UNSUPPORTED_FEATURE);
+            }
+            declaredTotalUncompressedBytes += entry.uncompressedSize;
+            selectedEntries.push(entry);
+        }
+        const extractedEntries = [];
+        let actualTotalUncompressedBytes = 0;
+        for (const entry of selectedEntries) {
+            const compressedData = data.subarray(entry.dataStart, entry.dataEnd);
+            let content;
+            let crcState = 0xffffffff;
+            if (entry.compressionMethod === 0) {
+                if (entry.compressedSize !== entry.uncompressedSize) {
+                    throw new ZipError(`ZIP stored entry ${entry.path} has inconsistent sizes`, ZIP_ERROR_CODES.UNCOMPRESSED_SIZE_MISMATCH);
+                }
+                if (entry.uncompressedSize >
+                    options.maxTotalUncompressedBytes - actualTotalUncompressedBytes) {
+                    throw new ZipError('ZIP selected entries exceed the total uncompressed-size limit', ZIP_ERROR_CODES.TOTAL_UNCOMPRESSED_SIZE_LIMIT);
+                }
+                content = new Uint8Array(compressedData);
+                crcState = updateCrc32(crcState, content);
+                actualTotalUncompressedBytes += content.length;
+            }
+            else {
+                const chunks = [];
+                let actualEntryBytes = 0;
+                let zstream;
+                const inflater = new plugins.pako.Inflate({
+                    raw: true,
+                    chunkSize: PAKO_OUTPUT_CHUNK_BYTES,
+                });
+                inflater.onStart = (stream) => {
+                    zstream = stream;
+                };
+                inflater.onData = (chunk) => {
+                    if (chunk.length > entry.uncompressedSize - actualEntryBytes) {
+                        throw new ZipError(`ZIP selected entry ${entry.path} expands beyond its declared size`, ZIP_ERROR_CODES.UNCOMPRESSED_SIZE_MISMATCH);
+                    }
+                    if (chunk.length > options.maxUncompressedEntryBytes - actualEntryBytes) {
+                        throw new ZipError(`ZIP selected entry ${entry.path} exceeds the uncompressed-size limit`, ZIP_ERROR_CODES.UNCOMPRESSED_SIZE_LIMIT);
+                    }
+                    if (chunk.length >
+                        options.maxTotalUncompressedBytes - actualTotalUncompressedBytes) {
+                        throw new ZipError('ZIP selected entries exceed the total uncompressed-size limit', ZIP_ERROR_CODES.TOTAL_UNCOMPRESSED_SIZE_LIMIT);
+                    }
+                    const retainedChunk = chunk.slice();
+                    chunks.push(retainedChunk);
+                    crcState = updateCrc32(crcState, retainedChunk);
+                    actualEntryBytes += retainedChunk.length;
+                    actualTotalUncompressedBytes += retainedChunk.length;
+                };
+                let pushSucceeded = true;
+                let inputOffset = 0;
+                try {
+                    do {
+                        const inputEnd = Math.min(inputOffset + PAKO_INPUT_CHUNK_BYTES, compressedData.length);
+                        pushSucceeded = inflater.push(compressedData.subarray(inputOffset, inputEnd), inputEnd === compressedData.length);
+                        inputOffset = inputEnd;
+                        if (!pushSucceeded)
+                            break;
+                        if (inflater.ended && inputOffset < compressedData.length) {
+                            throw new ZipError(`ZIP selected entry ${entry.path} ended before consuming its compressed data`, ZIP_ERROR_CODES.COMPRESSED_SIZE_MISMATCH);
+                        }
+                    } while (inputOffset < compressedData.length);
+                }
+                catch (error) {
+                    if (error instanceof ZipError)
+                        throw error;
+                    throw new ZipError(`ZIP selected entry ${entry.path} contains invalid DEFLATE data`, ZIP_ERROR_CODES.INVALID_ARCHIVE);
+                }
+                if (!pushSucceeded || inflater.err || !inflater.ended || !zstream) {
+                    throw new ZipError(`ZIP selected entry ${entry.path} contains invalid or truncated DEFLATE data`, ZIP_ERROR_CODES.INVALID_ARCHIVE);
+                }
+                if (zstream.avail_in !== 0 || zstream.total_in !== compressedData.length) {
+                    throw new ZipError(`ZIP selected entry ${entry.path} did not consume its exact compressed data`, ZIP_ERROR_CODES.COMPRESSED_SIZE_MISMATCH);
+                }
+                if (actualEntryBytes !== entry.uncompressedSize) {
+                    throw new ZipError(`ZIP selected entry ${entry.path} did not produce its declared size`, ZIP_ERROR_CODES.UNCOMPRESSED_SIZE_MISMATCH);
+                }
+                content = combineChunks(chunks, actualEntryBytes);
+            }
+            const actualCrc32 = (crcState ^ 0xffffffff) >>> 0;
+            if (actualCrc32 !== entry.crc32) {
+                throw new ZipError(`ZIP selected entry ${entry.path} failed its CRC check`, ZIP_ERROR_CODES.CRC_MISMATCH);
+            }
+            extractedEntries.push({ path: entry.path, content });
+        }
+        return extractedEntries;
     }
     /**
      * Create a ZIP archive from an array of entries
@@ -66,15 +530,8 @@ export class ZipTools {
             else if (entry.content instanceof Uint8Array) {
                 data = entry.content;
             }
-            else if (entry.content instanceof plugins.smartfile.SmartFile) {
-                data = new Uint8Array(entry.content.contents);
-            }
-            else if (entry.content instanceof plugins.smartfile.StreamFile) {
-                const buffer = await entry.content.getContentAsBuffer();
-                data = new Uint8Array(buffer);
-            }
             else {
-                throw new Error('Unsupported content type for ZIP entry');
+                throw new Error('Shared ZIP creation accepts string or Uint8Array content');
             }
             if (compressionLevel !== undefined) {
                 filesObj[entry.archivePath] = [data, { level: compressionLevel }];
@@ -100,4 +557,4 @@ export class ZipTools {
         return entries;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.ziptools.js","sourceRoot":"","sources":["../ts_shared/classes.ziptools.ts"],"names":[],"mappings":"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"}