@zip.js/zip.js 2.16.1 → 2.18.0

package/dist/zip-core.js

@@ -1900,7 +1900,9 @@
 
 	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 = "Z_MEM_ERROR";
 	const FORMAT_DEFLATE_RAW = "deflate-raw";
 	const FORMAT_DEFLATE64_RAW = "deflate64-raw";
 	const FORMAT_GZIP = "gzip";
@@ -1935,13 +1937,13 @@
 						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);
 						} catch {
-							throw error;
+							throw mapMemoryError(error);
 						}
 						readable = pipeThroughBackpressured(readable, gzipStream);
 						readable = pipeThrough(readable, new GzipToRawDeflateStream());
@@ -2005,50 +2007,30 @@
 		}
 	}
 
-	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();
@@ -2057,19 +2039,16 @@
 				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);
@@ -2084,54 +2063,68 @@
 			}
 		}
 
-		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 {
@@ -2150,11 +2143,12 @@
 				}
 			}
 			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 {
@@ -2165,24 +2159,25 @@
 					}
 					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);
 							} 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();
@@ -2255,7 +2250,7 @@
 		}
 	}
 
-	function pipeThroughCompressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamFallback) {
+	function pipeThroughCompressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamFallback, sourceErrors) {
 		const Stream = useCompressionStream && CompressionStreamNative ?
 			CompressionStreamNative :
 			CompressionStreamFallback || CompressionStreamNative;
@@ -2270,14 +2265,14 @@
 				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();
@@ -2287,7 +2282,7 @@
 			try {
 				for (; ;) {
 					await writer.ready;
-					const result = await reader.read();
+					const result = await readSource(reader, sourceErrors);
 					if (result.done) {
 						await writer.close();
 						break;
@@ -2317,7 +2312,36 @@
 		}
 	}
 
-	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;
+	}
+
+	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) {
@@ -2330,12 +2354,7 @@
 					}
 				} 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) {
@@ -2699,10 +2718,11 @@
 			}
 			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,
@@ -2770,6 +2790,7 @@
 	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;
@@ -2946,6 +2967,13 @@
 				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;
@@ -3208,9 +3236,6 @@
 			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 {
@@ -3220,6 +3245,14 @@
 				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;
@@ -4790,7 +4823,7 @@
 	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],
@@ -5444,12 +5477,12 @@
 				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);
@@ -5542,6 +5575,7 @@
 					({ 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 });
 					}
@@ -5688,8 +5722,16 @@
 		});
 		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) {
@@ -5702,10 +5744,13 @@
 			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);
@@ -5748,20 +5793,35 @@
 		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) {
@@ -6337,6 +6397,7 @@
 		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,
@@ -7686,6 +7747,7 @@
 				const result = await runWorker({ readable, writable }, workerOptions);
 				compressedSize = result.outputSize;
 				writer.size += compressedSize;
+				throwIfAborted(signal);
 				if (!passThroughCompression) {
 					uncompressedSize = result.inputSize;
 					if (!encrypted || zipCrypto) {
@@ -8865,7 +8927,7 @@
 	 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.
@@ -9322,6 +9384,7 @@
 	exports.ERR_AMBIGUOUS_ARCHIVE = ERR_AMBIGUOUS_ARCHIVE;
 	exports.ERR_BAD_FORMAT = ERR_BAD_FORMAT;
 	exports.ERR_CENTRAL_DIRECTORY_NOT_FOUND = ERR_CENTRAL_DIRECTORY_NOT_FOUND;
+	exports.ERR_CODEC_OUT_OF_MEMORY = ERR_CODEC_OUT_OF_MEMORY;
 	exports.ERR_DUPLICATED_NAME = ERR_DUPLICATED_NAME;
 	exports.ERR_ENCRYPTED = ERR_ENCRYPTED;
 	exports.ERR_ENCRYPTED_CENTRAL_DIRECTORY = ERR_ENCRYPTED_CENTRAL_DIRECTORY;