@zip.js/zip.js 2.20.0 → 2.22.0

package/index.cjs

@@ -120,6 +120,10 @@ const MIN_DATE = new Date(1980, 0, 1);
 
 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";
@@ -215,6 +219,7 @@ 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_INVALID_READER_OPTIONS = "Invalid readerOptions (must be an object)";
 const ERR_ABORTED = "The operation was aborted";
 const ABORT_ERROR_NAME$1 = "AbortError";
 
@@ -225,6 +230,13 @@ function checkFunctionOption(value) {
 	return value;
 }
 
+function checkReaderOptionsObject(readerOptions) {
+	if (readerOptions && (typeof readerOptions != OBJECT_TYPE || Array.isArray(readerOptions))) {
+		throw new Error(ERR_INVALID_READER_OPTIONS);
+	}
+	return readerOptions;
+}
+
 function checkSignalOption(signal) {
 	if (signal && (typeof signal.addEventListener != FUNCTION_TYPE || typeof signal.aborted != BOOLEAN_TYPE)) {
 		throw new Error(ERR_INVALID_SIGNAL);
@@ -320,7 +332,6 @@ const DEFAULT_CONFIGURATION = {
 	workerStartupTimeout: 5000,
 	useWebWorkers: true,
 	useCompressionStream: true,
-	transferStreams: true,
 	CompressionStream: typeof CompressionStream != UNDEFINED_TYPE && CompressionStream,
 	DecompressionStream: typeof DecompressionStream != UNDEFINED_TYPE && DecompressionStream
 };
@@ -334,8 +345,7 @@ const URI_PROPERTY_NAMES = [
 ];
 const BOOLEAN_PROPERTY_NAMES = [
 	"useCompressionStream",
-	"useWebWorkers",
-	"transferStreams"
+	"useWebWorkers"
 ];
 const NUMBER_PROPERTY_NAMES = [
 	"chunkSize",
@@ -4779,12 +4789,9 @@ const ERR_BAD_FORMAT = "File format is not recognized";
 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";
@@ -4848,8 +4855,9 @@ class ZipReader {
 	constructor(reader, options = {}) {
 		Object.assign(this, {
 			reader: new GenericReader(reader),
-			options,
-			readRanges: { indexes: new Set(), sortedRanges: [], pendingRanges: [] }
+			options: options || {},
+			readRanges: { indexes: new Set(), sortedRanges: [], pendingRanges: [] },
+			entriesMissingZip64ExtraField: new WeakSet()
 		});
 	}
 
@@ -4920,16 +4928,22 @@ class ZipReader {
 				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);
@@ -4974,10 +4988,6 @@ class ZipReader {
 		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);
 		}
@@ -4985,52 +4995,64 @@ class ZipReader {
 			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);
-			}
 			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 (expectedDirectoryDataOffset >= 0 && expectedDirectoryDataOffset + 4 <= reader.size) {
-					const expectedPointsAtDirectory = await pointsAtDirectory(reader, expectedDirectoryDataOffset);
-					if (storedPointsAtDirectory) {
-						reconcile = expectedPointsAtDirectory;
-					} else if (!expectedPointsAtDirectory) {
+					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;
 					directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
 					directoryView = getDataView(directoryArray);
-					if (directoryDataOffset > originalDirectoryDataOffset) {
-						prependedDataLength += directoryDataOffset - originalDirectoryDataOffset;
+					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);
-						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;
-							}
+						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) {
@@ -5072,8 +5094,10 @@ class ZipReader {
 				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);
@@ -5164,13 +5188,17 @@ class ZipReader {
 			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);
 			}
@@ -5207,12 +5235,15 @@ class ZipReader {
 				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;
 			};
@@ -5420,8 +5451,9 @@ let ZipEntry$1 = class ZipEntry {
 		});
 	}
 
-	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);
 		}
