@zip.js/zip.js 2.18.2 → 2.20.0

package/lib/core/zip-reader.js

@@ -175,7 +175,6 @@ import {
 	STRICTNESS_TOLERANT,
 	OPTION_USE_WEB_WORKERS,
 	OPTION_USE_COMPRESSION_STREAM,
-	OPTION_TRANSFER_STREAMS,
 	OPTION_PREVENT_CLOSE,
 	checkFunctionOption,
 	checkSignalOption,
@@ -213,6 +212,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";
@@ -375,6 +376,8 @@ class ZipReader {
 					reportAmbiguity(checkAmbiguity, warnings, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY);
 				}
 				directoryDataOffset = getDiskOffset(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;
@@ -397,25 +400,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(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(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(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);
 				}
 			}
 		}
@@ -499,17 +521,6 @@ class ZipReader {
 			if (filename === UNDEFINED_VALUE) {
 				filename = decodeText(rawFilename, rawFilenameEncoding);
 			}
-			if (normalizeFilename) {
-				const normalizedFilename = normalizeFilename(filename);
-				if (normalizedFilename !== UNDEFINED_VALUE) {
-					filename = normalizedFilename;
-				}
-			}
-			if (isUnsafeFilename(filename, filenameValidation)) {
-				const error = new Error(ERR_UNSAFE_FILENAME);
-				error.filename = filename;
-				throw error;
-			}
 			let comment = decode(rawComment, rawCommentEncoding, TEXT_TYPE_COMMENT);
 			if (comment === UNDEFINED_VALUE) {
 				comment = decodeText(rawComment, rawCommentEncoding);
@@ -537,7 +548,29 @@ class ZipReader {
 				filename,
 				comment
 			});
-			if (readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6)) {
+			let malformedExtraField;
+			try {
+				malformedExtraField = readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6);
+			} catch (error) {
+				if (checkAmbiguity || error.message != ERR_EXTRAFIELD_ZIP64_NOT_FOUND) {
+					throw error;
+				}
+				fileEntry.zip64ExtraFieldMissing = true;
+				addWarning(warnings, WARNING_MISSING_ZIP64_EXTRA_FIELD, fileEntry.filename);
+			}
+			filename = fileEntry.filename;
+			if (normalizeFilename) {
+				const normalizedFilename = normalizeFilename(filename);
+				if (normalizedFilename !== UNDEFINED_VALUE) {
+					filename = fileEntry.filename = normalizedFilename;
+				}
+			}
+			if (isUnsafeFilename(filename, filenameValidation)) {
+				const error = new Error(ERR_UNSAFE_FILENAME);
+				error.filename = filename;
+				throw error;
+			}
+			if (malformedExtraField) {
 				addWarning(warnings, WARNING_MALFORMED_EXTRA_FIELD, filename);
 			}
 			fileEntry.offset += prependedDataLength;
@@ -566,11 +599,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,
@@ -578,7 +612,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);
@@ -634,10 +668,10 @@ class ZipReader {
 		const extractAppendedData = getOptionValue(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) {
@@ -826,6 +860,8 @@ export {
 	WARNING_PREPENDED_DATA,
 	WARNING_PREPENDED_CENTRAL_DIRECTORY,
 	WARNING_TRAILING_CENTRAL_DIRECTORY_DATA,
+	WARNING_MISMATCHED_CENTRAL_DIRECTORY_OFFSET,
+	WARNING_MISSING_ZIP64_EXTRA_FIELD,
 	WARNING_DUPLICATE_FILENAME,
 	WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY,
 	WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY,
@@ -846,6 +882,9 @@ 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,
@@ -990,7 +1029,6 @@ class ZipEntry {
 				encrypted,
 				useWebWorkers: getOptionValue(zipEntry, options, OPTION_USE_WEB_WORKERS),
 				useCompressionStream,
-				transferStreams: getOptionValue(zipEntry, options, OPTION_TRANSFER_STREAMS),
 				deflate64,
 				format: registeredCodec ? registeredCodec.format : UNDEFINED_VALUE,
 				codecURI: registeredCodec ? registeredCodec.codecURI : UNDEFINED_VALUE,
@@ -1084,6 +1122,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(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(tailView, indexByte) == DIGITAL_SIGNATURE_RECORD_SIGNATURE &&
+			indexByte + 6 + getUint16(tailView, indexByte + 4) == tailArray.length) {
+			return startOffset + indexByte;
+		}
+	}
+}
+
 function readDigitalSignature(signatureRecordArray) {
 	if (signatureRecordArray.length >= 6) {
 		const signatureRecordView = getDataView(signatureRecordArray);
@@ -1215,29 +1277,27 @@ 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);
 		directory.extraFieldNTFS = extraFieldNTFS;
 	}
-	const extraFieldUnix = extraField.get(EXTRAFIELD_TYPE_UNIX);
+	const extraFieldInfoZip = extraField.get(EXTRAFIELD_TYPE_INFOZIP);
 	let unixIdsRead;
+	if (extraFieldInfoZip) {
+		unixIdsRead = readExtraFieldUnix(extraFieldInfoZip, directory, true);
+		directory.extraFieldInfoZip = extraFieldInfoZip;
+	}
+	const extraFieldUnix = extraField.get(EXTRAFIELD_TYPE_UNIX);
 	if (extraFieldUnix) {
-		unixIdsRead = readExtraFieldUnix(extraFieldUnix, directory, false);
+		readExtraFieldUnix(extraFieldUnix, unixIdsRead ? {} : directory, false);
 		directory.extraFieldUnix = extraFieldUnix;
 	}
-	if (!unixIdsRead) {
-		const extraFieldInfoZip = extraField.get(EXTRAFIELD_TYPE_INFOZIP);
-		if (extraFieldInfoZip) {
-			readExtraFieldUnix(extraFieldInfoZip, directory, true);
-			directory.extraFieldInfoZip = extraFieldInfoZip;
-		}
-	}
-	const extraFieldExtendedTimestamp = extraField.get(EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
-	if (extraFieldExtendedTimestamp) {
-		readExtraFieldExtendedTimestamp(extraFieldExtendedTimestamp, directory, localDirectory);
-		directory.extraFieldExtendedTimestamp = extraFieldExtendedTimestamp;
-	}
 	const extraFieldUSDZ = extraField.get(EXTRAFIELD_TYPE_USDZ);
 	if (extraFieldUSDZ) {
 		directory.extraFieldUSDZ = extraFieldUSDZ;

package/lib/core/zip-writer.js

@@ -218,7 +218,6 @@ import {
 	OPTION_SIGNAL,
 	OPTION_USE_WEB_WORKERS,
 	OPTION_USE_COMPRESSION_STREAM,
-	OPTION_TRANSFER_STREAMS,
 	OPTION_PREVENT_CLOSE,
 	OPTION_ENCRYPTION_STRENGTH,
 	OPTION_EXTENDED_TIMESTAMP,
@@ -343,13 +342,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));
 		}
@@ -368,10 +368,16 @@ class ZipWriter {
 			const { ZipReader } = await import("./zip-reader.js");
 			const zipReader = new ZipReader(reader);
 			const entries = await zipReader.getEntries();
+			const keptEntries = [];
+			for (const entry of entries) {
+				if (!filter || await filter(entry)) {
+					keptEntries.push(entry);
+				}
+			}
 			await zipReader.close();
 			await initStream(zipWriter.writer);
 			const { directoryOffset } = zipReader;
-			entries.forEach(({ filename }) => {
+			keptEntries.forEach(({ filename }) => {
 				if (filenames.has(filename)) {
 					throw new Error(ERR_DUPLICATED_NAME);
 				}
@@ -392,8 +398,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,
@@ -449,6 +455,7 @@ class ZipWriter {
 					rawExtraFieldExtendedTimestamp: EMPTY_UINT8_ARRAY,
 					rawExtraFieldNTFS: EMPTY_UINT8_ARRAY,
 					rawExtraFieldUnix: EMPTY_UINT8_ARRAY,
+					rawCentralExtraFieldUnix: EMPTY_UINT8_ARRAY,
 					rawExtraField,
 					rawCentralExtraField: EMPTY_UINT8_ARRAY,
 					headerArray,
@@ -1063,7 +1070,6 @@ function resolveMetadata(zipWriter, name, options) {
 	const ntfsTimestamp = getOptionValue(zipWriter, options, OPTION_NTFS_TIMESTAMP);
 	const keepOrder = getOptionValue(zipWriter, options, OPTION_KEEP_ORDER, true);
 	const useWebWorkers = getOptionValue(zipWriter, options, OPTION_USE_WEB_WORKERS);
-	const transferStreams = getOptionValue(zipWriter, options, OPTION_TRANSFER_STREAMS);
 	const bufferedWrite = getOptionValue(zipWriter, options, OPTION_BUFFERED_WRITE);
 	const createTempStream = getFunctionOptionValue(zipWriter, options, OPTION_CREATE_TEMP_STREAM);
 	const dataDescriptorSignature = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR_SIGNATURE, true);
@@ -1129,7 +1135,6 @@ function resolveMetadata(zipWriter, name, options) {
 			ntfsTimestamp,
 			keepOrder,
 			useWebWorkers,
-			transferStreams,
 			bufferedWrite,
 			createTempStream,
 			dataDescriptorSignature,
@@ -1188,7 +1193,7 @@ async function resolveSizes(zipWriter, reader, { resolvedOptions: metadata }, op
 	if (reader) {
 		reader = new GenericReader(reader);
 		await initStream(reader);
-		if (!reader.readable && !reader.readUint8Array) {
+		if (!reader.readUint8Array && !reader.readable) {
 			throw new Error(ERR_INVALID_READER);
 		}
 		({ size: contentSize } = reader);
@@ -1549,6 +1554,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		extraFieldExtendedTimestampTime,
 		rawExtraFieldNTFS,
 		rawExtraFieldUnix,
+		rawCentralExtraFieldUnix,
 		rawExtraFieldAES,
 	} = headerInfo;
 	const { dataDescriptorArray } = dataDescriptorInfo;
@@ -1573,7 +1579,6 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		rawExtraField,
 		rawCentralExtraField,
 		useWebWorkers,
-		transferStreams,
 		onstart,
 		onprogress,
 		onend,
@@ -1615,6 +1620,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		rawExtraFieldExtendedTimestamp,
 		rawExtraFieldNTFS,
 		rawExtraFieldUnix,
+		rawCentralExtraFieldUnix,
 		rawExtraFieldAES,
 		rawExtraField,
 		rawCentralExtraField,
@@ -1661,7 +1667,6 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 				encrypted: encrypted && !passThroughEncryption,
 				useWebWorkers,
 				useCompressionStream,
-				transferStreams,
 				format,
 				codecURI,
 				compressionMethod
@@ -1839,6 +1844,7 @@ function getHeaderInfo(options) {
 		rawExtraFieldNTFS = rawExtraFieldExtendedTimestamp = EMPTY_UINT8_ARRAY;
 	}
 	let rawExtraFieldUnix;
+	let rawCentralExtraFieldUnix;
 	try {
 		const { uid, gid, unixExtraFieldType } = options;
 		if (unixExtraFieldType == INFOZIP_EXTRA_FIELD_TYPE && (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE)) {
@@ -1853,7 +1859,7 @@ function getHeaderInfo(options) {
 			extraFieldUnix.writeBytes(uidBytes);
 			extraFieldUnix.writeUint8(gidBytes.length);
 			extraFieldUnix.writeBytes(gidBytes);
-			rawExtraFieldUnix = extraFieldUnix.array;
+			rawExtraFieldUnix = rawCentralExtraFieldUnix = extraFieldUnix.array;
 		} else if (unixExtraFieldType == UNIX_EXTRA_FIELD_TYPE && (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE)) {
 			const extraFieldUnix = createRecordWriter(8);
 			extraFieldUnix.writeUint16(EXTRAFIELD_TYPE_UNIX);
@@ -1861,11 +1867,15 @@ function getHeaderInfo(options) {
 			extraFieldUnix.writeUint16((uid === UNDEFINED_VALUE ? 0 : uid) & MAX_16_BITS);
 			extraFieldUnix.writeUint16((gid === UNDEFINED_VALUE ? 0 : gid) & MAX_16_BITS);
 			rawExtraFieldUnix = extraFieldUnix.array;
+			const centralExtraFieldUnix = createRecordWriter(4);
+			centralExtraFieldUnix.writeUint16(EXTRAFIELD_TYPE_UNIX);
+			centralExtraFieldUnix.writeUint16(0);
+			rawCentralExtraFieldUnix = centralExtraFieldUnix.array;
 		} else {
-			rawExtraFieldUnix = EMPTY_UINT8_ARRAY;
+			rawExtraFieldUnix = rawCentralExtraFieldUnix = EMPTY_UINT8_ARRAY;
 		}
 	} catch {
-		rawExtraFieldUnix = EMPTY_UINT8_ARRAY;
+		rawExtraFieldUnix = rawCentralExtraFieldUnix = EMPTY_UINT8_ARRAY;
 	}
 	if (compressionMethod === UNDEFINED_VALUE) {
 		compressionMethod = compressed ? COMPRESSION_METHOD_DEFLATE : COMPRESSION_METHOD_STORE;
@@ -1957,6 +1967,7 @@ function getHeaderInfo(options) {
 		rawExtraFieldExtendedTimestamp,
 		rawExtraFieldNTFS,
 		rawExtraFieldUnix,
+		rawCentralExtraFieldUnix,
 		rawExtraFieldAES,
 		extraFieldLength
 	};
@@ -2132,7 +2143,7 @@ function createDirectoryRecords(files) {
 			rawExtraFieldAES,
 			rawComment,
 			rawExtraFieldNTFS,
-			rawExtraFieldUnix,
+			rawCentralExtraFieldUnix,
 			rawExtraField,
 			rawCentralExtraField,
 			extraFieldExtendedTimestampFlag,
@@ -2194,7 +2205,7 @@ function createDirectoryRecords(files) {
 			rawExtraFieldZip64,
 			rawExtraFieldAES,
 			rawExtraFieldNTFS,
-			rawExtraFieldUnix,
+			rawCentralExtraFieldUnix,
 			rawExtraFieldTimestamp,
 			rawExtraField,
 			rawCentralExtraField);
@@ -2223,7 +2234,7 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 			rawExtraFieldAES,
 			rawExtraFieldExtendedTimestamp,
 			rawExtraFieldNTFS,
-			rawExtraFieldUnix,
+			rawCentralExtraFieldUnix,
 			rawExtraField,
 			rawCentralExtraField,
 			rawComment,
@@ -2240,7 +2251,7 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 			uncompressedSize,
 			compressedSize
 		} = fileEntry;
-		const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField, rawCentralExtraField);
+		const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawCentralExtraFieldUnix, rawExtraField, rawCentralExtraField);
 		const directoryRecordLength = CENTRAL_FILE_HEADER_LENGTH + getLength(rawFilename, rawComment) + extraFieldLength;
 		if (exceedsAvailableSize(writer, offset + directoryRecordLength - directoryDiskOffset)) {
 			await writeData(writer, directoryArray.slice(directoryDiskOffset, offset));
@@ -2276,7 +2287,7 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 		directoryRecord.writeBytes(rawExtraFieldAES);
 		directoryRecord.writeBytes(rawExtraFieldExtendedTimestamp);
 		directoryRecord.writeBytes(rawExtraFieldNTFS);
-		directoryRecord.writeBytes(rawExtraFieldUnix);
+		directoryRecord.writeBytes(rawCentralExtraFieldUnix);
 		directoryRecord.writeBytes(rawExtraField);
 		directoryRecord.writeBytes(rawCentralExtraField);
 		directoryRecord.writeBytes(rawComment);
@@ -2445,26 +2456,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();
+		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];
+				}
 			}
-			entryPositions.set(entry, {
-				offset: getSegmentOffset(zipWriter, writer),
-				diskNumberStart: getDiskNumber(writer)
-			});
-			copiedLength = sourceOffset;
 		}
-		await copyData(zipWriter, reader, copiedLength, directoryOffset - copiedLength);
+		if (!compact) {
+			await copyData(zipWriter, reader, copiedOffset, directoryOffset - copiedOffset);
+		}
 	} else {
 		const baseOffset = zipWriter.offset;
 		await copyData(zipWriter, reader, 0, directoryOffset);
@@ -2476,6 +2503,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;

package/lib/zip-core-reader.js

@@ -68,6 +68,8 @@ export {
 	WARNING_PREPENDED_DATA,
 	WARNING_PREPENDED_CENTRAL_DIRECTORY,
 	WARNING_TRAILING_CENTRAL_DIRECTORY_DATA,
+	WARNING_MISMATCHED_CENTRAL_DIRECTORY_OFFSET,
+	WARNING_MISSING_ZIP64_EXTRA_FIELD,
 	WARNING_DUPLICATE_FILENAME,
 	WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY,
 	WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY,

package/package.json

@@ -3,7 +3,7 @@
   "description": "A JavaScript library to zip and unzip files in the browser, Deno and Node.js",
   "author": "Gildas Lormeau",
   "license": "BSD-3-Clause",
-  "version": "2.18.2",
+  "version": "2.20.0",
   "type": "module",
   "keywords": [
     "zip",

package/worker-message-property-names.js

@@ -1,3 +1,3 @@
-const WORKER_MESSAGE_PROPERTY_NAMES = ["baseURI", "cause", "checkAuthenticationCode", "checkCrc32", "checkPasswordOnly", "chunkSize", "code", "codecImportFailed", "codecType", "codecURI", "compressed", "compressionMethod", "computeCrc32", "config", "crc32", "deflate64", "done", "encrypted", "encryptionStrength", "error", "errorValue", "format", "inputSize", "level", "message", "messageId", "name", "options", "outputSize", "password", "passwordVerification", "rawBitFlag", "rawPassword", "readable", "result", "stack", "transferStreams", "type", "useCompressionStream", "useWebWorkers", "value", "wasmURI", "workerStartupTimeout", "writable", "zipCrypto"];
+const WORKER_MESSAGE_PROPERTY_NAMES = ["baseURI", "cause", "checkAuthenticationCode", "checkCrc32", "checkPasswordOnly", "chunkSize", "code", "codecImportFailed", "codecType", "codecURI", "compressed", "compressionMethod", "computeCrc32", "config", "crc32", "deflate64", "done", "encrypted", "encryptionStrength", "error", "errorValue", "format", "inputSize", "level", "message", "messageId", "name", "options", "outputSize", "password", "passwordVerification", "rawBitFlag", "rawPassword", "result", "stack", "type", "useCompressionStream", "useWebWorkers", "value", "wasmURI", "workerStartupTimeout", "zipCrypto"];
 
 export { WORKER_MESSAGE_PROPERTY_NAMES };