@zip.js/zip.js 2.8.58 → 2.8.60

package/dist/zip-fs-external.js

@@ -74,6 +74,7 @@ const BITFLAG_LEVEL_MAX_MASK = 0b010;
 const BITFLAG_LEVEL_FAST_MASK = 0b100;
 const BITFLAG_LEVEL_SUPER_FAST_MASK = 0b110;
 const BITFLAG_DATA_DESCRIPTOR = 0b1000;
+const BITFLAG_COMPRESSED_PATCHED_DATA = 0b100000;
 const BITFLAG_STRONG_ENCRYPTION = 0b1000000;
 const BITFLAG_LANG_ENCODING_FLAG = 0b100000000000;
 const BITFLAG_MASKED_LOCAL_HEADERS = 0b10000000000000;
@@ -191,6 +192,7 @@ const OPTION_OFFSET = "offset";
 const OPTION_USDZ = "usdz";
 const OPTION_UNIX_EXTRA_FIELD_TYPE = "unixExtraFieldType";
 const OPTION_LOCAL_EXTRA_FIELD = "localExtraField";
+const OPTION_CENTRAL_EXTRA_FIELD = "centralExtraField";
 const OPTION_STRICTNESS = "strictness";
 const OPTION_FILENAME_VALIDATION = "filenameValidation";
 const OPTION_NORMALIZE_FILENAME = "normalizeFilename";
@@ -2107,6 +2109,10 @@ function getRegisteredCodec(compressionMethod) {
 	return registeredCodecs.get(compressionMethod);
 }
 
+function getRegisteredCodecs() {
+	return Array.from(registeredCodecs.values(), codec => Object.assign({}, codec, codecStreams.get(codec.format)));
+}
+
 function getCodecStreams(format) {
 	return codecStreams.get(format);
 }
@@ -2158,9 +2164,9 @@ const ERR_INVALID_UNCOMPRESSED_SIZE = "Invalid uncompressed size";
 const ERR_INVALID_COMPRESSED_DATA = "Invalid compressed data";
 const ERR_INVALID_CRC32 = ERR_INVALID_SIGNATURE;
 const ERR_UNSUPPORTED_COMPRESSION$2 = "Compression method not supported";
-const FORMAT_DEFLATE_RAW = "deflate-raw";
-const FORMAT_DEFLATE64_RAW = "deflate64-raw";
-const FORMAT_GZIP = "gzip";
+const FORMAT_DEFLATE_RAW$1 = "deflate-raw";
+const FORMAT_DEFLATE64_RAW$1 = "deflate64-raw";
+const FORMAT_GZIP$1 = "gzip";
 const GZIP_HEADER_LENGTH = 10;
 const GZIP_TRAILER_LENGTH = 8;
 const GZIP_HEADER_BYTES = [0x1f, 0x8b, 0x08];