@@ -5495,10 +5527,10 @@ let ZipEntry$1 = class ZipEntry {
 		}
 		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) {
@@ -5527,7 +5559,7 @@ let ZipEntry$1 = class ZipEntry {
 				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;
@@ -5593,6 +5625,7 @@ let ZipEntry$1 = class ZipEntry {
 				extraFieldZip64: extraFieldZip64 || localDirectory.extraFieldZip64,
 				readRanges
 			});
+			validateDataDescriptor(zipEntry, localDirectory, checkLocalDirectory ? UNDEFINED_VALUE : warnings);
 		}
 		let writable, abortError, aborted;
 		try {
@@ -5612,10 +5645,7 @@ let ZipEntry$1 = class ZipEntry {
 				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) {
@@ -5643,13 +5673,7 @@ let ZipEntry$1 = class ZipEntry {
 };
 
 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) {
@@ -5686,6 +5710,46 @@ async function findDigitalSignatureRecordOffset(reader, endOffset) {
 	}
 }
 
+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);
@@ -5775,6 +5839,7 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 		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;
@@ -5784,7 +5849,7 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 		if (localDirectory) {
 			malformedExtraField = true;
 		} else {
-			throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
+			extraFieldZip64Missing = true;
 		}
 	}
 	const extraFieldUnicodePath = extraField.get(EXTRAFIELD_TYPE_UNICODE_PATH);
@@ -5842,6 +5907,9 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 	if (extraFieldUSDZ) {
 		directory.extraFieldUSDZ = extraFieldUSDZ;
 	}
+	if (extraFieldZip64Missing) {
+		throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
+	}
 	return malformedExtraField;
 }
 
@@ -6056,13 +6124,7 @@ async function detectOverlappingEntry({
 	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);
@@ -6132,6 +6194,25 @@ function mergeRanges(sortedRanges, pendingRanges) {
 	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) ||
@@ -6391,6 +6472,18 @@ function validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, chec
 	}
 }
 
+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);
@@ -6493,6 +6586,7 @@ var zipReader = /*#__PURE__*/Object.freeze({
 	WARNING_WRAPPED_ENTRIES_COUNT: WARNING_WRAPPED_ENTRIES_COUNT,
 	ZipReader: ZipReader,
 	ZipReaderStream: ZipReaderStream,
+	getEntryDataDescriptorLength: getEntryDataDescriptorLength,
 	isZipFile: isZipFile
 });
 
