@zip.js/zip.js 2.19.0 → 2.21.0

package/dist/zip-fs-core.js

@@ -126,6 +126,10 @@
 
 	const UNDEFINED_VALUE = undefined;
 	const INFINITY_VALUE = Infinity;
+	const ERR_LOCAL_FILE_HEADER_NOT_FOUND = "Local file header not found";
+	const ERR_OVERLAPPING_ENTRY = "Overlapping entry found";
+	const ERR_EXTRAFIELD_ZIP64_NOT_FOUND = "Zip64 extra field not found";
+
 	const UNDEFINED_TYPE = "undefined";
 	const FUNCTION_TYPE = "function";
 	const OBJECT_TYPE = "object";
@@ -4775,12 +4779,9 @@
 	const ERR_EOCDR_NOT_FOUND = "End of central directory not found";
 	const ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND = "End of Zip64 central directory locator not found";
 	const ERR_CENTRAL_DIRECTORY_NOT_FOUND = "Central directory header not found";
-	const ERR_LOCAL_FILE_HEADER_NOT_FOUND = "Local file header not found";
-	const ERR_EXTRAFIELD_ZIP64_NOT_FOUND = "Zip64 extra field not found";
 	const ERR_ENCRYPTED = "File contains encrypted entry";
 	const ERR_UNSUPPORTED_ENCRYPTION = "Encryption method not supported";
 	const ERR_SPLIT_ZIP_FILE = "Split zip file";
-	const ERR_OVERLAPPING_ENTRY = "Overlapping entry found";
 	const ERR_ENTRY_DATA_OUT_OF_BOUNDS = "Entry data out of bounds";
 	const ERR_AMBIGUOUS_ARCHIVE = "Ambiguous archive";
 	const ERR_ENCRYPTED_CENTRAL_DIRECTORY = "Encrypted central directory is not supported";
@@ -4799,6 +4800,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";
@@ -4843,7 +4846,8 @@
 			Object.assign(this, {
 				reader: new GenericReader(reader),
 				options,
-				readRanges: { indexes: new Set(), sortedRanges: [], pendingRanges: [] }
+				readRanges: { indexes: new Set(), sortedRanges: [], pendingRanges: [] },
+				entriesMissingZip64ExtraField: new WeakSet()
 			});
 		}
 
@@ -4914,16 +4918,22 @@
 					directoryDataOffset = getDiskOffset$1(reader, getUint32$1(endOfDirectoryLocatorView, 4)) + getBigUint64(endOfDirectoryLocatorView, 8);
 					let endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH);
 					let endOfDirectoryView = getDataView(endOfDirectoryArray);
