@zip.js/zip.js 2.14.1 → 2.16.0

package/dist/zip-core.js

@@ -1858,7 +1858,6 @@
 	const GZIP_HEADER_LENGTH = 10;
 	const GZIP_TRAILER_LENGTH = 8;
 	const GZIP_HEADER_BYTES = [0x1f, 0x8b, 0x08];
-	const GZIP_OUTPUT_STALL_TIMEOUT = 5000;
 
 	class DeflateStream extends TransformStream {
 
@@ -1869,8 +1868,8 @@
 			let crc32Stream, encryptionStream, gzipCrc32Stream;
 			let readable = super.readable;
 			const codecStreams = format && getCodecStreams(format);
-			const useGzipCrc32 = computeCrc32 && compressed && !deflate64 && !codecStreams && (!encrypted || zipCrypto) &&
-				Boolean(useCompressionStream && CompressionStream);
+			const GzipCompressionStream = getGzipCodecStream(useCompressionStream, CompressionStream, CompressionStreamFallback);
+			const useGzipCrc32 = computeCrc32 && compressed && !deflate64 && !codecStreams && (!encrypted || zipCrypto) && Boolean(GzipCompressionStream);
 			if ((!encrypted || zipCrypto) && computeCrc32 && !useGzipCrc32) {
 				crc32Stream = new Crc32Stream();
 				readable = pipeThrough(readable, crc32Stream);
@@ -1880,12 +1879,15 @@
 					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 GzipCompressionStream(FORMAT_GZIP, { level, chunkSize }));
 					readable = pipeThrough(readable, gzipCrc32Stream);
 				} else {
 					try {
 						readable = pipeThroughCompressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamFallback);
 					} catch (error) {
+						if (!useCompressionStream && CompressionStreamFallback) {
+							throw error;
+						}
 						let gzipStream;
 						try {
 							gzipStream = new CompressionStream(FORMAT_GZIP);
@@ -1954,82 +1956,144 @@
 		}
 	}
 
