@zip.js/zip.js 2.11.4 → 2.12.0

package/dist/zip-fs-core.js

@@ -134,6 +134,7 @@
 	const BOOLEAN_TYPE = "boolean";
 
 	const EMPTY_UINT8_ARRAY = new Uint8Array();
+	const SYMBOL_ASYNC_DISPOSE = Symbol.asyncDispose || Symbol();
 
 	/*
 	 Copyright (c) 2022 Gildas Lormeau. All rights reserved.
@@ -178,6 +179,7 @@
 	const OPTION_CHECK_OVERLAPPING_ENTRY = "checkOverlappingEntry";
 	const OPTION_CHECK_AMBIGUITY = "checkAmbiguity";
 	const OPTION_CHECK_LOCAL_DIRECTORY = "checkLocalDirectory";
+	const OPTION_CHECK_LOCAL_FILENAME = "checkLocalFilename";
 	const OPTION_CHECK_SIGNATURE = "checkSignature";
 	const OPTION_CHECK_CRC32 = "checkCrc32";
 	const OPTION_CHECK_AUTHENTICATION_CODE = "checkAuthenticationCode";
@@ -208,15 +210,18 @@
 	const OPTION_MAX_APPENDED_DATA_SIZE = "maxAppendedDataSize";
 	const OPTION_DECRYPT_CENTRAL_DIRECTORY = "decryptCentralDirectory";
 	const OPTION_SIGN_CENTRAL_DIRECTORY = "signCentralDirectory";
+	const OPTION_ENTRY = "entry";
 	const TEXT_TYPE_FILENAME = "filename";
 	const TEXT_TYPE_COMMENT = "comment";
 	const STRICTNESS_STRICT = "strict";
 	const STRICTNESS_BALANCED = "balanced";
 	const STRICTNESS_TOLERANT = "tolerant";
+	const PASS_THROUGH_COMPRESSED = "compressed";
 
 	const ERR_INVALID_FUNCTION_OPTION = "Invalid option (must be a function)";
 	const ERR_INVALID_SIGNAL = "Invalid signal (must be an AbortSignal instance)";
 	const ERR_INVALID_PASSWORD_TYPE = "Invalid password (password must be a string, rawPassword must be a Uint8Array)";
+	const ERR_INVALID_PASS_THROUGH_VALUE = "Invalid passThrough option (must be a boolean or 'compressed')";
 	const ERR_ABORTED = "The operation was aborted";
 	const ABORT_ERROR_NAME = "AbortError";
 
@@ -246,6 +251,13 @@
 		}
 	}
 
+	function checkPassThroughOption(passThrough) {
+		if (passThrough !== UNDEFINED_VALUE && typeof passThrough != BOOLEAN_TYPE && passThrough !== PASS_THROUGH_COMPRESSED) {
+			throw new Error(ERR_INVALID_PASS_THROUGH_VALUE);
+		}
+		return passThrough;
+	}
+
 	function checkInteger(value, maxValue, errorMessage) {
 		if (!Number.isInteger(value) || value < 0 || value > maxValue) {
 			throw new Error(errorMessage);
@@ -295,6 +307,8 @@
 	const MINIMUM_CHUNK_SIZE = 64;
 	const MINIMUM_PROPERTY_VALUE = 1;
 	const ERR_INVALID_MAX_WORKERS = "Invalid maxWorkers (must be an integer greater than 0)";
+	const ERR_INVALID_BASE_URI = "Invalid baseURI (must be a string)";
+	const ERR_INVALID_URI = "Invalid URI (must be a string or a function returning a string)";
 	let maxWorkers = 2;
 	try {
 		if (typeof navigator != UNDEFINED_TYPE && navigator.hardwareConcurrency) {
@@ -319,9 +333,9 @@
 	};
 
 	const PROPERTY_NAME_MAX_WORKERS = "maxWorkers";
+	const PROPERTY_NAME_BASE_URI = "baseURI";
 
-	const STRING_PROPERTY_NAMES = [
-		"baseURI",
+	const URI_PROPERTY_NAMES = [
 		"wasmURI",
 		"workerURI"
 	];
@@ -345,7 +359,8 @@
 		"DecompressionStreamFallback"
 	];
 	const CONFIGURABLE_PROPERTY_NAMES = [
-		...STRING_PROPERTY_NAMES,
+		PROPERTY_NAME_BASE_URI,
+		...URI_PROPERTY_NAMES,
 		...BOOLEAN_PROPERTY_NAMES,
 		...NUMBER_PROPERTY_NAMES,
 		...FUNCTION_PROPERTY_NAMES
@@ -389,6 +404,14 @@
 			}
 		} else if (FUNCTION_PROPERTY_NAMES.includes(propertyName)) {
 			checkFunctionOption(propertyValue);
+		} else if (propertyName == PROPERTY_NAME_BASE_URI) {
+			if (propertyValue && typeof propertyValue != STRING_TYPE) {
+				throw new Error(ERR_INVALID_BASE_URI);
+			}
+		} else if (URI_PROPERTY_NAMES.includes(propertyName)) {
+			if (propertyValue && typeof propertyValue != STRING_TYPE && typeof propertyValue != FUNCTION_TYPE) {
+				throw new Error(ERR_INVALID_URI);
+			}
 		}
 		return propertyValue;
 	}
@@ -2605,6 +2628,7 @@
 		constructor(chunkSize) {
 			const pendingChunks = [];
 			let pendingLength = 0;
+			let outputSize = 0;
 			if (!Number.isFinite(chunkSize) || chunkSize < 1) {
 				chunkSize = DEFAULT_CHUNK_SIZE;
 			}
@@ -2613,15 +2637,20 @@
 					pendingChunks.push(chunk);
 					pendingLength += chunk.length;
 					while (pendingLength > chunkSize) {
+						outputSize += chunkSize;
 						controller.enqueue(shiftChunk());
 					}
 				},
 				flush(controller) {
 					if (pendingLength) {
+						outputSize += pendingLength;
 						controller.enqueue(concatChunks(pendingChunks, pendingLength));
 					}
 				}
 			});
+			Object.defineProperty(this, "outputSize", {
+				get: () => outputSize
+			});
 
 			function shiftChunk() {
 				const result = new Uint8Array(chunkSize);
@@ -2822,7 +2851,7 @@
 	}
 
 	async function runWorker$1({ options, readable, writable, onTaskFinished }, config) {
-		let codecStream;
+		let codecStream, chunkStream;
 		try {
 			if (options.compressed && !options.format) {
 				const deflate = options.codecType.startsWith(CODEC_DEFLATE);
@@ -2845,9 +2874,10 @@
 				}
 			}
 			codecStream = new CodecStream(options, config);
+			chunkStream = new ChunkStream(getChunkSize(config));
 			await readable
 				.pipeThrough(codecStream)
-				.pipeThrough(new ChunkStream(getChunkSize(config)))
+				.pipeThrough(chunkStream)
 				.pipeTo(writable, { preventClose: true, preventAbort: true });
 			const {
 				crc32,
@@ -2861,7 +2891,7 @@
 			};
 		} catch (error) {
 			if (codecStream) {
-				error.outputSize = codecStream.outputSize;
+				error.outputSize = chunkStream ? chunkStream.outputSize : 0;
 			}
 			throw error;
 		} finally {
@@ -2970,11 +3000,17 @@
 		let resolveResult, rejectResult;
 		const result = new Promise((resolve, reject) => {
 			resolveResult = resolve;
-			rejectResult = reject;
+			rejectResult = error => {
+				if (error && error.outputSize === UNDEFINED_VALUE) {
+					error.outputSize = workerData.outputSize;
+				}
+				reject(error);
+			};
 		});
 		Object.assign(workerData, {
 			reader: null,
 			writer: null,
+			outputSize: 0,
 			resolveResult,
 			rejectResult,
 			result
@@ -3258,8 +3294,10 @@
 					}
 				}
 				if (type == MESSAGE_DATA) {
+					const chunk = new Uint8Array(value);
 					await writer.ready;
-					await writer.write(new Uint8Array(value));
+					await writer.write(chunk);
+					workerData.outputSize += chunk.length;
 					if (!stale()) {
 						sendMessage({ type: MESSAGE_ACK_DATA, messageId }, workerData);
 					}
@@ -3567,10 +3605,13 @@
 
 
 	const ERR_HTTP_STATUS = "HTTP error ";
+	const MIN_SUCCESS_HTTP_STATUS = 200;
+	const MAX_SUCCESS_HTTP_STATUS = 299;
 	const ERR_HTTP_RANGE = "HTTP Range not supported";
 	const ERR_HTTP_RESOURCE_CHANGED = "HTTP resource changed";
 	const ERR_ITERATOR_COMPLETED_TOO_SOON = "Writer iterator completed too soon";
 	const ERR_WRITER_NOT_INITIALIZED = "Writer not initialized";
+	const ERR_WRITER_SIZE_NOT_WRITABLE = "Invalid writer (size must be writable)";
 
 	const CONTENT_TYPE_TEXT_PLAIN = "text/plain";
 	const HTTP_HEADER_CONTENT_LENGTH = "Content-Length";
@@ -3762,6 +3803,7 @@
 			const reader = this;
 			const { sourceBlob, size } = reader;
 			const { offset = 0, size: readSize = size - offset } = options || {};
+			// deno-lint-ignore valid-typeof
 			if (typeof sourceBlob.stream == FUNCTION_TYPE) {
 				if (!offset && readSize >= size) {
 					return toCompatibleReadable(sourceBlob.stream());
@@ -4168,7 +4210,7 @@
 
 	async function sendFetchRequest(method, { fetch: fetchFunction = fetch, options, url }, headers) {
 		const response = await fetchFunction(url, Object.assign({}, options, { method, headers }));
-		if (response.status < 400) {
+		if (response.status >= MIN_SUCCESS_HTTP_STATUS && response.status <= MAX_SUCCESS_HTTP_STATUS) {
 			return response;
 		} else {
 			throw response.status == 416 ? new Error(ERR_HTTP_RANGE) : new Error(ERR_HTTP_STATUS + (response.statusText || response.status));
@@ -4179,7 +4221,7 @@
 		return new Promise((resolve, reject) => {
 			const request = new XMLHttpRequest();
 			request.addEventListener("load", () => {
-				if (request.status < 400) {
+				if (request.status >= MIN_SUCCESS_HTTP_STATUS && request.status <= MAX_SUCCESS_HTTP_STATUS) {
 					const headers = [];
 					request.getAllResponseHeaders().trim().split(/[\r\n]+/).forEach(header => {
 						const splitHeader = header.trim().split(/\s*:\s*/);