-					const expectedDirectoryDataOffset = endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH - ZIP64_END_OF_CENTRAL_DIR_LENGTH;
-					if ((endOfDirectoryArray.length < ZIP64_END_OF_CENTRAL_DIR_LENGTH || getUint32$1(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) &&
-						directoryDataOffset != expectedDirectoryDataOffset && expectedDirectoryDataOffset >= 0) {
-						const originalDirectoryDataOffset = directoryDataOffset;
-						directoryDataOffset = expectedDirectoryDataOffset;
-						if (directoryDataOffset > originalDirectoryDataOffset) {
-							prependedDataLength = directoryDataOffset - originalDirectoryDataOffset;
+					if (endOfDirectoryArray.length < ZIP64_END_OF_CENTRAL_DIR_LENGTH || getUint32$1(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) {
+						const locatorOffset = endOfDirectoryInfo.offset - ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH;
+						let expectedDirectoryDataOffset = locatorOffset - ZIP64_END_OF_CENTRAL_DIR_LENGTH;
+						if (!await startsWithSignature(reader, expectedDirectoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_SIGNATURE)) {
+							expectedDirectoryDataOffset = await findZip64EndOfDirectoryOffset(reader, locatorOffset);
+						}
+						if (expectedDirectoryDataOffset !== UNDEFINED_VALUE && expectedDirectoryDataOffset >= 0 &&
+							directoryDataOffset != expectedDirectoryDataOffset) {
+							const originalDirectoryDataOffset = directoryDataOffset;
+							directoryDataOffset = expectedDirectoryDataOffset;
+							if (directoryDataOffset > originalDirectoryDataOffset) {
+								prependedDataLength = directoryDataOffset - originalDirectoryDataOffset;
+							}
+							endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH);
+							endOfDirectoryView = getDataView(endOfDirectoryArray);
 						}
-						endOfDirectoryArray = await readUint8Array(reader, directoryDataOffset, ZIP64_END_OF_CENTRAL_DIR_LENGTH);
-						endOfDirectoryView = getDataView(endOfDirectoryArray);
 					}
 					if (endOfDirectoryArray.length < ZIP64_END_OF_CENTRAL_DIR_LENGTH || getUint32$1(endOfDirectoryView, 0) != ZIP64_END_OF_CENTRAL_DIR_SIGNATURE) {
 						throw new Error(ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND);
@@ -4961,15 +4971,13 @@
 						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;
 			const centralDirectoryEndOffset = endOfDirectoryInfo.offset -
 				(zip64EndOfDirectory ? zip64EndOfDirectoryLength + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH : 0);
-			if (directoryDataOffset >= reader.size) {
-				prependedDataLength = reader.size - directoryDataOffset - directoryDataLength - END_OF_CENTRAL_DIR_LENGTH;
-				directoryDataOffset = reader.size - directoryDataLength - END_OF_CENTRAL_DIR_LENGTH;
-			}
 			if (expectedLastDiskNumber != lastDiskNumber) {
 				throw new Error(ERR_SPLIT_ZIP_FILE);
 			}
@@ -4977,33 +4985,64 @@
 				throw new Error(ERR_BAD_FORMAT);
 			}
 			let offset = 0;
-			let directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
+			let directoryArray = directoryDataOffset < reader.size ?
+				await readUint8Array(reader, directoryDataOffset, directoryDataLength) :
+				EMPTY_UINT8_ARRAY;
 			let directoryView = getDataView(directoryArray);
 			if (directoryDataLength) {
-				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 ||
+					const storedPointsAtDirectory = directoryArray.length >= 4 && (
+						getUint32$1(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE ||
 						Boolean(directoryEncryptionInfo && directoryEncryptionInfo.compressedSize) ||
-						detectEncryptedCentralDirectory(directoryView);
+						detectEncryptedCentralDirectory(directoryView));
+					if (!storedPointsAtDirectory && expectedDirectoryDataOffset < 0) {
+						throw new Error(ERR_BAD_FORMAT);
+					}
 					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) {
+						let expectedPointsAtDirectory = await pointsAtDirectory(reader, expectedDirectoryDataOffset);
+						if (!expectedPointsAtDirectory) {
+							const signatureRecordOffset = await findDigitalSignatureRecordOffset(reader, centralDirectoryEndOffset);
+							const signedDirectoryDataOffset = signatureRecordOffset - directoryDataLength;
+							if (signatureRecordOffset !== UNDEFINED_VALUE && signedDirectoryDataOffset >= 0 &&
+								await pointsAtDirectory(reader, signedDirectoryDataOffset)) {
+								expectedDirectoryDataOffset = signedDirectoryDataOffset;
+								expectedPointsAtDirectory = true;
+							}
+						}
+						if (storedPointsAtDirectory) {
+							reconcile = expectedPointsAtDirectory;
+						}
 					}
-					if (reconcile) {
+					if (reconcile && expectedDirectoryDataOffset != directoryDataOffset) {
 						const originalDirectoryDataOffset = directoryDataOffset;
 						directoryDataOffset = expectedDirectoryDataOffset;
-						if (directoryDataOffset > originalDirectoryDataOffset) {
-							prependedDataLength += directoryDataOffset - originalDirectoryDataOffset;
-							prependedCentralDirectory = storedPointsAtDirectory;
-						}
 						directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
 						directoryView = getDataView(directoryArray);
+						const offsetDelta = directoryDataOffset - originalDirectoryDataOffset;
+						const localHeaderOffset = getFirstLocalHeaderOffset(directoryArray, directoryView);
+						const localHeaderFound = localHeaderOffset !== UNDEFINED_VALUE &&
+							await startsWithSignature(reader, localHeaderOffset, LOCAL_FILE_HEADER_SIGNATURE);
+						const shiftedLocalHeaderFound = localHeaderOffset !== UNDEFINED_VALUE &&
+							await startsWithSignature(reader, localHeaderOffset + offsetDelta, LOCAL_FILE_HEADER_SIGNATURE);
+						if (offsetDelta > 0 && !(localHeaderFound && !shiftedLocalHeaderFound)) {
+							prependedDataLength += offsetDelta;
+							prependedCentralDirectory = storedPointsAtDirectory;
+						} else {
+							reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_CENTRAL_DIRECTORY_OFFSET);
+							if (offsetDelta < 0 && !localHeaderFound && shiftedLocalHeaderFound) {
+								prependedDataLength += offsetDelta;
+							}
+						}
 					}
 				}
+				if (directoryArray.length < 4) {
+					throw new Error(ERR_BAD_FORMAT);
+				}
+			} else if (!filesLength && directoryDataOffset < centralDirectoryEndOffset && diskNumber == lastDiskNumber) {
+				prependedDataLength += centralDirectoryEndOffset - directoryDataOffset;
+				directoryDataOffset = centralDirectoryEndOffset;
 			}
 			const expectedDirectoryDataLength = centralDirectoryEndOffset - directoryDataOffset;
 			if (directoryDataLength != expectedDirectoryDataLength && expectedDirectoryDataLength >= 0 && diskNumber == lastDiskNumber) {
@@ -5045,8 +5084,10 @@
 					addWarning(warnings, WARNING_WRAPPED_ENTRIES_COUNT);
 				}
 			}
+			const entryOptions = Object.assign({}, zipReader.options, options, { [OPTION_STRICTNESS]: strictness });
+			delete entryOptions[OPTION_CHECK_AMBIGUITY];
 			for (let indexFile = 0; indexFile < filesLength; indexFile++) {
-				const fileEntry = new ZipEntry$1(reader, zipReader.options);
+				const fileEntry = new ZipEntry$1(reader, entryOptions);
 				if (offset + CENTRAL_FILE_HEADER_LENGTH > directoryArray.length || getUint32$1(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE) {
 					if (indexFile == 0 && !decryptedDirectory && (zip64EndOfDirectoryVersion2 || detectEncryptedCentralDirectory(directoryView))) {
 						throw new Error(ERR_ENCRYPTED_CENTRAL_DIRECTORY);
@@ -5112,7 +5153,16 @@
 					filename,
 					comment
 				});
-				const malformedExtraField = 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);
@@ -5128,13 +5178,17 @@
 				if (malformedExtraField) {
 					addWarning(warnings, WARNING_MALFORMED_EXTRA_FIELD, filename);
 				}
-				fileEntry.offset += prependedDataLength;
-				const entryPosition = getDiskOffset$1(reader, fileEntry.diskNumberStart) + fileEntry.offset;
-				startOffset = Math.min(entryPosition, startOffset);
-				if (entryPosition < previousEntryPosition) {
-					addWarning(warnings, WARNING_UNSORTED_CENTRAL_DIRECTORY, filename);
+				if (fileEntry.zip64ExtraFieldMissing && fileEntry.offset == MAX_32_BITS) {
+					startOffset = 0;
+				} else {
+					fileEntry.offset += prependedDataLength;
+					const entryPosition = getDiskOffset$1(reader, fileEntry.diskNumberStart) + fileEntry.offset;
+					startOffset = Math.min(entryPosition, startOffset);
+					if (entryPosition < previousEntryPosition) {
+						addWarning(warnings, WARNING_UNSORTED_CENTRAL_DIRECTORY, filename);
+					}
+					previousEntryPosition = entryPosition;
 				}
-				previousEntryPosition = entryPosition;
 				if ((fileEntry.version & MAX_8_BITS) > MAX_KNOWN_VERSION) {
 					addWarning(warnings, WARNING_UNKNOWN_VERSION, filename);
 				}
@@ -5154,11 +5208,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,
@@ -5166,16 +5221,19 @@
 					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);
-				entry.getData = (writer, options) => fileEntry.getData(writer, entry, zipReader.readRanges, options);
+				if (fileEntry.zip64ExtraFieldMissing) {
+					zipReader.entriesMissingZip64ExtraField.add(entry);
+				}
+				entry.getData = (writer, options) => fileEntry.getData(writer, entry, zipReader, options);
 				entry.arrayBuffer = async options => {
 					const writer = new TransformStream();
 					const arrayBufferPromise = streamToBlob(writer.readable).then(blob => blob.arrayBuffer());
 					arrayBufferPromise.catch(() => { });
-					await fileEntry.getData(writer, entry, zipReader.readRanges,
+					await fileEntry.getData(writer, entry, zipReader,
 						Object.assign({}, options, { preventClose: false }));
 					return arrayBufferPromise;
 				};
@@ -5222,10 +5280,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) {
@@ -5383,8 +5441,12 @@
 			});
 		}
 
