@zip.js/zip.js 2.18.2 → 2.20.0

package/dist/zip-core.js

@@ -185,7 +185,6 @@
 	const OPTION_CHECK_AUTHENTICATION_CODE = "checkAuthenticationCode";
 	const OPTION_USE_WEB_WORKERS = "useWebWorkers";
 	const OPTION_USE_COMPRESSION_STREAM = "useCompressionStream";
-	const OPTION_TRANSFER_STREAMS = "transferStreams";
 	const OPTION_PREVENT_CLOSE = "preventClose";
 	const OPTION_ENCRYPTION_STRENGTH = "encryptionStrength";
 	const OPTION_EXTENDED_TIMESTAMP = "extendedTimestamp";
@@ -303,7 +302,7 @@
 	 */
 
 
-	const DEFAULT_CHUNK_SIZE$1 = 64 * 1024;
+	const DEFAULT_CHUNK_SIZE$1 = 256 * 1024;
 	const MINIMUM_CHUNK_SIZE = 64;
 	const MINIMUM_PROPERTY_VALUE = 1;
 	const ERR_INVALID_MAX_WORKERS = "Invalid maxWorkers (must be an integer greater than 0)";
@@ -2392,7 +2391,7 @@
 	 */
 
 
-	const DEFAULT_CHUNK_SIZE = 64 * 1024;
+	const DEFAULT_CHUNK_SIZE = 256 * 1024;
 	const MESSAGE_EVENT_TYPE = "message";
 	const MESSAGE_START = "start";
 	const MESSAGE_PULL = "pull";
