@zip.js/zip.js 2.19.0 → 2.20.0

package/index.cjs

@@ -4803,6 +4803,8 @@ const WARNING_APPENDED_DATA = "appended data";
 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";
@@ -4965,6 +4967,8 @@ class ZipReader {
 					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;
@@ -4987,25 +4991,44 @@ class ZipReader {
 			if (directoryArray.length < 4) {
 				throw new Error(ERR_BAD_FORMAT);
 			}
-			const expectedDirectoryDataOffset = centralDirectoryEndOffset - directoryDataLength;
+			let expectedDirectoryDataOffset = centralDirectoryEndOffset - directoryDataLength;
 			if (directoryDataOffset != expectedDirectoryDataOffset && diskNumber == lastDiskNumber) {
 				const storedPointsAtDirectory = getUint32$1(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE ||
 					Boolean(directoryEncryptionInfo && directoryEncryptionInfo.compressedSize) ||
 					detectEncryptedCentralDirectory(directoryView);
 				let reconcile = !storedPointsAtDirectory;
-				if (!reconcile && expectedDirectoryDataOffset >= 0 && expectedDirectoryDataOffset + 4 <= reader.size) {
-					const expectedSignatureArray = await readUint8Array(reader, expectedDirectoryDataOffset, 4);
-					reconcile = getUint32$1(getDataView(expectedSignatureArray), 0) == CENTRAL_FILE_HEADER_SIGNATURE;
+				if (expectedDirectoryDataOffset >= 0 && expectedDirectoryDataOffset + 4 <= reader.size) {
+					const expectedPointsAtDirectory = await pointsAtDirectory(reader, expectedDirectoryDataOffset);
+					if (storedPointsAtDirectory) {
+						reconcile = expectedPointsAtDirectory;
+					} else if (!expectedPointsAtDirectory) {
+						const signatureRecordOffset = await findDigitalSignatureRecordOffset(reader, centralDirectoryEndOffset);
+						const signedDirectoryDataOffset = signatureRecordOffset - directoryDataLength;
+						if (signatureRecordOffset !== UNDEFINED_VALUE && signedDirectoryDataOffset >= 0 &&
+							await pointsAtDirectory(reader, signedDirectoryDataOffset)) {
+							expectedDirectoryDataOffset = signedDirectoryDataOffset;
+						}
+					}
 				}
 				if (reconcile) {
 					const originalDirectoryDataOffset = directoryDataOffset;
 					directoryDataOffset = expectedDirectoryDataOffset;
+					directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
+					directoryView = getDataView(directoryArray);
 					if (directoryDataOffset > originalDirectoryDataOffset) {
 						prependedDataLength += directoryDataOffset - originalDirectoryDataOffset;
 						prependedCentralDirectory = storedPointsAtDirectory;
+					} else {
+						reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_CENTRAL_DIRECTORY_OFFSET);
+						const offsetDelta = directoryDataOffset - originalDirectoryDataOffset;
+						if (directoryArray.length >= CENTRAL_FILE_HEADER_LENGTH) {
+							const localHeaderOffset = getUint32$1(directoryView, 42);
+							if (!await startsWithSignature(reader, localHeaderOffset, LOCAL_FILE_HEADER_SIGNATURE) &&
+								await startsWithSignature(reader, localHeaderOffset + offsetDelta, LOCAL_FILE_HEADER_SIGNATURE)) {
+								prependedDataLength += offsetDelta;
+							}
+						}
 					}
-					directoryArray = await readUint8Array(reader, directoryDataOffset, directoryDataLength);
-					directoryView = getDataView(directoryArray);
 				}
 			}
 		}
@@ -5116,7 +5139,16 @@ class ZipReader {
 				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);
@@ -5158,11 +5190,12 @@ class ZipReader {
 			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,
@@ -5170,7 +5203,7 @@ class ZipReader {
 				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);
@@ -5226,10 +5259,10 @@ class ZipReader {
 		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) {
@@ -5389,6 +5422,9 @@ let ZipEntry$1 = class ZipEntry {
 
 	async getData(writer, fileEntry, readRanges, options = {}) {
 		const zipEntry = this;
+		if (zipEntry.zip64ExtraFieldMissing) {
+			throw new Error(ERR_EXTRAFIELD_ZIP64_NOT_FOUND);
+		}
 		const config = getConfiguration();
 		const {
 			reader,
@@ -5626,6 +5662,30 @@ function getWrappedFilesLength(directoryView, directoryArray, offset) {
 	return wrappedFilesLength % (MAX_16_BITS + 1) ? 0 : wrappedFilesLength;
 }
 
+function pointsAtDirectory(reader, offset) {
+	return startsWithSignature(reader, offset, CENTRAL_FILE_HEADER_SIGNATURE);
+}
+
+async function startsWithSignature(reader, offset, signature) {
+	if (offset < 0 || offset + 4 > reader.size) {
+		return false;
+	}
+	const signatureArray = await readUint8Array(reader, offset, 4);
+	return getUint32$1(getDataView(signatureArray), 0) == signature;
+}
+
+async function findDigitalSignatureRecordOffset(reader, endOffset) {
+	const startOffset = Math.max(0, endOffset - (6 + MAX_16_BITS));
+	const tailArray = await readUint8Array(reader, startOffset, endOffset - startOffset);
+	const tailView = getDataView(tailArray);
+	for (let indexByte = tailArray.length - 6; indexByte >= 0; indexByte--) {
+		if (getUint32$1(tailView, indexByte) == DIGITAL_SIGNATURE_RECORD_SIGNATURE &&
+			indexByte + 6 + getUint16$1(tailView, indexByte + 4) == tailArray.length) {
+			return startOffset + indexByte;
+		}
+	}
+}
+
 function readDigitalSignature(signatureRecordArray) {
 	if (signatureRecordArray.length >= 6) {
 		const signatureRecordView = getDataView(signatureRecordArray);
@@ -5757,6 +5817,11 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 		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);
@@ -5773,11 +5838,6 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 		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;
@@ -6416,11 +6476,13 @@ var zipReader = /*#__PURE__*/Object.freeze({
 	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,
@@ -6553,13 +6615,14 @@ class ZipWriter {
 		return watchPromiseError(this, prependZipEntries(this, reader));
 	}
 
-	appendZip(reader) {
-		return watchPromiseError(this, this.appendZipEntries(reader));
+	appendZip(reader, options = {}) {
+		return watchPromiseError(this, this.appendZipEntries(reader, options));
 	}
 
-	async appendZipEntries(reader) {
+	async appendZipEntries(reader, options = {}) {
 		const zipWriter = this;
 		const { pendingAddFileCalls, filenames, fileEntries } = zipWriter;
+		const filter = checkFunctionOption(options.filter);
 		while (pendingAddFileCalls.size) {
 			await Promise.allSettled(Array.from(pendingAddFileCalls));
 		}
@@ -6578,10 +6641,16 @@ class ZipWriter {
 			const { ZipReader } = await Promise.resolve().then(function () { return zipReader; });
 			const zipReader$1 = new ZipReader(reader);
 			const entries = await zipReader$1.getEntries();
+			const keptEntries = [];
+			for (const entry of entries) {
+				if (!filter || await filter(entry)) {
+					keptEntries.push(entry);
+				}
+			}
 			await zipReader$1.close();
 			await initStream(zipWriter.writer);
 			const { directoryOffset } = zipReader$1;
-			entries.forEach(({ filename }) => {
+			keptEntries.forEach(({ filename }) => {
 				if (filenames.has(filename)) {
 					throw new Error(ERR_DUPLICATED_NAME);
 				}
@@ -6602,8 +6671,8 @@ class ZipWriter {
 					zipWriter.offset += SPLIT_ZIP_FILE_SIGNATURE_LENGTH;
 				}
 			}
-			const entryPositions = await copyZipData(zipWriter, reader, entries, directoryOffset);
-			entries.forEach(entry => {
+			const entryPositions = await copyZipData(zipWriter, reader, entries, keptEntries, directoryOffset, Boolean(filter));
+			keptEntries.forEach(entry => {
 				const {
 					version,
 					rawLastModDate,
@@ -8614,26 +8683,42 @@ function removeExtraFieldZip64(rawExtraField) {
 	return rawExtraField;
 }
 
-async function copyZipData(zipWriter, reader, entries, directoryOffset) {
+async function copyZipData(zipWriter, reader, entries, keptEntries, directoryOffset, compact) {
 	const { writer } = zipWriter;
 	const entryPositions = new Map();
-	if (writer.closeDisk) {
+	if (writer.closeDisk || compact) {
 		const sortedEntries = Array.from(entries).sort((firstEntry, secondEntry) =>
 			getSourceOffset(reader, firstEntry) - getSourceOffset(reader, secondEntry));
-		let copiedLength = 0;
-		for (const entry of sortedEntries) {
-			const sourceOffset = getSourceOffset(reader, entry);
-			await copyData(zipWriter, reader, copiedLength, sourceOffset - copiedLength);
-			if (exceedsAvailableSize(writer, await getLocalHeaderLength(reader, sourceOffset))) {
-				await writer.closeDisk();
-			}
-			entryPositions.set(entry, {
-				offset: getSegmentOffset(zipWriter, writer),
-				diskNumberStart: getDiskNumber(writer)
-			});
-			copiedLength = sourceOffset;
+		const regionEnds = getRegionEnds(reader, sortedEntries, directoryOffset);
+		const keptEntrySet = new Set(keptEntries);
+		let copiedOffset = 0;
+		let lastPosition;
+		for (let indexEntry = 0; indexEntry < sortedEntries.length; indexEntry++) {
+			const entry = sortedEntries[indexEntry];
+			if (keptEntrySet.has(entry)) {
+				const sourceOffset = getSourceOffset(reader, entry);
+				if (sourceOffset < copiedOffset) {
+					entryPositions.set(entry, lastPosition);
+				} else {
+					if (!compact) {
+						await copyData(zipWriter, reader, copiedOffset, sourceOffset - copiedOffset);
+					}
+					if (writer.closeDisk && exceedsAvailableSize(writer, await getLocalHeaderLength(reader, sourceOffset))) {
+						await writer.closeDisk();
+					}
+					lastPosition = {
+						offset: getSegmentOffset(zipWriter, writer),
+						diskNumberStart: getDiskNumber(writer)
+					};
+					entryPositions.set(entry, lastPosition);
+					await copyData(zipWriter, reader, sourceOffset, regionEnds[indexEntry] - sourceOffset);
+					copiedOffset = regionEnds[indexEntry];
+				}
+			}
+		}
+		if (!compact) {
+			await copyData(zipWriter, reader, copiedOffset, directoryOffset - copiedOffset);
 		}
-		await copyData(zipWriter, reader, copiedLength, directoryOffset - copiedLength);
 	} else {
 		const baseOffset = zipWriter.offset;
 		await copyData(zipWriter, reader, 0, directoryOffset);
@@ -8645,6 +8730,20 @@ async function copyZipData(zipWriter, reader, entries, directoryOffset) {
 	return entryPositions;
 }
 
+function getRegionEnds(reader, sortedEntries, directoryOffset) {
+	const regionEnds = new Array(sortedEntries.length);
+	let regionEnd = directoryOffset;
+	for (let indexEntry = sortedEntries.length - 1; indexEntry >= 0; indexEntry--) {
+		const sourceOffset = getSourceOffset(reader, sortedEntries[indexEntry]);
+		const nextEntry = sortedEntries[indexEntry + 1];
+		if (nextEntry && getSourceOffset(reader, nextEntry) > sourceOffset) {
+			regionEnd = getSourceOffset(reader, nextEntry);
+		}
+		regionEnds[indexEntry] = regionEnd;
+	}
+	return regionEnds;
+}
+
 async function copyData(zipWriter, reader, offset, size) {
 	if (size > 0) {
 		const { writer } = zipWriter;
@@ -9022,7 +9121,7 @@ function formatSupported(StreamClass, format) {
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const VERSION = "2.19.0";
+const VERSION = "2.20.0";
 
 /*
  Copyright (c) 2025 Gildas Lormeau. All rights reserved.
@@ -11762,11 +11861,13 @@ exports.WARNING_COMPRESSED_PATCHED_DATA = WARNING_COMPRESSED_PATCHED_DATA;
 exports.WARNING_COMPRESSION_UNAVAILABLE = WARNING_COMPRESSION_UNAVAILABLE;
 exports.WARNING_DUPLICATE_FILENAME = WARNING_DUPLICATE_FILENAME;
 exports.WARNING_MALFORMED_EXTRA_FIELD = WARNING_MALFORMED_EXTRA_FIELD;
+exports.WARNING_MISMATCHED_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;

package/index.d.cts

@@ -1543,9 +1543,12 @@ export class ZipReader<Type> {
    * `strictness: "strict"` rejects with {@link ERR_AMBIGUOUS_ARCHIVE}: when the effective strictness tolerates
    * one of them and the evidence is already in hand, the same reason string is deposited as a warning instead —
    * {@link WARNING_APPENDED_DATA}, {@link WARNING_PREPENDED_DATA}, {@link WARNING_TRAILING_CENTRAL_DIRECTORY_DATA},
-   * {@link WARNING_DUPLICATE_FILENAME} and {@link WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY}.
+   * {@link WARNING_MISMATCHED_CENTRAL_DIRECTORY_OFFSET}, {@link WARNING_DUPLICATE_FILENAME} and
+   * {@link WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY}.
    * {@link WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY} is the one reason of that group which is never tolerated,
-   * so it is only ever the reason of an error.
+   * so it is only ever the reason of an error. {@link WARNING_MISSING_ZIP64_EXTRA_FIELD} is deposited when an
+   * entry cannot be read because its central directory record lacks a Zip64 extra field, and `"strict"` throws
+   * {@link ERR_EXTRAFIELD_ZIP64_NOT_FOUND} for it.
    *
    * The warnings related to the local file header of an entry are deposited on
    * {@link EntryMetaData#warnings} when its data is read, not here.
@@ -1758,9 +1761,10 @@ export interface GetEntriesOptions {
    * systems, and it also occurs as the trail byte of legitimate double-byte filenames (e.g. CP932) decoded with
    * another charset.
    *
-   * Names are validated, never rewritten, so the filename reported for an entry always matches its central
-   * directory record. The name validated is the final one, i.e. the name of a valid Unicode Path extra field
-   * (see {@link EntryMetaData#extraFieldUnicodePath}) when the entry carries one.
+   * Names are validated, never rewritten: the filename reported for an entry is the one its central directory
+   * record stores, decoded, or the one of its Unicode Path extra field when the entry carries a valid one (see
+   * {@link EntryMetaData#extraFieldUnicodePath}), and the bytes of the record stay available in
+   * {@link EntryMetaData#rawFilename}. The name validated is that final name.
    *
    * @defaultValue The value of {@link GetEntriesOptions#strictness}.
    */
@@ -2521,7 +2525,9 @@ export interface EntryMetaData {
    * `true` if the entry is an executable file
    *
    * Always `false` when {@link EntryMetaData#symlink} is `true`: the permissions of a symbolic link
-   * are not meaningful, Unix systems store them as `0o777`.
+   * are not meaningful, Unix systems store them as `0o777`. Always `false` when
+   * {@link EntryMetaData#directory} is `true` too: the execute bits of a directory mean that it can be
+   * searched, and every directory carries them; read {@link EntryMetaData#unixMode} for the bits themselves.
    */
   executable: boolean;
   /**
@@ -2569,8 +2575,9 @@ export interface EntryMetaData {
   creationDate?: Date;
   /**
    * The last modification date (raw), as the MS-DOS date and time stored in the header. Unlike
-   * {@link EntryMetaData#lastModDate}, it is not replaced by the value of the NTFS extra field when that field
-   * is present; read {@link EntryMetaData#extraFieldNTFS} for the raw NTFS value.
+   * {@link EntryMetaData#lastModDate}, it is not replaced by the value of the extended timestamp or NTFS extra
+   * field when one is present (the NTFS value wins over the extended timestamp one, being the finer of the two);
+   * read {@link EntryMetaData#extraFieldNTFS} for the raw NTFS value.
    */
   rawLastModDate: number | bigint;
   /**
@@ -3079,7 +3086,13 @@ export class ZipWriter<Type> {
    * The returned promise can safely be left un-awaited: {@link ZipWriter#close} waits for the copy
    * and throws its error if it was not caught.
    *
+   * With the {@link ZipWriterAppendZipOptions#filter} option, only the entries the function keeps are copied.
+   * Combined with {@link ZipWriter#add}, this edits an existing zip file into a new one without decompressing
+   * its data: the entries to keep are copied as-is, the entries to delete or replace are left out, and the
+   * replacements and additions are added afterwards.
+   *
    * @param reader The {@link Reader} instance used to read the content of the zip file.
+   * @param options The options.
    * @returns A promise resolving when the zip file has been added.
    */
   appendZip<ReaderType>(
@@ -3089,7 +3102,8 @@ export class ZipWriter<Type> {
       | ReadableStream
       | Reader<unknown>[]
       | ReadableReader[]
-      | ReadableStream[]
+      | ReadableStream[],
+    options?: ZipWriterAppendZipOptions
   ): Promise<void>;
 
   /**
@@ -3307,6 +3321,29 @@ export interface ZipWriterAddDataOptions
 /**
  * Represents the options passed to  {@link ZipWriter#close}.
  */
+/**
+ * Represents the options passed to {@link ZipWriter#appendZip}.
+ */
+export interface ZipWriterAppendZipOptions {
+  /**
+   * Selects the entries of the zip file to copy: the function is called once per entry, in the order of the
+   * central directory, and the entry is copied when it returns (or resolves to) `true`. The function can read
+   * the data of the entry with {@link Entry#getData} to decide, the zip file is closed after the last call.
+   *
+   * @remarks
+   * When the option is set, the data of the zip file is copied entry by entry and the entries left out leave no
+   * bytes behind in the output, unlike {@link ZipWriter#remove}, which drops an entry from the central directory
+   * after its data has been written. The bytes of the zip file outside its entries, e.g. a self-extracting stub
+   * before the first entry, are not copied either. Without the option, the data of the zip file is copied as a
+   * whole. The duplicate filename check applies to the entries kept only, so an entry can be replaced by
+   * leaving it out and adding its replacement with {@link ZipWriter#add}.
+   *
+   * @param entry The entry read from the zip file.
+   * @returns `true` to copy the entry.
+   */
+  filter?: (entry: Entry) => boolean | Promise<boolean>;
+}
+
 export interface ZipWriterCloseOptions extends EntryOnprogressOptions {
   /**
    * `true` to use Zip64 to write the entries directory.
@@ -4998,7 +5035,9 @@ export const ERR_BAD_FORMAT: string;
  */
 export const ERR_EOCDR_NOT_FOUND: string;
 /**
- * Zip64 End of Central Directory Locator not found error
+ * Zip64 End of Central Directory Locator not found error: the end of central directory record holds a Zip64
+ * sentinel in its offset, size or disk number field but no Zip64 locator precedes it, or the locator does not
+ * point at a Zip64 end of central directory record
  */
 export const ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND: string;
 /**
@@ -5597,6 +5636,27 @@ export const WARNING_PREPENDED_CENTRAL_DIRECTORY: string;
  * the reason of {@link ERR_AMBIGUOUS_ARCHIVE} under `strictness: "strict"`
  */
 export const WARNING_TRAILING_CENTRAL_DIRECTORY_DATA: string;
+/**
+ * Warning reason: the end of central directory record stores a central directory offset that points past the
+ * central directory actually found before it, so the archive was read from the directory found rather than from
+ * the stored offset (see {@link ZipReader#warnings}); the reason of {@link ERR_AMBIGUOUS_ARCHIVE} under
+ * `strictness: "strict"`
+ *
+ * @remarks
+ * Such an archive is typically one written with absolute offsets for a prefix that is no longer there, e.g. a
+ * self-extracting archive whose stub was removed. When the local file header of the first entry is found at
+ * the same shifted position, the entries are read from the shifted positions; otherwise the offsets stored in
+ * the central directory are used as they are.
+ */
+export const WARNING_MISMATCHED_CENTRAL_DIRECTORY_OFFSET: string;
+/**
+ * Warning reason: a central directory record holds the Zip64 sentinel in a size, offset or disk number field
+ * but carries no Zip64 extra field resolving it (see {@link ZipReader#warnings}). The entry is listed, its
+ * sizes and offset are unusable, and reading its data throws {@link ERR_EXTRAFIELD_ZIP64_NOT_FOUND}; the
+ * other entries are unaffected. Under `strictness: "strict"`, {@link ZipReader#getEntries} throws
+ * {@link ERR_EXTRAFIELD_ZIP64_NOT_FOUND} instead.
+ */
+export const WARNING_MISSING_ZIP64_EXTRA_FIELD: string;
 /**
  * Warning reason: several entries share the same filename (see {@link ZipReader#warnings}); the reason of
  * {@link ERR_AMBIGUOUS_ARCHIVE} under `strictness: "strict"`

package/index.d.ts

@@ -1543,9 +1543,12 @@ export class ZipReader<Type> {
    * `strictness: "strict"` rejects with {@link ERR_AMBIGUOUS_ARCHIVE}: when the effective strictness tolerates
    * one of them and the evidence is already in hand, the same reason string is deposited as a warning instead —
    * {@link WARNING_APPENDED_DATA}, {@link WARNING_PREPENDED_DATA}, {@link WARNING_TRAILING_CENTRAL_DIRECTORY_DATA},
-   * {@link WARNING_DUPLICATE_FILENAME} and {@link WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY}.
+   * {@link WARNING_MISMATCHED_CENTRAL_DIRECTORY_OFFSET}, {@link WARNING_DUPLICATE_FILENAME} and
+   * {@link WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY}.
    * {@link WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY} is the one reason of that group which is never tolerated,
-   * so it is only ever the reason of an error.
+   * so it is only ever the reason of an error. {@link WARNING_MISSING_ZIP64_EXTRA_FIELD} is deposited when an
+   * entry cannot be read because its central directory record lacks a Zip64 extra field, and `"strict"` throws
+   * {@link ERR_EXTRAFIELD_ZIP64_NOT_FOUND} for it.
    *
    * The warnings related to the local file header of an entry are deposited on
    * {@link EntryMetaData#warnings} when its data is read, not here.
@@ -1758,9 +1761,10 @@ export interface GetEntriesOptions {
    * systems, and it also occurs as the trail byte of legitimate double-byte filenames (e.g. CP932) decoded with
    * another charset.
    *
-   * Names are validated, never rewritten, so the filename reported for an entry always matches its central
-   * directory record. The name validated is the final one, i.e. the name of a valid Unicode Path extra field
-   * (see {@link EntryMetaData#extraFieldUnicodePath}) when the entry carries one.
+   * Names are validated, never rewritten: the filename reported for an entry is the one its central directory
+   * record stores, decoded, or the one of its Unicode Path extra field when the entry carries a valid one (see
+   * {@link EntryMetaData#extraFieldUnicodePath}), and the bytes of the record stay available in
+   * {@link EntryMetaData#rawFilename}. The name validated is that final name.
    *
    * @defaultValue The value of {@link GetEntriesOptions#strictness}.
    */
@@ -2521,7 +2525,9 @@ export interface EntryMetaData {
    * `true` if the entry is an executable file
    *
    * Always `false` when {@link EntryMetaData#symlink} is `true`: the permissions of a symbolic link
-   * are not meaningful, Unix systems store them as `0o777`.
+   * are not meaningful, Unix systems store them as `0o777`. Always `false` when
+   * {@link EntryMetaData#directory} is `true` too: the execute bits of a directory mean that it can be
+   * searched, and every directory carries them; read {@link EntryMetaData#unixMode} for the bits themselves.
    */
   executable: boolean;
   /**
@@ -2569,8 +2575,9 @@ export interface EntryMetaData {
   creationDate?: Date;
   /**
    * The last modification date (raw), as the MS-DOS date and time stored in the header. Unlike
-   * {@link EntryMetaData#lastModDate}, it is not replaced by the value of the NTFS extra field when that field
-   * is present; read {@link EntryMetaData#extraFieldNTFS} for the raw NTFS value.
+   * {@link EntryMetaData#lastModDate}, it is not replaced by the value of the extended timestamp or NTFS extra
+   * field when one is present (the NTFS value wins over the extended timestamp one, being the finer of the two);
+   * read {@link EntryMetaData#extraFieldNTFS} for the raw NTFS value.
    */
   rawLastModDate: number | bigint;
   /**
@@ -3079,7 +3086,13 @@ export class ZipWriter<Type> {
    * The returned promise can safely be left un-awaited: {@link ZipWriter#close} waits for the copy
    * and throws its error if it was not caught.
    *
+   * With the {@link ZipWriterAppendZipOptions#filter} option, only the entries the function keeps are copied.
+   * Combined with {@link ZipWriter#add}, this edits an existing zip file into a new one without decompressing
+   * its data: the entries to keep are copied as-is, the entries to delete or replace are left out, and the
+   * replacements and additions are added afterwards.
+   *
    * @param reader The {@link Reader} instance used to read the content of the zip file.
+   * @param options The options.
    * @returns A promise resolving when the zip file has been added.
    */
   appendZip<ReaderType>(
@@ -3089,7 +3102,8 @@ export class ZipWriter<Type> {
       | ReadableStream
       | Reader<unknown>[]
       | ReadableReader[]
-      | ReadableStream[]
+      | ReadableStream[],
+    options?: ZipWriterAppendZipOptions
   ): Promise<void>;
 
   /**
@@ -3307,6 +3321,29 @@ export interface ZipWriterAddDataOptions
 /**
  * Represents the options passed to  {@link ZipWriter#close}.
  */
+/**
+ * Represents the options passed to {@link ZipWriter#appendZip}.
+ */
+export interface ZipWriterAppendZipOptions {
+  /**
+   * Selects the entries of the zip file to copy: the function is called once per entry, in the order of the
+   * central directory, and the entry is copied when it returns (or resolves to) `true`. The function can read
+   * the data of the entry with {@link Entry#getData} to decide, the zip file is closed after the last call.
+   *
+   * @remarks
+   * When the option is set, the data of the zip file is copied entry by entry and the entries left out leave no
+   * bytes behind in the output, unlike {@link ZipWriter#remove}, which drops an entry from the central directory
+   * after its data has been written. The bytes of the zip file outside its entries, e.g. a self-extracting stub
+   * before the first entry, are not copied either. Without the option, the data of the zip file is copied as a
+   * whole. The duplicate filename check applies to the entries kept only, so an entry can be replaced by
+   * leaving it out and adding its replacement with {@link ZipWriter#add}.
+   *
+   * @param entry The entry read from the zip file.
+   * @returns `true` to copy the entry.
+   */
+  filter?: (entry: Entry) => boolean | Promise<boolean>;
+}
+
 export interface ZipWriterCloseOptions extends EntryOnprogressOptions {
   /**
    * `true` to use Zip64 to write the entries directory.
@@ -4998,7 +5035,9 @@ export const ERR_BAD_FORMAT: string;
  */
 export const ERR_EOCDR_NOT_FOUND: string;
 /**
- * Zip64 End of Central Directory Locator not found error
+ * Zip64 End of Central Directory Locator not found error: the end of central directory record holds a Zip64
+ * sentinel in its offset, size or disk number field but no Zip64 locator precedes it, or the locator does not
+ * point at a Zip64 end of central directory record
  */
 export const ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND: string;
 /**
@@ -5597,6 +5636,27 @@ export const WARNING_PREPENDED_CENTRAL_DIRECTORY: string;
  * the reason of {@link ERR_AMBIGUOUS_ARCHIVE} under `strictness: "strict"`
  */
 export const WARNING_TRAILING_CENTRAL_DIRECTORY_DATA: string;
+/**
+ * Warning reason: the end of central directory record stores a central directory offset that points past the
+ * central directory actually found before it, so the archive was read from the directory found rather than from
+ * the stored offset (see {@link ZipReader#warnings}); the reason of {@link ERR_AMBIGUOUS_ARCHIVE} under
+ * `strictness: "strict"`
+ *
+ * @remarks
+ * Such an archive is typically one written with absolute offsets for a prefix that is no longer there, e.g. a
+ * self-extracting archive whose stub was removed. When the local file header of the first entry is found at
+ * the same shifted position, the entries are read from the shifted positions; otherwise the offsets stored in
+ * the central directory are used as they are.
+ */
+export const WARNING_MISMATCHED_CENTRAL_DIRECTORY_OFFSET: string;
+/**
+ * Warning reason: a central directory record holds the Zip64 sentinel in a size, offset or disk number field
+ * but carries no Zip64 extra field resolving it (see {@link ZipReader#warnings}). The entry is listed, its
+ * sizes and offset are unusable, and reading its data throws {@link ERR_EXTRAFIELD_ZIP64_NOT_FOUND}; the
+ * other entries are unaffected. Under `strictness: "strict"`, {@link ZipReader#getEntries} throws
+ * {@link ERR_EXTRAFIELD_ZIP64_NOT_FOUND} instead.
+ */
+export const WARNING_MISSING_ZIP64_EXTRA_FIELD: string;
 /**
  * Warning reason: several entries share the same filename (see {@link ZipReader#warnings}); the reason of
  * {@link ERR_AMBIGUOUS_ARCHIVE} under `strictness: "strict"`