-	function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize) {
-		const crc32 = new Crc32();
+	function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, crc32) {
+		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 watchdogTimeout;
+		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(() => { });
-		if (!outputSize) {
-			resolveTrailerReady();
-		}
-		const gzipWrapStream = new TransformStream({
-			start(controller) {
+		pump();
+		return new ReadableStream({
+			async pull(controller) {
+				let result;
+				try {
+					result = await read();
+				} catch (error) {
+					throw trailerWritten ? getTrailerError(error) : error;
+				}
+				const { value, done } = result;
+				if (done) {
+					controller.close();
+				} else {
+					outputLength += value.length;
+					if (outputLength > outputSize) {
+						const error = new Error(ERR_INVALID_UNCOMPRESSED_SIZE);
+						rejectTrailerReady(error);
+						await cancel(reader, error);
+						throw error;
+					}
+					if (outputCrc32) {
+						outputCrc32.append(value);
+					}
+					controller.enqueue(value);
+				}
+			},
+			cancel(reason) {
+				rejectTrailerReady(reason);
+				return reader.cancel(reason);
+			}
+		});
+
+		async function pump() {
+			const inputReader = readable.getReader();
+			try {
 				const header = new Uint8Array(GZIP_HEADER_LENGTH);
 				header.set(GZIP_HEADER_BYTES);
-				controller.enqueue(header);
-			},
-			transform(chunk, controller) {
-				controller.enqueue(chunk);
-			},
-			async flush(controller) {
+				await writer.write(header);
+				for (; ;) {
+					await writer.ready;
+					const { value, done } = await inputReader.read();
+					if (done) {
+						break;
+					}
+					await writer.write(value);
+				}
 				inputDone = true;
-				startWatchdog();
-				try {
+				if (outputCrc32) {
+					if (readPending) {
+						armIdleCheck();
+					}
 					await trailerReady;
-				} finally {
-					stopWatchdog();
 				}
 				const trailer = new Uint8Array(GZIP_TRAILER_LENGTH);
 				const dataView = getDataView(trailer);
-				dataView.setUint32(0, crc32.get(), true);
+				dataView.setUint32(0, outputCrc32 ? outputCrc32.get() : crc32, true);
 				dataView.setUint32(4, outputSize, true);
-				controller.enqueue(trailer);
-			},
-			cancel(reason) {
-				rejectTrailerReady(reason);
+				trailerWritten = true;
+				await writer.write(trailer);
+				await writer.close();
+			} catch (error) {
+				await abort(writer, error);
+				await cancel(inputReader, error);
 			}
-		});
-		const outputStream = new TransformStream({
-			transform(chunk, controller) {
-				crc32.append(chunk);
-				outputLength += chunk.length;
-				if (outputLength >= outputSize) {
-					resolveTrailerReady();
-				} else if (inputDone) {
-					startWatchdog();
-				}
-				controller.enqueue(chunk);
-			},
-			cancel(reason) {
-				rejectTrailerReady(reason);
+		}
+
+		function read() {
+			readCount++;
+			readPending = true;
+			const result = reader.read();
+			result.then(onReadSettled, onReadSettled);
+			if (inputDone && outputCrc32) {
+				armIdleCheck();
 			}
-		});
-		readable = pipeThrough(readable, gzipWrapStream);
-		readable = pipeThroughBackpressured(readable, gzipStream);
-		return pipeThrough(readable, outputStream);
+			return result;
+		}
 
-		function startWatchdog() {
-			stopWatchdog();
-			watchdogTimeout = setTimeout(() => rejectTrailerReady(new Error(ERR_INVALID_UNCOMPRESSED_SIZE)), GZIP_OUTPUT_STALL_TIMEOUT);
+		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 stopWatchdog() {
-			clearTimeout(watchdogTimeout);
+		function getTrailerError(error) {
+			const trailerError = new Error(outputLength == outputSize ? ERR_INVALID_CRC32 : ERR_INVALID_UNCOMPRESSED_SIZE);
+			trailerError.cause = error;
+			return trailerError;
 		}
 	}
 
+	function nextTask() {
+		return new Promise(resolve => {
+			const { port1, port2 } = new MessageChannel();
+			port2.onmessage = () => {
+				port1.close();
+				port2.close();
+				resolve();
+			};
+			port1.postMessage(UNDEFINED_VALUE);
+		});
+	}
+
 	class InflateStream extends TransformStream {
 
 		constructor(options, { chunkSize, DecompressionStreamFallback, DecompressionStream }) {
 			super({});
 			const { zipCrypto, encrypted, checkCrc32, crc32, compressed, useCompressionStream, deflate64, format, compressionMethod, rawBitFlag, outputSize } = options;
-			let crc32Stream, decryptionStream;
+			let crc32Stream, decryptionStream, gzipCrc32;
 			let readable = super.readable;
 			if (encrypted) {
 				if (zipCrypto) {
@@ -2044,31 +2108,44 @@
 				if (codecStreams) {
 					readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.DecompressionStream, format, { chunkSize, compressionMethod, rawBitFlag, uncompressedSize: outputSize }));
 				} else {
-					try {
-						readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamFallback);
-					} catch (error) {
-						if (deflate64 || outputSize === UNDEFINED_VALUE) {
-							throw error;
-						}
-						let gzipStream;
+					let gzipStream;
+					const GzipDecompressionStream = getGzipCodecStream(useCompressionStream, DecompressionStream, DecompressionStreamFallback);
+					if (checkCrc32 && !deflate64 && crc32 !== UNDEFINED_VALUE && outputSize !== UNDEFINED_VALUE && GzipDecompressionStream) {
 						try {
-							gzipStream = new DecompressionStream(FORMAT_GZIP);
+							gzipStream = new GzipDecompressionStream(FORMAT_GZIP, { chunkSize });
 						} catch {
-							throw error;
+							gzipStream = UNDEFINED_VALUE;
+						}
+					}
+					if (!gzipStream) {
+						try {
+							readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamFallback);
+						} catch (error) {
+							if (deflate64 || outputSize === UNDEFINED_VALUE || (!useCompressionStream && DecompressionStreamFallback)) {
+								throw error;
+							}
+							try {
+								gzipStream = new DecompressionStream(FORMAT_GZIP);
+							} catch {
+								throw error;
+							}
 						}
-						readable = pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize);
+					}
+					if (gzipStream) {
+						gzipCrc32 = true;
+						readable = pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, crc32);
 					}
 				}
 				readable = mapInflateStreamError(readable);
 			}
-			if (checkCrc32) {
+			if (checkCrc32 && !gzipCrc32) {
 				crc32Stream = new Crc32Stream();
 				readable = pipeThrough(readable, crc32Stream);
 			}
 			setReadable(this, readable, () => {
-				if (checkCrc32) {
-					const computedCrc32View = new DataView(crc32Stream.value.buffer);
-					if (crc32 != computedCrc32View.getUint32(0, false)) {
+				if (crc32Stream) {
+					const computedCrc32 = new DataView(crc32Stream.value.buffer).getUint32(0, false);
+					if (crc32 != computedCrc32) {
 						throw new Error(ERR_INVALID_CRC32);
 					}
 				}
@@ -2124,6 +2201,14 @@
 		return new CodecStreamClass(format, options);
 	}
 
+	function getGzipCodecStream(useCompressionStream, CodecStreamNative, CodecStreamFallback) {
+		if (useCompressionStream && CodecStreamNative) {
+			return CodecStreamNative;
+		} else if (CodecStreamFallback && CodecStreamFallback.requiresModule) {
+			return CodecStreamFallback;
+		}
+	}
+
 	function pipeThroughCompressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamFallback) {
 		const Stream = useCompressionStream && CompressionStreamNative ?
 			CompressionStreamNative :
@@ -2492,10 +2577,12 @@
 								workerData.terminated = true;
 								worker.terminate();
 							}
-							terminateResolvers.forEach(resolve => resolve());
 						}
 						workerData.busy = false;
-						onTaskFinished(workerData);
+						const pendingTasks = onTaskFinished(workerData);
+						if (terminateResolvers) {
+							terminateResolvers.forEach(resolve => resolve(pendingTasks));
+						}
 					}
 				}
 			});
@@ -3180,7 +3267,10 @@
 
 		function onTaskFinished(workerData) {
 			clearStarvationTimeout();
-			if (pendingRequests.length) {
+			if (workerData.terminated) {
+				workerData.terminated = false;
+				return runPendingRequestsInline();
+			} else if (pendingRequests.length) {
 				const [{ resolve, stream, workerOptions }] = pendingRequests.splice(0, 1);
 				resolve(new CodecWorker(workerData, stream, workerOptions, onTaskFinished));
 				armStarvationTimeout();
@@ -3218,12 +3308,26 @@
 		starvationTimeout = null;
 		if (pendingRequests.length) {
 			const [{ resolve, stream, workerOptions }] = pendingRequests.splice(0, 1);
-			const inlineWorkerOptions = Object.assign({}, workerOptions, { useWebWorkers: false, workerURI: UNDEFINED_VALUE, createWorker: UNDEFINED_VALUE });
-			resolve(new CodecWorker({}, stream, inlineWorkerOptions, onInlineTaskFinished));
+			resolve(new CodecWorker({}, stream, getInlineWorkerOptions(workerOptions), onInlineTaskFinished));
 			armStarvationTimeout();
 		}
 	}
 
+	function runPendingRequestsInline() {
+		const tasks = pendingRequests.splice(0).map(({ resolve, stream, workerOptions }) => new Promise(resolveTask => {
+			resolve(new CodecWorker({}, stream, getInlineWorkerOptions(workerOptions), () => {
+				onInlineTaskFinished();
+				resolveTask();
+			}));
+		}));
+		clearStarvationTimeout();
+		return Promise.all(tasks);
+	}
+
+	function getInlineWorkerOptions(workerOptions) {
+		return Object.assign({}, workerOptions, { useWebWorkers: false, workerURI: UNDEFINED_VALUE, createWorker: UNDEFINED_VALUE });
+	}
+
 	function onInlineTaskFinished() {
 		clearStarvationTimeout();
 		armStarvationTimeout();
@@ -3233,18 +3337,14 @@
 		const { config } = workerOptions;
 		const { terminateWorkerTimeout } = config;
 		if (Number.isFinite(terminateWorkerTimeout) && terminateWorkerTimeout >= 0) {
-			if (workerData.terminated) {
-				workerData.terminated = false;
-			} else {
-				workerData.terminateTimeout = setTimeout(async () => {
-					pool = pool.filter(data => data != workerData);
-					try {
-						await workerData.terminate();
-					} catch {
-						// ignored
-					}
-				}, terminateWorkerTimeout);
-			}
+			workerData.terminateTimeout = setTimeout(async () => {
+				pool = pool.filter(data => data != workerData);
+				try {
+					await workerData.terminate();
+				} catch {
+					// ignored
+				}
+			}, terminateWorkerTimeout);
 		}
 	}
 
@@ -3257,10 +3357,13 @@
 	}
 
 	async function terminateWorkers() {
-		await Promise.allSettled(pool.map(workerData => {
-			clearTerminateTimeout(workerData);
-			return workerData.terminate();
-		}));
+		await Promise.allSettled([
+			runPendingRequestsInline(),
+			...pool.map(workerData => {
+				clearTerminateTimeout(workerData);
+				return workerData.terminate();
+			})
+		]);
 		resetWebWorkerSupport();
 	}
 
@@ -3335,6 +3438,19 @@
 		return decode(value, encoding, true);
 	}
 
+	function isUTF8Text(value) {
+		if (value.some(byte => byte > 0x7f)) {
+			try {
+				new TextDecoder("utf-8", { fatal: true }).decode(value);
+				return true;
+			} catch {
+				return false;
+			}
+		} else {
+			return false;
+		}
+	}
+
 	function decodeTextRemovingBOM(value, encoding) {
 		return decode(value, encoding, false);
 	}
@@ -3667,10 +3783,11 @@
 
 		createReadable(options) {
 			const reader = this;
-			const { useRangeHeader, forceRangeRequests, size } = reader;
+			const { useRangeHeader, forceRangeRequests, size, eocdCache } = reader;
 			if ((useRangeHeader || forceRangeRequests) && size !== UNDEFINED_VALUE) {
 				const { offset = 0, size: readSize = size - offset } = options || {};
-				if (readSize > 0 && offset < size) {
+				const cached = eocdCache && offset >= size - eocdCache.length;
+				if (readSize > 0 && offset < size && !cached) {
 					return createRangeReadable(reader, offset, Math.min(readSize, size - offset));
 				}
 			}
@@ -4624,6 +4741,7 @@
 	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 PARENT_DIRECTORY_REGEXP = /(^|[\\/])\.\.([\\/]|$)/;
 	const CHARSET_UTF8 = "utf-8";
 	const PROPERTY_NAME_UTF8_SUFFIX = "UTF8";
 	const CHARSET_CP437 = "cp437";
@@ -4876,12 +4994,13 @@
 				const versionMadeBy = getUint16$1(directoryView, offset + 4);
 				const msDosCompatible = versionMadeBy >> 8 == 0;
 				const unixCompatible = versionMadeBy >> 8 == 3;
-				const rawFilename = directoryArray.subarray(filenameOffset, extraFieldOffset);
 				const commentLength = getUint16$1(directoryView, offset + 32);
 				const endOffset = commentOffset + commentLength;
-				const rawComment = directoryArray.subarray(commentOffset, endOffset);
-				const filenameUTF8 = languageEncodingFlag;
-				const commentUTF8 = languageEncodingFlag;
+				const rawEntryData = new Uint8Array(directoryArray.subarray(filenameOffset, endOffset));
+				const rawFilename = rawEntryData.subarray(0, fileEntry.filenameLength);
+				const rawComment = rawEntryData.subarray(fileEntry.filenameLength + fileEntry.extraFieldLength);
+				const filenameUTF8 = languageEncodingFlag || (!filenameEncoding && isUTF8Text(rawFilename));
+				const commentUTF8 = languageEncodingFlag || (!commentEncoding && isUTF8Text(rawComment));
 				const externalFileAttributes = getUint32$1(directoryView, offset + 38);
 				const msdosAttributesRaw = externalFileAttributes & MAX_8_BITS;
 				const msdosAttributes = {
@@ -4932,7 +5051,7 @@
 					rawFilename,
 					filenameUTF8,
 					commentUTF8,
-					rawExtraField: directoryArray.subarray(extraFieldOffset, commentOffset),
+					rawExtraField: rawEntryData.subarray(fileEntry.filenameLength, fileEntry.filenameLength + fileEntry.extraFieldLength),
 					rawComment,
 					filename,
 					comment
@@ -5440,7 +5559,7 @@
 			if (getUint32$1(signatureRecordView, 0) == DIGITAL_SIGNATURE_RECORD_SIGNATURE) {
 				const signatureDataLength = getUint16$1(signatureRecordView, 4);
 				if (6 + signatureDataLength <= signatureRecordArray.length) {
-					return signatureRecordArray.subarray(6, 6 + signatureDataLength);
+					return new Uint8Array(signatureRecordArray.subarray(6, 6 + signatureDataLength));
 				}
 			}
 		}
@@ -5963,10 +6082,10 @@
 		if (pathParts.length > 1 && pathParts[pathParts.length - 1] === "") {
 			pathParts.pop();
 		}
-		if (pathParts.includes("..") || filename.startsWith("/") || filename.startsWith("\\\\") || DRIVE_LETTER_REGEXP.test(filename)) {
+		if (PARENT_DIRECTORY_REGEXP.test(filename) || filename.startsWith("/") || filename.startsWith("\\") || DRIVE_LETTER_REGEXP.test(filename)) {
 			return true;
 		}
-		return filenameValidation == STRICTNESS_STRICT && (pathParts.includes(".") || pathParts.includes(""));
+		return filenameValidation == STRICTNESS_STRICT && (pathParts.includes(".") || pathParts.includes("") || filename.includes("\0"));
 	}
 
 	function getMaxAppendedDataSize(maxAppendedDataSize, strictness) {
@@ -6052,7 +6171,7 @@
 	}
 
 	function getEndOfCentralDirectoryInfo(scanArray, indexByte, offset) {
-		return { offset, buffer: scanArray.slice(indexByte, indexByte + END_OF_CENTRAL_DIR_LENGTH).buffer };
+		return { offset, buffer: new Uint8Array(scanArray.subarray(indexByte, indexByte + END_OF_CENTRAL_DIR_LENGTH)).buffer };
 	}
 
 	async function getCentralDirectoryReachability(reader, view, anchoredOffset, indexByte, offset, size, remoteProbeBudget) {
@@ -8699,7 +8818,7 @@
 	 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 	 */
 
-	const VERSION = "2.14.1";
+	const VERSION = "2.16.0";
 
 	/*
 	 Copyright (c) 2025 Gildas Lormeau. All rights reserved.