@@ -2598,7 +2597,7 @@
 	class CodecWorker {
 
 		constructor(workerData, { readable, writable }, workerOptions, onTaskFinished) {
-			const { options, config, streamOptions, useWebWorkers, transferStreams, workerURI } = workerOptions;
+			const { options, config, streamOptions, useWebWorkers, workerURI } = workerOptions;
 			let { createWorker } = workerOptions;
 			const { signal } = streamOptions;
 			if (createWorkerFailed) {
@@ -2615,7 +2614,6 @@
 				workerOptions,
 				workerURI,
 				createWorker,
-				transferStreams,
 				terminate() {
 					return new Promise(resolve => {
 						const { worker, busy } = workerData;
@@ -2793,12 +2791,6 @@
 	const ABORT_EVENT_TYPE = "abort";
 
 	let webWorkerSource, webWorkerURI, webWorkerOptions;
-	let transferStreamsSupported = true;
-	try {
-		transferStreamsSupported = typeof structuredClone == FUNCTION_TYPE && structuredClone(new DOMException("", "AbortError")).code !== UNDEFINED_VALUE;
-	} catch {
-		// ignored
-	}
 
 	setWebWorkerBackend(createWebWorkerInterface);
 
@@ -2885,14 +2877,11 @@
 		});
 		const { readable, options } = workerData;
 		const { writable, closed, abortPipe } = watchClosedStream(workerData.writable, workerData);
-		let streamsTransferred;
 		try {
-			streamsTransferred = sendMessage({
+			sendMessage({
 				type: MESSAGE_START,
 				options,
-				config,
-				readable,
-				writable
+				config
 			}, workerData);
 		} catch (error) {
 			abortPipe();
@@ -2904,12 +2893,10 @@
 			workerData.onTaskFinished();
 			throw error;
 		}
-		if (!streamsTransferred) {
-			Object.assign(workerData, {
-				reader: readable.getReader(),
-				writer: writable.getWriter()
-			});
-		}
+		Object.assign(workerData, {
+			reader: readable.getReader(),
+			writer: writable.getWriter()
+		});
 		const { workerStartupTimeout } = config;
 		if (!workerData.workerAlive && Number.isFinite(workerStartupTimeout) && workerStartupTimeout >= 0) {
 			workerData.startupTimeout = setTimeout(() => onStartupTimeout(workerData), workerStartupTimeout);
@@ -2942,7 +2929,7 @@
 		}
 
 		async function closeWritable() {
-			if (!streamsTransferred && !writable.locked) {
+			if (!writable.locked) {
 				try {
 					await writable.getWriter().close();
 				} catch {
@@ -3133,31 +3120,14 @@
 		}
 	}
 
-	function sendMessage(message, { worker, writer, transferStreams, workerAlive }) {
+	function sendMessage(message, { worker, writer }) {
 		try {
-			const { value, readable, writable } = message;
-			const transferables = [];
+			const { value } = message;
 			if (value) {
 				message.value = toExactUint8Array(value);
-				transferables.push(message.value.buffer);
-			}
-			if (transferStreams && transferStreamsSupported && workerAlive) {
-				if (readable) {
-					transferables.push(readable);
-				}
-				if (writable) {
-					transferables.push(writable);
-				}
-			} else {
-				message.readable = message.writable = null;
-			}
-			if (transferables.length) {
 				try {
-					worker.postMessage(message, transferables);
-					return true;
+					worker.postMessage(message, [message.value.buffer]);
 				} catch {
-					transferStreamsSupported = false;
-					message.readable = message.writable = null;
 					worker.postMessage(message);
 				}
 			} else {
@@ -3306,7 +3276,7 @@
 
 	async function runWorker(stream, workerOptions) {
 		const { options, config } = workerOptions;
-		const { transferStreams, useWebWorkers, useCompressionStream, compressed, checkCrc32, computeCrc32, encrypted, format, codecURI } = options;
+		const { useWebWorkers, useCompressionStream, compressed, checkCrc32, computeCrc32, encrypted, format, codecURI } = options;
 		const { workerURI, createWorker, maxWorkers } = config;
 		if (format) {
 			if (codecURI) {
@@ -3314,7 +3284,6 @@
 			}
 			await ensureCodecStreams(format, options.codecURI);
 		}
-		workerOptions.transferStreams = !format && (transferStreams || (transferStreams === UNDEFINED_VALUE && config.transferStreams));
 		const streamCopy = !compressed && !checkCrc32 && !computeCrc32 && !encrypted;
 		const workerSupported = format === UNDEFINED_VALUE || Boolean(options.codecURI);
 		workerOptions.useWebWorkers = !streamCopy && workerSupported && (useWebWorkers || (useWebWorkers === UNDEFINED_VALUE && config.useWebWorkers));
@@ -4810,6 +4779,8 @@
 	const WARNING_PREPENDED_DATA = "prepended data";
 	const WARNING_PREPENDED_CENTRAL_DIRECTORY = "prepended central directory";
 	const WARNING_TRAILING_CENTRAL_DIRECTORY_DATA = "trailing central directory data";
+	const WARNING_MISMATCHED_CENTRAL_DIRECTORY_OFFSET = "mismatched central directory offset";
+	const WARNING_MISSING_ZIP64_EXTRA_FIELD = "missing zip64 extra field";
 	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";
@@ -4972,6 +4943,8 @@
 						reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY);
 					}
 					directoryDataOffset = getDiskOffset$1(reader, diskNumber) + getBigUint64(endOfDirectoryView, 48) + prependedDataLength;
+				} else if (directoryDataOffset == MAX_32_BITS || directoryDataLength == MAX_32_BITS || diskNumber == MAX_16_BITS) {
+					throw new Error(ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND);
 				}
 			}
 			let declaredDirectoryDataLength = directoryDataLength;
@@ -4994,25 +4967,44 @@
 				if (directoryArray.length < 4) {
 					throw new Error(ERR_BAD_FORMAT);
 				}
-				const expectedDirectoryDataOffset = centralDirectoryEndOffset - directoryDataLength;
+				let expectedDirectoryDataOffset = centralDirectoryEndOffset - directoryDataLength;
 				if (directoryDataOffset != expectedDirectoryDataOffset && diskNumber == lastDiskNumber) {
 					const storedPointsAtDirectory = getUint32$1(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE ||
 						Boolean(directoryEncryptionInfo && directoryEncryptionInfo.compressedSize) ||
 						detectEncryptedCentralDirectory(directoryView);
 					let reconcile = !storedPointsAtDirectory;
-					if (!reconcile && expectedDirectoryDataOffset >= 0 && expectedDirectoryDataOffset + 4 <= reader.size) {
-						const expectedSignatureArray = await readUint8Array(reader, expectedDirectoryDataOffset, 4);
-						reconcile = getUint32$1(getDataView(expectedSignatureArray), 0) == CENTRAL_FILE_HEADER_SIGNATURE;
+					if (expectedDirectoryDataOffset >= 0 && expectedDirectoryDataOffset + 4 <= reader.size) {
+						const expectedPointsAtDirectory = await pointsAtDirectory(reader, expectedDirectoryDataOffset);
+						if (storedPointsAtDirectory) {
+							reconcile = expectedPointsAtDirectory;
+						} else if (!expectedPointsAtDirectory) {
+							const signatureRecordOffset = await findDigitalSignatureRecordOffset(reader, centralDirectoryEndOffset);
+							const signedDirectoryDataOffset = signatureRecordOffset - directoryDataLength;
+							if (signatureRecordOffset !== UNDEFINED_VALUE && signedDirectoryDataOffset >= 0 &&
+								await pointsAtDirectory(reader, signedDirectoryDataOffset)) {
+								expectedDirectoryDataOffset = signedDirectoryDataOffset;
+							}
+						}
 					}
 					if (reconcile) {
 						const originalDirectoryDataOffset = directoryDataOffset;
 						directoryDataOffset = expectedDirectoryDataOffset;
+						directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
+						directoryView = getDataView(directoryArray);
 						if (directoryDataOffset > originalDirectoryDataOffset) {
 							prependedDataLength += directoryDataOffset - originalDirectoryDataOffset;
 							prependedCentralDirectory = storedPointsAtDirectory;
+						} else {
+							reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_CENTRAL_DIRECTORY_OFFSET);
+							const offsetDelta = directoryDataOffset - originalDirectoryDataOffset;
+							if (directoryArray.length >= CENTRAL_FILE_HEADER_LENGTH) {
+								const localHeaderOffset = getUint32$1(directoryView, 42);
+								if (!await startsWithSignature(reader, localHeaderOffset, LOCAL_FILE_HEADER_SIGNATURE) &&
+									await startsWithSignature(reader, localHeaderOffset + offsetDelta, LOCAL_FILE_HEADER_SIGNATURE)) {
+									prependedDataLength += offsetDelta;
+								}
+							}
 						}
-						directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
-						directoryView = getDataView(directoryArray);
 					}
 				}
 			}
@@ -5096,17 +5088,6 @@
 				if (filename === UNDEFINED_VALUE) {
 					filename = decodeText(rawFilename, rawFilenameEncoding);
 				}
-				if (normalizeFilename) {
-					const normalizedFilename = normalizeFilename(filename);
-					if (normalizedFilename !== UNDEFINED_VALUE) {
-						filename = normalizedFilename;
-					}
-				}
-				if (isUnsafeFilename(filename, filenameValidation)) {
-					const error = new Error(ERR_UNSAFE_FILENAME);
-					error.filename = filename;
-					throw error;
-				}
 				let comment = decode(rawComment, rawCommentEncoding, TEXT_TYPE_COMMENT);
 				if (comment === UNDEFINED_VALUE) {
 					comment = decodeText(rawComment, rawCommentEncoding);
@@ -5134,7 +5115,29 @@
 					filename,
 					comment
 				});
-				if (readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6)) {
+				let malformedExtraField;
+				try {
+					malformedExtraField = readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6);
+				} catch (error) {
+					if (checkAmbiguity || error.message != ERR_EXTRAFIELD_ZIP64_NOT_FOUND) {
+						throw error;
+					}
+					fileEntry.zip64ExtraFieldMissing = true;
+					addWarning(warnings, WARNING_MISSING_ZIP64_EXTRA_FIELD, fileEntry.filename);
+				}
+				filename = fileEntry.filename;
+				if (normalizeFilename) {
+					const normalizedFilename = normalizeFilename(filename);
+					if (normalizedFilename !== UNDEFINED_VALUE) {
+						filename = fileEntry.filename = normalizedFilename;
+					}
+				}
+				if (isUnsafeFilename(filename, filenameValidation)) {
+					const error = new Error(ERR_UNSAFE_FILENAME);
+					error.filename = filename;
+					throw error;
+				}
+				if (malformedExtraField) {
 					addWarning(warnings, WARNING_MALFORMED_EXTRA_FIELD, filename);
 				}
 				fileEntry.offset += prependedDataLength;
@@ -5163,11 +5166,12 @@
 				const sticky = Boolean(fileEntry.unixMode & FILE_ATTR_UNIX_STICKY_MASK);
 				const unixType = fileEntry.unixMode === UNDEFINED_VALUE ? unixExternalUpper : fileEntry.unixMode;
 				const symlink = (unixType & FILE_ATTR_UNIX_TYPE_MASK) == FILE_ATTR_UNIX_TYPE_SYMLINK;
-				const executable = !symlink && ((fileEntry.unixMode !== UNDEFINED_VALUE)
-					? ((fileEntry.unixMode & FILE_ATTR_UNIX_EXECUTABLE_MASK) != 0)
-					: (unixCompatible && ((unixExternalUpper & FILE_ATTR_UNIX_EXECUTABLE_MASK) != 0)));
 				const modeIsDir = fileEntry.unixMode !== UNDEFINED_VALUE && ((fileEntry.unixMode & FILE_ATTR_UNIX_TYPE_MASK) == FILE_ATTR_UNIX_TYPE_DIR);
 				const upperIsDir = ((unixExternalUpper & FILE_ATTR_UNIX_TYPE_MASK) == FILE_ATTR_UNIX_TYPE_DIR);
+				const directory = modeIsDir || upperIsDir || (msDosCompatible && msdosAttributes.directory) || fileEntry.filename.endsWith(DIRECTORY_SIGNATURE);
+				const executable = !symlink && !directory && ((fileEntry.unixMode !== UNDEFINED_VALUE)
+					? ((fileEntry.unixMode & FILE_ATTR_UNIX_EXECUTABLE_MASK) != 0)
+					: (unixCompatible && ((unixExternalUpper & FILE_ATTR_UNIX_EXECUTABLE_MASK) != 0)));
 				Object.assign(fileEntry, {
 					setuid,
 					setgid,
@@ -5175,7 +5179,7 @@
 					symlink,
 					unixExternalUpper,
 					executable,
-					directory: modeIsDir || upperIsDir || (msDosCompatible && msdosAttributes.directory) || fileEntry.filename.endsWith(DIRECTORY_SIGNATURE),
+					directory,
 					zipCrypto: fileEntry.encrypted && !fileEntry.extraFieldAES
 				});
 				const entry = new Entry(fileEntry);
@@ -5231,10 +5235,10 @@
 			const extractAppendedData = getOptionValue$1(zipReader, options, OPTION_EXTRACT_APPENDED_DATA);
 			const splitZipSignatureLength = (checkAmbiguity || extractPrependedData) && filesLength &&
 				startOffset == SPLIT_ZIP_FILE_SIGNATURE_LENGTH && await startsWithSplitZipMarker(reader) ? SPLIT_ZIP_FILE_SIGNATURE_LENGTH : 0;
-			if (checkAmbiguity && (prependedDataLength || (filesLength && startOffset > splitZipSignatureLength))) {
+			if (checkAmbiguity && (prependedDataLength > 0 || (filesLength && startOffset > splitZipSignatureLength))) {
 				throwAmbiguousArchive(WARNING_PREPENDED_DATA);
 			}
-			if (prependedDataLength || (filesLength && startOffset > SPLIT_ZIP_FILE_SIGNATURE_LENGTH)) {
+			if (prependedDataLength > 0 || (filesLength && startOffset > SPLIT_ZIP_FILE_SIGNATURE_LENGTH)) {
 				addWarning(warnings, WARNING_PREPENDED_DATA);
 			}
 			if (prependedCentralDirectory) {
@@ -5394,6 +5398,9 @@
 
 		async getData(writer, fileEntry, readRanges, options = {}) {
 			const zipEntry = this;
+			if (zipEntry.zip64ExtraFieldMissing) {
+				throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
+			}
 			const config = getConfiguration();
 			const {
 				reader,
@@ -5538,7 +5545,6 @@
 					encrypted,
 					useWebWorkers: getOptionValue$1(zipEntry, options, OPTION_USE_WEB_WORKERS),
 					useCompressionStream,
-					transferStreams: getOptionValue$1(zipEntry, options, OPTION_TRANSFER_STREAMS),
 					deflate64,
 					format: registeredCodec ? registeredCodec.format : UNDEFINED_VALUE,
 					codecURI: registeredCodec ? registeredCodec.codecURI : UNDEFINED_VALUE,
@@ -5632,6 +5638,30 @@
 		return wrappedFilesLength % (MAX_16_BITS + 1) ? 0 : wrappedFilesLength;
 	}
 
+	function pointsAtDirectory(reader, offset) {
+		return startsWithSignature(reader, offset, CENTRAL_FILE_HEADER_SIGNATURE);
+	}
+
+	async function startsWithSignature(reader, offset, signature) {
+		if (offset < 0 || offset + 4 > reader.size) {
+			return false;
+		}
+		const signatureArray = await readUint8Array(reader, offset, 4);
+		return getUint32$1(getDataView(signatureArray), 0) == signature;
+	}
+
+	async function findDigitalSignatureRecordOffset(reader, endOffset) {
+		const startOffset = Math.max(0, endOffset - (6 + MAX_16_BITS));
+		const tailArray = await readUint8Array(reader, startOffset, endOffset - startOffset);
+		const tailView = getDataView(tailArray);
+		for (let indexByte = tailArray.length - 6; indexByte >= 0; indexByte--) {
+			if (getUint32$1(tailView, indexByte) == DIGITAL_SIGNATURE_RECORD_SIGNATURE &&
+				indexByte + 6 + getUint16$1(tailView, indexByte + 4) == tailArray.length) {
+				return startOffset + indexByte;
+			}
+		}
+	}
+
 	function readDigitalSignature(signatureRecordArray) {
 		if (signatureRecordArray.length >= 6) {
 			const signatureRecordView = getDataView(signatureRecordArray);
@@ -5763,29 +5793,27 @@
 			readExtraFieldUnixDates(extraFieldUnixType1, directory);
 			directory.extraFieldUnixType1 = extraFieldUnixType1;
 		}
+		const extraFieldExtendedTimestamp = extraField.get(EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
+		if (extraFieldExtendedTimestamp) {
+			readExtraFieldExtendedTimestamp(extraFieldExtendedTimestamp, directory, localDirectory);
+			directory.extraFieldExtendedTimestamp = extraFieldExtendedTimestamp;
+		}
 		const extraFieldNTFS = extraField.get(EXTRAFIELD_TYPE_NTFS);
 		if (extraFieldNTFS) {
 			readExtraFieldNTFS(extraFieldNTFS, directory);
 			directory.extraFieldNTFS = extraFieldNTFS;
 		}
-		const extraFieldUnix = extraField.get(EXTRAFIELD_TYPE_UNIX);
+		const extraFieldInfoZip = extraField.get(EXTRAFIELD_TYPE_INFOZIP);
 		let unixIdsRead;
+		if (extraFieldInfoZip) {
+			unixIdsRead = readExtraFieldUnix(extraFieldInfoZip, directory, true);
+			directory.extraFieldInfoZip = extraFieldInfoZip;
+		}
+		const extraFieldUnix = extraField.get(EXTRAFIELD_TYPE_UNIX);
 		if (extraFieldUnix) {
-			unixIdsRead = readExtraFieldUnix(extraFieldUnix, directory, false);
+			readExtraFieldUnix(extraFieldUnix, unixIdsRead ? {} : directory, false);
 			directory.extraFieldUnix = extraFieldUnix;
 		}
-		if (!unixIdsRead) {
-			const extraFieldInfoZip = extraField.get(EXTRAFIELD_TYPE_INFOZIP);
-			if (extraFieldInfoZip) {
-				readExtraFieldUnix(extraFieldInfoZip, directory, true);
-				directory.extraFieldInfoZip = extraFieldInfoZip;
-			}
-		}
-		const extraFieldExtendedTimestamp = extraField.get(EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
-		if (extraFieldExtendedTimestamp) {
-			readExtraFieldExtendedTimestamp(extraFieldExtendedTimestamp, directory, localDirectory);
-			directory.extraFieldExtendedTimestamp = extraFieldExtendedTimestamp;
-		}
 		const extraFieldUSDZ = extraField.get(EXTRAFIELD_TYPE_USDZ);
 		if (extraFieldUSDZ) {
 			directory.extraFieldUSDZ = extraFieldUSDZ;
@@ -6424,11 +6452,13 @@
 		WARNING_COMPRESSED_PATCHED_DATA: WARNING_COMPRESSED_PATCHED_DATA,
 		WARNING_DUPLICATE_FILENAME: WARNING_DUPLICATE_FILENAME,
 		WARNING_MALFORMED_EXTRA_FIELD: WARNING_MALFORMED_EXTRA_FIELD,
+		WARNING_MISMATCHED_CENTRAL_DIRECTORY_OFFSET: WARNING_MISMATCHED_CENTRAL_DIRECTORY_OFFSET,
 		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_MISSING_ZIP64_EXTRA_FIELD: WARNING_MISSING_ZIP64_EXTRA_FIELD,
 		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,
@@ -6561,13 +6591,14 @@
 			return watchPromiseError(this, prependZipEntries(this, reader));
 		}
 
-		appendZip(reader) {
-			return watchPromiseError(this, this.appendZipEntries(reader));
+		appendZip(reader, options = {}) {
+			return watchPromiseError(this, this.appendZipEntries(reader, options));
 		}
 
-		async appendZipEntries(reader) {
+		async appendZipEntries(reader, options = {}) {
 			const zipWriter = this;
 			const { pendingAddFileCalls, filenames, fileEntries } = zipWriter;
+			const filter = checkFunctionOption(options.filter);
 			while (pendingAddFileCalls.size) {
 				await Promise.allSettled(Array.from(pendingAddFileCalls));
 			}
@@ -6586,10 +6617,16 @@
 				const { ZipReader } = await Promise.resolve().then(function () { return zipReader; });
 				const zipReader$1 = new ZipReader(reader);
 				const entries = await zipReader$1.getEntries();
+				const keptEntries = [];
+				for (const entry of entries) {
+					if (!filter || await filter(entry)) {
+						keptEntries.push(entry);
+					}
+				}
 				await zipReader$1.close();
 				await initStream(zipWriter.writer);
 				const { directoryOffset } = zipReader$1;
-				entries.forEach(({ filename }) => {
+				keptEntries.forEach(({ filename }) => {
 					if (filenames.has(filename)) {
 						throw new Error(ERR_DUPLICATED_NAME);
 					}
@@ -6610,8 +6647,8 @@
 						zipWriter.offset += SPLIT_ZIP_FILE_SIGNATURE_LENGTH;
 					}
 				}
-				const entryPositions = await copyZipData(zipWriter, reader, entries, directoryOffset);
-				entries.forEach(entry => {
+				const entryPositions = await copyZipData(zipWriter, reader, entries, keptEntries, directoryOffset, Boolean(filter));
+				keptEntries.forEach(entry => {
 					const {
 						version,
 						rawLastModDate,
@@ -6667,6 +6704,7 @@
 						rawExtraFieldExtendedTimestamp: EMPTY_UINT8_ARRAY,
 						rawExtraFieldNTFS: EMPTY_UINT8_ARRAY,
 						rawExtraFieldUnix: EMPTY_UINT8_ARRAY,
+						rawCentralExtraFieldUnix: EMPTY_UINT8_ARRAY,
 						rawExtraField,
 						rawCentralExtraField: EMPTY_UINT8_ARRAY,
 						headerArray,
@@ -7235,7 +7273,6 @@
 		const ntfsTimestamp = getOptionValue(zipWriter, options, OPTION_NTFS_TIMESTAMP);
 		const keepOrder = getOptionValue(zipWriter, options, OPTION_KEEP_ORDER, true);
 		const useWebWorkers = getOptionValue(zipWriter, options, OPTION_USE_WEB_WORKERS);
-		const transferStreams = getOptionValue(zipWriter, options, OPTION_TRANSFER_STREAMS);
 		const bufferedWrite = getOptionValue(zipWriter, options, OPTION_BUFFERED_WRITE);
 		const createTempStream = getFunctionOptionValue(zipWriter, options, OPTION_CREATE_TEMP_STREAM);
 		const dataDescriptorSignature = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR_SIGNATURE, true);
@@ -7301,7 +7338,6 @@
 				ntfsTimestamp,
 				keepOrder,
 				useWebWorkers,
-				transferStreams,
 				bufferedWrite,
 				createTempStream,
 				dataDescriptorSignature,
@@ -7360,7 +7396,7 @@
 		if (reader) {
 			reader = new GenericReader(reader);
 			await initStream(reader);
-			if (!reader.readable && !reader.readUint8Array) {
+			if (!reader.readUint8Array && !reader.readable) {
 				throw new Error(ERR_INVALID_READER);
 			}
 			({ size: contentSize } = reader);
@@ -7623,6 +7659,7 @@
 			extraFieldExtendedTimestampTime,
 			rawExtraFieldNTFS,
 			rawExtraFieldUnix,
+			rawCentralExtraFieldUnix,
 			rawExtraFieldAES,
 		} = headerInfo;
 		const { dataDescriptorArray } = dataDescriptorInfo;
@@ -7647,7 +7684,6 @@
 			rawExtraField,
 			rawCentralExtraField,
 			useWebWorkers,
-			transferStreams,
 			onstart,
 			onprogress,
 			onend,
@@ -7689,6 +7725,7 @@
 			rawExtraFieldExtendedTimestamp,
 			rawExtraFieldNTFS,
 			rawExtraFieldUnix,
+			rawCentralExtraFieldUnix,
 			rawExtraFieldAES,
 			rawExtraField,
 			rawCentralExtraField,
@@ -7735,7 +7772,6 @@
 					encrypted: encrypted && !passThroughEncryption,
 					useWebWorkers,
 					useCompressionStream,
-					transferStreams,
 					format,
 					codecURI,
 					compressionMethod
@@ -7913,6 +7949,7 @@
 			rawExtraFieldNTFS = rawExtraFieldExtendedTimestamp = EMPTY_UINT8_ARRAY;
 		}
 		let rawExtraFieldUnix;
+		let rawCentralExtraFieldUnix;
 		try {
 			const { uid, gid, unixExtraFieldType } = options;
 			if (unixExtraFieldType == INFOZIP_EXTRA_FIELD_TYPE && (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE)) {
@@ -7927,7 +7964,7 @@
 				extraFieldUnix.writeBytes(uidBytes);
 				extraFieldUnix.writeUint8(gidBytes.length);
 				extraFieldUnix.writeBytes(gidBytes);
-				rawExtraFieldUnix = extraFieldUnix.array;
+				rawExtraFieldUnix = rawCentralExtraFieldUnix = extraFieldUnix.array;
 			} else if (unixExtraFieldType == UNIX_EXTRA_FIELD_TYPE && (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE)) {
 				const extraFieldUnix = createRecordWriter(8);
 				extraFieldUnix.writeUint16(EXTRAFIELD_TYPE_UNIX);
@@ -7935,11 +7972,15 @@
 				extraFieldUnix.writeUint16((uid === UNDEFINED_VALUE ? 0 : uid) & MAX_16_BITS);
 				extraFieldUnix.writeUint16((gid === UNDEFINED_VALUE ? 0 : gid) & MAX_16_BITS);
 				rawExtraFieldUnix = extraFieldUnix.array;
+				const centralExtraFieldUnix = createRecordWriter(4);
+				centralExtraFieldUnix.writeUint16(EXTRAFIELD_TYPE_UNIX);
+				centralExtraFieldUnix.writeUint16(0);
+				rawCentralExtraFieldUnix = centralExtraFieldUnix.array;
 			} else {
-				rawExtraFieldUnix = EMPTY_UINT8_ARRAY;
+				rawExtraFieldUnix = rawCentralExtraFieldUnix = EMPTY_UINT8_ARRAY;
 			}
 		} catch {
-			rawExtraFieldUnix = EMPTY_UINT8_ARRAY;
+			rawExtraFieldUnix = rawCentralExtraFieldUnix = EMPTY_UINT8_ARRAY;
 		}
 		if (compressionMethod === UNDEFINED_VALUE) {
 			compressionMethod = compressed ? COMPRESSION_METHOD_DEFLATE : COMPRESSION_METHOD_STORE;
@@ -8031,6 +8072,7 @@
 			rawExtraFieldExtendedTimestamp,
 			rawExtraFieldNTFS,
 			rawExtraFieldUnix,
+			rawCentralExtraFieldUnix,
 			rawExtraFieldAES,
 			extraFieldLength
 		};
@@ -8206,7 +8248,7 @@
 				rawExtraFieldAES,
 				rawComment,
 				rawExtraFieldNTFS,
-				rawExtraFieldUnix,
+				rawCentralExtraFieldUnix,
 				rawExtraField,
 				rawCentralExtraField,
 				extraFieldExtendedTimestampFlag,
@@ -8268,7 +8310,7 @@
 				rawExtraFieldZip64,
 				rawExtraFieldAES,
 				rawExtraFieldNTFS,
-				rawExtraFieldUnix,
+				rawCentralExtraFieldUnix,
 				rawExtraFieldTimestamp,
 				rawExtraField,
 				rawCentralExtraField);
@@ -8297,7 +8339,7 @@
 				rawExtraFieldAES,
 				rawExtraFieldExtendedTimestamp,
 				rawExtraFieldNTFS,
-				rawExtraFieldUnix,
+				rawCentralExtraFieldUnix,
 				rawExtraField,
 				rawCentralExtraField,
 				rawComment,
@@ -8314,7 +8356,7 @@
 				uncompressedSize,
 				compressedSize
 			} = fileEntry;
-			const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField, rawCentralExtraField);
+			const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawCentralExtraFieldUnix, rawExtraField, rawCentralExtraField);
 			const directoryRecordLength = CENTRAL_FILE_HEADER_LENGTH + getLength(rawFilename, rawComment) + extraFieldLength;
 			if (exceedsAvailableSize(writer, offset + directoryRecordLength - directoryDiskOffset)) {
 				await writeData(writer, directoryArray.slice(directoryDiskOffset, offset));
@@ -8350,7 +8392,7 @@
 			directoryRecord.writeBytes(rawExtraFieldAES);
 			directoryRecord.writeBytes(rawExtraFieldExtendedTimestamp);
 			directoryRecord.writeBytes(rawExtraFieldNTFS);
-			directoryRecord.writeBytes(rawExtraFieldUnix);
+			directoryRecord.writeBytes(rawCentralExtraFieldUnix);
 			directoryRecord.writeBytes(rawExtraField);
 			directoryRecord.writeBytes(rawCentralExtraField);
 			directoryRecord.writeBytes(rawComment);
@@ -8519,26 +8561,42 @@
 		return rawExtraField;
 	}
 
-	async function copyZipData(zipWriter, reader, entries, directoryOffset) {
+	async function copyZipData(zipWriter, reader, entries, keptEntries, directoryOffset, compact) {
 		const { writer } = zipWriter;
 		const entryPositions = new Map();
-		if (writer.closeDisk) {
+		if (writer.closeDisk || compact) {
 			const sortedEntries = Array.from(entries).sort((firstEntry, secondEntry) =>
 				getSourceOffset(reader, firstEntry) - getSourceOffset(reader, secondEntry));
-			let copiedLength = 0;
-			for (const entry of sortedEntries) {
-				const sourceOffset = getSourceOffset(reader, entry);
-				await copyData(zipWriter, reader, copiedLength, sourceOffset - copiedLength);
-				if (exceedsAvailableSize(writer, await getLocalHeaderLength(reader, sourceOffset))) {
-					await writer.closeDisk();
-				}
-				entryPositions.set(entry, {
-					offset: getSegmentOffset(zipWriter, writer),
-					diskNumberStart: getDiskNumber(writer)
-				});
-				copiedLength = sourceOffset;
+			const regionEnds = getRegionEnds(reader, sortedEntries, directoryOffset);
+			const keptEntrySet = new Set(keptEntries);
+			let copiedOffset = 0;
+			let lastPosition;
+			for (let indexEntry = 0; indexEntry < sortedEntries.length; indexEntry++) {
+				const entry = sortedEntries[indexEntry];
+				if (keptEntrySet.has(entry)) {
+					const sourceOffset = getSourceOffset(reader, entry);
+					if (sourceOffset < copiedOffset) {
+						entryPositions.set(entry, lastPosition);
+					} else {
+						if (!compact) {
+							await copyData(zipWriter, reader, copiedOffset, sourceOffset - copiedOffset);
+						}
+						if (writer.closeDisk && exceedsAvailableSize(writer, await getLocalHeaderLength(reader, sourceOffset))) {
+							await writer.closeDisk();
+						}
+						lastPosition = {
+							offset: getSegmentOffset(zipWriter, writer),
+							diskNumberStart: getDiskNumber(writer)
+						};
+						entryPositions.set(entry, lastPosition);
+						await copyData(zipWriter, reader, sourceOffset, regionEnds[indexEntry] - sourceOffset);
+						copiedOffset = regionEnds[indexEntry];
+					}
+				}
+			}
+			if (!compact) {
+				await copyData(zipWriter, reader, copiedOffset, directoryOffset - copiedOffset);
 			}
-			await copyData(zipWriter, reader, copiedLength, directoryOffset - copiedLength);
 		} else {
 			const baseOffset = zipWriter.offset;
 			await copyData(zipWriter, reader, 0, directoryOffset);
@@ -8550,6 +8608,20 @@
 		return entryPositions;
 	}
 
+	function getRegionEnds(reader, sortedEntries, directoryOffset) {
+		const regionEnds = new Array(sortedEntries.length);
+		let regionEnd = directoryOffset;
+		for (let indexEntry = sortedEntries.length - 1; indexEntry >= 0; indexEntry--) {
+			const sourceOffset = getSourceOffset(reader, sortedEntries[indexEntry]);
+			const nextEntry = sortedEntries[indexEntry + 1];
+			if (nextEntry && getSourceOffset(reader, nextEntry) > sourceOffset) {
+				regionEnd = getSourceOffset(reader, nextEntry);
+			}
+			regionEnds[indexEntry] = regionEnd;
+		}
+		return regionEnds;
+	}
+
 	async function copyData(zipWriter, reader, offset, size) {
 		if (size > 0) {
 			const { writer } = zipWriter;
@@ -8927,7 +8999,7 @@
 	 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 	 */
 
-	const VERSION = "2.18.2";
+	const VERSION = "2.20.0";
 
 	/*
 	 Copyright (c) 2025 Gildas Lormeau. All rights reserved.
@@ -9476,11 +9548,13 @@
 	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_CENTRAL_DIRECTORY_OFFSET = WARNING_MISMATCHED_CENTRAL_DIRECTORY_OFFSET;
 	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_MISSING_ZIP64_EXTRA_FIELD = WARNING_MISSING_ZIP64_EXTRA_FIELD;
 	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;