@zip.js/zip.js 2.8.46 → 2.8.48

package/dist/zip-fs-core-external.js

@@ -38,6 +38,7 @@ const LOCAL_FILE_HEADER_SIGNATURE = 0x04034b50;
 const SPLIT_ZIP_FILE_SIGNATURE = 0x08074b50;
 const DATA_DESCRIPTOR_RECORD_SIGNATURE = SPLIT_ZIP_FILE_SIGNATURE;
 const ARCHIVE_EXTRA_DATA_SIGNATURE = 0x08064b50;
+const DIGITAL_SIGNATURE_RECORD_SIGNATURE = 0x05054b50;
 const CENTRAL_FILE_HEADER_SIGNATURE = 0x02014b50;
 const END_OF_CENTRAL_DIR_SIGNATURE = 0x06054b50;
 const ZIP64_END_OF_CENTRAL_DIR_SIGNATURE = 0x06064b50;
@@ -1900,6 +1901,8 @@ function getInt32(number) {
  */
 
 
+const HTTP_HEADER_CONTENT_TYPE = "Content-Type";
+
 function toCompatibleReadable(readable) {
 	if (readable instanceof ReadableStream) {
 		return readable;
@@ -1920,6 +1923,29 @@ function toCompatibleReadable(readable) {
 	});
 }
 
+function streamToBlob(readable, contentType) {
+	readable = toCompatibleReadable(readable);
+	if (responseSupportsGlobalReadable()) {
+		const options = {};
+		if (contentType) {
+			options.headers = [[HTTP_HEADER_CONTENT_TYPE, contentType]];
+		}
+		return new Response(readable, options).blob();
+	}
+	const chunks = [];
+	return readable
+		.pipeTo(new WritableStream({
+			write(chunk) {
+				chunks.push(chunk);
+			}
+		}))
+		.then(() => new Blob(chunks, contentType ? { type: contentType } : {}));
+}
+
+function responseSupportsGlobalReadable() {
+	return typeof Blob.prototype.stream != FUNCTION_TYPE || new Blob([]).stream() instanceof ReadableStream;
+}
+
 function toCompatibleWritable(writable) {
 	if (writable instanceof WritableStream) {
 		return writable;
@@ -3263,7 +3289,6 @@ const HTTP_HEADER_CONTENT_ENCODING = "Content-Encoding";
 const HTTP_HEADER_CONTENT_RANGE = "Content-Range";
 const HTTP_HEADER_ACCEPT_RANGES = "Accept-Ranges";
 const HTTP_HEADER_RANGE = "Range";
-const HTTP_HEADER_CONTENT_TYPE = "Content-Type";
 const HTTP_HEADER_ETAG = "Etag";
 const HTTP_HEADER_LAST_MODIFIED = "Last-Modified";
 const HTTP_METHOD_HEAD = "HEAD";
@@ -3468,10 +3493,6 @@ class BlobReader extends Reader {
 	}
 }
 
-function responseSupportsGlobalReadable() {
-	return typeof Blob.prototype.stream != FUNCTION_TYPE || new Blob([]).stream() instanceof ReadableStream;
-}
-
 class BlobWriter extends Stream {
 
 	constructor(contentType) {
@@ -3483,22 +3504,7 @@ class BlobWriter extends Stream {
 				return transformStream.writable;
 			}
 		});
-		if (responseSupportsGlobalReadable()) {
-			const headers = [];
-			if (contentType) {
-				headers.push([HTTP_HEADER_CONTENT_TYPE, contentType]);
-			}
-			writer.blob = new Response(transformStream.readable, { headers }).blob();
-		} else {
-			const chunks = [];
-			writer.blob = transformStream.readable
-				.pipeTo(new WritableStream({
-					write(chunk) {
-						chunks.push(chunk);
-					}
-				}))
-				.then(() => new Blob(chunks, { type: contentType }));
-		}
+		writer.blob = streamToBlob(transformStream.readable, contentType);
 		writer.blob.catch(() => { });
 	}
 
@@ -4485,6 +4491,8 @@ const OPTION_UNIX_EXTRA_FIELD_TYPE = "unixExtraFieldType";
 const OPTION_LOCAL_EXTRA_FIELD = "localExtraField";
 const OPTION_STRICTNESS = "strictness";
 const OPTION_MAX_APPENDED_DATA_SIZE = "maxAppendedDataSize";
+const OPTION_DECRYPT_CENTRAL_DIRECTORY = "decryptCentralDirectory";
+const OPTION_SIGN_CENTRAL_DIRECTORY = "signCentralDirectory";
 const STRICTNESS_STRICT = "strict";
 const STRICTNESS_BALANCED = "balanced";
 const STRICTNESS_TOLERANT = "tolerant";
@@ -4570,7 +4578,7 @@ class ZipReader {
 		const { config } = zipReader;
 		await initStream(reader);
 		if (reader.size === UNDEFINED_VALUE || !reader.readUint8Array) {
-			reader = new BlobReader(await new Response(reader.readable).blob());
+			reader = new BlobReader(await streamToBlob(reader.readable));
 			await initStream(reader);
 		}
 		if (reader.size < END_OF_CENTRAL_DIR_LENGTH) {
@@ -4610,6 +4618,7 @@ class ZipReader {
 		let startOffset;
 		let zip64EndOfDirectory;
 		let zip64EndOfDirectoryVersion2;
+		let directoryEncryptionInfo;
 		const requiresZip64 = directoryDataOffset == MAX_32_BITS || directoryDataLength == MAX_32_BITS || filesLength == MAX_16_BITS || diskNumber == MAX_16_BITS;
 		if (directoryDataOffset != MAX_32_BITS && diskNumber != MAX_16_BITS) {
 			directoryDataOffset += getDiskOffset$1(reader, diskNumber);
@@ -4640,6 +4649,15 @@ class ZipReader {
 				}
 				zip64EndOfDirectory = true;
 				zip64EndOfDirectoryVersion2 = getBigUint64(endOfDirectoryView, 4) > ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12;
+				if (zip64EndOfDirectoryVersion2) {
+					const extensibleDataLength = Math.min(
+						Number(getBigUint64(endOfDirectoryView, 4)) - (ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12),
+						reader.size - directoryDataOffset - ZIP64_END_OF_CENTRAL_DIR_LENGTH);
+					if (extensibleDataLength > 0) {
+						const rawExtensibleData = await readUint8Array(reader, directoryDataOffset + ZIP64_END_OF_CENTRAL_DIR_LENGTH, extensibleDataLength);
+						directoryEncryptionInfo = getDirectoryEncryptionInfo(rawExtensibleData);
+					}
+				}
 				if (lastDiskNumber == MAX_16_BITS) {
 					lastDiskNumber = getUint32(endOfDirectoryView, 16);
 				} else if (checkAmbiguity && lastDiskNumber != getUint32(endOfDirectoryView, 16)) {
@@ -4663,7 +4681,7 @@ class ZipReader {
 				directoryDataOffset = getDiskOffset$1(reader, diskNumber) + getBigUint64(endOfDirectoryView, 48) + prependedDataLength;
 			}
 		}
-		const declaredDirectoryDataLength = directoryDataLength;
+		let declaredDirectoryDataLength = directoryDataLength;
 		const centralDirectoryEndOffset = endOfDirectoryInfo.offset -
 			(zip64EndOfDirectory ? ZIP64_END_OF_CENTRAL_DIR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH : 0);
 		if (directoryDataOffset >= reader.size) {
@@ -4711,6 +4729,18 @@ class ZipReader {
 		if (directoryDataOffset < 0 || directoryDataOffset >= reader.size) {
 			throw new Error(ERR_BAD_FORMAT);
 		}
+		zipReader.directoryOffset = directoryDataOffset;
+		zipReader.directoryLength = declaredDirectoryDataLength;
+		const decryptCentralDirectory = getOptionValue$1(zipReader, options, OPTION_DECRYPT_CENTRAL_DIRECTORY);
+		let decryptedDirectory;
+		if (decryptCentralDirectory && filesLength && directoryArray.length >= 4 &&
+			getUint32(directoryView, 0) != CENTRAL_FILE_HEADER_SIGNATURE &&
+			(zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
+			directoryArray = await decryptCentralDirectory(directoryArray, directoryEncryptionInfo);
+			directoryView = getDataView(directoryArray);
+			declaredDirectoryDataLength = directoryArray.length;
+			decryptedDirectory = true;
+		}
 		startOffset = directoryDataOffset;
 		const filenameEncoding = getOptionValue$1(zipReader, options, OPTION_FILENAME_ENCODING);
 		const commentEncoding = getOptionValue$1(zipReader, options, OPTION_COMMENT_ENCODING);
@@ -4719,7 +4749,7 @@ class ZipReader {
 		for (let indexFile = 0; indexFile < filesLength; indexFile++) {
 			const fileEntry = new ZipEntry$1(reader, config, zipReader.options);
 			if (offset + CENTRAL_FILE_HEADER_LENGTH > directoryArray.length || getUint32(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE) {
-				if (indexFile == 0 && (zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
+				if (indexFile == 0 && !decryptedDirectory && (zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
 					throw new Error(ERR_ENCRYPTED_CENTRAL_DIRECTORY);
 				}
 				throw new Error(ERR_CENTRAL_DIRECTORY_NOT_FOUND);
@@ -4817,7 +4847,7 @@ class ZipReader {
 			entry.arrayBuffer = async options => {
 				const writer = new TransformStream();
 				const [arrayBuffer] = await Promise.all([
-					new Response(writer.readable).arrayBuffer(),
+					streamToBlob(writer.readable).then(blob => blob.arrayBuffer()),
 					fileEntry.getData(writer, entry, zipReader.readRanges, options)]);
 				return arrayBuffer;
 			};
@@ -4832,7 +4862,15 @@ class ZipReader {
 			}
 			yield entry;
 		}
-		if (checkAmbiguity && offset != declaredDirectoryDataLength) {
+		let offsetAfterSignature = offset;
+		if (offset + 6 <= directoryArray.length && getUint32(directoryView, offset) == DIGITAL_SIGNATURE_RECORD_SIGNATURE) {
+			const signatureDataLength = getUint16(directoryView, offset + 4);
+			if (offset + 6 + signatureDataLength <= directoryArray.length) {
+				zipReader.digitalSignature = directoryArray.subarray(offset + 6, offset + 6 + signatureDataLength);
+				offsetAfterSignature = offset + 6 + signatureDataLength;
+			}
+		}
+		if (checkAmbiguity && offset != declaredDirectoryDataLength && offsetAfterSignature != declaredDirectoryDataLength) {
 			throwAmbiguousArchive("trailing central directory data");
 		}
 		if (duplicateFilename) {
@@ -5104,6 +5142,25 @@ function detectEncryptedCentralDirectory(directoryView) {
 	return false;
 }
 
+function getDirectoryEncryptionInfo(rawExtensibleData) {
+	const directoryEncryptionInfo = { rawExtensibleData };
+	if (rawExtensibleData.length >= 28) {
+		const extensibleDataView = getDataView(rawExtensibleData);
+		const hashDataLength = getUint16(extensibleDataView, 26);
+		Object.assign(directoryEncryptionInfo, {
+			compressionMethod: getUint16(extensibleDataView, 0),
+			compressedSize: Number(getBigUint64(extensibleDataView, 2)),
+			uncompressedSize: Number(getBigUint64(extensibleDataView, 10)),
+			encryptionAlgorithm: getUint16(extensibleDataView, 18),
+			bitLength: getUint16(extensibleDataView, 20),
+			flags: getUint16(extensibleDataView, 22),
+			hashAlgorithm: getUint16(extensibleDataView, 24),
+			hashData: rawExtensibleData.subarray(28, 28 + hashDataLength)
+		});
+	}
+	return directoryEncryptionInfo;
+}
+
 function readCommonHeader(directory, dataView, offset) {
 	const rawBitFlag = directory.rawBitFlag = getUint16(dataView, offset + 2);
 	const encrypted = (rawBitFlag & BITFLAG_ENCRYPTED) == BITFLAG_ENCRYPTED;
@@ -5655,6 +5712,7 @@ var zipReader = /*#__PURE__*/Object.freeze({
 	ERR_SPLIT_ZIP_FILE: ERR_SPLIT_ZIP_FILE,
 	ERR_UNSUPPORTED_COMPRESSION: ERR_UNSUPPORTED_COMPRESSION$1,
 	ERR_UNSUPPORTED_ENCRYPTION: ERR_UNSUPPORTED_ENCRYPTION,
+	ERR_WORKER_STARTUP_TIMEOUT: ERR_WORKER_STARTUP_TIMEOUT,
 	ZipReader: ZipReader,
 	ZipReaderStream: ZipReaderStream
 });
@@ -5713,6 +5771,7 @@ const ERR_INVALID_UNIX_EXTRA_FIELD_TYPE = "Invalid unixExtraFieldType (must be '
 const ERR_INVALID_UNIX_ID_SIZE = "uid/gid must be 0..65535 for unixExtraFieldType 'unix' (use 'infozip' for larger ids)";
 const ERR_INVALID_MSDOS_ATTRIBUTES = "Invalid msdosAttributesRaw (must be integer 0..255)";
 const ERR_INVALID_MSDOS_DATA = "Invalid msdosAttributes (must be an object with boolean flags)";
+const ERR_INVALID_SIGNATURE_DATA = "Signature data exceeds 64KB";
 
 const EXTRAFIELD_DATA_AES = new Uint8Array([0x07, 0x00, 0x02, 0x00, 0x41, 0x45, 0x03, 0x00, 0x00]);
 const EXTRAFIELD_OFFSET_AES_VENDOR_VERSION = 4;
@@ -7072,8 +7131,9 @@ function updateLocalHeader({
 
 async function closeFile(zipWriter, comment, options) {
 	const directoryDataLength = createDirectoryRecords(zipWriter.files);
-	const directoryStart = await writeDirectoryRecords(zipWriter, directoryDataLength, options);
-	await writeEndOfDirectoryRecord(zipWriter, comment, options, { directoryStart, directoryDataLength });
+	const { directoryStart, directoryArray } = await writeDirectoryRecords(zipWriter, directoryDataLength, options);
+	const signatureLength = await writeDigitalSignatureRecord(zipWriter, directoryArray, options);
+	await writeEndOfDirectoryRecord(zipWriter, comment, options, { directoryStart, directoryDataLength, signatureLength });
 }
 
 function createDirectoryRecords(files) {
@@ -7230,12 +7290,33 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 		}
 	}
 	await writeData(writer, directoryDiskOffset ? directoryArray.slice(directoryDiskOffset) : directoryArray);
-	return { diskNumber: directoryStartDiskNumber, diskOffset: directoryStartDiskOffset };
+	return {
+		directoryStart: { diskNumber: directoryStartDiskNumber, diskOffset: directoryStartDiskOffset },
+		directoryArray
+	};
+}
+
+async function writeDigitalSignatureRecord(zipWriter, directoryArray, options) {
+	const signCentralDirectory = getOptionValue(zipWriter, options, OPTION_SIGN_CENTRAL_DIRECTORY);
+	if (signCentralDirectory) {
+		const signatureData = await signCentralDirectory(directoryArray);
+		const signatureDataLength = getLength(signatureData);
+		if (signatureDataLength > MAX_16_BITS) {
+			throw new Error(ERR_INVALID_SIGNATURE_DATA);
+		}
+		const signatureRecord = createRecordWriter(6 + signatureDataLength);
+		signatureRecord.uint32(DIGITAL_SIGNATURE_RECORD_SIGNATURE);
+		signatureRecord.uint16(signatureDataLength);
+		signatureRecord.bytes(signatureData);
+		await writeData(zipWriter.writer, signatureRecord.array);
+		return 6 + signatureDataLength;
+	}
+	return 0;
 }
 
 async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 	const { writer } = zipWriter;
-	const { directoryStart } = cdInfo;
+	const { directoryStart, signatureLength } = cdInfo;
 	let { directoryDataLength } = cdInfo;
 	let filesLength = zipWriter.files.size;
 	let diskNumber = directoryStart.diskNumber;
@@ -7274,7 +7355,7 @@ async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 		endOfdirectoryRecord.uint64(directoryOffset);
 		endOfdirectoryRecord.uint32(ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE);
 		endOfdirectoryRecord.uint32(lastDiskNumber);
-		endOfdirectoryRecord.uint64(BigInt(getSegmentOffset(zipWriter, writer)) + BigInt(directoryDataLength));
+		endOfdirectoryRecord.uint64(BigInt(getSegmentOffset(zipWriter, writer)) + BigInt(directoryDataLength) + BigInt(signatureLength));
 		endOfdirectoryRecord.uint32(lastDiskNumber + 1);
 		const supportZip64SplitFile = getOptionValue(zipWriter, options, OPTION_SUPPORT_ZIP64_SPLIT_FILE, true);
 		if (supportZip64SplitFile) {
@@ -7574,7 +7655,7 @@ function createOPFSTempStream(options = {}) {
 
 		async function spillToFile() {
 			const directoryHandle = await getTempDirectory();
-			fileName = crypto.randomUUID();
+			fileName = getRandomFileName$1();
 			fileHandle = await directoryHandle.getFileHandle(fileName, { create: true });
 			fileWriter = (await fileHandle.createWritable()).getWriter();
 			spilled = true;
@@ -7655,6 +7736,13 @@ function createOPFSTempStream(options = {}) {
 	};
 }
 
+function getRandomFileName$1() {
+	if (crypto.randomUUID) {
+		return crypto.randomUUID();
+	}
+	return Array.from(crypto.getRandomValues(new Uint8Array(16)), byteValue => byteValue.toString(16).padStart(2, "0")).join("");
+}
+
 /*
  Copyright (c) 2025 Gildas Lormeau. All rights reserved.
 
@@ -7698,7 +7786,7 @@ function createBlobTempStream(options = {}) {
 
 		async function spillToBlob() {
 			const transformStream = new TransformStream();
-			blobPromise = new Response(transformStream.readable).blob();
+			blobPromise = streamToBlob(transformStream.readable);
 			blobWriter = transformStream.writable.getWriter();
 			spilled = true;
 			for (const chunk of memoryChunks) {
@@ -7838,7 +7926,7 @@ function createSyncAccessHandleTempStream(options = {}) {
 
 		async function spillToFile() {
 			const directoryHandle = await getTempDirectory();
-			fileName = crypto.randomUUID();
+			fileName = getRandomFileName();
 			const fileHandle = await directoryHandle.getFileHandle(fileName, { create: true });
 			accessHandle = await fileHandle.createSyncAccessHandle();
 			spilled = true;
@@ -7918,6 +8006,13 @@ function createSyncAccessHandleTempStream(options = {}) {
 	};
 }
 
+function getRandomFileName() {
+	if (crypto.randomUUID) {
+		return crypto.randomUUID();
+	}
+	return Array.from(crypto.getRandomValues(new Uint8Array(16)), byteValue => byteValue.toString(16).padStart(2, "0")).join("");
+}
+
 /*
  Copyright (c) 2025 Gildas Lormeau. All rights reserved.
 
@@ -8468,7 +8563,7 @@ class ZipFileEntry extends ZipEntry {
 			await Promise.all([initStream(reader), initStream(writer, uncompressedSize)]);
 			const { readable } = reader;
 			zipEntry.uncompressedSize = reader.size;
-			await readable.pipeTo(writer.writable);
+			await toCompatibleReadable(readable).pipeTo(toCompatibleWritable(writer.writable));
 			return writer.getData ? writer.getData() : writer.writable;
 		}
 	}
@@ -9388,4 +9483,4 @@ function addChild(parent, name, params, directory) {
 	}
 }
 
-export { BlobReader, BlobWriter, Data64URIReader, Data64URIWriter, ERR_AMBIGUOUS_ARCHIVE, ERR_BAD_FORMAT, ERR_CENTRAL_DIRECTORY_NOT_FOUND, ERR_DUPLICATED_NAME, ERR_ENCRYPTED, ERR_ENCRYPTED_CENTRAL_DIRECTORY, ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND, ERR_EOCDR_NOT_FOUND, ERR_EXTRAFIELD_ZIP64_NOT_FOUND, ERR_HTTP_RANGE, ERR_HTTP_RESOURCE_CHANGED, ERR_INVALID_AUTHENTICATION_CODE, ERR_INVALID_CODEC_DEFINITION, ERR_INVALID_CODEC_MODULE, ERR_INVALID_COMMENT, ERR_INVALID_COMPRESSED_DATA, ERR_INVALID_CRC32, ERR_INVALID_ENCRYPTION_STRENGTH, ERR_INVALID_ENTRY_COMMENT, ERR_INVALID_ENTRY_NAME, ERR_INVALID_EXTRAFIELD_DATA, ERR_INVALID_EXTRAFIELD_TYPE, ERR_INVALID_PASSWORD, ERR_INVALID_SIGNATURE, ERR_INVALID_UNCOMPRESSED_SIZE, ERR_INVALID_VERSION, ERR_ITERATOR_COMPLETED_TOO_SOON, ERR_LOCAL_FILE_HEADER_NOT_FOUND, ERR_OVERLAPPING_ENTRY, ERR_RESERVED_COMPRESSION_METHOD, ERR_SPLIT_ZIP_FILE, ERR_UNDEFINED_READER, ERR_UNDEFINED_UNCOMPRESSED_SIZE, ERR_UNSUPPORTED_COMPRESSION$1 as ERR_UNSUPPORTED_COMPRESSION, ERR_UNSUPPORTED_ENCRYPTION, ERR_UNSUPPORTED_ENCRYPTION_USDZ, ERR_UNSUPPORTED_FORMAT, ERR_WRITER_NOT_INITIALIZED, ERR_ZIP_NOT_EMPTY, HttpRangeReader, HttpReader, Reader, SplitDataReader, SplitDataWriter, TextReader, TextWriter, Uint8ArrayReader, Uint8ArrayWriter, Writer, ZipReader, ZipReaderStream, ZipWriter, ZipWriterStream, configure, createBlobTempStream, createOPFSTempStream, createSyncAccessHandleTempStream, fs, getMimeType, registerCodec, resetConfiguration, terminateWorkersAndModule as terminateWorkers, unregisterCodec };
+export { BlobReader, BlobWriter, Data64URIReader, Data64URIWriter, ERR_AMBIGUOUS_ARCHIVE, ERR_BAD_FORMAT, ERR_CENTRAL_DIRECTORY_NOT_FOUND, ERR_DUPLICATED_NAME, ERR_ENCRYPTED, ERR_ENCRYPTED_CENTRAL_DIRECTORY, ERR_ENTRY_EXISTS, ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND, ERR_EOCDR_NOT_FOUND, ERR_EXTRAFIELD_ZIP64_NOT_FOUND, ERR_HTTP_RANGE, ERR_HTTP_RESOURCE_CHANGED, ERR_INVALID_AUTHENTICATION_CODE, ERR_INVALID_CODEC_DEFINITION, ERR_INVALID_CODEC_MODULE, ERR_INVALID_COMMENT, ERR_INVALID_COMPRESSED_DATA, ERR_INVALID_CRC32, ERR_INVALID_ENCRYPTION_STRENGTH, ERR_INVALID_ENTRY_COMMENT, ERR_INVALID_ENTRY_NAME, ERR_INVALID_EXTRAFIELD_DATA, ERR_INVALID_EXTRAFIELD_TYPE, ERR_INVALID_GID, ERR_INVALID_MSDOS_ATTRIBUTES, ERR_INVALID_MSDOS_DATA, ERR_INVALID_PASSWORD, ERR_INVALID_SIGNATURE, ERR_INVALID_SIGNATURE_DATA, ERR_INVALID_UID, ERR_INVALID_UNCOMPRESSED_SIZE, ERR_INVALID_UNIX_EXTRA_FIELD_TYPE, ERR_INVALID_UNIX_ID_SIZE, ERR_INVALID_UNIX_MODE, ERR_INVALID_VERSION, ERR_ITERATOR_COMPLETED_TOO_SOON, ERR_LOCAL_FILE_HEADER_NOT_FOUND, ERR_OVERLAPPING_ENTRY, ERR_READABLE_CONSUMED, ERR_RESERVED_COMPRESSION_METHOD, ERR_SPLIT_ZIP_FILE, ERR_UNDEFINED_READER, ERR_UNDEFINED_UNCOMPRESSED_SIZE, ERR_UNSUPPORTED_COMPRESSION$1 as ERR_UNSUPPORTED_COMPRESSION, ERR_UNSUPPORTED_CONTEXT, ERR_UNSUPPORTED_CRYPTO_API, ERR_UNSUPPORTED_ENCRYPTION, ERR_UNSUPPORTED_ENCRYPTION_USDZ, ERR_UNSUPPORTED_FORMAT, ERR_WORKER_STARTUP_TIMEOUT, ERR_WRITER_NOT_INITIALIZED, ERR_ZIP_NOT_EMPTY, HttpRangeReader, HttpReader, Reader, SplitDataReader, SplitDataWriter, TextReader, TextWriter, Uint8ArrayReader, Uint8ArrayWriter, Writer, ZipReader, ZipReaderStream, ZipWriter, ZipWriterStream, configure, createBlobTempStream, createOPFSTempStream, createSyncAccessHandleTempStream, fs, getMimeType, registerCodec, resetConfiguration, terminateWorkersAndModule as terminateWorkers, unregisterCodec };