@zip.js/zip.js 2.16.1 → 2.18.0

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

@@ -1931,7 +1931,9 @@ async function ensureCodecStreams(format, codecURI) {
 
 const ERR_INVALID_UNCOMPRESSED_SIZE = "Invalid uncompressed size";
 const ERR_INVALID_COMPRESSED_DATA = "Invalid compressed data";
+const ERR_CODEC_OUT_OF_MEMORY = "Codec out of memory";
 const ERR_INVALID_CRC32 = "Invalid CRC32";
+const Z_MEM_ERROR_CODE$1 = "Z_MEM_ERROR";
 const FORMAT_DEFLATE_RAW$1 = "deflate-raw";
 const FORMAT_DEFLATE64_RAW$1 = "deflate64-raw";
 const FORMAT_GZIP$1 = "gzip";
@@ -1966,13 +1968,13 @@ class DeflateStream extends TransformStream {
 					readable = pipeThroughCompressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamFallback);
 				} catch (error) {
 					if (!useCompressionStream && CompressionStreamFallback) {
-						throw error;
+						throw mapMemoryError(error);
 					}
 					let gzipStream;
 					try {
 						gzipStream = new CompressionStream(FORMAT_GZIP$1);
 					} catch {
-						throw error;
+						throw mapMemoryError(error);
 					}
 					readable = pipeThroughBackpressured(readable, gzipStream);
 					readable = pipeThrough(readable, new GzipToRawDeflateStream());
@@ -2036,50 +2038,30 @@ class GzipToRawDeflateStream extends TransformStream {
 	}
 }
 
