@zip.js/zip.js 2.11.3 → 2.12.0

package/lib/core/zip-reader.js

@@ -95,6 +95,7 @@ import {
 	FILE_ATTR_UNIX_STICKY_MASK,
 	NUMBER_TYPE,
 	EMPTY_UINT8_ARRAY,
+	SYMBOL_ASYNC_DISPOSE,
 	MIN_DATE
 } from "./constants.js";
 import { getConfiguration } from "./configuration.js";
@@ -120,6 +121,7 @@ import {
 } from "./io.js";
 import { decodeText } from "./util/decode-text.js";
 import { getDataView } from "./util/array.js";
+import { addWarning } from "./util/warnings.js";
 import { toCompatibleReadable, streamToBlob } from "./util/compatible-streams.js";
 import { Crc32 } from "./streams/codecs/crc32.js";
 import {
@@ -137,7 +139,8 @@ import {
 	PROPERTY_NAME_RAW_LAST_ACCESS_DATE,
 	PROPERTY_NAME_CREATION_DATE,
 	PROPERTY_NAME_RAW_CREATION_DATE,
-	Entry
+	Entry,
+	getEncryptionOverhead
 } from "./zip-entry.js";
 import {
 	OPTION_FILENAME_ENCODING,
@@ -154,6 +157,7 @@ import {
 	OPTION_CHECK_OVERLAPPING_ENTRY,
 	OPTION_CHECK_AMBIGUITY,
 	OPTION_CHECK_LOCAL_DIRECTORY,
+	OPTION_CHECK_LOCAL_FILENAME,
 	OPTION_CHECK_SIGNATURE,
 	OPTION_CHECK_CRC32,
 	OPTION_CHECK_AUTHENTICATION_CODE,
@@ -173,7 +177,9 @@ import {
 	OPTION_PREVENT_CLOSE,
 	checkFunctionOption,
 	checkSignalOption,
+	throwIfAborted,
 	checkPasswordOption,
+	checkPassThroughOption,
 	toNumber
 } from "./options.js";
 
@@ -207,6 +213,8 @@ const WARNING_PREPENDED_CENTRAL_DIRECTORY = "prepended central directory";
 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_MULTIPLE_END_OF_CENTRAL_DIRECTORY = "multiple end of central directory records";
+const WARNING_MISMATCHED_LOCAL_FILE_HEADER_FILENAME = "mismatched local file header (filename)";
 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)";
@@ -277,7 +285,7 @@ class ZipReader {
 			}
 		}
 		if (rejectAmbiguousEndOfDirectory && endOfDirectoryReachingEndCount > 1) {
-			throwAmbiguousArchive("multiple end of central directory records");
+			throwAmbiguousArchive(WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY);
 		}
 		const endOfDirectoryView = getDataView(endOfDirectoryInfo);
 		let directoryDataLength = getUint32(endOfDirectoryView, 12);
@@ -575,7 +583,8 @@ class ZipReader {
 				const writer = new TransformStream();
 				const arrayBufferPromise = streamToBlob(writer.readable).then(blob => blob.arrayBuffer());
 				arrayBufferPromise.catch(() => { });
-				await fileEntry.getData(writer, entry, zipReader.readRanges, options);
+				await fileEntry.getData(writer, entry, zipReader.readRanges,
+					Object.assign({}, options, { preventClose: false }));
 				return arrayBufferPromise;
 			};
 			offset = endOffset;
@@ -656,48 +665,101 @@ class ZipReader {
 			await reader.readable.cancel();
 		}
 	}
+
+	[SYMBOL_ASYNC_DISPOSE]() {
+		return this.close();
+	}
 }
 
 class ZipReaderStream {
 
 	constructor(options = {}) {
-		const { readable, writable } = new TransformStream();
-		const gen = new ZipReader(readable, options).getEntriesGenerator();
+		let sourceController;
+		const { readable, writable } = new TransformStream({
+			start(controller) {
+				sourceController = controller;
+			}
+		});
+		const zipReader = new ZipReader(readable, options);
+		const gen = zipReader.getEntriesGenerator();
+		const pendingEntries = new Set();
 		this.readable = new ReadableStream({
 			async pull(controller) {
 				const { done, value } = await gen.next();
 				if (done)
 					return controller.close();
+				const entryStream = createEntryStream(value, pendingEntries);
 				const chunk = {
 					...value,
-					readable: (function () {
-						const { readable, writable } = new TransformStream();
-						if (value.getData) {
-							getData();
-							return readable;
-						}
-
-						async function getData() {
-							try {
-								await value.getData(writable);
-							} catch (error) {
-								try {
-									await writable.abort(error);
-								} catch {
-									// ignored
-								}
-							}
-						}
-					})()
+					readable: entryStream.readable
 				};
 				delete chunk.getData;
+				Object.defineProperties(chunk, {
+					localDirectory: {
+						get: () => value.localDirectory,
+						enumerable: true
+					},
+					warnings: {
+						get: () => value.warnings,
+						enumerable: true
+					}
+				});
 				controller.enqueue(chunk);
+			},
+			async cancel(reason) {
+				const entryStreams = Array.from(pendingEntries);
+				pendingEntries.clear();
+				sourceController.error(reason);
+				await Promise.allSettled(entryStreams.map(entryStream => entryStream.cancel(reason)));
+				await Promise.allSettled([gen.return(), zipReader.close()]);
 			}
 		});
 		this.writable = writable;
 	}
 }
 