-		async getData(writer, fileEntry, readRanges, options = {}) {
+		async getData(writer, fileEntry, zipReader, options = {}) {
 			const zipEntry = this;
+			const { readRanges, directoryOffset } = zipReader;
+			if (zipEntry.zip64ExtraFieldMissing) {
+				throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
+			}
 			const config = getConfiguration();
 			const {
 				reader,
@@ -5455,10 +5517,10 @@
 			}
 			validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename, checkLocalDirectory ? UNDEFINED_VALUE : warnings);
 			const { lastAccessDate, creationDate, uid, gid } = localDirectory;
-			if (lastAccessDate) {
+			if (lastAccessDate && fileEntry.lastAccessDate === UNDEFINED_VALUE) {
 				fileEntry.lastAccessDate = lastAccessDate;
 			}
-			if (creationDate) {
+			if (creationDate && fileEntry.creationDate === UNDEFINED_VALUE) {
 				fileEntry.creationDate = creationDate;
 			}
 			if (uid !== UNDEFINED_VALUE && fileEntry.uid === UNDEFINED_VALUE) {
@@ -5487,7 +5549,7 @@
 					throw new Error(ERR_ENCRYPTED);
 				}
 			}
-			if (dataOffset + compressedSize > reader.size) {
+			if (dataOffset + compressedSize > Math.min(reader.size, directoryOffset)) {
 				throw new Error(ERR_ENTRY_DATA_OUT_OF_BOUNDS);
 			}
 			const size = compressedSize;
@@ -5553,6 +5615,7 @@
 					extraFieldZip64: extraFieldZip64 || localDirectory.extraFieldZip64,
 					readRanges
 				});
+				validateDataDescriptor(zipEntry, localDirectory, checkLocalDirectory ? UNDEFINED_VALUE : warnings);
 			}
 			let writable, abortError, aborted;
 			try {
@@ -5572,10 +5635,7 @@
 					writer.size += writtenSize;
 				}
 			} catch (error) {
-				const { outputSize: failedOutputSize } = workerOptions;
-				if (failedOutputSize !== UNDEFINED_VALUE) {
-					writer.size += failedOutputSize;
-				} else if (isErrorObject(error) && error.outputSize !== UNDEFINED_VALUE) {
+				if (isErrorObject(error) && error.outputSize !== UNDEFINED_VALUE) {
 					writer.size += error.outputSize;
 				}
 				if (!checkPasswordOnly || !isErrorObject(error) || error.message != ERR_ABORT_CHECK_PASSWORD) {
@@ -5603,13 +5663,7 @@
 	};
 
 	function detectEncryptedCentralDirectory(directoryView) {
-		const maxOffset = Math.min(directoryView.byteLength, 1024) - 3;
-		for (let offset = 0; offset < maxOffset; offset++) {
-			if (getUint32$1(directoryView, offset) == ARCHIVE_EXTRA_DATA_SIGNATURE) {
-				return true;
-			}
-		}
-		return false;
+		return directoryView.byteLength >= 4 && getUint32$1(directoryView, 0) == ARCHIVE_EXTRA_DATA_SIGNATURE;
 	}
 
 	function getWrappedFilesLength(directoryView, directoryArray, offset) {
@@ -5622,6 +5676,70 @@
 		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;
+			}
+		}
+	}
+
+	async function findZip64EndOfDirectoryOffset(reader, endOffset) {
+		const startOffset = Math.max(0, endOffset - (ZIP64_END_OF_CENTRAL_DIR_LENGTH + MAX_16_BITS));
+		const tailArray = await readUint8Array(reader, startOffset, endOffset - startOffset);
+		const tailView = getDataView(tailArray);
+		for (let indexByte = tailArray.length - ZIP64_END_OF_CENTRAL_DIR_LENGTH; indexByte >= 0; indexByte--) {
+			if (getUint32$1(tailView, indexByte) == ZIP64_END_OF_CENTRAL_DIR_SIGNATURE &&
+				indexByte + 12 + Number(tailView.getBigUint64(indexByte + 4, true)) == tailArray.length) {
+				return startOffset + indexByte;
+			}
+		}
+	}
+
+	function getFirstLocalHeaderOffset(directoryArray, directoryView) {
+		if (directoryArray.length < CENTRAL_FILE_HEADER_LENGTH) {
+			return UNDEFINED_VALUE;
+		}
+		const localHeaderOffset = getUint32$1(directoryView, 42);
+		if (localHeaderOffset != MAX_32_BITS) {
+			return localHeaderOffset;
+		}
+		let offsetExtraField = CENTRAL_FILE_HEADER_LENGTH + getUint16$1(directoryView, 28);
+		const endExtraField = Math.min(offsetExtraField + getUint16$1(directoryView, 30), directoryArray.length);
+		while (offsetExtraField + 4 <= endExtraField) {
+			const type = getUint16$1(directoryView, offsetExtraField);
+			const size = getUint16$1(directoryView, offsetExtraField + 2);
+			if (type == EXTRAFIELD_TYPE_ZIP64) {
+				let offsetValue = offsetExtraField + 4;
+				if (getUint32$1(directoryView, 24) == MAX_32_BITS) {
+					offsetValue += 8;
+				}
+				if (getUint32$1(directoryView, 20) == MAX_32_BITS) {
+					offsetValue += 8;
+				}
+				return offsetValue + 8 <= endExtraField ? getBigUint64(directoryView, offsetValue) : UNDEFINED_VALUE;
+			}
+			offsetExtraField += 4 + size;
+		}
+		return UNDEFINED_VALUE;
+	}
+
 	function readDigitalSignature(signatureRecordArray) {
 		if (signatureRecordArray.length >= 6) {
 			const signatureRecordView = getDataView(signatureRecordArray);
@@ -5711,6 +5829,7 @@
 			uncompressedSize: getUint32$1(dataView, offset + HEADER_OFFSET_UNCOMPRESSED_SIZE)
 		});
 		const extraFieldZip64 = extraField.get(EXTRAFIELD_TYPE_ZIP64);
