@zip.js/zip.js 2.20.0 → 2.22.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";
@@ -221,6 +225,7 @@
 	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";
 
@@ -231,6 +236,13 @@
 		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);
@@ -326,7 +338,6 @@
 		workerStartupTimeout: 5000,
 		useWebWorkers: true,
 		useCompressionStream: true,
-		transferStreams: true,
 		CompressionStream: typeof CompressionStream != UNDEFINED_TYPE && CompressionStream,
 		DecompressionStream: typeof DecompressionStream != UNDEFINED_TYPE && DecompressionStream
 	};
@@ -340,8 +351,7 @@
 	];
 	const BOOLEAN_PROPERTY_NAMES = [
 		"useCompressionStream",
-		"useWebWorkers",
-		"transferStreams"
+		"useWebWorkers"
 	];
 	const NUMBER_PROPERTY_NAMES = [
 		"chunkSize",
@@ -4775,12 +4785,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";
@@ -4844,8 +4851,9 @@
 		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()
 			});
 		}
 
@@ -4916,16 +4924,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);
@@ -4970,10 +4984,6 @@
 			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);
 			}
@@ -4981,52 +4991,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);
-				}
 				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) {
@@ -5068,8 +5090,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);
@@ -5160,13 +5184,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);
 				}
@@ -5203,12 +5231,15 @@
 					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;
 				};
@@ -5416,8 +5447,9 @@
 			});
 		}
 
-		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);
 			}
@@ -5491,10 +5523,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) {
@@ -5523,7 +5555,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;
@@ -5589,6 +5621,7 @@
 					extraFieldZip64: extraFieldZip64 || localDirectory.extraFieldZip64,
 					readRanges
 				});
+				validateDataDescriptor(zipEntry, localDirectory, checkLocalDirectory ? UNDEFINED_VALUE : warnings);
 			}
 			let writable, abortError, aborted;
 			try {
@@ -5608,10 +5641,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) {
@@ -5639,13 +5669,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) {
@@ -5682,6 +5706,46 @@
 		}
 	}
 
+	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);
@@ -5771,6 +5835,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;
@@ -5780,7 +5845,7 @@
 			if (localDirectory) {
 				malformedExtraField = true;
 			} else {
-				throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
+				extraFieldZip64Missing = true;
 			}
 		}
 		const extraFieldUnicodePath = extraField.get(EXTRAFIELD_TYPE_UNICODE_PATH);
@@ -5838,6 +5903,9 @@
 		if (extraFieldUSDZ) {
 			directory.extraFieldUSDZ = extraFieldUSDZ;
 		}
+		if (extraFieldZip64Missing) {
+			throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
+		}
 		return malformedExtraField;
 	}
 
@@ -6052,13 +6120,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);
@@ -6128,6 +6190,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) ||
@@ -6387,6 +6468,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);
@@ -6489,6 +6582,7 @@
 		WARNING_WRAPPED_ENTRIES_COUNT: WARNING_WRAPPED_ENTRIES_COUNT,
 		ZipReader: ZipReader,
 		ZipReaderStream: ZipReaderStream,
+		getEntryDataDescriptorLength: getEntryDataDescriptorLength,
 		isZipFile: isZipFile
 	});
 
@@ -6612,136 +6706,7 @@
 		}
 
 		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 = {}) {
@@ -6903,11 +6868,149 @@
 		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) {
@@ -8679,7 +8782,7 @@
 		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) {
@@ -8687,6 +8790,27 @@
 				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++) {
@@ -8699,7 +8823,7 @@
 						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 = {
@@ -8733,7 +8857,7 @@
 			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;
 		}
@@ -8747,11 +8871,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 {
@@ -8762,11 +8888,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);
@@ -9117,7 +9248,7 @@
 	 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.
@@ -9608,7 +9739,6 @@
 	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)";
@@ -10534,9 +10664,7 @@
 	}
 
 	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);