-function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, crc32) {
+function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, crc32, sourceErrors) {
 	const writer = gzipStream.writable.getWriter();
 	const reader = gzipStream.readable.getReader();
 	const outputCrc32 = crc32 === UNDEFINED_VALUE ? new Crc32() : UNDEFINED_VALUE;
 	let outputLength = 0;
-	let inputDone = false;
 	let trailerWritten = false;
-	let idleCheckArmed = false;
-	let readCount = 0;
-	let readPending = false;
-	let resolveTrailerReady, rejectTrailerReady;
-	const trailerReady = new Promise((resolve, reject) => {
-		resolveTrailerReady = resolve;
-		rejectTrailerReady = reject;
-	});
-	trailerReady.catch(() => { });
-	pump();
-	return new ReadableStream({
-		async pull(controller) {
-			try {
-				const { value, done } = await read();
-				if (done) {
-					controller.close();
-				} else {
-					outputLength += value.length;
-					if (outputLength > outputSize) {
-						throw new Error(ERR_INVALID_UNCOMPRESSED_SIZE);
-					}
-					if (outputCrc32) {
-						outputCrc32.append(value);
-					}
-					controller.enqueue(value);
-				}
-			} catch (error) {
-				rejectTrailerReady(error);
-				await cancel(reader, error);
-				throw trailerWritten ? getTrailerError(error) : error;
-			}
+	let settled = false;
+	let resolvePull, controller;
+	const output = new ReadableStream({
+		start(streamController) {
+			controller = streamController;
+		},
+		pull() {
+			resumePump();
 		},
 		cancel(reason) {
-			rejectTrailerReady(reason);
+			settled = true;
+			resumePump();
 			return reader.cancel(reason);
 		}
 	});
+	pump();
+	drain();
+	return output;
 
 	async function pump() {
 		const inputReader = readable.getReader();
@@ -2088,19 +2070,16 @@ function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, cr
 			header.set(GZIP_HEADER_BYTES);
 			await writer.write(header);
 			for (; ;) {
+				await outputCapacity();
 				await writer.ready;
-				const { value, done } = await inputReader.read();
+				const { value, done } = await readSource(inputReader, sourceErrors);
 				if (done) {
 					break;
 				}
 				await writer.write(value);
 			}
-			inputDone = true;
 			if (outputCrc32) {
-				if (readPending) {
-					armIdleCheck();
-				}
-				await trailerReady;
+				await writer.write(new Uint8Array(0));
 			}
 			const trailer = new Uint8Array(GZIP_TRAILER_LENGTH);
 			const dataView = getDataView(trailer);
@@ -2115,54 +2094,68 @@ function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, cr
 		}
 	}
 
-	function read() {
-		readCount++;
-		readPending = true;
-		const result = reader.read();
-		result.then(onReadSettled, onReadSettled);
-		if (inputDone && outputCrc32) {
-			armIdleCheck();
+	async function drain() {
+		try {
+			for (; ;) {
+				const { value, done } = await read();
+				if (done) {
+					break;
+				}
+				outputLength += value.length;
+				if (outputLength > outputSize) {
+					throw new Error(ERR_INVALID_UNCOMPRESSED_SIZE);
+				}
+				if (outputCrc32) {
+					outputCrc32.append(value);
+				}
+				controller.enqueue(value);
+			}
+			if (!settled) {
+				settled = true;
+				controller.close();
+			}
+		} catch (error) {
+			fail(error);
+			await cancel(reader, error);
 		}
-		return result;
-	}
-
-	function onReadSettled() {
-		readPending = false;
 	}
 
-	async function armIdleCheck() {
-		if (!idleCheckArmed) {
-			idleCheckArmed = true;
-			const count = readCount;
-			await nextTask();
-			idleCheckArmed = false;
-			if (readPending) {
-				if (readCount == count) {
-					resolveTrailerReady();
-				} else {
-					armIdleCheck();
+	function read() {
+		return reader.read().catch(error => {
+			if (trailerWritten) {
+				if (!outputCrc32) {
+					throw mapError(error, ERR_INVALID_CRC32);
+				}
+				if (outputLength != outputSize) {
+					throw mapError(error, ERR_INVALID_UNCOMPRESSED_SIZE);
 				}
+				return { done: true };
 			}
-		}
+			throw mapCodecError(error, sourceErrors);
+		});
 	}
 
-	function getTrailerError(error) {
-		const trailerError = new Error(outputLength == outputSize ? ERR_INVALID_CRC32 : ERR_INVALID_UNCOMPRESSED_SIZE);
-		trailerError.cause = error;
-		return trailerError;
+	function outputCapacity() {
+		if (!settled && controller.desiredSize <= 0) {
+			return new Promise(resolve => resolvePull = resolve);
+		}
 	}
-}
 
-function nextTask() {
-	return new Promise(resolve => {
-		const { port1, port2 } = new MessageChannel();
-		port2.onmessage = () => {
-			port1.close();
-			port2.close();
+	function resumePump() {
+		if (resolvePull) {
+			const resolve = resolvePull;
+			resolvePull = UNDEFINED_VALUE;
 			resolve();
-		};
-		port1.postMessage(UNDEFINED_VALUE);
-	});
+		}
+	}
+
+	function fail(error) {
+		if (!settled) {
+			settled = true;
+			controller.error(error);
+			resumePump();
+		}
+	}
 }
 
 class InflateStream extends TransformStream {
@@ -2181,11 +2174,12 @@ class InflateStream extends TransformStream {
 			}
 		}
 		if (compressed) {
+			const sourceErrors = new Set();
 			const codecStreams = format && getCodecStreams(format);
+			let gzipStream;
 			if (codecStreams) {
-				readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.DecompressionStream, format, { chunkSize, compressionMethod, rawBitFlag, uncompressedSize: outputSize }));
+				readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.DecompressionStream, format, { chunkSize, compressionMethod, rawBitFlag, uncompressedSize: outputSize }), sourceErrors);
 			} else {
-				let gzipStream;
 				const GzipDecompressionStream = getGzipCodecStream(useCompressionStream, DecompressionStream, DecompressionStreamFallback);
 				if (checkCrc32 && !deflate64 && crc32 !== UNDEFINED_VALUE && outputSize !== UNDEFINED_VALUE && GzipDecompressionStream) {
 					try {
@@ -2196,24 +2190,25 @@ class InflateStream extends TransformStream {
 				}
 				if (!gzipStream) {
 					try {
-						readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamFallback);
+						readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamFallback, sourceErrors);
 					} catch (error) {
 						if (deflate64 || outputSize === UNDEFINED_VALUE || (!useCompressionStream && DecompressionStreamFallback)) {
-							throw error;
+							throw mapMemoryError(error);
 						}
 						try {
 							gzipStream = new DecompressionStream(FORMAT_GZIP$1);
 						} catch {
-							throw error;
+							throw mapMemoryError(error);
 						}
 					}
 				}
-				if (gzipStream) {
-					gzipCrc32 = true;
-					readable = pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, crc32);
-				}
 			}
-			readable = mapInflateStreamError(readable);
+			if (gzipStream) {
+				gzipCrc32 = true;
+				readable = pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, crc32, sourceErrors);
+			} else {
+				readable = mapInflateStreamError(readable, sourceErrors);
+			}
 		}
 		if (checkCrc32 && !gzipCrc32) {
 			crc32Stream = new Crc32Stream();
@@ -2286,7 +2281,7 @@ function getGzipCodecStream(useCompressionStream, CodecStreamNative, CodecStream
 	}
 }
 
-function pipeThroughCompressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamFallback) {
+function pipeThroughCompressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamFallback, sourceErrors) {
 	const Stream = useCompressionStream && CompressionStreamNative ?
 		CompressionStreamNative :
 		CompressionStreamFallback || CompressionStreamNative;
@@ -2301,14 +2296,14 @@ function pipeThroughCompressionStream(readable, useCompressionStream, options, C
 			throw error;
 		}
 	}
-	return pipeThroughBackpressured(readable, codecStream);
+	return pipeThroughBackpressured(readable, codecStream, sourceErrors);
 }
 
 function pipeThrough(readable, transformStream) {
 	return toCompatibleReadable(readable).pipeThrough(transformStream);
 }
 