@@ -4483,8 +4525,10 @@
 					writable: toCompatibleWritable(writer)
 				};
 			}
-			if (writer.size === UNDEFINED_VALUE) {
-				writer.size = 0;
+			try {
+				writer.size = writer.size === UNDEFINED_VALUE ? 0 : writer.size;
+			} catch {
+				throw new Error(ERR_WRITER_SIZE_NOT_WRITABLE);
 			}
 			return writer;
 		}
@@ -4532,6 +4576,45 @@
 		}
 	}
 
+	/*
+	 Copyright (c) 2026 Gildas Lormeau. All rights reserved.
+
+	 Redistribution and use in source and binary forms, with or without
+	 modification, are permitted provided that the following conditions are met:
+
+	 1. Redistributions of source code must retain the above copyright notice,
+	 this list of conditions and the following disclaimer.
+
+	 2. Redistributions in binary form must reproduce the above copyright
+	 notice, this list of conditions and the following disclaimer in
+	 the documentation and/or other materials provided with the distribution.
+
+	 3. The names of the authors may not be used to endorse or promote products
+	 derived from this software without specific prior written permission.
+
+	 THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+	 INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+	 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+	 INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+	 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+	 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+	 OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+	 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+	 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+	 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+	 */
+
+
+	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);
+		}
+	}
+
 	/*
 	 Copyright (c) 2025 Gildas Lormeau. All rights reserved.
 
@@ -4560,6 +4643,7 @@
 	 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 	 */
 
+
 	const PROPERTY_NAME_FILENAME = "filename";
 	const PROPERTY_NAME_RAW_FILENAME = "rawFilename";
 	const PROPERTY_NAME_COMMENT = "comment";
@@ -4684,6 +4768,38 @@
 
 	}
 