+function createEntryStream(entry, pendingEntries) {
+	const { readable, writable } = new TransformStream();
+	let dataReader;
+	const entryStream = {
+		cancel: async reason => {
+			pendingEntries.delete(entryStream);
+			await (dataReader ? dataReader.cancel(reason) : readable.cancel(reason));
+		}
+	};
+	entryStream.readable = new ReadableStream({
+		async pull(controller) {
+			if (!dataReader) {
+				dataReader = readable.getReader();
+				pendingEntries.add(entryStream);
+				getData();
+			}
+			const { done, value } = await dataReader.read();
+			if (done) {
+				controller.close();
+			} else {
+				controller.enqueue(value);
+			}
+		},
+		cancel: reason => entryStream.cancel(reason)
+	}, { highWaterMark: 0 });
+	return entryStream;
+
+	async function getData() {
+		try {
+			await entry.getData(writable, { preventClose: false });
+		} catch (error) {
+			try {
+				await writable.abort(error);
+			} catch {
+				// ignored
+			}
+		} finally {
+			pendingEntries.delete(entryStream);
+		}
+	}
+}
+
 async function isZipFile(reader, options = {}) {
 	reader = new GenericReader(reader);
 	await initStream(reader);
@@ -761,6 +823,8 @@ export {
 	WARNING_TRAILING_CENTRAL_DIRECTORY_DATA,
 	WARNING_DUPLICATE_FILENAME,
 	WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY,
+	WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY,
+	WARNING_MISMATCHED_LOCAL_FILE_HEADER_FILENAME,
 	WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG,
 	WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD,
 	WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES
@@ -803,7 +867,9 @@ class ZipEntry {
 		const dataView = getDataView(dataArray);
 		let password = getOptionValue(zipEntry, options, OPTION_PASSWORD);
 		let rawPassword = getOptionValue(zipEntry, options, OPTION_RAW_PASSWORD);
-		const passThrough = getOptionValue(zipEntry, options, OPTION_PASS_THROUGH);
+		const passThrough = checkPassThroughOption(getOptionValue(zipEntry, options, OPTION_PASS_THROUGH));
+		const passThroughCompression = Boolean(passThrough);
+		const passThroughEncryption = passThrough === true;
 		checkPasswordOption(password, rawPassword);
 		password = password && password.length && password;
 		rawPassword = rawPassword && rawPassword.length && rawPassword;
@@ -824,7 +890,9 @@ class ZipEntry {
 		const checkLocalDirectoryOption = getOptionValue(zipEntry, options, OPTION_CHECK_LOCAL_DIRECTORY);
 		const entryStrictness = getStrictness(options, zipEntry.options);
 		const checkLocalDirectory = getCheckLocalDirectory(checkLocalDirectoryOption, entryStrictness);
-		const checkLocalFilename = getCheckLocalFilename(checkLocalDirectoryOption, entryStrictness);
+		const checkLocalFilenameOption = getOptionValue(zipEntry, options, OPTION_CHECK_LOCAL_FILENAME);
+		const checkLocalFilename = getCheckLocalFilename(
+			checkLocalFilenameOption === UNDEFINED_VALUE ? checkLocalDirectoryOption : checkLocalFilenameOption, entryStrictness);
 		let rawLocalFilename = EMPTY_UINT8_ARRAY;
 		if (checkLocalFilename && (filenameLength || extraFieldLength)) {
 			const trailingDataArray = await readUint8Array(reader, localHeaderOffset + HEADER_SIZE, filenameLength + extraFieldLength);
@@ -855,16 +923,17 @@ class ZipEntry {
 		if (gid !== UNDEFINED_VALUE && fileEntry.gid === UNDEFINED_VALUE) {
 			fileEntry.gid = gid;
 		}
-		const encrypted = zipEntry.encrypted && localDirectory.encrypted && !passThrough;
+		const checkPasswordOnly = getOptionValue(zipEntry, options, OPTION_CHECK_PASSWORD_ONLY);
+		const encrypted = zipEntry.encrypted && localDirectory.encrypted && (!passThroughEncryption || checkPasswordOnly);
 		const zipCrypto = encrypted && !extraFieldAES;
-		if (!passThrough) {
+		if (!passThroughEncryption) {
 			fileEntry.zipCrypto = zipCrypto;
 		}
 		if (encrypted && (localDirectory.rawBitFlag & BITFLAG_STRONG_ENCRYPTION) == BITFLAG_STRONG_ENCRYPTION) {
 			throw new Error(ERR_UNSUPPORTED_ENCRYPTION);
 		}
-		const registeredCodec = passThrough ? UNDEFINED_VALUE : getRegisteredCodec(compressionMethod);
-		if (compressionMethod != COMPRESSION_METHOD_STORE && compressionMethod != COMPRESSION_METHOD_DEFLATE && compressionMethod != COMPRESSION_METHOD_DEFLATE_64 && !registeredCodec && !passThrough) {
+		const registeredCodec = passThroughCompression ? UNDEFINED_VALUE : getRegisteredCodec(compressionMethod);
+		if (compressionMethod != COMPRESSION_METHOD_STORE && compressionMethod != COMPRESSION_METHOD_DEFLATE && compressionMethod != COMPRESSION_METHOD_DEFLATE_64 && !registeredCodec && !passThroughCompression) {
 			throw new Error(ERR_UNSUPPORTED_COMPRESSION);
 		}
 		if (encrypted) {
@@ -880,15 +949,17 @@ class ZipEntry {
 		const size = compressedSize;
 		const readable = toCompatibleReadable(reader.createReadable({ offset: dataOffset, size }));
 		const signal = checkSignalOption(getOptionValue(zipEntry, options, OPTION_SIGNAL));
-		const checkPasswordOnly = getOptionValue(zipEntry, options, OPTION_CHECK_PASSWORD_ONLY);
+		throwIfAborted(signal);
 		let checkOverlappingEntry = getOptionValue(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY);
 		const checkOverlappingEntryOnly = getOptionValue(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY_ONLY);
 		if (checkOverlappingEntryOnly) {
 			checkOverlappingEntry = true;
 		}
 		const { onstart, onprogress, onend } = options;
-		const compressed = compressionMethod != COMPRESSION_METHOD_STORE && !passThrough;
-		const outputSize = passThrough ? compressedSize : uncompressedSize;
+		const compressed = compressionMethod != COMPRESSION_METHOD_STORE && !passThroughCompression;
+		const outputSize = passThroughCompression ?
+			compressedSize - getEncryptionOverhead(encrypted, zipCrypto, extraFieldAES && extraFieldAES.strength) :
+			uncompressedSize;
 		const deflate64 = compressionMethod == COMPRESSION_METHOD_DEFLATE_64;
 		let useCompressionStream = getOptionValue(zipEntry, options, OPTION_USE_COMPRESSION_STREAM);
 		if (deflate64) {
@@ -897,7 +968,7 @@ class ZipEntry {
 		const checkCrc32Option = getOptionValue(zipEntry, options, OPTION_CHECK_CRC32);
 		const checkCrc32 = (checkCrc32Option === UNDEFINED_VALUE ?
 			getOptionValue(zipEntry, options, OPTION_CHECK_SIGNATURE) :
-			checkCrc32Option) && !passThrough &&
+			checkCrc32Option) && !passThroughCompression &&
 			(!encrypted || zipCrypto || (extraFieldAES && extraFieldAES.vendorVersion == VENDOR_VERSION_AE_1));
 		const workerOptions = {
 			options: {
@@ -951,10 +1022,10 @@ class ZipEntry {
 				await initStream(writer, getDecodableOutputSize(outputSize, compressedSize, compressed));
 				({ writable } = writer);
 				const { outputSize: writtenSize } = await runWorker({ readable, writable }, workerOptions);
-				writer.size += writtenSize;
 				if (writtenSize != outputSize) {
-					throw new Error(ERR_INVALID_UNCOMPRESSED_SIZE);
+					throw Object.assign(new Error(ERR_INVALID_UNCOMPRESSED_SIZE), { outputSize: writtenSize });
 				}
+				writer.size += writtenSize;
 			}
 		} catch (error) {
 			if (error.outputSize !== UNDEFINED_VALUE) {
@@ -1620,7 +1691,7 @@ function validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, chec
 	if (checkLocalFilename && !maskedLocalDirectory &&
 		(rawLocalFilename.length != rawFilename.length ||
 			rawLocalFilename.some((byteValue, indexByte) => byteValue != rawFilename[indexByte]))) {
-		reportAmbiguity(reject, warnings, "mismatched local file header (filename)");
+		reportAmbiguity(reject, warnings, WARNING_MISMATCHED_LOCAL_FILE_HEADER_FILENAME);
 	}
 	if ((localDirectory.rawBitFlag & BITFLAG_AMBIGUITY_MASK) != (zipEntry.rawBitFlag & BITFLAG_AMBIGUITY_MASK)) {
 		reportAmbiguity(reject, warnings, WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG);
@@ -1645,16 +1716,6 @@ function reportAmbiguity(reject, 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);
-	}
-}
-
 function throwAmbiguousArchive(reason) {
 	const error = new Error(ERR_AMBIGUOUS_ARCHIVE);
 	error.reason = reason;