+		let extraFieldZip64Missing;
 		if (extraFieldZip64) {
 			if (!readExtraFieldZip64(extraFieldZip64, directory, localDirectory)) {
 				malformedExtraField = true;
@@ -5720,7 +5839,7 @@
 			if (localDirectory) {
 				malformedExtraField = true;
 			} else {
-				throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
+				extraFieldZip64Missing = true;
 			}
 		}
 		const extraFieldUnicodePath = extraField.get(EXTRAFIELD_TYPE_UNICODE_PATH);
@@ -5753,6 +5872,11 @@
 			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);
@@ -5769,15 +5893,13 @@
 			readExtraFieldUnix(extraFieldUnix, unixIdsRead ? {} : directory, false);
 			directory.extraFieldUnix = extraFieldUnix;
 		}
-		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;
 		}
+		if (extraFieldZip64Missing) {
+			throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
+		}
 		return malformedExtraField;
 	}
 
@@ -5992,13 +6114,7 @@
 		let dataDescriptorLength = 0;
 		if (dataDescriptor) {
 			const zip64 = Boolean(extraFieldZip64);
-			const dataDescriptorArray = await readUint8Array(reader, dataOffset + compressedSize, DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH);
-			const dataDescriptorView = getDataView(dataDescriptorArray);
-			const candidates = [[zip64, true], [zip64, false], [!zip64, true], [!zip64, false]]
-				.map(([zip64Layout, signature]) => readDataDescriptor(dataDescriptorView, zip64Layout, signature))
-				.filter(candidate => candidate && candidate.compressedSize == compressedSize && candidate.uncompressedSize == uncompressedSize);
-			const localDataDescriptor = candidates.find(candidate => candidate.crc32 == crc32) || candidates[0] ||
-				readDataDescriptor(dataDescriptorView, zip64, true) || readDataDescriptor(dataDescriptorView, zip64, false);
+			const localDataDescriptor = await readLocalDataDescriptor(reader, dataOffset + compressedSize, { crc32, compressedSize, uncompressedSize, zip64 });
 			if (localDataDescriptor) {
 				fileEntry.localDirectory.dataDescriptor = localDataDescriptor;
 				dataDescriptorLength = getDataDescriptorLength(localDataDescriptor.zip64, localDataDescriptor.signature);
@@ -6068,6 +6184,25 @@
 		return mergedRanges;
 	}
 
+	async function readLocalDataDescriptor(reader, offset, { crc32, compressedSize, uncompressedSize, zip64 }) {
+		const maxLength = DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH;
+		const length = Math.min(maxLength, Math.max(0, reader.size - offset));
+		const dataDescriptorArray = length ? await readUint8Array(reader, offset, length) : EMPTY_UINT8_ARRAY;
+		const dataDescriptorView = getDataView(dataDescriptorArray);
+		const candidates = [[zip64, true], [zip64, false], [!zip64, true], [!zip64, false]]
+			.map(([zip64Layout, signature]) => readDataDescriptor(dataDescriptorView, zip64Layout, signature))
+			.filter(candidate => candidate && candidate.compressedSize == compressedSize && candidate.uncompressedSize == uncompressedSize);
+		return candidates.find(candidate => candidate.crc32 == crc32) || candidates[0] ||
+			readDataDescriptor(dataDescriptorView, zip64, true) || readDataDescriptor(dataDescriptorView, zip64, false);
+	}
+
+	async function getEntryDataDescriptorLength(reader, offset, { crc32, compressedSize, uncompressedSize, extraFieldZip64 }) {
+		const dataDescriptor = await readLocalDataDescriptor(reader, offset, { crc32, compressedSize, uncompressedSize, zip64: Boolean(extraFieldZip64) });
+		if (dataDescriptor && dataDescriptor.compressedSize == compressedSize && dataDescriptor.uncompressedSize == uncompressedSize) {
+			return getDataDescriptorLength(dataDescriptor.zip64, dataDescriptor.signature);
+		}
+	}
+
 	function readDataDescriptor(dataDescriptorView, zip64, signature) {
 		const offset = signature ? DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH : 0;
 		if (dataDescriptorView.byteLength < getDataDescriptorLength(zip64, signature) ||
@@ -6327,6 +6462,18 @@
 		}
 	}
 
+	function validateDataDescriptor(zipEntry, localDirectory, warnings) {
+		const { dataDescriptor } = localDirectory;
+		const maskedLocalDirectory = zipEntry.decryptedDirectory &&
+			(localDirectory.rawBitFlag & BITFLAG_MASKED_LOCAL_HEADERS) == BITFLAG_MASKED_LOCAL_HEADERS;
+		if (dataDescriptor && !maskedLocalDirectory &&
+			((zipEntry.crc32 !== UNDEFINED_VALUE && dataDescriptor.crc32 != zipEntry.crc32) ||
+				dataDescriptor.compressedSize != zipEntry.compressedSize ||
+				dataDescriptor.uncompressedSize != zipEntry.uncompressedSize)) {
+			reportAmbiguity(!warnings, warnings, WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES);
+		}
+	}
+
 	function reportAmbiguity(reject, warnings, reason) {
 		if (reject) {
 			throwAmbiguousArchive(reason);
@@ -6412,11 +6559,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,
@@ -6427,6 +6576,7 @@
 		WARNING_WRAPPED_ENTRIES_COUNT: WARNING_WRAPPED_ENTRIES_COUNT,
 		ZipReader: ZipReader,
 		ZipReaderStream: ZipReaderStream,
+		getEntryDataDescriptorLength: getEntryDataDescriptorLength,
 		isZipFile: isZipFile
 	});
 
@@ -6549,130 +6699,8 @@
 			return watchPromiseError(this, prependZipEntries(this, reader));
 		}
 