@@ -2170,7 +2176,7 @@ class DeflateStream extends TransformStream {
 
 	constructor(options, { chunkSize, CompressionStreamFallback, CompressionStream }) {
 		super({});
-		const { compressed, encrypted, useCompressionStream, zipCrypto, computeCrc32, level, deflate64, format, compressionMethod } = options;
+		const { compressed, encrypted, useCompressionStream, zipCrypto, computeCrc32, level, deflate64, format, compressionMethod, inputSize } = options;
 		const stream = this;
 		let crc32Stream, encryptionStream, gzipCrc32Stream;
 		let readable = super.readable;
@@ -2183,10 +2189,10 @@ class DeflateStream extends TransformStream {
 		}
 		if (compressed) {
 			if (codecStreams) {
-				readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.CompressionStream, format, { level, chunkSize, compressionMethod }));
+				readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.CompressionStream, format, { level, chunkSize, compressionMethod, uncompressedSize: inputSize }));
 			} else if (useGzipCrc32) {
 				gzipCrc32Stream = new GzipToRawDeflateStream();
-				readable = pipeThroughBackpressured(readable, new CompressionStream(FORMAT_GZIP));
+				readable = pipeThroughBackpressured(readable, new CompressionStream(FORMAT_GZIP$1));
 				readable = pipeThrough(readable, gzipCrc32Stream);
 			} else {
 				try {
@@ -2194,7 +2200,7 @@ class DeflateStream extends TransformStream {
 				} catch (error) {
 					let gzipStream;
 					try {
-						gzipStream = new CompressionStream(FORMAT_GZIP);
+						gzipStream = new CompressionStream(FORMAT_GZIP$1);
 					} catch {
 						throw error;
 					}
@@ -2358,7 +2364,7 @@ class InflateStream extends TransformStream {
 					}
 					let gzipStream;
 					try {
-						gzipStream = new DecompressionStream(FORMAT_GZIP);
+						gzipStream = new DecompressionStream(FORMAT_GZIP$1);
 					} catch {
 						throw error;
 					}
@@ -2407,11 +2413,11 @@ function supportsFormat(StreamClass, format) {
 }
 
 function supportsDeflateRaw(StreamClass) {
-	return supportsFormat(StreamClass, FORMAT_DEFLATE_RAW);
+	return supportsFormat(StreamClass, FORMAT_DEFLATE_RAW$1);
 }
 
 function supportsGzip(StreamClass) {
-	return supportsFormat(StreamClass, FORMAT_GZIP);
+	return supportsFormat(StreamClass, FORMAT_GZIP$1);
 }
 
 function setReadable(stream, readable, flush) {
@@ -2434,7 +2440,7 @@ function pipeThroughCompressionStream(readable, useCompressionStream, options, C
 	const Stream = useCompressionStream && CompressionStreamNative ?
 		CompressionStreamNative :
 		CompressionStreamFallback || CompressionStreamNative;
-	const format = options.deflate64 ? FORMAT_DEFLATE64_RAW : FORMAT_DEFLATE_RAW;
+	const format = options.deflate64 ? FORMAT_DEFLATE64_RAW$1 : FORMAT_DEFLATE_RAW$1;
 	let codecStream;
 	try {
 		codecStream = new Stream(format, options);
@@ -4760,6 +4766,21 @@ const ERR_INVALID_STRICTNESS = "Invalid strictness (must be 'strict', 'balanced'
 const ERR_INVALID_FILENAME_VALIDATION = "Invalid filenameValidation (must be 'strict', 'balanced' or 'tolerant')";
 const ERR_INVALID_MAX_APPENDED_DATA_SIZE = "Invalid maxAppendedDataSize (must be a number greater than or equal to 0)";
 const ERR_UNSUPPORTED_UINT64 = "64-bit value exceeds Number.MAX_SAFE_INTEGER";
+const WARNING_UNSORTED_CENTRAL_DIRECTORY = "unsorted central directory";
+const WARNING_UNKNOWN_VERSION = "unknown version needed to extract";
+const WARNING_COMPRESSED_PATCHED_DATA = "compressed patched data";
+const WARNING_MALFORMED_EXTRA_FIELD = "malformed extra field";
+const WARNING_UNKNOWN_ZIP64_EXTENSIBLE_DATA = "unknown zip64 extensible data";
+const WARNING_WRAPPED_ENTRIES_COUNT = "wrapped entries count";
+const WARNING_APPENDED_DATA = "appended data";
+const WARNING_PREPENDED_DATA = "prepended data";
+const WARNING_TRAILING_CENTRAL_DIRECTORY_DATA = "trailing central directory data";
+const WARNING_DUPLICATE_FILENAME = "duplicate filename";
+const WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY = "mismatched zip64 end of central directory record";
+const WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG = "mismatched local file header (general purpose bit flag)";
+const WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD = "mismatched local file header (compression method)";
+const WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES = "mismatched local file header (crc32 or sizes)";
+const MAX_KNOWN_VERSION = 63;
 const DRIVE_LETTER_REGEXP = /^[a-zA-Z]:/;
 const CHARSET_UTF8 = "utf-8";
 const PROPERTY_NAME_UTF8_SUFFIX = "UTF8";
@@ -4810,6 +4831,7 @@ class ZipReader {
 		if (reader.size < END_OF_CENTRAL_DIR_LENGTH) {
 			throw new Error(ERR_BAD_FORMAT);
 		}
+		const warnings = zipReader.warnings = [];
 		const strictness = getStrictness(options, zipReader.options);
 		const checkAmbiguity = strictness == STRICTNESS_STRICT;
 		const rejectAmbiguousEndOfDirectory = strictness != STRICTNESS_TOLERANT;
@@ -4833,8 +4855,12 @@ class ZipReader {
 		const commentOffset = endOfDirectoryInfo.offset;
 		const commentLength = getUint16$1(endOfDirectoryView, 20);
 		const appendedDataOffset = commentOffset + END_OF_CENTRAL_DIR_LENGTH + commentLength;
-		if (reader.size - appendedDataOffset > maxAppendedDataSize) {
-			throwAmbiguousArchive("appended data");
+		const appendedDataLength = reader.size - appendedDataOffset;
+		if (appendedDataLength > maxAppendedDataSize) {
+			throwAmbiguousArchive(WARNING_APPENDED_DATA);
+		}
+		if (appendedDataLength > 0) {
+			addWarning(warnings, WARNING_APPENDED_DATA);
 		}
 		let lastDiskNumber = getUint16$1(endOfDirectoryView, 4);
 		const expectedLastDiskNumber = reader.lastDiskNumber || 0;
@@ -4888,23 +4914,23 @@ class ZipReader {
 				}
 				if (lastDiskNumber == MAX_16_BITS) {
 					lastDiskNumber = getUint32$1(endOfDirectoryView, 16);
-				} else if (checkAmbiguity && lastDiskNumber != getUint32$1(endOfDirectoryView, 16)) {
-					throwAmbiguousArchive("mismatched zip64 end of central directory record");
+				} else if (lastDiskNumber != getUint32$1(endOfDirectoryView, 16)) {
+					reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY);
 				}
 				if (diskNumber == MAX_16_BITS) {
 					diskNumber = getUint32$1(endOfDirectoryView, 20);
-				} else if (checkAmbiguity && diskNumber != getUint32$1(endOfDirectoryView, 20)) {
-					throwAmbiguousArchive("mismatched zip64 end of central directory record");
+				} else if (diskNumber != getUint32$1(endOfDirectoryView, 20)) {
+					reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY);
 				}
 				if (filesLength == MAX_16_BITS) {
 					filesLength = getBigUint64(endOfDirectoryView, 32);
-				} else if (checkAmbiguity && filesLength != getBigUint64(endOfDirectoryView, 32)) {
-					throwAmbiguousArchive("mismatched zip64 end of central directory record");
+				} else if (filesLength != getBigUint64(endOfDirectoryView, 32)) {
+					reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY);
 				}
 				if (directoryDataLength == MAX_32_BITS) {
 					directoryDataLength = getBigUint64(endOfDirectoryView, 40);
-				} else if (checkAmbiguity && directoryDataLength != getBigUint64(endOfDirectoryView, 40)) {
-					throwAmbiguousArchive("mismatched zip64 end of central directory record");
+				} else if (directoryDataLength != getBigUint64(endOfDirectoryView, 40)) {
+					reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY);
 				}
 				directoryDataOffset = getDiskOffset$1(reader, diskNumber) + getBigUint64(endOfDirectoryView, 48) + prependedDataLength;
 			}
@@ -4973,14 +4999,22 @@ class ZipReader {
 			declaredDirectoryDataLength = directoryArray.length;
 			decryptedDirectory = true;
 		}
+		if (directoryEncryptionInfo && !decryptedDirectory &&
+			(directoryArray.length < 4 || getUint32$1(directoryView, 0) == CENTRAL_FILE_HEADER_SIGNATURE)) {
+			addWarning(warnings, WARNING_UNKNOWN_ZIP64_EXTENSIBLE_DATA);
+		}
 		startOffset = directoryDataOffset;
 		const filenameEncoding = getOptionValue$1(zipReader, options, OPTION_FILENAME_ENCODING);
 		const commentEncoding = getOptionValue$1(zipReader, options, OPTION_COMMENT_ENCODING);
-		const filenames = checkAmbiguity ? new Set() : UNDEFINED_VALUE;
+		const filenames = new Set();
 		let duplicateFilename;
+		let previousEntryPosition = -1;
 		const recoverWrappedFilesLength = !checkAmbiguity && !zip64EndOfDirectory;
 		if (!filesLength && recoverWrappedFilesLength) {
 			filesLength = getWrappedFilesLength(directoryView, directoryArray, offset);
+			if (filesLength) {
+				addWarning(warnings, WARNING_WRAPPED_ENTRIES_COUNT);
+			}
 		}
 		for (let indexFile = 0; indexFile < filesLength; indexFile++) {
 			const fileEntry = new ZipEntry$1(reader, zipReader.options);
@@ -5059,15 +5093,26 @@ class ZipReader {
 				filename,
 				comment
 			});
-			readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6);
+			if (readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6)) {
+				addWarning(warnings, WARNING_MALFORMED_EXTRA_FIELD, filename);
+			}
 			fileEntry.offset += prependedDataLength;
-			startOffset = Math.min(getDiskOffset$1(reader, fileEntry.diskNumberStart) + fileEntry.offset, startOffset);
-			if (checkAmbiguity) {
-				if (filenames.has(fileEntry.filename)) {
-					duplicateFilename = true;
-				}
-				filenames.add(fileEntry.filename);
+			const entryPosition = getDiskOffset$1(reader, fileEntry.diskNumberStart) + fileEntry.offset;
+			startOffset = Math.min(entryPosition, startOffset);
+			if (entryPosition < previousEntryPosition) {
+				addWarning(warnings, WARNING_UNSORTED_CENTRAL_DIRECTORY, filename);
+			}
+			previousEntryPosition = entryPosition;
+			if ((fileEntry.version & MAX_8_BITS) > MAX_KNOWN_VERSION) {
+				addWarning(warnings, WARNING_UNKNOWN_VERSION, filename);
 			}
+			if ((fileEntry.rawBitFlag & BITFLAG_COMPRESSED_PATCHED_DATA) == BITFLAG_COMPRESSED_PATCHED_DATA) {
+				addWarning(warnings, WARNING_COMPRESSED_PATCHED_DATA, filename);
+			}
+			if (filenames.has(fileEntry.filename)) {
+				duplicateFilename = true;
+			}
+			filenames.add(fileEntry.filename);
 			const unixExternalUpper = (fileEntry.externalFileAttributes >> 16) & MAX_16_BITS;
 			if (fileEntry.unixMode === UNDEFINED_VALUE && (unixExternalUpper & (FILE_ATTR_UNIX_DEFAULT_MASK | FILE_ATTR_UNIX_EXECUTABLE_MASK | FILE_ATTR_UNIX_TYPE_DIR)) != 0) {
 				fileEntry.unixMode = unixExternalUpper;
@@ -5105,7 +5150,11 @@ class ZipReader {
 			};
 			offset = endOffset;
 			if (indexFile == filesLength - 1 && recoverWrappedFilesLength) {
-				filesLength += getWrappedFilesLength(directoryView, directoryArray, offset);
+				const wrappedFilesLength = getWrappedFilesLength(directoryView, directoryArray, offset);
+				if (wrappedFilesLength) {
+					filesLength += wrappedFilesLength;
+					addWarning(warnings, WARNING_WRAPPED_ENTRIES_COUNT);
+				}
 			}
 			const { onprogress } = options;
 			if (onprogress) {
@@ -5131,18 +5180,22 @@ class ZipReader {
 			zipReader.digitalSignature = digitalSignature;
 			offsetAfterSignature = offset + 6 + digitalSignature.length;
 		}
-		if (checkAmbiguity && offset != declaredDirectoryDataLength && offsetAfterSignature != declaredDirectoryDataLength) {
-			throwAmbiguousArchive("trailing central directory data");
+		if ((offset != declaredDirectoryDataLength && offsetAfterSignature != declaredDirectoryDataLength) ||
+			(!decryptedDirectory && offset != directoryDataLength && offsetAfterSignature != directoryDataLength)) {
+			reportAmbiguity(checkAmbiguity, warnings, WARNING_TRAILING_CENTRAL_DIRECTORY_DATA);
 		}
 		if (duplicateFilename) {
-			throwAmbiguousArchive("duplicate filename");
+			reportAmbiguity(checkAmbiguity, warnings, WARNING_DUPLICATE_FILENAME);
 		}
 		const extractPrependedData = getOptionValue$1(zipReader, options, OPTION_EXTRACT_PREPENDED_DATA);
 		const extractAppendedData = getOptionValue$1(zipReader, options, OPTION_EXTRACT_APPENDED_DATA);
 		const splitZipSignatureLength = (checkAmbiguity || extractPrependedData) && filesLength &&
 			startOffset == SPLIT_ZIP_FILE_SIGNATURE_LENGTH && await startsWithSplitZipMarker(reader) ? SPLIT_ZIP_FILE_SIGNATURE_LENGTH : 0;
 		if (checkAmbiguity && (prependedDataLength || (filesLength && startOffset > splitZipSignatureLength))) {
-			throwAmbiguousArchive("prepended data");
+			throwAmbiguousArchive(WARNING_PREPENDED_DATA);
+		}
+		if (prependedDataLength || (filesLength && startOffset > SPLIT_ZIP_FILE_SIGNATURE_LENGTH)) {
+			addWarning(warnings, WARNING_PREPENDED_DATA);
 		}
 		if (extractPrependedData) {
 			zipReader.prependedData = startOffset > splitZipSignatureLength ?
@@ -5212,6 +5265,28 @@ class ZipReaderStream {
 	}
 }
 
+async function isZipFile(reader, options = {}) {
+	reader = new GenericReader(reader);
+	await initStream(reader);
+	if (reader.size === UNDEFINED_VALUE || !reader.readUint8Array) {
+		reader = new BlobReader(await streamToBlob(reader.readable));
+		await initStream(reader);
+	}
+	if (reader.size < END_OF_CENTRAL_DIR_LENGTH) {
+		return false;
+	}
+	const strictness = getStrictness(options, {});
+	const rejectAmbiguousEndOfDirectory = strictness != STRICTNESS_TOLERANT;
+	const maxAppendedDataSize = getMaxAppendedDataSize(options[OPTION_MAX_APPENDED_DATA_SIZE], strictness);
+	const { endOfDirectoryInfo, endOfDirectoryReachingEndCount } = await findEndOfCentralDirectory(reader, rejectAmbiguousEndOfDirectory, maxAppendedDataSize);
+	if (!endOfDirectoryInfo || (strictness == STRICTNESS_STRICT && endOfDirectoryReachingEndCount > 1)) {
+		return false;
+	}
+	const commentLength = getUint16$1(getDataView(endOfDirectoryInfo), 20);
+	const appendedDataOffset = endOfDirectoryInfo.offset + END_OF_CENTRAL_DIR_LENGTH + commentLength;
+	return reader.size - appendedDataOffset <= maxAppendedDataSize;
+}
+
 let ZipEntry$1 = class ZipEntry {
 
 	constructor(reader, options) {
@@ -5243,6 +5318,7 @@ let ZipEntry$1 = class ZipEntry {
 			dataDescriptor
 		} = bitFlag;
 		const localDirectory = fileEntry.localDirectory = {};
+		const warnings = fileEntry.warnings = [];
 		const localHeaderOffset = getDiskOffset$1(reader, diskNumberStart) + offset;
 		const dataArray = await readUint8Array(reader, localHeaderOffset, HEADER_SIZE);
 		const dataView = getDataView(dataArray);
@@ -5283,10 +5359,10 @@ let ZipEntry$1 = class ZipEntry {
 		if (checkLocalFilename) {
 			localDirectory.rawFilename = rawLocalFilename;
 		}
-		readCommonFooter(zipEntry, localDirectory, dataView, 4, true);
-		if (checkLocalDirectory) {
-			validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename);
+		if (readCommonFooter(zipEntry, localDirectory, dataView, 4, true)) {
+			addWarning(warnings, WARNING_MALFORMED_EXTRA_FIELD);
 		}
+		validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename, checkLocalDirectory ? UNDEFINED_VALUE : warnings);
 		const { lastAccessDate, creationDate, uid, gid } = localDirectory;
 		if (lastAccessDate) {
 			fileEntry.lastAccessDate = lastAccessDate;
@@ -5512,6 +5588,7 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 	const extraField = directory.extraField = new Map();
 	const rawExtraFieldView = getDataView(rawExtraField);
 	let offsetExtraField = 0;
+	let malformedExtraField = false;
 	try {
 		while (offsetExtraField < rawExtraField.length) {
 			const type = getUint16$1(rawExtraFieldView, offsetExtraField);
@@ -5523,7 +5600,10 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 			offsetExtraField += 4 + size;
 		}
 	} catch {
-		// ignored
+		malformedExtraField = true;
+	}
+	if (offsetExtraField > rawExtraField.length) {
+		malformedExtraField = true;
 	}
 	const compressionMethod = getUint16$1(dataView, offset + 4);
 	Object.assign(directory, {
@@ -5591,6 +5671,7 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 	if (extraFieldUSDZ) {
 		directory.extraFieldUSDZ = extraFieldUSDZ;
 	}
+	return malformedExtraField;
 }
 
 function readExtraFieldZip64(extraFieldZip64, directory) {
@@ -6052,27 +6133,46 @@ async function readSignature(reader, view, anchoredOffset, signatureOffset, size
 	return UNDEFINED_VALUE;
 }
 
-function validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename) {
+function validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename, warnings) {
 	const { rawFilename } = zipEntry;
+	const reject = !warnings;
 	const maskedLocalDirectory = zipEntry.decryptedDirectory &&
 		(localDirectory.rawBitFlag & BITFLAG_MASKED_LOCAL_HEADERS) == BITFLAG_MASKED_LOCAL_HEADERS;
 	if (checkLocalFilename && !maskedLocalDirectory &&
 		(rawLocalFilename.length != rawFilename.length ||
 			rawLocalFilename.some((byteValue, indexByte) => byteValue != rawFilename[indexByte]))) {
-		throwAmbiguousArchive("mismatched local file header (filename)");
+		reportAmbiguity(reject, warnings, "mismatched local file header (filename)");
 	}
 	if ((localDirectory.rawBitFlag & BITFLAG_AMBIGUITY_MASK) != (zipEntry.rawBitFlag & BITFLAG_AMBIGUITY_MASK)) {
-		throwAmbiguousArchive("mismatched local file header (general purpose bit flag)");
+		reportAmbiguity(reject, warnings, WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG);
 	}
 	if (localDirectory.compressionMethod != zipEntry.compressionMethod) {
-		throwAmbiguousArchive("mismatched local file header (compression method)");
+		reportAmbiguity(reject, warnings, WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD);
 	}
 	if (!localDirectory.bitFlag.dataDescriptor && !maskedLocalDirectory &&
 		(localDirectory.crc32 || localDirectory.compressedSize || localDirectory.uncompressedSize) &&
 		(localDirectory.crc32 != zipEntry.crc32 ||
 			localDirectory.compressedSize != zipEntry.compressedSize ||
 			localDirectory.uncompressedSize != zipEntry.uncompressedSize)) {
-		throwAmbiguousArchive("mismatched local file header (crc32 or sizes)");
+		reportAmbiguity(reject, warnings, WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES);
+	}
+}
+
+function reportAmbiguity(reject, warnings, reason) {
+	if (reject) {
+		throwAmbiguousArchive(reason);
+	} else {
+		addWarning(warnings, reason);
+	}
+}
+
+function addWarning(warnings, reason, filename) {
+	if (!warnings.some(warning => warning.reason == reason)) {
+		const warning = { reason };
+		if (filename !== UNDEFINED_VALUE) {
+			warning.filename = filename;
+		}
+		warnings.push(warning);
 	}
 }
 
@@ -6149,8 +6249,23 @@ var zipReader = /*#__PURE__*/Object.freeze({
 	ERR_UNSUPPORTED_ENCRYPTION: ERR_UNSUPPORTED_ENCRYPTION,
 	ERR_UNSUPPORTED_UINT64: ERR_UNSUPPORTED_UINT64,
 	ERR_WORKER_STARTUP_TIMEOUT: ERR_WORKER_STARTUP_TIMEOUT,
+	WARNING_APPENDED_DATA: WARNING_APPENDED_DATA,
+	WARNING_COMPRESSED_PATCHED_DATA: WARNING_COMPRESSED_PATCHED_DATA,
+	WARNING_DUPLICATE_FILENAME: WARNING_DUPLICATE_FILENAME,
+	WARNING_MALFORMED_EXTRA_FIELD: WARNING_MALFORMED_EXTRA_FIELD,
+	WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG: WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG,
+	WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD: WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD,
+	WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES: WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES,
+	WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY: WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY,
+	WARNING_PREPENDED_DATA: WARNING_PREPENDED_DATA,
+	WARNING_TRAILING_CENTRAL_DIRECTORY_DATA: WARNING_TRAILING_CENTRAL_DIRECTORY_DATA,
+	WARNING_UNKNOWN_VERSION: WARNING_UNKNOWN_VERSION,
+	WARNING_UNKNOWN_ZIP64_EXTENSIBLE_DATA: WARNING_UNKNOWN_ZIP64_EXTENSIBLE_DATA,
+	WARNING_UNSORTED_CENTRAL_DIRECTORY: WARNING_UNSORTED_CENTRAL_DIRECTORY,
+	WARNING_WRAPPED_ENTRIES_COUNT: WARNING_WRAPPED_ENTRIES_COUNT,
 	ZipReader: ZipReader,
-	ZipReaderStream: ZipReaderStream
+	ZipReaderStream: ZipReaderStream,
+	isZipFile: isZipFile
 });
 
 /*
@@ -6363,6 +6478,7 @@ class ZipWriter {
 					rawExtraFieldNTFS: EMPTY_UINT8_ARRAY,
 					rawExtraFieldUnix: EMPTY_UINT8_ARRAY,
 					rawExtraField,
+					rawCentralExtraField: EMPTY_UINT8_ARRAY,
 					extendedTimestamp: false,
 					headerArray,
 					headerView
@@ -6536,7 +6652,6 @@ async function prependZipEntries(zipWriter, reader) {
 
 async function addFileEntry(zipWriter, name, reader, options) {
 	options = Object.assign({}, options);
-	name = name.trim();
 	if (getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY) && !name.endsWith(DIRECTORY_SIGNATURE)) {
 		name += DIRECTORY_SIGNATURE;
 	}
@@ -6627,7 +6742,6 @@ async function addFile(zipWriter, name, reader, options) {
 }
 
 function resolveAttributes(zipWriter, name, options) {
-	name = name.trim();
 	let msDosCompatible = getOptionValue(zipWriter, options, PROPERTY_NAME_MS_DOS_COMPATIBLE);
 	let versionMadeBy = getOptionValue(zipWriter, options, PROPERTY_NAME_VERSION_MADE_BY, msDosCompatible ? VERSION_MADE_BY_MSDOS : VERSION_MADE_BY_UNIX);
 	const executable = getOptionValue(zipWriter, options, PROPERTY_NAME_EXECUTABLE);
@@ -6832,6 +6946,7 @@ function resolveMetadata(zipWriter, name, options) {
 	}
 	const rawExtraField = serializeExtraField(options[PROPERTY_NAME_EXTRA_FIELD]);
 	const rawLocalExtraField = serializeExtraField(options[OPTION_LOCAL_EXTRA_FIELD]);
+	const rawCentralExtraField = serializeExtraField(options[OPTION_CENTRAL_EXTRA_FIELD]);
 	return {
 		comment,
 		resolvedOptions: {
@@ -6867,7 +6982,8 @@ function resolveMetadata(zipWriter, name, options) {
 			dataDescriptor,
 			zip64,
 			rawExtraField,
-			rawLocalExtraField
+			rawLocalExtraField,
+			rawCentralExtraField
 		}
 	};
 }
@@ -7009,7 +7125,6 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 		let { name } = entry;
 		const { size } = entry;
 		const options = Object.assign({}, entry.options);
-		name = name.trim();
 		if (getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY) && !name.endsWith(DIRECTORY_SIGNATURE)) {
 			name += DIRECTORY_SIGNATURE;
 		}
@@ -7265,6 +7380,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		versionMadeBy,
 		rawComment,
 		rawExtraField,
+		rawCentralExtraField,
 		useWebWorkers,
 		transferStreams,
 		onstart,
@@ -7308,6 +7424,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		rawExtraFieldUnix,
 		rawExtraFieldAES,
 		rawExtraField,
+		rawCentralExtraField,
 		extendedTimestamp,
 		msDosCompatible,
 		internalFileAttributes,
@@ -7339,6 +7456,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		const workerOptions = {
 			options: {
 				codecType: CODEC_DEFLATE,
+				inputSize: size,
 				level,
 				rawPassword,
 				password,
@@ -7808,6 +7926,7 @@ function createDirectoryRecords(files) {
 			rawExtraFieldNTFS,
 			rawExtraFieldUnix,
 			rawExtraField,
+			rawCentralExtraField,
 			extendedTimestamp,
 			extraFieldExtendedTimestampFlag,
 			lastModDate,
@@ -7862,7 +7981,8 @@ function createDirectoryRecords(files) {
 			rawExtraFieldNTFS,
 			rawExtraFieldUnix,
 			rawExtraFieldTimestamp,
-			rawExtraField);
+			rawExtraField,
+			rawCentralExtraField);
 		if (extraFieldLength > MAX_16_BITS) {
 			throw new Error(ERR_INVALID_EXTRAFIELD_DATA);
 		}
@@ -7890,6 +8010,7 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 			rawExtraFieldNTFS,
 			rawExtraFieldUnix,
 			rawExtraField,
+			rawCentralExtraField,
 			rawComment,
 			versionMadeBy,
 			headerArray,
@@ -7904,7 +8025,7 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 			uncompressedSize,
 			compressedSize
 		} = fileEntry;
-		const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField);
+		const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField, rawCentralExtraField);
 		const directoryRecordLength = CENTRAL_FILE_HEADER_LENGTH + getLength(rawFilename, rawComment) + extraFieldLength;
 		if (exceedsAvailableSize(writer, offset + directoryRecordLength - directoryDiskOffset)) {
 			await writeData(writer, directoryArray.slice(directoryDiskOffset, offset));
@@ -7942,6 +8063,7 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 		directoryRecord.writeBytes(rawExtraFieldNTFS);
 		directoryRecord.writeBytes(rawExtraFieldUnix);
 		directoryRecord.writeBytes(rawExtraField);
+		directoryRecord.writeBytes(rawCentralExtraField);
 		directoryRecord.writeBytes(rawComment);
 		arraySet(directoryArray, directoryRecord.array, offset);
 		offset += directoryRecordLength;
@@ -8445,6 +8567,111 @@ function getMimeType$1() {
  */
 
 
+function getSupportedCompressionMethods() {
+	const { CompressionStream, DecompressionStream, CompressionStreamFallback, DecompressionStreamFallback } = getConfiguration();
+	const supportedMethods = [{
+		compressionMethod: COMPRESSION_METHOD_STORE,
+		compression: true,
+		decompression: true,
+		registered: false
+	}, {
+		compressionMethod: COMPRESSION_METHOD_DEFLATE,
+		compression: formatSupported(CompressionStreamFallback, FORMAT_DEFLATE_RAW$1) ||
+			formatSupported(CompressionStream, FORMAT_DEFLATE_RAW$1) || formatSupported(CompressionStream, FORMAT_GZIP$1),
+		decompression: formatSupported(DecompressionStreamFallback, FORMAT_DEFLATE_RAW$1) ||
+			formatSupported(DecompressionStream, FORMAT_DEFLATE_RAW$1) || formatSupported(DecompressionStream, FORMAT_GZIP$1),
+		registered: false
+	}, {
+		compressionMethod: COMPRESSION_METHOD_DEFLATE_64,
+		compression: false,
+		decompression: formatSupported(DecompressionStreamFallback, FORMAT_DEFLATE64_RAW$1) ||
+			formatSupported(DecompressionStream, FORMAT_DEFLATE64_RAW$1),
+		registered: false
+	}];
+	for (const codec of getRegisteredCodecs()) {
+		const codecStreams = getCodecStreams(codec.format);
+		supportedMethods.push({
+			compressionMethod: codec.compressionMethod,
+			// deno-lint-ignore valid-typeof
+			compression: codecStreams ? typeof codecStreams.CompressionStream == FUNCTION_TYPE : UNDEFINED_VALUE,
+			// deno-lint-ignore valid-typeof
+			decompression: codecStreams ? typeof codecStreams.DecompressionStream == FUNCTION_TYPE : UNDEFINED_VALUE,
+			registered: true
+		});
+	}
+	return supportedMethods;
+}
+
+function formatSupported(StreamClass, format) {
+	if (!StreamClass) {
+		return false;
+	}
+	const { supportedFormats } = StreamClass;
+	if (supportedFormats) {
+		return supportedFormats.includes(format);
+	}
+	return supportsFormat(StreamClass, format);
+}
+
+/*
+ Copyright (c) 2025 Gildas Lormeau. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+ INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+const VERSION = "2.8.60";
+
+/*
+ Copyright (c) 2025 Gildas Lormeau. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+ INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
 const DEFAULT_THRESHOLD$2 = 1024 * 1024;
 const DEFAULT_DIRECTORY_NAME$1 = ".zip.js-temp";
 
@@ -8893,6 +9120,11 @@ try {
 
 /* global TransformStream */
 
+const FORMAT_DEFLATE = "deflate";
+const FORMAT_DEFLATE_RAW = "deflate-raw";
+const FORMAT_DEFLATE64_RAW = "deflate64-raw";
+const FORMAT_GZIP = "gzip";
+
 let wasm, malloc, free, memory, initError;
 
 function setWasmExports(wasmAPI) {
@@ -8938,15 +9170,15 @@ function _make(isCompress, type, options = {}) {
 					this._last_consumed = wasm.deflate_last_consumed;
 					this._end = wasm.deflate_end;
 					this.streamHandle = wasm.deflate_new();
-					if (type === "gzip") {
+					if (type === FORMAT_GZIP) {
 						result = wasm.deflate_init_gzip(this.streamHandle, level);
-					} else if (type === "deflate-raw") {
+					} else if (type === FORMAT_DEFLATE_RAW) {
 						result = wasm.deflate_init_raw(this.streamHandle, level);
 					} else {
 						result = wasm.deflate_init(this.streamHandle, level);
 					}
 				} else {
-					if (type === "deflate64-raw") {
+					if (type === FORMAT_DEFLATE64_RAW) {
 						this._process = wasm.inflate9_process;
 						this._last_consumed = wasm.inflate9_last_consumed;
 						this._end = wasm.inflate9_end;
@@ -8957,9 +9189,9 @@ function _make(isCompress, type, options = {}) {
 						this._last_consumed = wasm.inflate_last_consumed;
 						this._end = wasm.inflate_end;
 						this.streamHandle = wasm.inflate_new();
-						if (type === "deflate-raw") {
+						if (type === FORMAT_DEFLATE_RAW) {
 							result = wasm.inflate_init_raw(this.streamHandle);
-						} else if (type === "gzip") {
+						} else if (type === FORMAT_GZIP) {
 							result = wasm.inflate_init_gzip(this.streamHandle);
 						} else {
 							result = wasm.inflate_init(this.streamHandle);
@@ -9080,12 +9312,12 @@ function _make(isCompress, type, options = {}) {
 }
 
 class CompressionStreamZlib {
-	constructor(type = "deflate", options) {
+	constructor(type = FORMAT_DEFLATE, options) {
 		return _make(true, type, options);
 	}
 }
 class DecompressionStreamZlib {
-	constructor(type = "deflate", options) {
+	constructor(type = FORMAT_DEFLATE, options) {
 		return _make(false, type, options);
 	}
 }
@@ -9094,6 +9326,11 @@ class DecompressionStreamZlib {
 // module fails to load, rather than discarding a self-contained codec supplied through config.
 CompressionStreamZlib.requiresModule = true;
 DecompressionStreamZlib.requiresModule = true;
+// Constructing these classes before the module is loaded throws, so capability probes cannot rely
+// on trying the constructor; the formats are declared instead, next to the branches implementing
+// them in _make().
+CompressionStreamZlib.supportedFormats = [FORMAT_DEFLATE, FORMAT_DEFLATE_RAW, FORMAT_GZIP];
+DecompressionStreamZlib.supportedFormats = [FORMAT_DEFLATE, FORMAT_DEFLATE_RAW, FORMAT_GZIP, FORMAT_DEFLATE64_RAW];
 
 /*
  Copyright (c) 2025 Gildas Lormeau. All rights reserved.
@@ -10619,4 +10856,4 @@ function decodeMimeTypes(data) {
 	return mimeTypes;
 }
 
-export { BlobReader, BlobWriter, Data64URIReader, Data64URIWriter, ERR_ABORTED, ERR_AMBIGUOUS_ARCHIVE, ERR_BAD_FORMAT, ERR_CENTRAL_DIRECTORY_NOT_FOUND, ERR_DUPLICATED_NAME, ERR_ENCRYPTED, ERR_ENCRYPTED_CENTRAL_DIRECTORY, ERR_ENTRY_DATA_OUT_OF_BOUNDS, 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_COMMENT_TYPE, ERR_INVALID_COMPRESSED_DATA, ERR_INVALID_CRC32, ERR_INVALID_DATE, ERR_INVALID_ENCRYPTION_STRENGTH, ERR_INVALID_ENTRY_COMMENT, ERR_INVALID_ENTRY_COMMENT_TYPE, ERR_INVALID_ENTRY_NAME, ERR_INVALID_EXTRAFIELD, ERR_INVALID_EXTRAFIELD_DATA, ERR_INVALID_EXTRAFIELD_DATA_TYPE, ERR_INVALID_EXTRAFIELD_TYPE, ERR_INVALID_FILENAME_VALIDATION, ERR_INVALID_FUNCTION_OPTION, ERR_INVALID_GID, ERR_INVALID_LEVEL, ERR_INVALID_MAX_APPENDED_DATA_SIZE, ERR_INVALID_MAX_WORKERS, ERR_INVALID_MSDOS_ATTRIBUTES, ERR_INVALID_MSDOS_DATA, ERR_INVALID_PASSWORD, ERR_INVALID_PASSWORD_TYPE, ERR_INVALID_PASS_THROUGH, ERR_INVALID_READER_OPTIONS, ERR_INVALID_SIGNAL, ERR_INVALID_SIGNATURE, ERR_INVALID_SIGNATURE_DATA, ERR_INVALID_STRICTNESS, 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_COMPRESSION_METHOD, ERR_UNDEFINED_READER, ERR_UNDEFINED_UNCOMPRESSED_SIZE, ERR_UNDETERMINED_SIZE, ERR_UNSAFE_FILENAME, ERR_UNSUPPORTED_COMPRESSION$1 as ERR_UNSUPPORTED_COMPRESSION, ERR_UNSUPPORTED_CONTEXT, ERR_UNSUPPORTED_CRYPTO_API, ERR_UNSUPPORTED_ENCRYPTION, ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH, ERR_UNSUPPORTED_ENCRYPTION_USDZ, ERR_UNSUPPORTED_FORMAT, ERR_UNSUPPORTED_UINT64, ERR_WORKER_STARTUP_TIMEOUT, ERR_WRITER_NOT_INITIALIZED, ERR_ZIP_CRYPTO_LAST_MOD_DATE, ERR_ZIP_NOT_EMPTY, HttpRangeReader, HttpReader, Reader, SplitDataReader, SplitDataWriter, TextReader, TextWriter, Uint8ArrayReader, Uint8ArrayWriter, Writer, ZipDirectoryEntry, ZipEntry, ZipFS, ZipFileEntry, ZipReader, ZipReaderStream, ZipWriter, ZipWriterStream, configure, createBlobTempStream, createOPFSTempStream, createSyncAccessHandleTempStream, fs, getMimeType, registerCodec, resetConfiguration, terminateWorkersAndModule as terminateWorkers, unregisterCodec };
+export { BlobReader, BlobWriter, Data64URIReader, Data64URIWriter, ERR_ABORTED, ERR_AMBIGUOUS_ARCHIVE, ERR_BAD_FORMAT, ERR_CENTRAL_DIRECTORY_NOT_FOUND, ERR_DUPLICATED_NAME, ERR_ENCRYPTED, ERR_ENCRYPTED_CENTRAL_DIRECTORY, ERR_ENTRY_DATA_OUT_OF_BOUNDS, 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_COMMENT_TYPE, ERR_INVALID_COMPRESSED_DATA, ERR_INVALID_CRC32, ERR_INVALID_DATE, ERR_INVALID_ENCRYPTION_STRENGTH, ERR_INVALID_ENTRY_COMMENT, ERR_INVALID_ENTRY_COMMENT_TYPE, ERR_INVALID_ENTRY_NAME, ERR_INVALID_EXTRAFIELD, ERR_INVALID_EXTRAFIELD_DATA, ERR_INVALID_EXTRAFIELD_DATA_TYPE, ERR_INVALID_EXTRAFIELD_TYPE, ERR_INVALID_FILENAME_VALIDATION, ERR_INVALID_FUNCTION_OPTION, ERR_INVALID_GID, ERR_INVALID_LEVEL, ERR_INVALID_MAX_APPENDED_DATA_SIZE, ERR_INVALID_MAX_WORKERS, ERR_INVALID_MSDOS_ATTRIBUTES, ERR_INVALID_MSDOS_DATA, ERR_INVALID_PASSWORD, ERR_INVALID_PASSWORD_TYPE, ERR_INVALID_PASS_THROUGH, ERR_INVALID_READER_OPTIONS, ERR_INVALID_SIGNAL, ERR_INVALID_SIGNATURE, ERR_INVALID_SIGNATURE_DATA, ERR_INVALID_STRICTNESS, 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_COMPRESSION_METHOD, ERR_UNDEFINED_READER, ERR_UNDEFINED_UNCOMPRESSED_SIZE, ERR_UNDETERMINED_SIZE, ERR_UNSAFE_FILENAME, ERR_UNSUPPORTED_COMPRESSION$1 as ERR_UNSUPPORTED_COMPRESSION, ERR_UNSUPPORTED_CONTEXT, ERR_UNSUPPORTED_CRYPTO_API, ERR_UNSUPPORTED_ENCRYPTION, ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH, ERR_UNSUPPORTED_ENCRYPTION_USDZ, ERR_UNSUPPORTED_FORMAT, ERR_UNSUPPORTED_UINT64, ERR_WORKER_STARTUP_TIMEOUT, ERR_WRITER_NOT_INITIALIZED, ERR_ZIP_CRYPTO_LAST_MOD_DATE, ERR_ZIP_NOT_EMPTY, HttpRangeReader, HttpReader, Reader, SplitDataReader, SplitDataWriter, TextReader, TextWriter, Uint8ArrayReader, Uint8ArrayWriter, VERSION, WARNING_APPENDED_DATA, WARNING_COMPRESSED_PATCHED_DATA, WARNING_DUPLICATE_FILENAME, WARNING_MALFORMED_EXTRA_FIELD, WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG, WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD, WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY, WARNING_PREPENDED_DATA, WARNING_TRAILING_CENTRAL_DIRECTORY_DATA, WARNING_UNKNOWN_VERSION, WARNING_UNKNOWN_ZIP64_EXTENSIBLE_DATA, WARNING_UNSORTED_CENTRAL_DIRECTORY, WARNING_WRAPPED_ENTRIES_COUNT, Writer, ZipDirectoryEntry, ZipEntry, ZipFS, ZipFileEntry, ZipReader, ZipReaderStream, ZipWriter, ZipWriterStream, configure, createBlobTempStream, createOPFSTempStream, createSyncAccessHandleTempStream, fs, getMimeType, getRegisteredCodecs, getSupportedCompressionMethods, isZipFile, registerCodec, resetConfiguration, terminateWorkersAndModule as terminateWorkers, unregisterCodec };