@zip.js/zip.js 2.11.4 → 2.13.0

package/lib/core/zip-fs.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global WritableStream, AbortController, DOMException */
+/* global WritableStream, AbortController */
 // deno-lint-ignore-file no-this-alias
 
 import {
@@ -50,39 +50,30 @@ import {
 } from "./zip-reader.js";
 import {
 	ZipWriter,
-	getEntriesSize
+	getEntriesSize,
+	getSourceEntryOptions
 } from "./zip-writer.js";
 import {
 	Entry
 } from "./zip-entry.js";
-import { checkSignalOption, ERR_ABORTED, ABORT_ERROR_NAME } from "./options.js";
+import { checkSignalOption, throwIfAborted, checkPassThroughOption, PASS_THROUGH_COMPRESSED } from "./options.js";
 import { ProgressWatcherStream, callHandler } from "./codec-worker.js";
 import {
 	UNDEFINED_VALUE,
 	FUNCTION_TYPE,
-	OBJECT_TYPE,
-	MAX_8_BITS,
-	MIN_DATE,
-	MAX_DATE,
-	EXTRAFIELD_TYPE_ZIP64,
-	EXTRAFIELD_TYPE_AES,
-	EXTRAFIELD_TYPE_NTFS,
-	EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP,
-	EXTRAFIELD_TYPE_UNICODE_PATH,
-	EXTRAFIELD_TYPE_UNICODE_COMMENT,
-	EXTRAFIELD_TYPE_USDZ,
-	EXTRAFIELD_TYPE_INFOZIP,
-	EXTRAFIELD_TYPE_UNIX,
-	EXTRAFIELD_TYPE_UNIX_TYPE1,
-	EXTRAFIELD_TYPE_PKWARE_UNIX
+	OBJECT_TYPE
 } from "./constants.js";
 import { toExactUint8Array } from "./util/array.js";
 import { toCompatibleReadable, toCompatibleWritable } from "./util/compatible-streams.js";
+import { isErrorObject } from "./util/error.js";
 
 const ERR_ENTRY_EXISTS = "Entry filename already exists";
 const ERR_DUPLICATE_IMPORTED_ENTRY = "Duplicate entry filename in the imported zip file";
 const ERR_INVALID_DUPLICATES = "Invalid duplicates option (must be \"throw\", \"keep-first\" or \"keep-last\")";
-const ERR_ANCESTOR_ENTRY = "Entry is a ancestor of target entry";
+const ERR_ANCESTOR_ENTRY = "Entry is an ancestor of target entry";
+const ERR_ROOT_DIRECTORY_NOT_MOVABLE = "Root directory cannot be moved";
+const ERR_TARGET_NOT_DIRECTORY = "Target entry is not a directory";
+const ERR_PARENT_NOT_DIRECTORY = "Parent entry is not a directory";
 const ERR_READABLE_CONSUMED = "Readable stream already consumed";
 const DUPLICATES_THROW = "throw";
 const DUPLICATES_KEEP_FIRST = "keep-first";
@@ -90,22 +81,8 @@ const DUPLICATES_KEEP_LAST = "keep-last";
 const DUPLICATES_VALUES = new Set([DUPLICATES_THROW, DUPLICATES_KEEP_FIRST, DUPLICATES_KEEP_LAST]);
 const ERR_INVALID_PASS_THROUGH = "Invalid passThrough option (use readerOptions.passThrough or set uncompressedSize for each entry)";
 const ERR_INVALID_READER_OPTIONS = "Invalid readerOptions (must be an object)";
-const ERR_ZIP_CRYPTO_LAST_MOD_DATE = "The last modification date of an entry encrypted with ZipCrypto cannot be changed when passThrough is set";
+const ERR_UNSUPPORTED_PASS_THROUGH_VALUE = "The 'compressed' passThrough option is only supported by Entry#getData() and ZipWriter#add()";
 const ERR_ABORT_EXPORT = "zipjs-abort-export";
-const INFOZIP_EXTRA_FIELD_TYPE = "infozip";
-const INTERPRETED_EXTRA_FIELD_TYPES = new Set([
-	EXTRAFIELD_TYPE_ZIP64,
-	EXTRAFIELD_TYPE_AES,
-	EXTRAFIELD_TYPE_NTFS,
-	EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP,
-	EXTRAFIELD_TYPE_UNICODE_PATH,
-	EXTRAFIELD_TYPE_UNICODE_COMMENT,
-	EXTRAFIELD_TYPE_USDZ,
-	EXTRAFIELD_TYPE_INFOZIP,
-	EXTRAFIELD_TYPE_UNIX,
-	EXTRAFIELD_TYPE_UNIX_TYPE1,
-	EXTRAFIELD_TYPE_PKWARE_UNIX
-]);
 
 class ZipEntry {
 
@@ -237,7 +214,7 @@ class ZipFileEntry extends ZipEntry {
 				}));
 				return true;
 			} catch (error) {
-				if (error.message == ERR_INVALID_PASSWORD) {
+				if (isErrorObject(error) && error.message == ERR_INVALID_PASSWORD) {
 					return false;
 				} else {
 					throw error;
@@ -477,6 +454,7 @@ class ZipDirectoryEntry extends ZipEntry {
 			await initStream(reader);
 			zipReader = new ZipReader(reader, options);
 		}
+		checkPassThroughValue(options.passThrough);
 		const duplicates = checkDuplicatesOption(options.duplicates);
 		const importedEntries = [];
 		const entries = await zipReader.getEntries(options);
@@ -567,18 +545,25 @@ class ZipDirectoryEntry extends ZipEntry {
 
 	async exportZip(writer, options = {}) {
 		const zipEntry = this;
+		const zipWriterProvided = Boolean(writer) && typeof writer.add == FUNCTION_TYPE;
 		options = Object.assign({}, options);
-		if (options.bufferedWrite === UNDEFINED_VALUE) {
+		if (!zipWriterProvided && options.bufferedWrite === UNDEFINED_VALUE) {
 			options.bufferedWrite = true;
 		}
-		const [readers] = await Promise.all([initReaders(zipEntry, checkReaderOptions(options.readerOptions)), initStream(writer)]);
-		const zipWriter = new ZipWriter(writer, options);
+		const [readers] = await Promise.all([
+			initReaders(zipEntry, checkReaderOptions(options.readerOptions)),
+			zipWriterProvided ? UNDEFINED_VALUE : initStream(writer)
+		]);
+		const zipWriter = zipWriterProvided ? writer : new ZipWriter(writer, options);
 		await exportZip(zipWriter, zipEntry, getTotalSize([zipEntry], getUncompressedSize), options, readers);
+		if (zipWriterProvided) {
+			return zipWriter;
+		}
 		await zipWriter.close(options.globalComment);
 		return writer.getData ? writer.getData() : writer.writable;
 	}
 
-	getExportedSize(options = {}) {
+	async getExportedSize(options = {}) {
 		const zipEntry = this;
 		options = Object.assign({}, options);
 		checkReaderOptions(options.readerOptions);
@@ -593,7 +578,7 @@ class ZipDirectoryEntry extends ZipEntry {
 		const writeOrderGuaranteed = !options.bufferedWrite ||
 			(entries.every(entry => entry.options.keepOrder !== false) &&
 				children.every(child => isImplicitDirectory(child) || !child.children.length));
-		return getEntriesSize(options, entries, writeOrderGuaranteed, options.globalComment);
+		return await getEntriesSize(options, entries, writeOrderGuaranteed, options.globalComment);
 	}
 
 	getChildByName(name) {
@@ -654,7 +639,7 @@ class ZipFS {
 
 	move(entry, destination) {
 		if (entry == this.root) {
-			throw new Error("Root directory cannot be moved");
+			throw new Error(ERR_ROOT_DIRECTORY_NOT_MOVABLE);
 		} else {
 			if (destination.directory) {
 				if (!destination.isDescendantOf(entry)) {
@@ -675,7 +660,7 @@ class ZipFS {
 					throw new Error(ERR_ANCESTOR_ENTRY);
 				}
 			} else {
-				throw new Error("Target entry is not a directory");
+				throw new Error(ERR_TARGET_NOT_DIRECTORY);
 			}
 		}
 	}
@@ -807,7 +792,7 @@ class ZipFS {
 }
 
 const fs = { FS: ZipFS, ZipDirectoryEntry, ZipFileEntry };
-export { ZipFS, ZipEntry, ZipFileEntry, ZipDirectoryEntry, fs, ERR_ENTRY_EXISTS, ERR_DUPLICATE_IMPORTED_ENTRY, ERR_INVALID_DUPLICATES, ERR_READABLE_CONSUMED, ERR_INVALID_PASS_THROUGH, ERR_INVALID_READER_OPTIONS, ERR_ZIP_CRYPTO_LAST_MOD_DATE, ERR_ABORTED };
+export { ZipFS, ZipEntry, ZipFileEntry, ZipDirectoryEntry, fs, ERR_ENTRY_EXISTS, ERR_DUPLICATE_IMPORTED_ENTRY, ERR_INVALID_DUPLICATES, ERR_READABLE_CONSUMED, ERR_INVALID_PASS_THROUGH, ERR_UNSUPPORTED_PASS_THROUGH_VALUE, ERR_INVALID_READER_OPTIONS, ERR_ANCESTOR_ENTRY, ERR_ROOT_DIRECTORY_NOT_MOVABLE, ERR_TARGET_NOT_DIRECTORY, ERR_PARENT_NOT_DIRECTORY };
 
 function getTotalSize(entries, getEntrySize) {
 	let size = 0;
@@ -989,70 +974,11 @@ function getChildEntryOptions(child, selectedEntry, options) {
 	let zipEntryMetadata = {};
 	let passThroughOptions = {};
 	if (child.data instanceof Entry) {
-		const {
-			externalFileAttributes,
-			versionMadeBy,
-			comment,
-			lastModDate,
-			rawLastModDate,
-			creationDate,
-			lastAccessDate,
-			uncompressedSize,
-			encrypted,
-			zipCrypto,
-			crc32,
-			compressionMethod,
-			extraFieldAES,
-			internalFileAttributes,
-			extraField,
-			bitFlag,
-			uid,
-			gid
-		} = child.data;
-		zipEntryMetadata = {
-			externalFileAttributes,
-			versionMadeBy,
-			comment,
-			lastModDate,
-			creationDate,
-			lastAccessDate,
-			internalFileAttributes
-		};
-		const userExtraField = getUserExtraField(extraField);
-		if (userExtraField) {
-			zipEntryMetadata.extraField = userExtraField;
-		}
-		if (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE) {
-			Object.assign(zipEntryMetadata, {
-				uid,
-				gid,
-				unixExtraFieldType: INFOZIP_EXTRA_FIELD_TYPE
-			});
-		}
-		if (isPassThrough(child, options)) {
-			let encryptionStrength;
-			if (extraFieldAES) {
-				encryptionStrength = extraFieldAES.strength;
-			}
-			passThroughOptions = {
-				passThrough: true,
-				encrypted,
-				zipCrypto,
-				crc32,
-				uncompressedSize,
-				encryptionStrength,
-				compressionMethod
-			};
-			if (bitFlag) {
-				passThroughOptions.dataDescriptor = bitFlag.dataDescriptor;
-			}
-			const lastModDateOverride = childOptions.lastModDate === UNDEFINED_VALUE ? options.lastModDate : childOptions.lastModDate;
-			if (lastModDateOverride === UNDEFINED_VALUE) {
-				passThroughOptions.rawLastModDate = rawLastModDate;
-			} else if (zipCrypto && (!bitFlag || bitFlag.dataDescriptor) && lastModDateOverride instanceof Date &&
-				getDosTimeHighByte(lastModDateOverride) != ((rawLastModDate >>> 8) & MAX_8_BITS)) {
-				throw new Error(ERR_ZIP_CRYPTO_LAST_MOD_DATE);
-			}
+		const passThrough = isPassThrough(child, options);
+		const lastModDateOverride = childOptions.lastModDate === UNDEFINED_VALUE ? options.lastModDate : childOptions.lastModDate;
+		({ entryOptions: zipEntryMetadata, passThroughOptions } = getSourceEntryOptions(child.data, passThrough, lastModDateOverride));
+		if (passThrough) {
+			passThroughOptions.passThrough = true;
 		}
 	}
 	const entryOptions = Object.assign({ lastModDate: child.defaultLastModDate }, zipEntryMetadata, options, childOptions, passThroughOptions, { directory: child.directory });
@@ -1062,16 +988,6 @@ function getChildEntryOptions(child, selectedEntry, options) {
 	return { name, entryOptions };
 }
 
-function getDosTimeHighByte(lastModDate) {
-	let dosLastModDate = new Date(Math.ceil(Math.floor(lastModDate.getTime() / 1000) / 2) * 2000);
-	if (dosLastModDate < MIN_DATE) {
-		dosLastModDate = MIN_DATE;
-	} else if (dosLastModDate > MAX_DATE) {
-		dosLastModDate = MAX_DATE;
-	}
-	return ((dosLastModDate.getHours() << 3) | (dosLastModDate.getMinutes() >> 3)) & MAX_8_BITS;
-}
-
 function getDeterminedSize(child, passThrough) {
 	const { reader } = child;
 	if (reader && reader.size !== UNDEFINED_VALUE) {
@@ -1084,9 +1000,18 @@ function checkReaderOptions(readerOptions) {
 	if (readerOptions && (typeof readerOptions != OBJECT_TYPE || Array.isArray(readerOptions))) {
 		throw new Error(ERR_INVALID_READER_OPTIONS);
 	}
+	if (readerOptions) {
+		checkPassThroughValue(readerOptions.passThrough);
+	}
 	return readerOptions;
 }
 
+function checkPassThroughValue(passThrough) {
+	if (checkPassThroughOption(passThrough) === PASS_THROUGH_COMPRESSED) {
+		throw new Error(ERR_UNSUPPORTED_PASS_THROUGH_VALUE);
+	}
+}
+
 function replaceContent(zipEntry, params) {
 	const { uncompressedSize } = params;
 	Object.assign(zipEntry, params, {
@@ -1115,20 +1040,6 @@ function isImplicitDirectory(child) {
 	return child.directory && child.data === null;
 }
 
-function getUserExtraField(extraField) {
-	if (extraField) {
-		const userExtraField = new Map();
-		extraField.forEach((field, type) => {
-			if (!INTERPRETED_EXTRA_FIELD_TYPES.has(type)) {
-				userExtraField.set(type, field.data);
-			}
-		});
-		if (userExtraField.size) {
-			return userExtraField;
-		}
-	}
-}
-
 async function exportZip(zipWriter, entry, totalSize, options, readers) {
 	const { onstart, onprogress, onend, onentryprogress } = options;
 	const selectedEntry = entry;
@@ -1231,6 +1142,7 @@ function addFileSystemHandle(zipEntry, handle, options) {
 
 async function exportFileSystemHandle(zipEntry, directoryHandle, options) {
 	const { onstart, onprogress, onend } = options;
+	checkPassThroughValue(options.passThrough);
 	const readerOptions = checkReaderOptions(options.readerOptions);
 	const abortController = new AbortController();
 	const { signal } = abortController;
@@ -1306,7 +1218,7 @@ async function exportFileSystemHandle(zipEntry, directoryHandle, options) {
 			if (exportAborted || isExportAborted(signal.reason)) {
 				return;
 			}
-			throw signal.reason === UNDEFINED_VALUE ? new DOMException(ERR_ABORTED, ABORT_ERROR_NAME) : signal.reason;
+			throwIfAborted(signal);
 		}
 		try {
 			if (child.directory) {
@@ -1439,7 +1351,7 @@ function addChild(parent, name, params, directory) {
 		}
 		return directory ? new ZipDirectoryEntry(parent.fs, name, params, parent) : new ZipFileEntry(parent.fs, name, params, parent);
 	} else {
-		throw new Error("Parent entry is not a directory");
+		throw new Error(ERR_PARENT_NOT_DIRECTORY);
 	}
 }
 

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,7 +121,9 @@ 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 { isErrorObject } from "./util/error.js";
 import { Crc32 } from "./streams/codecs/crc32.js";
 import {
 	PROPERTY_NAME_RAW_FILENAME,
@@ -137,7 +140,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 +158,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,
@@ -175,6 +180,7 @@ import {
 	checkSignalOption,
 	throwIfAborted,
 	checkPasswordOption,
+	checkPassThroughOption,
 	toNumber
 } from "./options.js";
 
@@ -208,6 +214,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)";
@@ -278,7 +286,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);
@@ -576,7 +584,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;
@@ -657,49 +666,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 entryReadable = (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
-							}
-						}
-					}
-				})();
+				const entryStream = createEntryStream(value, pendingEntries);
 				const chunk = {
 					...value,
-					readable: entryReadable
+					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);
@@ -763,6 +824,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
@@ -805,7 +868,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;
@@ -826,7 +891,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);
@@ -857,16 +924,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) {
@@ -883,15 +951,16 @@ class ZipEntry {
 		const readable = toCompatibleReadable(reader.createReadable({ offset: dataOffset, size }));
 		const signal = checkSignalOption(getOptionValue(zipEntry, options, OPTION_SIGNAL));
 		throwIfAborted(signal);
-		const checkPasswordOnly = getOptionValue(zipEntry, options, OPTION_CHECK_PASSWORD_ONLY);
 		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) {
@@ -900,7 +969,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: {
@@ -944,7 +1013,7 @@ class ZipEntry {
 				readRanges
 			});
 		}
-		let writable, abortError;
+		let writable, abortError, aborted;
 		try {
 			if (!checkOverlappingEntryOnly) {
 				if (checkPasswordOnly) {
@@ -954,24 +1023,28 @@ 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) {
+			const { outputSize: failedOutputSize } = workerOptions;
+			if (failedOutputSize !== UNDEFINED_VALUE) {
+				writer.size += failedOutputSize;
+			} else if (isErrorObject(error) && error.outputSize !== UNDEFINED_VALUE) {
 				writer.size += error.outputSize;
 			}
-			if (!checkPasswordOnly || error.message != ERR_ABORT_CHECK_PASSWORD) {
+			if (!checkPasswordOnly || !isErrorObject(error) || error.message != ERR_ABORT_CHECK_PASSWORD) {
 				abortError = error;
+				aborted = true;
 				throw error;
 			}
 		} finally {
 			const preventClose = !ownsWritable(writer) && getOptionValue(zipEntry, options, OPTION_PREVENT_CLOSE);
 			if (!preventClose && writable && !writable.locked) {
 				const writableWriter = writable.getWriter();
-				if (abortError) {
+				if (aborted) {
 					try {
 						await writableWriter.abort(abortError);
 					} catch {
@@ -1623,7 +1696,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);
@@ -1648,16 +1721,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;