-function pipeThroughBackpressured(readable, transformStream) {
+function pipeThroughBackpressured(readable, transformStream, sourceErrors) {
 	const writer = transformStream.writable.getWriter();
 	const reader = readable.getReader();
 	pump();
@@ -2318,7 +2313,7 @@ function pipeThroughBackpressured(readable, transformStream) {
 		try {
 			for (; ;) {
 				await writer.ready;
-				const result = await reader.read();
+				const result = await readSource(reader, sourceErrors);
 				if (result.done) {
 					await writer.close();
 					break;
@@ -2348,7 +2343,36 @@ async function cancel(reader, error) {
 	}
 }
 
-function mapInflateStreamError(readable) {
+function readSource(reader, sourceErrors) {
+	const result = reader.read();
+	return sourceErrors ? result.catch(error => {
+		sourceErrors.add(error);
+		throw error;
+	}) : result;
+}
+
+function mapCodecError(error, sourceErrors) {
+	if (sourceErrors.has(error)) {
+		return error;
+	}
+	return mapError(error, isMemoryError(error) ? ERR_CODEC_OUT_OF_MEMORY : ERR_INVALID_COMPRESSED_DATA);
+}
+
+function mapMemoryError(error) {
+	return isMemoryError(error) ? mapError(error, ERR_CODEC_OUT_OF_MEMORY) : error;
+}
+
+function isMemoryError(error) {
+	return isErrorObject(error) && error.code == Z_MEM_ERROR_CODE$1;
+}
+
+function mapError(error, message) {
+	const mappedError = new Error(message);
+	mappedError.cause = error;
+	return mappedError;
+}
+
+function mapInflateStreamError(readable, sourceErrors) {
 	const reader = readable.getReader();
 	return new ReadableStream({
 		async pull(controller) {
@@ -2361,12 +2385,7 @@ function mapInflateStreamError(readable) {
 				}
 			} catch (error) {
 				await cancel(reader, error);
-				if (error && error.message) {
-					throw error;
-				}
-				const mappedError = new Error(ERR_INVALID_COMPRESSED_DATA);
-				mappedError.cause = error;
-				throw mappedError;
+				throw mapCodecError(error, sourceErrors);
 			}
 		},
 		cancel(reason) {
@@ -2734,10 +2753,11 @@ async function runWorker$1({ options, readable, writable, onTaskFinished, worker
 		}
 		codecStream = new CodecStream(options, config);
 		chunkStream = new ChunkStream(getChunkSize(config));
+		const { signal } = workerOptions.streamOptions;
 		await readable
 			.pipeThrough(codecStream)
 			.pipeThrough(chunkStream)
-			.pipeTo(writable, { preventClose: true, preventAbort: true });
+			.pipeTo(writable, { preventClose: true, preventAbort: true, signal });
 		const {
 			crc32,
 			inputSize,
@@ -2805,6 +2825,7 @@ async function runWorker$1({ options, readable, writable, onTaskFinished, worker
 const MODULE_WORKER_OPTIONS = { type: "module" };
 const ERROR_EVENT_TYPE = "error";
 const MESSAGE_ERROR_EVENT_TYPE = "messageerror";
+const ABORT_EVENT_TYPE = "abort";
 
 let webWorkerSource, webWorkerURI, webWorkerOptions;
 let transferStreamsSupported = true;
@@ -2981,6 +3002,13 @@ function watchClosedStream(writableSource, workerData) {
 			Object.assign(workerData, { destinationFailed: true, destinationError: error });
 		}
 	});
+	const { signal } = workerData.workerOptions.streamOptions;
+	if (signal) {
+		const onAbort = () => abortController.abort(signal.reason);
+		const removeAbortListener = () => signal.removeEventListener(ABORT_EVENT_TYPE, onAbort);
+		signal.addEventListener(ABORT_EVENT_TYPE, onAbort);
+		closed.then(removeAbortListener, removeAbortListener);
+	}
 	return {
 		writable, closed, abortPipe: () => {
 			aborting = true;
@@ -3243,9 +3271,6 @@ function getResponseError(errorData, errorValue) {
 		responseError = errorValue.value;
 	} else {
 		responseError = Object.assign(new Error(message), { stack, code, name });
-		if (cause) {
-			responseError.cause = Object.assign(new Error(cause.message), { name: cause.name });
-		}
 	}
 	if (isErrorObject(responseError)) {
 		try {
@@ -3255,6 +3280,14 @@ function getResponseError(errorData, errorValue) {
 			if (codecImportFailed) {
 				responseError.codecImportFailed = true;
 			}
+			if (cause) {
+				if (!isErrorObject(responseError.cause)) {
+					responseError.cause = Object.assign(new Error(cause.message), { name: cause.name });
+				}
+				if (cause.code !== UNDEFINED_VALUE && responseError.cause.code !== cause.code) {
+					responseError.cause.code = cause.code;
+				}
+			}
 			if (errorValue) {
 				if (responseError.name !== name) {
 					responseError.name = name;
@@ -4845,7 +4878,7 @@ const PARENT_DIRECTORY_REGEXP = /(^|[\\/])\.\.([\\/]|$)/;
 const CHARSET_UTF8 = "utf-8";
 const PROPERTY_NAME_UTF8_SUFFIX = "UTF8";
 const CHARSET_CP437 = "cp437";
-const BITFLAG_AMBIGUITY_MASK = BITFLAG_ENCRYPTED | BITFLAG_DATA_DESCRIPTOR | BITFLAG_LANG_ENCODING_FLAG;
+const BITFLAG_AMBIGUITY_MASK = BITFLAG_ENCRYPTED | BITFLAG_DATA_DESCRIPTOR | BITFLAG_STRONG_ENCRYPTION | BITFLAG_LANG_ENCODING_FLAG;
 const VENDOR_VERSION_AE_1$1 = 1;
 const ZIP64_PROPERTIES = [
 	[PROPERTY_NAME_UNCOMPRESSED_SIZE, MAX_32_BITS],
@@ -5499,12 +5532,12 @@ let ZipEntry$1 = class ZipEntry {
 			fileEntry.gid = gid;
 		}
 		const checkPasswordOnly = getOptionValue$1(zipEntry, options, OPTION_CHECK_PASSWORD_ONLY);
-		const encrypted = zipEntry.encrypted && localDirectory.encrypted && (!passThroughEncryption || checkPasswordOnly);
+		const encrypted = zipEntry.encrypted && (!passThroughEncryption || checkPasswordOnly);
 		const zipCrypto = encrypted && !extraFieldAES;
 		if (!passThroughEncryption) {
 			fileEntry.zipCrypto = zipCrypto;
 		}
-		if (encrypted && (localDirectory.rawBitFlag & BITFLAG_STRONG_ENCRYPTION) == BITFLAG_STRONG_ENCRYPTION) {
+		if (encrypted && (zipEntry.rawBitFlag & BITFLAG_STRONG_ENCRYPTION) == BITFLAG_STRONG_ENCRYPTION) {
 			throw new Error(ERR_UNSUPPORTED_ENCRYPTION);
 		}
 		const registeredCodec = passThroughCompression ? UNDEFINED_VALUE : getRegisteredCodec(compressionMethod);
@@ -5597,6 +5630,7 @@ let ZipEntry$1 = class ZipEntry {
 				({ writable } = writer);
 				const readable = toCompatibleReadable(reader.createReadable({ offset: dataOffset, size }));
 				const { outputSize: writtenSize } = await runWorker({ readable, writable }, workerOptions);
+				throwIfAborted(signal);
 				if (writtenSize != outputSize) {
 					throw Object.assign(new Error(ERR_INVALID_UNCOMPRESSED_SIZE), { outputSize: writtenSize });
 				}
@@ -5743,8 +5777,16 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 	});
 	const extraFieldZip64 = extraField.get(EXTRAFIELD_TYPE_ZIP64);
 	if (extraFieldZip64) {
-		readExtraFieldZip64(extraFieldZip64, directory);
+		if (!readExtraFieldZip64(extraFieldZip64, directory, localDirectory)) {
+			malformedExtraField = true;
+		}
 		directory.extraFieldZip64 = extraFieldZip64;
+	} else if (ZIP64_PROPERTIES.some(([propertyName, max]) => directory[propertyName] == max)) {
+		if (localDirectory) {
+			malformedExtraField = true;
+		} else {
+			throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
+		}
 	}
 	const extraFieldUnicodePath = extraField.get(EXTRAFIELD_TYPE_UNICODE_PATH);
 	if (extraFieldUnicodePath) {
@@ -5757,10 +5799,13 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 		directory.extraFieldUnicodeComment = extraFieldUnicodeComment;
 	}
 	const extraFieldAES = extraField.get(EXTRAFIELD_TYPE_AES);
-	if (extraFieldAES && extraFieldAES.data.length >= 7) {
+	if (extraFieldAES && (compressionMethod == COMPRESSION_METHOD_AES || directory.encrypted) && extraFieldAES.data.length >= 7) {
 		readExtraFieldAES(extraFieldAES, directory, compressionMethod);
 		directory.extraFieldAES = extraFieldAES;
 	} else {
+		if (extraFieldAES) {
+			malformedExtraField = true;
+		}
 		directory.compressionMethod = compressionMethod;
 	}
 	const extraFieldPkwareUnix = extraField.get(EXTRAFIELD_TYPE_PKWARE_UNIX);
@@ -5803,20 +5848,35 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 	return malformedExtraField;
 }
 
-function readExtraFieldZip64(extraFieldZip64, directory) {
+function readExtraFieldZip64(extraFieldZip64, directory, localDirectory) {
 	directory.zip64 = true;
 	const extraFieldView = getDataView(extraFieldZip64.data);
 	const missingProperties = ZIP64_PROPERTIES.filter(([propertyName, max]) => directory[propertyName] == max);
 	const requiredLength = missingProperties.reduce((length, [, max]) => length + ZIP64_EXTRACTION[max].bytes, 0);
 	if (extraFieldZip64.data.length < requiredLength) {
+		if (localDirectory) {
+			return false;
+		}
 		throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
 	}
-	for (let indexMissingProperty = 0, offset = 0; indexMissingProperty < missingProperties.length; indexMissingProperty++) {
-		const [propertyName, max] = missingProperties[indexMissingProperty];
-		const extraction = ZIP64_EXTRACTION[max];
-		directory[propertyName] = extraFieldZip64[propertyName] = extraction.getValue(extraFieldView, offset);
-		offset += extraction.bytes;
+	const values = [];
+	try {
+		for (let indexMissingProperty = 0, offset = 0; indexMissingProperty < missingProperties.length; indexMissingProperty++) {
+			const [, max] = missingProperties[indexMissingProperty];
+			const extraction = ZIP64_EXTRACTION[max];
+			values.push(extraction.getValue(extraFieldView, offset));
+			offset += extraction.bytes;
+		}
+	} catch (error) {
+		if (localDirectory) {
+			return false;
+		}
+		throw error;
 	}
+	missingProperties.forEach(([propertyName], indexMissingProperty) => {
+		directory[propertyName] = extraFieldZip64[propertyName] = values[indexMissingProperty];
+	});
+	return true;
 }
 
 function readExtraFieldUnicode(extraFieldUnicode, propertyName, rawPropertyName, directory, fileEntry) {
@@ -6392,6 +6452,7 @@ var zipReader = /*#__PURE__*/Object.freeze({
 	ERR_AMBIGUOUS_ARCHIVE: ERR_AMBIGUOUS_ARCHIVE,
 	ERR_BAD_FORMAT: ERR_BAD_FORMAT,
 	ERR_CENTRAL_DIRECTORY_NOT_FOUND: ERR_CENTRAL_DIRECTORY_NOT_FOUND,
+	ERR_CODEC_OUT_OF_MEMORY: ERR_CODEC_OUT_OF_MEMORY,
 	ERR_ENCRYPTED: ERR_ENCRYPTED,
 	ERR_ENCRYPTED_CENTRAL_DIRECTORY: ERR_ENCRYPTED_CENTRAL_DIRECTORY,
 	ERR_ENTRY_DATA_OUT_OF_BOUNDS: ERR_ENTRY_DATA_OUT_OF_BOUNDS,
@@ -7839,6 +7900,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 			const result = await runWorker({ readable, writable }, workerOptions);
 			compressedSize = result.outputSize;
 			writer.size += compressedSize;
+			throwIfAborted(signal);
 			if (!passThroughCompression) {
 				uncompressedSize = result.inputSize;
 				if (!encrypted || zipCrypto) {
@@ -9018,7 +9080,7 @@ function formatSupported(StreamClass, format) {
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const VERSION = "2.16.1";
+const VERSION = "2.18.0";
 
 /*
  Copyright (c) 2025 Gildas Lormeau. All rights reserved.
@@ -9501,6 +9563,10 @@ const FORMAT_DEFLATE = "deflate";
 const FORMAT_DEFLATE_RAW = "deflate-raw";
 const FORMAT_DEFLATE64_RAW = "deflate64-raw";
 const FORMAT_GZIP = "gzip";
+const Z_MEM_ERROR = -4;
+const Z_MEM_ERROR_CODE = "Z_MEM_ERROR";
+const COMPRESSION_FORMATS = [FORMAT_DEFLATE, FORMAT_DEFLATE_RAW, FORMAT_GZIP];
+const DECOMPRESSION_FORMATS = [FORMAT_DEFLATE, FORMAT_DEFLATE_RAW, FORMAT_GZIP, FORMAT_DEFLATE64_RAW];
 
 let wasm$1, malloc, free, memory, initError;
 
@@ -9521,7 +9587,17 @@ function resetWasmExports$1() {
 	wasm$1 = malloc = free = memory = initError = null;
 }
 
+function setZlibCode(error, result) {
+	if (result === Z_MEM_ERROR) {
+		error.code = Z_MEM_ERROR_CODE;
+	}
+	return error;
+}
+
 function _make(isCompress, type, options = {}) {
+	if (!(isCompress ? COMPRESSION_FORMATS : DECOMPRESSION_FORMATS).includes(type)) {
+		throw new TypeError("Unsupported format: " + type);
+	}
 	if (!wasm$1) {
 		const error = new Error("WASM module not loaded");
 		error.cause = initError;
@@ -9530,7 +9606,7 @@ function _make(isCompress, type, options = {}) {
 	const level = (typeof options.level === "number") ? options.level : -1;
 	const outBufferSize = (typeof options.outBuffer === "number") ? options.outBuffer : 64 * 1024;
 	const inBufferSize = (typeof options.inBufferSize === "number") ? options.inBufferSize : 64 * 1024;
-	const state = { out: 0, in: 0, inBufferSize: 0, streamHandle: 0 };
+	const state = { out: 0, in: 0, inBufferSize: 0, streamHandle: 0, streamEnded: false };
 	let readableController, writableController, resolveWrite, cancelReason;
 	let backpressure = true;
 	let cancelled = false;
@@ -9583,7 +9659,7 @@ function _make(isCompress, type, options = {}) {
 			}
 			const result = disposeStream(state);
 			if (result !== 0) {
-				const error = new Error("end error:" + result);
+				const error = setZlibCode(new Error("end error:" + result), result);
 				readableController.error(error);
 				throw error;
 			}
@@ -9603,7 +9679,7 @@ function _make(isCompress, type, options = {}) {
 			state.in = malloc(inBufferSize);
 			state.inBufferSize = inBufferSize;
 			if (!state.out || !state.in) {
-				throw new Error("allocation failed");
+				throw setZlibCode(new Error("allocation failed"), Z_MEM_ERROR);
 			}
 			if (isCompress) {
 				state._process = wasm$1.deflate_process;
@@ -9639,7 +9715,7 @@ function _make(isCompress, type, options = {}) {
 				}
 			}
 			if (result !== 0) {
-				throw new Error("init failed:" + result);
+				throw setZlibCode(new Error("init failed:" + result), result);
 			}
 		} catch (error) {
 			disposeStream(state);
@@ -9654,6 +9730,9 @@ function _make(isCompress, type, options = {}) {
 		const out = state.out;
 		let offset = 0;
 		while (offset < chunk.length) {
+			if (state.streamEnded) {
+				throw new Error("trailing data after the end of the stream");
+			}
 			const toRead = Math.min(chunk.length - offset, 32 * 1024);
 			if (!state.in || state.inBufferSize < toRead) {
 				if (state.in && free) {
@@ -9663,7 +9742,7 @@ function _make(isCompress, type, options = {}) {
 				state.in = malloc(toRead);
 				state.inBufferSize = toRead;
 				if (!state.in) {
-					throw new Error("allocation failed");
+					throw setZlibCode(new Error("allocation failed"), Z_MEM_ERROR);
 				}
 			}
 			heap.set(chunk.subarray(offset, offset + toRead), state.in);
@@ -9672,14 +9751,16 @@ function _make(isCompress, type, options = {}) {
 			const code = (result >> 24) & 0xff;
 			const signedCode = (code & 0x80) ? code - 256 : code;
 			if (signedCode < 0) {
-				throw new Error("process error:" + signedCode);
+				throw setZlibCode(new Error("process error:" + signedCode), signedCode);
 			}
 			const prod = result & 0x00ffffff;
 			if (prod) {
 				enqueue(heap.slice(out, out + prod));
 			}
 			const consumed = last_consumed(state.streamHandle);
-			if (consumed === 0 && prod === 0) {
+			if (code === 1) {
+				state.streamEnded = true;
+			} else if (consumed === 0 && prod === 0) {
 				break;
 			}
 			offset += consumed;
@@ -9695,7 +9776,7 @@ function _make(isCompress, type, options = {}) {
 			const code = (result >> 24) & 0xff;
 			const signedCode = (code & 0x80) ? code - 256 : code;
 			if (signedCode < 0) {
-				throw new Error("process error:" + signedCode);
+				throw setZlibCode(new Error("process error:" + signedCode), signedCode);
 			}
 			const produced = result & 0x00ffffff;
 			if (produced) {
@@ -9754,10 +9835,10 @@ class DecompressionStreamZlib {
 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];
+// on trying the constructor; the formats are declared instead, the lists _make() checks a format
+// against before anything else.
+CompressionStreamZlib.supportedFormats = COMPRESSION_FORMATS;
+DecompressionStreamZlib.supportedFormats = DECOMPRESSION_FORMATS;
 
 /*
  Copyright (c) 2026 Gildas Lormeau. All rights reserved.
@@ -10053,6 +10134,7 @@ const ERR_INVALID_REQUEST_PASSWORD = "Invalid requestPassword option (must be a
 const ERR_ABORT_EXPORT = "zipjs-abort-export";
 const ABORT_ERROR_NAME = "AbortError";
 const EMPTY_RAW_PASSWORD = new Uint8Array(0);
+const FALSE_ACCEPT_ERRORS = new Set([ERR_INVALID_CRC32, ERR_INVALID_UNCOMPRESSED_SIZE, ERR_INVALID_COMPRESSED_DATA]);
 
 class ZipEntry {
 
@@ -11040,7 +11122,12 @@ async function readEntryData(entry, options, passwordState) {
 			release();
 		}
 	}
-	throw new Error(tried.size ? ERR_INVALID_PASSWORD : ERR_ENCRYPTED);
+	if (!tried.size) {
+		throw new Error(ERR_ENCRYPTED);
+	}
+	const passwordError = new Error(ERR_INVALID_PASSWORD);
+	passwordError.cause = error;
+	throw passwordError;
 
 	async function tryPasswordCandidate(candidate) {
 		tried.add(candidate.key);
@@ -11061,7 +11148,7 @@ async function readEntryData(entry, options, passwordState) {
 			rememberPassword(passwordState, candidate);
 			return { done: true, data };
 		} catch (readError) {
-			if (isAbortError(readError, signal) || (!entry.zipCrypto && !isInvalidPasswordError(readError))) {
+			if (isAbortError(readError, signal) || !isWrongPasswordError(readError, entry)) {
 				throw readError;
 			}
 			return { done: false, error: readError };
@@ -11073,6 +11160,10 @@ function isInvalidPasswordError(error) {
 	return isErrorObject(error) && error.message == ERR_INVALID_PASSWORD;
 }
 
+function isWrongPasswordError(error, entry) {
+	return isInvalidPasswordError(error) || (entry.zipCrypto && isErrorObject(error) && FALSE_ACCEPT_ERRORS.has(error.message));
+}
+
 function isAbortError(error, signal) {
 	return Boolean(signal && signal.aborted) || (isErrorObject(error) && error.name == ABORT_ERROR_NAME);
 }
@@ -11493,4 +11584,4 @@ function getPathParent(parent, path, movedEntry) {
 	return parent;
 }
 
-export { BlobReader, BlobWriter, Data64URIReader, Data64URIWriter, ERR_ABORTED, ERR_AMBIGUOUS_ARCHIVE, ERR_ANCESTOR_ENTRY, ERR_BAD_FORMAT, ERR_CENTRAL_DIRECTORY_NOT_FOUND, ERR_DUPLICATED_NAME, ERR_DUPLICATE_IMPORTED_ENTRY, 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_HTTP_STATUS, ERR_INVALID_AUTHENTICATION_CODE, ERR_INVALID_BASE_URI, 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_DUPLICATES, ERR_INVALID_ENCRYPTION_STRENGTH, ERR_INVALID_ENTRY, 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_PASSWORDS, ERR_INVALID_PASSWORD_TYPE, ERR_INVALID_PASS_THROUGH, ERR_INVALID_PASS_THROUGH_VALUE, ERR_INVALID_READER, ERR_INVALID_READER_OPTIONS, ERR_INVALID_REQUEST_PASSWORD, ERR_INVALID_SIGNAL, 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_URI, ERR_INVALID_VERSION, ERR_ITERATOR_COMPLETED_TOO_SOON, ERR_LOCAL_FILE_HEADER_NOT_FOUND, ERR_OVERLAPPING_ENTRY, ERR_PARENT_NOT_DIRECTORY, ERR_READABLE_CONSUMED, ERR_RESERVED_COMPRESSION_METHOD, ERR_ROOT_DIRECTORY_NOT_MOVABLE, ERR_SPLIT_ZIP_FILE, ERR_TARGET_NOT_DIRECTORY, ERR_UNDEFINED_COMPRESSION_METHOD, ERR_UNDEFINED_CRC32, ERR_UNDEFINED_READER, ERR_UNDEFINED_UNCOMPRESSED_SIZE, ERR_UNDETERMINED_SIZE, ERR_UNSAFE_FILENAME, 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_PASS_THROUGH_VALUE, ERR_UNSUPPORTED_SPLIT_USDZ, ERR_UNSUPPORTED_UINT64, ERR_WORKER_STARTUP_TIMEOUT, ERR_WRITER_NOT_INITIALIZED, ERR_WRITER_SIZE_NOT_WRITABLE, ERR_ZIP_CRYPTO_LAST_MOD_DATE, ERR_ZIP_NOT_EMPTY, HttpRangeReader, HttpReader, Reader, SplitDataReader, SplitDataWriter, TextReader, TextWriter, Uint8ArrayReader, Uint8ArrayWriter, VERSION, WARNING_APPENDED_DATA, WARNING_CLAMPED_LAST_MODIFICATION_DATE, WARNING_COMPRESSED_PATCHED_DATA, WARNING_COMPRESSION_UNAVAILABLE, 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_LOCAL_FILE_HEADER_FILENAME, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY, WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY, WARNING_PREPENDED_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 };
+export { BlobReader, BlobWriter, Data64URIReader, Data64URIWriter, ERR_ABORTED, ERR_AMBIGUOUS_ARCHIVE, ERR_ANCESTOR_ENTRY, ERR_BAD_FORMAT, ERR_CENTRAL_DIRECTORY_NOT_FOUND, ERR_CODEC_OUT_OF_MEMORY, ERR_DUPLICATED_NAME, ERR_DUPLICATE_IMPORTED_ENTRY, 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_HTTP_STATUS, ERR_INVALID_AUTHENTICATION_CODE, ERR_INVALID_BASE_URI, 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_DUPLICATES, ERR_INVALID_ENCRYPTION_STRENGTH, ERR_INVALID_ENTRY, 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_PASSWORDS, ERR_INVALID_PASSWORD_TYPE, ERR_INVALID_PASS_THROUGH, ERR_INVALID_PASS_THROUGH_VALUE, ERR_INVALID_READER, ERR_INVALID_READER_OPTIONS, ERR_INVALID_REQUEST_PASSWORD, ERR_INVALID_SIGNAL, 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_URI, ERR_INVALID_VERSION, ERR_ITERATOR_COMPLETED_TOO_SOON, ERR_LOCAL_FILE_HEADER_NOT_FOUND, ERR_OVERLAPPING_ENTRY, ERR_PARENT_NOT_DIRECTORY, ERR_READABLE_CONSUMED, ERR_RESERVED_COMPRESSION_METHOD, ERR_ROOT_DIRECTORY_NOT_MOVABLE, ERR_SPLIT_ZIP_FILE, ERR_TARGET_NOT_DIRECTORY, ERR_UNDEFINED_COMPRESSION_METHOD, ERR_UNDEFINED_CRC32, ERR_UNDEFINED_READER, ERR_UNDEFINED_UNCOMPRESSED_SIZE, ERR_UNDETERMINED_SIZE, ERR_UNSAFE_FILENAME, 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_PASS_THROUGH_VALUE, ERR_UNSUPPORTED_SPLIT_USDZ, ERR_UNSUPPORTED_UINT64, ERR_WORKER_STARTUP_TIMEOUT, ERR_WRITER_NOT_INITIALIZED, ERR_WRITER_SIZE_NOT_WRITABLE, ERR_ZIP_CRYPTO_LAST_MOD_DATE, ERR_ZIP_NOT_EMPTY, HttpRangeReader, HttpReader, Reader, SplitDataReader, SplitDataWriter, TextReader, TextWriter, Uint8ArrayReader, Uint8ArrayWriter, VERSION, WARNING_APPENDED_DATA, WARNING_CLAMPED_LAST_MODIFICATION_DATE, WARNING_COMPRESSED_PATCHED_DATA, WARNING_COMPRESSION_UNAVAILABLE, 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_LOCAL_FILE_HEADER_FILENAME, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY, WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY, WARNING_PREPENDED_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 };