+	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
+	]);
+
+	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;
+			}
+		}
+	}
+
+	function getEncryptionOverhead(encrypted, zipCrypto, encryptionStrength) {
+		return encrypted ? (zipCrypto ? 12 : 16 + encryptionStrength * 4) : 0;
+	}
+
 	/*
 	 Copyright (c) 2025 Gildas Lormeau. All rights reserved.
 
@@ -4743,6 +4859,8 @@
 	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)";
@@ -4813,7 +4931,7 @@
 				}
 			}
 			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$1(endOfDirectoryView, 12);
@@ -5111,7 +5229,8 @@
 					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;
@@ -5192,49 +5311,101 @@
 				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);
@@ -5294,7 +5465,9 @@
 			const dataView = getDataView(dataArray);
 			let password = getOptionValue$1(zipEntry, options, OPTION_PASSWORD);
 			let rawPassword = getOptionValue$1(zipEntry, options, OPTION_RAW_PASSWORD);
-			const passThrough = getOptionValue$1(zipEntry, options, OPTION_PASS_THROUGH);
+			const passThrough = checkPassThroughOption(getOptionValue$1(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;
@@ -5315,7 +5488,9 @@
 			const checkLocalDirectoryOption = getOptionValue$1(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$1(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);
@@ -5346,16 +5521,17 @@
 			if (gid !== UNDEFINED_VALUE && fileEntry.gid === UNDEFINED_VALUE) {
 				fileEntry.gid = gid;
 			}
-			const encrypted = zipEntry.encrypted && localDirectory.encrypted && !passThrough;
+			const checkPasswordOnly = getOptionValue$1(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) {
@@ -5372,15 +5548,16 @@
 			const readable = toCompatibleReadable(reader.createReadable({ offset: dataOffset, size }));
 			const signal = checkSignalOption(getOptionValue$1(zipEntry, options, OPTION_SIGNAL));
 			throwIfAborted(signal);
-			const checkPasswordOnly = getOptionValue$1(zipEntry, options, OPTION_CHECK_PASSWORD_ONLY);
 			let checkOverlappingEntry = getOptionValue$1(zipEntry, options, OPTION_CHECK_OVERLAPPING_ENTRY);
 			const checkOverlappingEntryOnly = getOptionValue$1(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$1(zipEntry, options, OPTION_USE_COMPRESSION_STREAM);
 			if (deflate64) {
@@ -5389,7 +5566,7 @@
 			const checkCrc32Option = getOptionValue$1(zipEntry, options, OPTION_CHECK_CRC32);
 			const checkCrc32 = (checkCrc32Option === UNDEFINED_VALUE ?
 				getOptionValue$1(zipEntry, options, OPTION_CHECK_SIGNATURE) :
-				checkCrc32Option) && !passThrough &&
+				checkCrc32Option) && !passThroughCompression &&
 				(!encrypted || zipCrypto || (extraFieldAES && extraFieldAES.vendorVersion == VENDOR_VERSION_AE_1$1));
 			const workerOptions = {
 				options: {
@@ -5443,10 +5620,10 @@
 					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) {
@@ -6112,7 +6289,7 @@
 		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);
@@ -6137,16 +6314,6 @@
 		}
 	}
 
-	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;
@@ -6226,7 +6393,9 @@
 		WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG: WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG,
 		WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD: WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD,
 		WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES: WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES,
+		WARNING_MISMATCHED_LOCAL_FILE_HEADER_FILENAME: WARNING_MISMATCHED_LOCAL_FILE_HEADER_FILENAME,
 		WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY: WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY,
+		WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY: WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY,
 		WARNING_PREPENDED_CENTRAL_DIRECTORY: WARNING_PREPENDED_CENTRAL_DIRECTORY,
 		WARNING_PREPENDED_DATA: WARNING_PREPENDED_DATA,
 		WARNING_TRAILING_CENTRAL_DIRECTORY_DATA: WARNING_TRAILING_CENTRAL_DIRECTORY_DATA,
@@ -6279,7 +6448,7 @@
 	const ERR_INVALID_ENCRYPTION_STRENGTH = "The strength must equal 1, 2, or 3";
 	const ERR_UNSUPPORTED_ENCRYPTION_USDZ = "Encryption is not supported in USDZ files";
 	const ERR_UNSUPPORTED_SPLIT_USDZ = "Split zip files are not supported in USDZ files";
-	const ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH = "Encryption is not supported when the 'passThrough' option is set";
+	const ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH = "Encryption is not supported when the 'passThrough' option is set to true (use 'compressed' instead)";
 	const ERR_INVALID_EXTRAFIELD = "Invalid extra field (must be a Map)";
 	const ERR_INVALID_EXTRAFIELD_TYPE = "Invalid extra field type (must be integer 0..65535)";
 	const ERR_INVALID_EXTRAFIELD_DATA_TYPE = "Invalid extra field data (must be a Uint8Array)";
@@ -6291,6 +6460,7 @@
 	const ERR_UNSUPPORTED_FORMAT = "Zip64 is not supported (set the 'zip64' option to 'true')";
 	const ERR_UNDEFINED_UNCOMPRESSED_SIZE = "Undefined uncompressed size";
 	const ERR_UNDEFINED_COMPRESSION_METHOD = "Undefined compression method";
+	const ERR_UNDEFINED_CRC32 = "Undefined CRC32";
 	const ERR_UNDETERMINED_SIZE = "Undetermined size";
 	const ERR_UNDEFINED_READER = "Undefined reader";
 	const ERR_INVALID_READER = "Invalid reader (must be a Reader instance, a ReadableStream instance, or an object with a 'readable' property)";
@@ -6304,14 +6474,21 @@
 	const ERR_INVALID_MSDOS_DATA = "Invalid msdosAttributes (must be an object with boolean flags)";
 	const ERR_INVALID_LEVEL = "Invalid level (must be integer 0..9)";
 	const ERR_INVALID_SIGNATURE_DATA = "Signature data exceeds 64KB";
+	const ERR_INVALID_ENTRY = "Invalid entry option (must be an entry returned by ZipReader#getEntries())";
+	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 WARNING_COMPRESSION_UNAVAILABLE = "compression unavailable";
+	const WARNING_CLAMPED_LAST_MODIFICATION_DATE = "clamped last modification date";
 
 	const EXTRAFIELD_DATA_AES = new Uint8Array([0x07, 0x00, 0x02, 0x00, 0x41, 0x45, 0x03, 0x00, 0x00]);
 	const EXTRAFIELD_OFFSET_AES_VENDOR_VERSION = 4;
 	const EXTRAFIELD_OFFSET_AES_COMPRESSION_METHOD = 9;
 	const EXTRAFIELD_USDZ_MAX_LENGTH = 67;
+	const MIN_PRINTABLE_ASCII_CHARACTER_CODE = 0x20;
+	const MAX_PRINTABLE_ASCII_CHARACTER_CODE = 0x7e;
 	const VENDOR_VERSION_AE_1 = 1;
-	const INFOZIP_EXTRA_FIELD_TYPE$1 = "infozip";
+	const INFOZIP_EXTRA_FIELD_TYPE = "infozip";
 	const UNIX_EXTRA_FIELD_TYPE = "unix";
+	const LEVEL_BY_BITFLAG_LEVEL = [8, 9, 5, 3];
 	const MAX_LEVEL = 9;
 
 	let workers = 0;
@@ -6338,9 +6515,11 @@
 				initialOffset: options[OPTION_OFFSET] === UNDEFINED_VALUE ? 0 : options[OPTION_OFFSET] - (writer.size || writer.writable.size || 0),
 				pendingAddFileCalls: new Set(),
 				pendingErrors: [],
+				warnings: [],
 				bufferedWrites: 0,
 				directWrites: 0,
-				lastFileEntry: UNDEFINED_VALUE
+				lastFileEntry: UNDEFINED_VALUE,
+				archiveClosed: false
 			});
 		}
 
@@ -6505,6 +6684,9 @@
 			const zipWriter = this;
 			const { pendingAddFileCalls, writer } = this;
 			const { writable } = writer;
+			if (zipWriter.archiveClosed) {
+				return getWriterData(writer);
+			}
 			if (!(comment instanceof Uint8Array)) {
 				throw new Error(ERR_INVALID_COMMENT_TYPE);
 			}
@@ -6528,11 +6710,16 @@
 				throw error;
 			}
 			await closeFile(zipWriter, comment, options);
+			zipWriter.archiveClosed = true;
 			const preventClose = !ownsWritable(writer) && getOptionValue(zipWriter, options, OPTION_PREVENT_CLOSE);
 			if (!preventClose) {
 				await writable.getWriter().close();
 			}
-			return writer.getData ? writer.getData() : writable;
+			return getWriterData(writer);
+		}
+
+		[SYMBOL_ASYNC_DISPOSE]() {
+			return this.close();
 		}
 	}
 
@@ -6611,6 +6798,10 @@
 		}
 	}
 
+	function getWriterData(writer) {
+		return writer.getData ? writer.getData() : writer.writable;
+	}
+
 	function watchPromiseError(zipWriter, promise) {
 		const watchedPromise = new WatchedPromise((resolve, reject) => Promise.prototype.then.call(promise, resolve, reject));
 		const watcher = {};
@@ -6629,6 +6820,14 @@
 
 	async function addFileEntry(zipWriter, name, reader, options) {
 		options = Object.assign({}, options);
+		const entry = options[OPTION_ENTRY];
+		if (entry !== UNDEFINED_VALUE) {
+			const { entryOptions, passThroughOptions } = getSourceEntryOptions(entry,
+				checkPassThroughOption(getOptionValue(zipWriter, options, OPTION_PASS_THROUGH)),
+				getOptionValue(zipWriter, options, PROPERTY_NAME_LAST_MODIFICATION_DATE));
+			delete options[OPTION_ENTRY];
+			options = Object.assign(entryOptions, passThroughOptions, options);
+		}
 		if (getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY) && !name.endsWith(DIRECTORY_SIGNATURE)) {
 			name += DIRECTORY_SIGNATURE;
 		}
@@ -6693,21 +6892,33 @@
 		try {
 			const { resolvedOptions } = metadataInfo;
 			if (resolvedOptions.level != 0 && resolvedOptions.compressionMethod === UNDEFINED_VALUE &&
-				!resolvedOptions.passThrough && !(await supportsDeflate(getConfiguration()))) {
+				!resolvedOptions.passThroughCompression && !(await supportsDeflate(getConfiguration()))) {
 				resolvedOptions.level = 0;
+				addWarning(zipWriter.warnings, WARNING_COMPRESSION_UNAVAILABLE, name);
 			}
 			const sizesInfo = await resolveSizes(zipWriter, reader, metadataInfo, options);
 			({ reader } = sizesInfo);
 			const diskOffset = getDiskOffset(zipWriter.writer);
 			const diskNumber = getDiskNumber(zipWriter.writer);
+			let crc32 = options.crc32 === UNDEFINED_VALUE ? options[PROPERTY_NAME_SIGNATURE] : options.crc32;
+			const storesAE2 = sizesInfo.resolvedOptions.encrypted && !resolvedOptions.zipCrypto;
+			if (resolvedOptions.passThroughCompression && !resolvedOptions.passThroughEncryption && storesAE2) {
+				crc32 = UNDEFINED_VALUE;
+			}
+			if (resolvedOptions.passThroughCompression && reader && !storesAE2 && crc32 === UNDEFINED_VALUE) {
+				throw new Error(ERR_UNDEFINED_CRC32);
+			}
 			options = Object.assign({}, options, attributesInfo.resolvedOptions, metadataInfo.resolvedOptions, sizesInfo.resolvedOptions, {
 				signature: options[PROPERTY_NAME_SIGNATURE],
-				crc32: options.crc32 === UNDEFINED_VALUE ? options[PROPERTY_NAME_SIGNATURE] : options.crc32,
+				crc32,
 				offset: zipWriter.offset - diskOffset,
 				diskNumberStart: diskNumber,
 				[OPTION_USDZ]: zipWriter.options[OPTION_USDZ]
 			});
 			const headerInfo = getHeaderInfo(options);
+			if (headerInfo.lastModDateClamped) {
+				addWarning(zipWriter.warnings, WARNING_CLAMPED_LAST_MODIFICATION_DATE, name);
+			}
 			const dataDescriptorInfo = getDataDescriptorInfo(options);
 			const metadataSize = getLength(headerInfo.localHeaderArray, dataDescriptorInfo.dataDescriptorArray);
 			fileEntry = await getFileEntry(zipWriter, name, reader, {
@@ -6734,6 +6945,95 @@
 		return new Entry(fileEntry);
 	}
 
+	function getSourceEntryOptions(entry, passThrough, lastModDateOverride) {
+		if (entry === null || typeof entry != OBJECT_TYPE || Array.isArray(entry)) {
+			throw new Error(ERR_INVALID_ENTRY);
+		}
+		const {
+			externalFileAttributes,
+			versionMadeBy,
+			comment,
+			lastModDate,
+			rawLastModDate,
+			creationDate,
+			lastAccessDate,
+			uncompressedSize,
+			encrypted,
+			zipCrypto,
+			crc32,
+			compressionMethod,
+			extraFieldAES,
+			extraFieldUnix,
+			internalFileAttributes,
+			extraField,
+			bitFlag,
+			directory,
+			uid,
+			gid
+		} = entry;
+		const entryOptions = {
+			externalFileAttributes,
+			versionMadeBy,
+			comment,
+			lastModDate,
+			creationDate,
+			lastAccessDate,
+			internalFileAttributes,
+			directory
+		};
+		if (bitFlag && bitFlag.languageEncodingFlag) {
+			entryOptions[OPTION_USE_UNICODE_FILE_NAMES] = true;
+		}
+		const userExtraField = getUserExtraField(extraField);
+		if (userExtraField) {
+			entryOptions[PROPERTY_NAME_EXTRA_FIELD] = userExtraField;
+		}
+		if (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE) {
+			Object.assign(entryOptions, {
+				uid,
+				gid,
+				unixExtraFieldType: extraFieldUnix ? UNIX_EXTRA_FIELD_TYPE : INFOZIP_EXTRA_FIELD_TYPE
+			});
+		}
+		const passThroughOptions = {};
+		if (passThrough && !directory) {
+			Object.assign(passThroughOptions, {
+				uncompressedSize,
+				crc32,
+				compressionMethod
+			});
+			if (passThrough !== PASS_THROUGH_COMPRESSED) {
+				Object.assign(passThroughOptions, {
+					encrypted,
+					zipCrypto,
+					encryptionStrength: extraFieldAES ? extraFieldAES.strength : UNDEFINED_VALUE
+				});
+			}
+			if (bitFlag) {
+				passThroughOptions.dataDescriptor = bitFlag.dataDescriptor;
+				passThroughOptions[OPTION_LEVEL] = LEVEL_BY_BITFLAG_LEVEL[bitFlag.level];
+			}
+			if (lastModDateOverride === UNDEFINED_VALUE) {
+				passThroughOptions.rawLastModDate = rawLastModDate;
+			} else if (passThrough !== PASS_THROUGH_COMPRESSED && zipCrypto && (!bitFlag || bitFlag.dataDescriptor) &&
+				lastModDateOverride instanceof Date &&
+				getDosTimeHighByte(lastModDateOverride) != ((rawLastModDate >>> 8) & MAX_8_BITS)) {
+				throw new Error(ERR_ZIP_CRYPTO_LAST_MOD_DATE);
+			}
+		}
+		return { entryOptions, passThroughOptions };
+	}
+
+	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 resolveAttributes(zipWriter, name, options) {
 		let msDosCompatible = getOptionValue(zipWriter, options, PROPERTY_NAME_MS_DOS_COMPATIBLE);
 		let versionMadeBy = getOptionValue(zipWriter, options, PROPERTY_NAME_VERSION_MADE_BY, msDosCompatible ? VERSION_MADE_BY_MSDOS : VERSION_MADE_BY_UNIX);
@@ -6748,7 +7048,7 @@
 		checkIntegerOption(uid, MAX_32_BITS, ERR_INVALID_UID);
 		checkIntegerOption(gid, MAX_32_BITS, ERR_INVALID_GID);
 		checkIntegerOption(unixMode, MAX_16_BITS, ERR_INVALID_UNIX_MODE);
-		if (unixExtraFieldType !== UNDEFINED_VALUE && unixExtraFieldType !== INFOZIP_EXTRA_FIELD_TYPE$1 && unixExtraFieldType !== UNIX_EXTRA_FIELD_TYPE) {
+		if (unixExtraFieldType !== UNDEFINED_VALUE && unixExtraFieldType !== INFOZIP_EXTRA_FIELD_TYPE && unixExtraFieldType !== UNIX_EXTRA_FIELD_TYPE) {
 			throw new Error(ERR_INVALID_UNIX_EXTRA_FIELD_TYPE);
 		}
 		if (unixExtraFieldType === UNIX_EXTRA_FIELD_TYPE &&
@@ -6756,7 +7056,7 @@
 			throw new Error(ERR_INVALID_UNIX_ID_SIZE);
 		}
 		if (unixExtraFieldType === UNDEFINED_VALUE && (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE)) {
-			unixExtraFieldType = INFOZIP_EXTRA_FIELD_TYPE$1;
+			unixExtraFieldType = INFOZIP_EXTRA_FIELD_TYPE;
 		}
 		let msdosAttributesRaw = getNumberOptionValue(zipWriter, options, PROPERTY_NAME_MSDOS_ATTRIBUTES_RAW);
 		let msdosAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_MSDOS_ATTRIBUTES);
@@ -6887,7 +7187,9 @@
 		const lastAccessDate = getDateOptionValue(zipWriter, options, PROPERTY_NAME_LAST_ACCESS_DATE);
 		const creationDate = getDateOptionValue(zipWriter, options, PROPERTY_NAME_CREATION_DATE);
 		const internalFileAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES, 0);
-		const passThrough = getOptionValue(zipWriter, options, OPTION_PASS_THROUGH);
+		const passThrough = checkPassThroughOption(getOptionValue(zipWriter, options, OPTION_PASS_THROUGH));
+		const passThroughCompression = Boolean(passThrough);
+		const passThroughEncryption = passThrough === true;
 		const password = getOptionValue(zipWriter, options, OPTION_PASSWORD);
 		const rawPassword = getOptionValue(zipWriter, options, OPTION_RAW_PASSWORD);
 		checkPasswordOption(password, rawPassword);
@@ -6903,10 +7205,11 @@
 		const dataDescriptorSignature = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR_SIGNATURE, true);
 		const signal = checkSignalOption(getOptionValue(zipWriter, options, OPTION_SIGNAL));
 		throwIfAborted(signal);
-		const useUnicodeFileNames = getOptionValue(zipWriter, options, OPTION_USE_UNICODE_FILE_NAMES, true);
+		const useUnicodeFileNames = getOptionValue(zipWriter, options, OPTION_USE_UNICODE_FILE_NAMES,
+			!isPrintableASCIIText(rawFilename) || !isPrintableASCIIText(rawComment));
 		const compressionMethod = getOptionValue(zipWriter, options, PROPERTY_NAME_COMPRESSION_METHOD);
-		const registeredCodec = passThrough || compressionMethod === UNDEFINED_VALUE ? UNDEFINED_VALUE : getRegisteredCodec(compressionMethod);
-		if (!passThrough && compressionMethod !== UNDEFINED_VALUE &&
+		const registeredCodec = passThroughCompression || compressionMethod === UNDEFINED_VALUE ? UNDEFINED_VALUE : getRegisteredCodec(compressionMethod);
+		if (!passThroughCompression && compressionMethod !== UNDEFINED_VALUE &&
 			compressionMethod !== COMPRESSION_METHOD_STORE && compressionMethod !== COMPRESSION_METHOD_DEFLATE && !registeredCodec) {
 			throw new Error(ERR_UNSUPPORTED_COMPRESSION);
 		}
@@ -6920,15 +7223,15 @@
 				level = 0;
 			}
 		}
-		if (passThrough) {
-			level = UNDEFINED_VALUE;
+		if (passThroughCompression) {
+			level = toNumber(options[OPTION_LEVEL]);
 		}
 		let useCompressionStream = getOptionValue(zipWriter, options, OPTION_USE_COMPRESSION_STREAM);
 		let dataDescriptor = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR);
 		if (bufferedWrite && dataDescriptor === UNDEFINED_VALUE) {
 			dataDescriptor = false;
 		}
-		if (dataDescriptor === UNDEFINED_VALUE || (zipCrypto && !passThrough)) {
+		if (dataDescriptor === UNDEFINED_VALUE || (zipCrypto && !passThroughEncryption)) {
 			dataDescriptor = true;
 		}
 		if (level !== UNDEFINED_VALUE && level != 6) {
@@ -6952,7 +7255,8 @@
 				lastAccessDate,
 				creationDate,
 				internalFileAttributes,
-				passThrough,
+				passThroughCompression,
+				passThroughEncryption,
 				password,
 				rawPassword,
 				encryptionStrength,
@@ -7013,7 +7317,7 @@
 	}
 
 	async function resolveSizes(zipWriter, reader, { resolvedOptions: metadata }, options) {
-		if (metadata.passThrough && !reader && !getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY)) {
+		if (metadata.passThroughCompression && !reader && !getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY)) {
 			throw new Error(ERR_UNDEFINED_READER);
 		}
 		let contentSize;
@@ -7029,12 +7333,12 @@
 	}
 
 	function resolveEntrySizes(zipWriter, hasContent, contentSize, metadata, options) {
-		const { passThrough, zipCrypto, password, rawPassword, encryptionStrength } = metadata;
+		const { passThroughCompression, passThroughEncryption, zipCrypto, password, rawPassword, encryptionStrength } = metadata;
 		let { dataDescriptor, zip64, level, compressionMethod } = metadata;
 		let maximumCompressedSize = 0;
 		let uncompressedSize = 0;
 		let unknownSize = false;
-		if (passThrough && hasContent) {
+		if (passThroughCompression && hasContent) {
 			uncompressedSize = options[PROPERTY_NAME_UNCOMPRESSED_SIZE];
 			if (uncompressedSize === UNDEFINED_VALUE) {
 				throw new Error(ERR_UNDEFINED_UNCOMPRESSED_SIZE);
@@ -7045,17 +7349,17 @@
 		}
 		const zip64Enabled = zip64 === true;
 		const encrypted = getOptionValue(zipWriter, options, PROPERTY_NAME_ENCRYPTED);
-		if (hasContent && passThrough && !encrypted && getLength(password, rawPassword)) {
+		if (hasContent && passThroughEncryption && !encrypted && getLength(password, rawPassword)) {
 			throw new Error(ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH);
 		}
-		const encryptedEntry = hasContent && (Boolean((password && getLength(password)) || (rawPassword && getLength(rawPassword))) || (passThrough && encrypted));
+		const encryptedEntry = hasContent && (Boolean((password && getLength(password)) || (rawPassword && getLength(rawPassword))) || (passThroughEncryption && encrypted));
 		if (!hasContent) {
 			level = 0;
 			compressionMethod = COMPRESSION_METHOD_STORE;
 		}
-		const encryptionOverhead = encryptedEntry ? (zipCrypto ? 12 : 16 + encryptionStrength * 4) : 0;
+		const encryptionOverhead = getEncryptionOverhead(encryptedEntry, zipCrypto, encryptionStrength);
 		if (hasContent) {
-			if (!passThrough) {
+			if (!passThroughCompression) {
 				if (contentSize === UNDEFINED_VALUE) {
 					dataDescriptor = true;
 					if (zip64 || zip64 === UNDEFINED_VALUE) {
@@ -7068,10 +7372,12 @@
 				}
 			} else {
 				options.uncompressedSize = uncompressedSize;
-				maximumCompressedSize = contentSize === UNDEFINED_VALUE ? getMaximumCompressedSize(uncompressedSize) + encryptionOverhead : contentSize;
+				maximumCompressedSize = contentSize === UNDEFINED_VALUE ?
+					getMaximumCompressedSize(uncompressedSize) + encryptionOverhead :
+					contentSize + (passThroughEncryption ? 0 : encryptionOverhead);
 			}
 		}
-		const emptyEntry = !encryptedEntry && (!hasContent || (contentSize === 0 && !passThrough)) && !isCompressed(compressionMethod, level);
+		const emptyEntry = !encryptedEntry && (!hasContent || (contentSize === 0 && !passThroughCompression)) && !isCompressed(compressionMethod, level);
 		if (emptyEntry && !zipCrypto && getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR) === UNDEFINED_VALUE) {
 			dataDescriptor = false;
 		}
@@ -7120,6 +7426,8 @@
 		const initialOffset = writerOptions[OPTION_OFFSET] === UNDEFINED_VALUE ? 0 : writerOptions[OPTION_OFFSET];
 		let offset = initialOffset;
 		let minimumEntrySize = INFINITY_VALUE;
+		const entrySizes = [];
+		const entriesAlreadyZip64 = new Set();
 		for (const entry of entries) {
 			let { name } = entry;
 			const { size } = entry;
@@ -7131,7 +7439,7 @@
 			({ name } = attributesInfo);
 			const { resolvedOptions: metadata } = resolveMetadata(zipWriter, name, options);
 			if (metadata.level != 0 && metadata.compressionMethod === UNDEFINED_VALUE &&
-				!metadata.passThrough && !(await supportsDeflate(getConfiguration()))) {
+				!metadata.passThroughCompression && !(await supportsDeflate(getConfiguration()))) {
 				metadata.level = 0;
 			}
 			const hasContent = !getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY);
@@ -7139,7 +7447,7 @@
 				throw new Error(ERR_UNDETERMINED_SIZE);
 			}
 			const { maximumCompressedSize, resolvedOptions: sizes } = resolveEntrySizes(zipWriter, hasContent, size, metadata, options);
-			if (hasContent && !metadata.passThrough && isCompressed(sizes.compressionMethod, sizes.level)) {
+			if (hasContent && !metadata.passThroughCompression && isCompressed(sizes.compressionMethod, sizes.level)) {
 				throw new Error(ERR_UNDETERMINED_SIZE);
 			}
 			const entryOptions = Object.assign({}, options, attributesInfo.resolvedOptions, metadata, sizes, { [OPTION_USDZ]: usdz });
@@ -7159,10 +7467,15 @@
 				compressedSize
 			}));
 			const entrySize = entryInfo.metadataSize + compressedSize;
+			entrySizes.push(entrySize);
+			entriesAlreadyZip64.add(Boolean(entryOptions.zip64Enabled ||
+				entryOptions.uncompressedSize >= MAX_32_BITS || compressedSize >= MAX_32_BITS));
 			minimumEntrySize = Math.min(minimumEntrySize, entrySize);
 			offset += entrySize;
 		}
-		const layoutDependsOnWriteOrder = files.size > 1 && (usdz || offset - minimumEntrySize >= MAX_32_BITS);
+		const layoutDependsOnWriteOrder = files.size > 1 && (usdz ||
+			(offset - minimumEntrySize >= MAX_32_BITS &&
+				(entriesAlreadyZip64.size > 1 || countEntriesBefore4GB(entrySizes, initialOffset, true) != countEntriesBefore4GB(entrySizes, initialOffset, false))));
 		if (layoutDependsOnWriteOrder && !writeOrderGuaranteed) {
 			throw new Error(ERR_UNDETERMINED_SIZE);
 		}
@@ -7180,6 +7493,20 @@
 		return offset - initialOffset + directoryDataLength + commentLength + (zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
 	}
 
+	function countEntriesBefore4GB(entrySizes, initialOffset, largestFirst) {
+		const ordered = entrySizes.slice().sort((first, second) => largestFirst ? second - first : first - second);
+		let position = initialOffset;
+		let count = 0;
+		for (const entrySize of ordered) {
+			if (position >= MAX_32_BITS) {
+				break;
+			}
+			position += entrySize;
+			count++;
+		}
+		return count;
+	}
+
 	async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		const {
 			fileEntries,
@@ -7355,6 +7682,7 @@
 			localExtraFieldZip64Length,
 			rawExtraFieldExtendedTimestamp,
 			extraFieldExtendedTimestampFlag,
+			extraFieldExtendedTimestampTime,
 			rawExtraFieldNTFS,
 			rawExtraFieldUnix,
 			rawExtraFieldAES,
@@ -7367,6 +7695,7 @@
 			password,
 			rawPassword,
 			level,
+			useUnicodeFileNames,
 			zip64,
 			zip64Enabled,
 			zip64UncompressedSize,
@@ -7401,7 +7730,8 @@
 			msdosAttributesRaw,
 			msdosAttributes,
 			useCompressionStream,
-			passThrough,
+			passThroughCompression,
+			passThroughEncryption,
 			format,
 			codecURI
 		} = options;
@@ -7412,9 +7742,9 @@
 			zip64Enabled,
 			directory: Boolean(directory),
 			executable: Boolean(executable),
-			filenameUTF8: true,
+			filenameUTF8: Boolean(useUnicodeFileNames),
 			rawFilename,
-			commentUTF8: true,
+			commentUTF8: Boolean(useUnicodeFileNames),
 			rawComment,
 			rawExtraFieldZip64,
 			localExtraFieldZip64Length,
@@ -7445,7 +7775,7 @@
 			uncompressedSize
 		} = options;
 		let compressedSize = 0;
-		if (!passThrough) {
+		if (!passThroughCompression) {
 			uncompressedSize = 0;
 		}
 		const { writable } = writer;
@@ -7462,9 +7792,9 @@
 					encryptionStrength,
 					zipCrypto: encrypted && zipCrypto,
 					passwordVerification: encrypted && zipCrypto && (rawLastModDate >> 8) & MAX_8_BITS,
-					computeCrc32: !passThrough,
-					compressed: compressed && !passThrough,
-					encrypted: encrypted && !passThrough,
+					computeCrc32: !passThroughCompression,
+					compressed: compressed && !passThroughCompression,
+					encrypted: encrypted && !passThroughEncryption,
 					useWebWorkers,
 					useCompressionStream,
 					transferStreams,
@@ -7479,7 +7809,7 @@
 				const result = await runWorker({ readable, writable }, workerOptions);
 				compressedSize = result.outputSize;
 				writer.size += compressedSize;
-				if (!passThrough) {
+				if (!passThroughCompression) {
 					uncompressedSize = result.inputSize;
 					if (!encrypted || zipCrypto) {
 						crc32 = result.crc32;
@@ -7522,8 +7852,9 @@
 			headerArray,
 			headerView,
 			signature: crc32,
-			crc32: encrypted && !zipCrypto && !passThrough ? UNDEFINED_VALUE : crc32,
+			crc32: encrypted && !zipCrypto && !passThroughCompression ? UNDEFINED_VALUE : crc32,
 			extraFieldExtendedTimestampFlag,
+			extraFieldExtendedTimestampTime,
 			zip64UncompressedSize,
 			zip64CompressedSize
 		});
@@ -7548,7 +7879,7 @@
 			encryptionStrength,
 			extendedTimestamp,
 			ntfsTimestamp,
-			passThrough,
+			passThroughCompression,
 			encrypted,
 			zip64UncompressedSize,
 			zip64CompressedSize,
@@ -7559,7 +7890,7 @@
 		let { version, compressionMethod } = options;
 		const compressed = !directory && isCompressed(compressionMethod, level);
 		let rawLocalExtraFieldZip64;
-		const uncompressedFile = passThrough || !compressed;
+		const uncompressedFile = passThroughCompression || !compressed;
 		const zip64ExtraFieldComplete = zip64 && (options.bufferedWrite || !dataDescriptor || ((!zip64UncompressedSize && !zip64CompressedSize) || (uncompressedFile && !unknownSize)));
 		const writeLocalExtraFieldZip64 = zip64ExtraFieldComplete || (zip64 && dataDescriptor && (zip64UncompressedSize || zip64CompressedSize));
 		if (zip64 && (zip64UncompressedSize || zip64CompressedSize)) {
@@ -7571,8 +7902,8 @@
 			if (zip64ExtraFieldComplete) {
 				extraFieldZip64.writeUint64(uncompressedSize);
 				if (uncompressedFile) {
-					const encryptionOverhead = encrypted ? (zipCrypto ? 12 : 16 + encryptionStrength * 4) : 0;
-					extraFieldZip64.writeUint64(passThrough ? 0 : uncompressedSize + encryptionOverhead);
+					const encryptionOverhead = getEncryptionOverhead(encrypted, zipCrypto, encryptionStrength);
+					extraFieldZip64.writeUint64(passThroughCompression ? 0 : uncompressedSize + encryptionOverhead);
 				}
 			}
 		} else {
@@ -7591,6 +7922,7 @@
 		let rawExtraFieldNTFS;
 		let rawExtraFieldExtendedTimestamp;
 		let extraFieldExtendedTimestampFlag;
+		let extraFieldExtendedTimestampTime;
 		if (extendedTimestamp) {
 			const lastModTimeUnix = getTimeUnix(lastModDate);
 			const lastModTimeUnixInRange = inUnixTimeRange(lastModTimeUnix);
@@ -7598,6 +7930,7 @@
 				const extraFieldTimestampLength = 9 + (lastAccessDate ? 4 : 0) + (creationDate ? 4 : 0);
 				const extraFieldTimestamp = createRecordWriter(extraFieldTimestampLength);
 				extraFieldExtendedTimestampFlag = 0x1 + (lastAccessDate ? 0x2 : 0) + (creationDate ? 0x4 : 0);
+				extraFieldExtendedTimestampTime = lastModTimeUnix;
 				extraFieldTimestamp.writeUint16(EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
 				extraFieldTimestamp.writeUint16(extraFieldTimestampLength - 4);
 				extraFieldTimestamp.writeUint8(extraFieldExtendedTimestampFlag);
@@ -7640,7 +7973,7 @@
 		let rawExtraFieldUnix;
 		try {
 			const { uid, gid, unixExtraFieldType } = options;
-			if (unixExtraFieldType == INFOZIP_EXTRA_FIELD_TYPE$1 && (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE)) {
+			if (unixExtraFieldType == INFOZIP_EXTRA_FIELD_TYPE && (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE)) {
 				const uidBytes = packUnixId(uid === UNDEFINED_VALUE ? 0 : uid);
 				const gidBytes = packUnixId(gid === UNDEFINED_VALUE ? 0 : gid);
 				const payloadLength = 3 + uidBytes.length + gidBytes.length;
@@ -7681,7 +8014,7 @@
 		}
 		if (encrypted && !zipCrypto) {
 			version = version > VERSION_AES ? version : VERSION_AES;
-			if (passThrough && crc32 !== UNDEFINED_VALUE) {
+			if (passThroughCompression && crc32 !== UNDEFINED_VALUE) {
 				rawExtraFieldAES[EXTRAFIELD_OFFSET_AES_VENDOR_VERSION] = VENDOR_VERSION_AE_1;
 			}
 			setUint16(getDataView(rawExtraFieldAES), EXTRAFIELD_OFFSET_AES_COMPRESSION_METHOD, compressionMethod);
@@ -7743,12 +8076,14 @@
 			headerArray,
 			headerView,
 			lastModDate: storedLastModDate,
+			lastModDateClamped: storedLastModDate === clampedLastModDate && dosLastModDate.getTime() != clampedLastModDate.getTime(),
 			rawLastModDate,
 			encrypted,
 			compressed,
 			version,
 			compressionMethod,
 			extraFieldExtendedTimestampFlag,
+			extraFieldExtendedTimestampTime,
 			rawExtraFieldZip64: EMPTY_UINT8_ARRAY,
 			localExtraFieldZip64Length,
 			rawExtraFieldExtendedTimestamp,
@@ -7851,7 +8186,7 @@
 	}, {
 		zip64,
 		zipCrypto,
-		passThrough,
+		passThroughCompression,
 		dataDescriptor
 	}) {
 		const {
@@ -7862,7 +8197,7 @@
 			dataDescriptorView,
 			dataDescriptorOffset
 		} = dataDescriptorInfo;
-		if ((!encrypted || zipCrypto || passThrough) && crc32 !== UNDEFINED_VALUE) {
+		if ((!encrypted || zipCrypto || passThroughCompression) && crc32 !== UNDEFINED_VALUE) {
 			setUint32(headerView, HEADER_OFFSET_SIGNATURE, crc32);
 			if (dataDescriptor) {
 				setUint32(dataDescriptorView, dataDescriptorOffset, crc32);
@@ -7893,9 +8228,9 @@
 		uncompressedSize,
 		zip64UncompressedSize,
 		zip64CompressedSize
-	}, localHeaderView, { dataDescriptor, passThrough }) {
+	}, localHeaderView, { dataDescriptor, passThroughCompression }) {
 		if (!dataDescriptor) {
-			if (!encrypted || (passThrough && crc32 !== UNDEFINED_VALUE)) {
+			if (!encrypted || (passThroughCompression && crc32 !== UNDEFINED_VALUE)) {
 				setUint32(localHeaderView, HEADER_OFFSET_SIGNATURE + LOCAL_HEADER_COMMON_OFFSET, crc32);
 			}
 			if (!zip64CompressedSize) {
@@ -7932,9 +8267,8 @@
 				rawExtraFieldUnix,
 				rawExtraField,
 				rawCentralExtraField,
-				extendedTimestamp,
 				extraFieldExtendedTimestampFlag,
-				lastModDate,
+				extraFieldExtendedTimestampTime,
 				zip64Enabled,
 				uncompressedSize,
 				compressedSize
@@ -7977,16 +8311,15 @@
 			fileEntry.zip64Offset = zip64Offset;
 			fileEntry.zip64DiskNumberStart = zip64DiskNumberStart;
 			let rawExtraFieldTimestamp;
-			const lastModTimeUnix = getTimeUnix(lastModDate);
-			if (extendedTimestamp && inUnixTimeRange(lastModTimeUnix)) {
+			if (extraFieldExtendedTimestampTime === UNDEFINED_VALUE) {
+				rawExtraFieldTimestamp = EMPTY_UINT8_ARRAY;
+			} else {
 				const extraFieldTimestamp = createRecordWriter(9);
 				extraFieldTimestamp.writeUint16(EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
 				extraFieldTimestamp.writeUint16(5);
 				extraFieldTimestamp.writeUint8(extraFieldExtendedTimestampFlag);
-				extraFieldTimestamp.writeUint32(lastModTimeUnix);
+				extraFieldTimestamp.writeUint32(extraFieldExtendedTimestampTime);
 				rawExtraFieldTimestamp = extraFieldTimestamp.array;
-			} else {
-				rawExtraFieldTimestamp = EMPTY_UINT8_ARRAY;
 			}
 			fileEntry.rawExtraFieldExtendedTimestamp = rawExtraFieldTimestamp;
 			const extraFieldLength = getLength(
@@ -8486,6 +8819,11 @@
 		};
 	}
 
+	function isPrintableASCIIText(rawText) {
+		return rawText.every(characterCode =>
+			characterCode >= MIN_PRINTABLE_ASCII_CHARACTER_CODE && characterCode <= MAX_PRINTABLE_ASCII_CHARACTER_CODE);
+	}
+
 	function getBitFlag(level, useUnicodeFileNames, dataDescriptor, encrypted, compressionMethod) {
 		let bitFlag = 0;
 		if (useUnicodeFileNames) {
@@ -8647,7 +8985,7 @@
 	 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 	 */
 