-		appendZip(reader) {
-			return watchPromiseError(this, this.appendZipEntries(reader));
-		}
-
-		async appendZipEntries(reader) {
-			const zipWriter = this;
-			const { pendingAddFileCalls, filenames, fileEntries } = zipWriter;
-			while (pendingAddFileCalls.size) {
-				await Promise.allSettled(Array.from(pendingAddFileCalls));
-			}
-			let resolveAppendZip;
-			const promiseAppendZip = new Promise(resolve => resolveAppendZip = resolve);
-			pendingAddFileCalls.add(promiseAppendZip);
-			const appendedFilenames = [];
-			let releaseLockWriter;
-			try {
-				reader = new GenericReader(reader);
-				await initStream(reader);
-				if (reader.size === UNDEFINED_VALUE || !reader.readUint8Array) {
-					reader = new BlobReader(await streamToBlob(reader.readable));
-					await initStream(reader);
-				}
-				const { ZipReader } = await Promise.resolve().then(function () { return zipReader; });
-				const zipReader$1 = new ZipReader(reader);
-				const entries = await zipReader$1.getEntries();
-				await zipReader$1.close();
-				await initStream(zipWriter.writer);
-				const { directoryOffset } = zipReader$1;
-				entries.forEach(({ filename }) => {
-					if (filenames.has(filename)) {
-						throw new Error(ERR_DUPLICATED_NAME);
-					}
-					filenames.add(filename);
-					appendedFilenames.push(filename);
-				});
-				zipWriter.writerLocked = true;
-				const { lockWriter } = zipWriter;
-				zipWriter.lockWriter = new Promise(resolve => releaseLockWriter = () => {
-					zipWriter.writerLocked = false;
-					resolve();
-				});
-				await lockWriter;
-				if (zipWriter.addSplitZipSignature) {
-					delete zipWriter.addSplitZipSignature;
-					if (!await startsWithSplitZipSignature(reader)) {
-						await writeData(zipWriter.writer, getSplitZipSignatureArray());
-						zipWriter.offset += SPLIT_ZIP_FILE_SIGNATURE_LENGTH;
-					}
-				}
-				const entryPositions = await copyZipData(zipWriter, reader, entries, directoryOffset);
-				entries.forEach(entry => {
-					const {
-						version,
-						rawLastModDate,
-						rawFilename,
-						bitFlag,
-						encrypted,
-						uncompressedSize,
-						compressedSize,
-						extraFieldZip64
-					} = entry;
-					let {
-						compressionMethod,
-						rawExtraField,
-					} = entry;
-					const { level, languageEncodingFlag, dataDescriptor } = bitFlag;
-					rawExtraField = removeExtraFieldZip64(rawExtraField || EMPTY_UINT8_ARRAY);
-					if (entry.extraFieldAES) {
-						compressionMethod = COMPRESSION_METHOD_AES;
-					}
-					const extraFieldLength = getLength(rawExtraField);
-					const zip64UncompressedSize = Boolean(extraFieldZip64) && extraFieldZip64.uncompressedSize !== UNDEFINED_VALUE;
-					const zip64CompressedSize = Boolean(extraFieldZip64) && extraFieldZip64.compressedSize !== UNDEFINED_VALUE;
-					const bitFlagValue = (getBitFlag(level, languageEncodingFlag, dataDescriptor, encrypted, compressionMethod) & ~BITFLAG_LEVEL) | (level << 1);
-					const {
-						headerArray,
-						headerView
-					} = getHeaderArrayData({
-						version,
-						bitFlag: bitFlagValue,
-						compressionMethod,
-						uncompressedSize,
-						compressedSize,
-						rawLastModDate,
-						rawFilename,
-						zip64CompressedSize,
-						zip64UncompressedSize,
-						extraFieldLength
-					});
-					const { crc32 } = entry;
-					if (crc32 !== UNDEFINED_VALUE) {
-						setUint32(headerView, HEADER_OFFSET_SIGNATURE, crc32);
-					}
-					const { offset, diskNumberStart } = entryPositions.get(entry);
-					Object.assign(entry, {
-						zip64Enabled: true,
-						zip64UncompressedSize,
-						zip64CompressedSize,
-						offset,
-						diskNumberStart,
-						zip64DiskNumberStart: false,
-						rawExtraFieldZip64: EMPTY_UINT8_ARRAY,
-						rawExtraFieldAES: EMPTY_UINT8_ARRAY,
-						rawExtraFieldExtendedTimestamp: EMPTY_UINT8_ARRAY,
-						rawExtraFieldNTFS: EMPTY_UINT8_ARRAY,
-						rawExtraFieldUnix: EMPTY_UINT8_ARRAY,
-						rawCentralExtraFieldUnix: EMPTY_UINT8_ARRAY,
-						rawExtraField,
-						rawCentralExtraField: EMPTY_UINT8_ARRAY,
-						headerArray,
-						headerView
-					});
-					fileEntries.set(entry.filename, entry);
-				});
-			} catch (error) {
-				appendedFilenames.forEach(filename => filenames.delete(filename));
-				throw error;
-			} finally {
-				resolveAppendZip();
-				pendingAddFileCalls.delete(promiseAppendZip);
-				if (releaseLockWriter) {
-					releaseLockWriter();
-				}
-			}
+		appendZip(reader, options = {}) {
+			return watchPromiseError(this, appendZipEntries(this, reader, options));
 		}
 
 		add(name = "", reader, options = {}) {
@@ -6834,11 +6862,140 @@
 		return watchedPromise;
 	}
 
+	async function appendZipEntries(zipWriter, reader, options = {}) {
+		const { pendingAddFileCalls, filenames, fileEntries } = zipWriter;
+		const filter = checkFunctionOption(options.filter);
+		while (pendingAddFileCalls.size) {
+			await Promise.allSettled(Array.from(pendingAddFileCalls));
+		}
+		let resolveAppendZip;
+		const promiseAppendZip = new Promise(resolve => resolveAppendZip = resolve);
+		pendingAddFileCalls.add(promiseAppendZip);
+		const appendedFilenames = [];
+		let releaseLockWriter;
+		try {
+			reader = new GenericReader(reader);
+			await initStream(reader);
+			if (reader.size === UNDEFINED_VALUE || !reader.readUint8Array) {
+				reader = new BlobReader(await streamToBlob(reader.readable));
+				await initStream(reader);
+			}
+			const { ZipReader, getEntryDataDescriptorLength } = 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, entriesMissingZip64ExtraField } = zipReader$1;
+			keptEntries.forEach(entry => {
+				const { filename } = entry;
+				if (entriesMissingZip64ExtraField.has(entry)) {
+					throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
+				}
+				if (filenames.has(filename)) {
+					throw new Error(ERR_DUPLICATED_NAME);
+				}
+				filenames.add(filename);
+				appendedFilenames.push(filename);
+			});
+			zipWriter.writerLocked = true;
+			const { lockWriter } = zipWriter;
+			zipWriter.lockWriter = new Promise(resolve => releaseLockWriter = () => {
+				zipWriter.writerLocked = false;
+				resolve();
+			});
+			await lockWriter;
+			if (zipWriter.addSplitZipSignature) {
+				delete zipWriter.addSplitZipSignature;
+				if (filter || !await startsWithSplitZipSignature(reader)) {
+					await writeData(zipWriter.writer, getSplitZipSignatureArray());
+					zipWriter.offset += SPLIT_ZIP_FILE_SIGNATURE_LENGTH;
+				}
+			}
+			const entryPositions = await copyZipData(zipWriter, reader, entries, keptEntries, directoryOffset, Boolean(filter), getEntryDataDescriptorLength);
+			keptEntries.forEach(entry => {
+				const {
+					version,
+					rawLastModDate,
+					rawFilename,
+					rawBitFlag,
+					uncompressedSize,
+					compressedSize,
+					extraFieldZip64
+				} = entry;
+				let {
+					compressionMethod,
+					rawExtraField,
+				} = entry;
+				rawExtraField = removeExtraFieldZip64(rawExtraField || EMPTY_UINT8_ARRAY);
+				if (entry.extraFieldAES) {
+					compressionMethod = COMPRESSION_METHOD_AES;
+				}
+				const extraFieldLength = getLength(rawExtraField);
+				const zip64UncompressedSize = Boolean(extraFieldZip64) && extraFieldZip64.uncompressedSize !== UNDEFINED_VALUE;
+				const zip64CompressedSize = Boolean(extraFieldZip64) && extraFieldZip64.compressedSize !== UNDEFINED_VALUE;
+				const {
+					headerArray,
+					headerView
+				} = getHeaderArrayData({
+					version,
+					bitFlag: rawBitFlag,
+					compressionMethod,
+					uncompressedSize,
+					compressedSize,
+					rawLastModDate,
+					rawFilename,
+					zip64CompressedSize,
+					zip64UncompressedSize,
+					extraFieldLength
+				});
+				const { crc32 } = entry;
+				if (crc32 !== UNDEFINED_VALUE) {
+					setUint32(headerView, HEADER_OFFSET_SIGNATURE, crc32);
+				}
+				const { offset, diskNumberStart } = entryPositions.get(entry);
+				Object.assign(entry, {
+					zip64Enabled: true,
+					zip64UncompressedSize,
+					zip64CompressedSize,
+					offset,
+					diskNumberStart,
+					zip64DiskNumberStart: false,
+					rawExtraFieldZip64: EMPTY_UINT8_ARRAY,
+					rawExtraFieldAES: EMPTY_UINT8_ARRAY,
+					rawExtraFieldExtendedTimestamp: EMPTY_UINT8_ARRAY,
+					rawExtraFieldNTFS: EMPTY_UINT8_ARRAY,
+					rawExtraFieldUnix: EMPTY_UINT8_ARRAY,
+					rawCentralExtraFieldUnix: EMPTY_UINT8_ARRAY,
+					rawExtraField,
+					rawCentralExtraField: EMPTY_UINT8_ARRAY,
+					headerArray,
+					headerView
+				});
+				fileEntries.set(entry.filename, entry);
+			});
+		} catch (error) {
+			appendedFilenames.forEach(filename => filenames.delete(filename));
+			throw error;
+		} finally {
+			resolveAppendZip();
+			pendingAddFileCalls.delete(promiseAppendZip);
+			if (releaseLockWriter) {
+				releaseLockWriter();
+			}
+		}
+	}
+
 	async function prependZipEntries(zipWriter, reader) {
 		if (zipWriter.filenames.size) {
 			throw new Error(ERR_ZIP_NOT_EMPTY);
 		}
-		await zipWriter.appendZipEntries(reader);
+		await appendZipEntries(zipWriter, reader);
 	}
 
 	async function addFileEntry(zipWriter, name, reader, options) {
@@ -8610,26 +8767,63 @@
 		return rawExtraField;
 	}
 