@@ -6616,136 +6710,7 @@ class ZipWriter {
 	}
 
 	appendZip(reader, options = {}) {
-		return watchPromiseError(this, this.appendZipEntries(reader, options));
-	}
-
-	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));
-		}
-		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();
-			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;
-			keptEntries.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, keptEntries, directoryOffset, Boolean(filter));
-			keptEntries.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();
-			}
-		}
+		return watchPromiseError(this, appendZipEntries(this, reader, options));
 	}
 
 	add(name = "", reader, options = {}) {
@@ -6907,11 +6872,149 @@ function watchPromiseError(zipWriter, promise) {
 	return watchedPromise;
 }
 
+async function appendZipEntries(zipWriter, reader, options = {}) {
+	const { pendingAddFileCalls, filenames, fileEntries } = zipWriter;
+	const filter = checkFunctionOption(options.filter);
+	const readerOptions = checkReaderOptionsObject(options.readerOptions);
+	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, readerOptions);
+		const keptEntries = [];
+		let entries;
+		try {
+			entries = await zipReader$1.getEntries();
+			for (const entry of entries) {
+				if (!filter || await filter(entry, getExistingEntry(fileEntries, entry.filename))) {
+					keptEntries.push(entry);
+				}
+			}
+		} finally {
+			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);
+			fileEntries.set(entry.filename, 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
+			}));
+		});
+	} catch (error) {
+		appendedFilenames.forEach(filename => filenames.delete(filename));
+		throw error;
+	} finally {
+		resolveAppendZip();
+		pendingAddFileCalls.delete(promiseAppendZip);
+		if (releaseLockWriter) {
+			releaseLockWriter();
+		}
+	}
+}
+
+function getExistingEntry(fileEntries, filename) {
+	const fileEntry = fileEntries.get(filename);
+	return fileEntry ? new Entry(fileEntry) : UNDEFINED_VALUE;
+}
+
 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) {
@@ -8683,7 +8786,7 @@ function removeExtraFieldZip64(rawExtraField) {
 	return rawExtraField;
 }
 
-async function copyZipData(zipWriter, reader, entries, keptEntries, directoryOffset, compact) {
+async function copyZipData(zipWriter, reader, entries, keptEntries, directoryOffset, compact, getEntryDataDescriptorLength) {
 	const { writer } = zipWriter;
 	const entryPositions = new Map();
 	if (writer.closeDisk || compact) {
@@ -8691,6 +8794,27 @@ async function copyZipData(zipWriter, reader, entries, keptEntries, directoryOff
 			getSourceOffset(reader, firstEntry) - getSourceOffset(reader, secondEntry));
 		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++) {
@@ -8703,7 +8827,7 @@ async function copyZipData(zipWriter, reader, entries, keptEntries, directoryOff
 					if (!compact) {
 						await copyData(zipWriter, reader, copiedOffset, sourceOffset - copiedOffset);
 					}
-					if (writer.closeDisk && exceedsAvailableSize(writer, await getLocalHeaderLength(reader, sourceOffset))) {
+					if (writer.closeDisk && exceedsAvailableSize(writer, localHeaderLengths.get(entry))) {
 						await writer.closeDisk();
 					}
 					lastPosition = {
@@ -8737,7 +8861,7 @@ function getRegionEnds(reader, sortedEntries, directoryOffset) {
 		const sourceOffset = getSourceOffset(reader, sortedEntries[indexEntry]);
 		const nextEntry = sortedEntries[indexEntry + 1];
 		if (nextEntry && getSourceOffset(reader, nextEntry) > sourceOffset) {
-			regionEnd = getSourceOffset(reader, nextEntry);
+			regionEnd = Math.min(getSourceOffset(reader, nextEntry), directoryOffset);
 		}
 		regionEnds[indexEntry] = regionEnd;
 	}
@@ -8751,11 +8875,13 @@ async function copyData(zipWriter, reader, offset, size) {
 		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 {
@@ -8766,11 +8892,16 @@ async function copyData(zipWriter, reader, offset, size) {
 }
 
 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);
@@ -9121,7 +9252,7 @@ function formatSupported(StreamClass, format) {
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const VERSION = "2.20.0";
+const VERSION = "2.22.0";
 
 /*
  Copyright (c) 2025 Gildas Lormeau. All rights reserved.
@@ -10196,7 +10327,6 @@ const DUPLICATES_KEEP_FIRST = "keep-first";
 const DUPLICATES_KEEP_LAST = "keep-last";
 const DUPLICATES_VALUES = new Set([DUPLICATES_THROW, DUPLICATES_KEEP_FIRST, DUPLICATES_KEEP_LAST]);
 const ERR_INVALID_PASS_THROUGH = "Invalid passThrough option (use readerOptions.passThrough or set uncompressedSize for each entry)";
-const ERR_INVALID_READER_OPTIONS = "Invalid readerOptions (must be an object)";
 const ERR_UNSUPPORTED_PASS_THROUGH_VALUE = "The 'compressed' passThrough option is only supported by Entry#getData() and ZipWriter#add()";
 const ERR_INVALID_PASSWORDS = "Invalid passwords option (must be an array of strings)";
 const ERR_INVALID_REQUEST_PASSWORD = "Invalid requestPassword option (must be a function returning a string or undefined)";
@@ -11122,9 +11252,7 @@ function getDeterminedSize(child, passThrough) {
 }
 
 function checkReaderOptions(readerOptions) {
-	if (readerOptions && (typeof readerOptions != OBJECT_TYPE || Array.isArray(readerOptions))) {
-		throw new Error(ERR_INVALID_READER_OPTIONS);
-	}
+	checkReaderOptionsObject(readerOptions);
 	if (readerOptions) {
 		checkPassThroughValue(readerOptions.passThrough);
 		checkPasswordCandidatesOptions(readerOptions);