-	const VERSION = "2.11.4";
+	const VERSION = "2.12.0";
 
 	/*
 	 Copyright (c) 2025 Gildas Lormeau. All rights reserved.
@@ -9128,7 +9466,10 @@
 	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";
@@ -9136,22 +9477,8 @@
 	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 {
 
@@ -9523,6 +9850,7 @@
 				await initStream(reader);
 				zipReader = new ZipReader(reader, options);
 			}
+			checkPassThroughValue(options.passThrough);
 			const duplicates = checkDuplicatesOption(options.duplicates);
 			const importedEntries = [];
 			const entries = await zipReader.getEntries(options);
@@ -9613,18 +9941,25 @@
 
 		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);
@@ -9639,7 +9974,7 @@
 			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) {
@@ -9700,7 +10035,7 @@
 
 		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)) {
@@ -9721,7 +10056,7 @@
 						throw new Error(ERR_ANCESTOR_ENTRY);
 					}
 				} else {
-					throw new Error("Target entry is not a directory");
+					throw new Error(ERR_TARGET_NOT_DIRECTORY);
 				}
 			}
 		}
@@ -10034,70 +10369,11 @@
 		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 });
@@ -10107,16 +10383,6 @@
 		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) {
@@ -10129,9 +10395,18 @@
 		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, {
@@ -10160,20 +10435,6 @@
 		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;
@@ -10276,6 +10537,7 @@
 
 	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;
@@ -10351,7 +10613,7 @@
 				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) {
@@ -10484,7 +10746,7 @@
 			}
 			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);
 		}
 	}
 
@@ -10531,6 +10793,7 @@
 	exports.Data64URIWriter = Data64URIWriter;
 	exports.ERR_ABORTED = ERR_ABORTED;
 	exports.ERR_AMBIGUOUS_ARCHIVE = ERR_AMBIGUOUS_ARCHIVE;
+	exports.ERR_ANCESTOR_ENTRY = ERR_ANCESTOR_ENTRY;
 	exports.ERR_BAD_FORMAT = ERR_BAD_FORMAT;
 	exports.ERR_CENTRAL_DIRECTORY_NOT_FOUND = ERR_CENTRAL_DIRECTORY_NOT_FOUND;
 	exports.ERR_DUPLICATED_NAME = ERR_DUPLICATED_NAME;
@@ -10544,7 +10807,9 @@
 	exports.ERR_EXTRAFIELD_ZIP64_NOT_FOUND = ERR_EXTRAFIELD_ZIP64_NOT_FOUND;
 	exports.ERR_HTTP_RANGE = ERR_HTTP_RANGE;
 	exports.ERR_HTTP_RESOURCE_CHANGED = ERR_HTTP_RESOURCE_CHANGED;
+	exports.ERR_HTTP_STATUS = ERR_HTTP_STATUS;
 	exports.ERR_INVALID_AUTHENTICATION_CODE = ERR_INVALID_AUTHENTICATION_CODE;
+	exports.ERR_INVALID_BASE_URI = ERR_INVALID_BASE_URI;
 	exports.ERR_INVALID_CODEC_DEFINITION = ERR_INVALID_CODEC_DEFINITION;
 	exports.ERR_INVALID_CODEC_MODULE = ERR_INVALID_CODEC_MODULE;
 	exports.ERR_INVALID_COMMENT = ERR_INVALID_COMMENT;
@@ -10554,6 +10819,7 @@
 	exports.ERR_INVALID_DATE = ERR_INVALID_DATE;
 	exports.ERR_INVALID_DUPLICATES = ERR_INVALID_DUPLICATES;
 	exports.ERR_INVALID_ENCRYPTION_STRENGTH = ERR_INVALID_ENCRYPTION_STRENGTH;
+	exports.ERR_INVALID_ENTRY = ERR_INVALID_ENTRY;
 	exports.ERR_INVALID_ENTRY_COMMENT = ERR_INVALID_ENTRY_COMMENT;
 	exports.ERR_INVALID_ENTRY_COMMENT_TYPE = ERR_INVALID_ENTRY_COMMENT_TYPE;
 	exports.ERR_INVALID_ENTRY_NAME = ERR_INVALID_ENTRY_NAME;
@@ -10572,6 +10838,7 @@
 	exports.ERR_INVALID_PASSWORD = ERR_INVALID_PASSWORD;
 	exports.ERR_INVALID_PASSWORD_TYPE = ERR_INVALID_PASSWORD_TYPE;
 	exports.ERR_INVALID_PASS_THROUGH = ERR_INVALID_PASS_THROUGH;
+	exports.ERR_INVALID_PASS_THROUGH_VALUE = ERR_INVALID_PASS_THROUGH_VALUE;
 	exports.ERR_INVALID_READER = ERR_INVALID_READER;
 	exports.ERR_INVALID_READER_OPTIONS = ERR_INVALID_READER_OPTIONS;
 	exports.ERR_INVALID_SIGNAL = ERR_INVALID_SIGNAL;
@@ -10582,14 +10849,19 @@
 	exports.ERR_INVALID_UNIX_EXTRA_FIELD_TYPE = ERR_INVALID_UNIX_EXTRA_FIELD_TYPE;
 	exports.ERR_INVALID_UNIX_ID_SIZE = ERR_INVALID_UNIX_ID_SIZE;
 	exports.ERR_INVALID_UNIX_MODE = ERR_INVALID_UNIX_MODE;
+	exports.ERR_INVALID_URI = ERR_INVALID_URI;
 	exports.ERR_INVALID_VERSION = ERR_INVALID_VERSION;
 	exports.ERR_ITERATOR_COMPLETED_TOO_SOON = ERR_ITERATOR_COMPLETED_TOO_SOON;
 	exports.ERR_LOCAL_FILE_HEADER_NOT_FOUND = ERR_LOCAL_FILE_HEADER_NOT_FOUND;
 	exports.ERR_OVERLAPPING_ENTRY = ERR_OVERLAPPING_ENTRY;
+	exports.ERR_PARENT_NOT_DIRECTORY = ERR_PARENT_NOT_DIRECTORY;
 	exports.ERR_READABLE_CONSUMED = ERR_READABLE_CONSUMED;
 	exports.ERR_RESERVED_COMPRESSION_METHOD = ERR_RESERVED_COMPRESSION_METHOD;
+	exports.ERR_ROOT_DIRECTORY_NOT_MOVABLE = ERR_ROOT_DIRECTORY_NOT_MOVABLE;
 	exports.ERR_SPLIT_ZIP_FILE = ERR_SPLIT_ZIP_FILE;
+	exports.ERR_TARGET_NOT_DIRECTORY = ERR_TARGET_NOT_DIRECTORY;
 	exports.ERR_UNDEFINED_COMPRESSION_METHOD = ERR_UNDEFINED_COMPRESSION_METHOD;
+	exports.ERR_UNDEFINED_CRC32 = ERR_UNDEFINED_CRC32;
 	exports.ERR_UNDEFINED_READER = ERR_UNDEFINED_READER;
 	exports.ERR_UNDEFINED_UNCOMPRESSED_SIZE = ERR_UNDEFINED_UNCOMPRESSED_SIZE;
 	exports.ERR_UNDETERMINED_SIZE = ERR_UNDETERMINED_SIZE;
@@ -10601,10 +10873,12 @@
 	exports.ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH = ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH;
 	exports.ERR_UNSUPPORTED_ENCRYPTION_USDZ = ERR_UNSUPPORTED_ENCRYPTION_USDZ;
 	exports.ERR_UNSUPPORTED_FORMAT = ERR_UNSUPPORTED_FORMAT;
+	exports.ERR_UNSUPPORTED_PASS_THROUGH_VALUE = ERR_UNSUPPORTED_PASS_THROUGH_VALUE;
 	exports.ERR_UNSUPPORTED_SPLIT_USDZ = ERR_UNSUPPORTED_SPLIT_USDZ;
 	exports.ERR_UNSUPPORTED_UINT64 = ERR_UNSUPPORTED_UINT64;
 	exports.ERR_WORKER_STARTUP_TIMEOUT = ERR_WORKER_STARTUP_TIMEOUT;
 	exports.ERR_WRITER_NOT_INITIALIZED = ERR_WRITER_NOT_INITIALIZED;
+	exports.ERR_WRITER_SIZE_NOT_WRITABLE = ERR_WRITER_SIZE_NOT_WRITABLE;
 	exports.ERR_ZIP_CRYPTO_LAST_MOD_DATE = ERR_ZIP_CRYPTO_LAST_MOD_DATE;
 	exports.ERR_ZIP_NOT_EMPTY = ERR_ZIP_NOT_EMPTY;
 	exports.HttpRangeReader = HttpRangeReader;
@@ -10618,13 +10892,17 @@
 	exports.Uint8ArrayWriter = Uint8ArrayWriter;
 	exports.VERSION = VERSION;
 	exports.WARNING_APPENDED_DATA = WARNING_APPENDED_DATA;
+	exports.WARNING_CLAMPED_LAST_MODIFICATION_DATE = WARNING_CLAMPED_LAST_MODIFICATION_DATE;
 	exports.WARNING_COMPRESSED_PATCHED_DATA = WARNING_COMPRESSED_PATCHED_DATA;
+	exports.WARNING_COMPRESSION_UNAVAILABLE = WARNING_COMPRESSION_UNAVAILABLE;
 	exports.WARNING_DUPLICATE_FILENAME = WARNING_DUPLICATE_FILENAME;
 	exports.WARNING_MALFORMED_EXTRA_FIELD = WARNING_MALFORMED_EXTRA_FIELD;
 	exports.WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG = WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG;
 	exports.WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD = WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD;
 	exports.WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES = WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES;
+	exports.WARNING_MISMATCHED_LOCAL_FILE_HEADER_FILENAME = WARNING_MISMATCHED_LOCAL_FILE_HEADER_FILENAME;
 	exports.WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY = WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY;
+	exports.WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY = WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY;
 	exports.WARNING_PREPENDED_CENTRAL_DIRECTORY = WARNING_PREPENDED_CENTRAL_DIRECTORY;
 	exports.WARNING_PREPENDED_DATA = WARNING_PREPENDED_DATA;
 	exports.WARNING_TRAILING_CENTRAL_DIRECTORY_DATA = WARNING_TRAILING_CENTRAL_DIRECTORY_DATA;