-	async function copyZipData(zipWriter, reader, entries, directoryOffset) {
+	async function copyZipData(zipWriter, reader, entries, keptEntries, directoryOffset, compact, getEntryDataDescriptorLength) {
 		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);
+			const localHeaderLengths = new Map();
+			for (let indexEntry = 0; indexEntry < sortedEntries.length; indexEntry++) {
+				const entry = sortedEntries[indexEntry];
+				if (keptEntrySet.has(entry)) {
+					const sourceOffset = getSourceOffset(reader, entry);
+					const localHeaderLength = await getLocalHeaderLength(reader, sourceOffset);
+					if (localHeaderLength === UNDEFINED_VALUE) {
+						throw new Error(ERR_LOCAL_FILE_HEADER_NOT_FOUND);
+					}
+					let entryEnd = sourceOffset + localHeaderLength + entry.compressedSize;
+					if (entry.bitFlag.dataDescriptor) {
+						const dataDescriptorLength = await getEntryDataDescriptorLength(reader, entryEnd, entry);
+						entryEnd = dataDescriptorLength === UNDEFINED_VALUE ? Math.max(entryEnd, regionEnds[indexEntry]) : entryEnd + dataDescriptorLength;
+					}
+					if (entryEnd > regionEnds[indexEntry]) {
+						throw new Error(ERR_OVERLAPPING_ENTRY);
+					}
+					regionEnds[indexEntry] = entryEnd;
+					localHeaderLengths.set(entry, localHeaderLength);
+				}
+			}
+			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, localHeaderLengths.get(entry))) {
+							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);
@@ -8641,6 +8835,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 = Math.min(getSourceOffset(reader, nextEntry), directoryOffset);
+			}
+			regionEnds[indexEntry] = regionEnd;
+		}
+		return regionEnds;
+	}
+
 	async function copyData(zipWriter, reader, offset, size) {
 		if (size > 0) {
 			const { writer } = zipWriter;
@@ -8648,11 +8856,13 @@
 			try {
 				await flushBufferedData(createReadable(reader, { offset, size }), writer, UNDEFINED_VALUE, chunkLength => copiedLength += chunkLength);
 			} catch (error) {
-				zipWriter.hasCorruptedEntries = true;
-				try {
-					error.corruptedEntry = true;
-				} catch {
-					// ignored
+				if (copiedLength) {
+					zipWriter.hasCorruptedEntries = true;
+					try {
+						error.corruptedEntry = true;
+					} catch {
+						// ignored
+					}
 				}
 				throw error;
 			} finally {
@@ -8663,11 +8873,16 @@
 	}
 
 	async function getLocalHeaderLength(reader, offset) {
-		const headerArray = await readUint8Array(reader, offset, HEADER_SIZE);
+		const headerArray = offset >= 0 && offset + HEADER_SIZE <= reader.size ?
+			await readUint8Array(reader, offset, HEADER_SIZE) :
+			EMPTY_UINT8_ARRAY;
 		if (getLength(headerArray) < HEADER_SIZE) {
-			return HEADER_SIZE;
+			return UNDEFINED_VALUE;
 		}
 		const headerView = getDataView(headerArray);
+		if (getUint32(headerView, 0) != LOCAL_FILE_HEADER_SIGNATURE) {
+			return UNDEFINED_VALUE;
+		}
 		return HEADER_SIZE +
 			getUint16(headerView, HEADER_OFFSET_FILENAME_LENGTH + LOCAL_HEADER_COMMON_OFFSET) +
 			getUint16(headerView, HEADER_OFFSET_EXTRAFIELD_LENGTH + LOCAL_HEADER_COMMON_OFFSET);
@@ -9018,7 +9233,7 @@
 	 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 	 */
 
-	const VERSION = "2.19.0";
+	const VERSION = "2.21.0";
 
 	/*
 	 Copyright (c) 2025 Gildas Lormeau. All rights reserved.
@@ -11079,11 +11294,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;