@zip.js/zip.js 2.8.57 → 2.8.59

package/lib/core/zip-writer.js

@@ -129,6 +129,7 @@ import {
 	FILE_ATTR_UNIX_SETUID_MASK,
 	FILE_ATTR_UNIX_SETGID_MASK,
 	FILE_ATTR_UNIX_STICKY_MASK,
+	VERSION_STORE,
 	VERSION_DEFLATE,
 	VERSION_MADE_BY_MSDOS,
 	VERSION_MADE_BY_UNIX,
@@ -174,6 +175,7 @@ import { concat, getDataView } from "./util/array.js";
 import { toCompatibleReadable, streamToBlob } from "./util/compatible-streams.js";
 import {
 	PROPERTY_NAME_LAST_MODIFICATION_DATE,
+	PROPERTY_NAME_RAW_LAST_MODIFICATION_DATE,
 	PROPERTY_NAME_LAST_ACCESS_DATE,
 	PROPERTY_NAME_CREATION_DATE,
 	PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES,
@@ -228,6 +230,7 @@ import {
 	OPTION_USDZ,
 	OPTION_UNIX_EXTRA_FIELD_TYPE,
 	OPTION_LOCAL_EXTRA_FIELD,
+	OPTION_CENTRAL_EXTRA_FIELD,
 	OPTION_SIGN_CENTRAL_DIRECTORY,
 	TEXT_TYPE_FILENAME,
 	TEXT_TYPE_COMMENT,
@@ -305,153 +308,151 @@ class ZipWriter {
 			offset: options[OPTION_OFFSET] === UNDEFINED_VALUE ? writer.size || writer.writable.size || 0 : options[OPTION_OFFSET],
 			initialOffset: options[OPTION_OFFSET] === UNDEFINED_VALUE ? 0 : options[OPTION_OFFSET] - (writer.size || writer.writable.size || 0),
 			pendingAddFileCalls: new Set(),
+			pendingErrors: [],
 			bufferedWrites: 0,
 			lastFileEntry: UNDEFINED_VALUE
 		});
 	}
 
-	async prependZip(reader) {
-		if (this.filenames.size) {
-			throw new Error(ERR_ZIP_NOT_EMPTY);
-		}
-		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 import("./zip-reader.js");
-		const zipReader = new ZipReader(reader);
-		const entries = await zipReader.getEntries();
-		await zipReader.close();
-		await initStream(this.writer);
-		const { directoryOffset } = zipReader;
-		if (this.addSplitZipSignature) {
-			delete this.addSplitZipSignature;
-			if (!await startsWithSplitZipSignature(reader)) {
-				await writeData(this.writer, getSplitZipSignatureArray());
-				this.offset += SPLIT_ZIP_FILE_SIGNATURE_LENGTH;
-			}
-		}
-		const entryPositions = await copyZipData(this, reader, entries, directoryOffset);
-		this.filenames = new Set(entries.map(entry => entry.filename));
-		this.fileEntries = new Map(entries.map(entry => {
-			const {
-				version,
-				rawLastModDate,
-				lastAccessDate,
-				creationDate,
-				rawFilename,
-				bitFlag,
-				encrypted,
-				uncompressedSize,
-				compressedSize,
-				extraFieldZip64
-			} = entry;
-			let {
-				compressionMethod,
-				rawExtraFieldZip64,
-				rawExtraFieldAES,
-				rawExtraFieldExtendedTimestamp,
-				rawExtraFieldNTFS,
-				rawExtraFieldUnix,
-				rawExtraField,
-			} = entry;
-			const { level, languageEncodingFlag, dataDescriptor } = bitFlag;
-			rawExtraFieldZip64 = rawExtraFieldZip64 || EMPTY_UINT8_ARRAY;
-			rawExtraFieldAES = rawExtraFieldAES || EMPTY_UINT8_ARRAY;
-			rawExtraFieldExtendedTimestamp = rawExtraFieldExtendedTimestamp || EMPTY_UINT8_ARRAY;
-			rawExtraFieldNTFS = rawExtraFieldNTFS || EMPTY_UINT8_ARRAY;
-			rawExtraFieldUnix = rawExtraFieldUnix || EMPTY_UINT8_ARRAY;
-			rawExtraField = removeExtraFieldZip64(rawExtraField || EMPTY_UINT8_ARRAY);
-			if (entry.extraFieldAES) {
-				compressionMethod = COMPRESSION_METHOD_AES;
-			}
-			const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, 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, {
-				zip64UncompressedSize,
-				zip64CompressedSize,
-				offset,
-				diskNumberStart,
-				zip64DiskNumberStart: false,
-				rawExtraFieldZip64,
-				rawExtraFieldAES,
-				rawExtraFieldExtendedTimestamp,
-				rawExtraFieldNTFS,
-				rawExtraFieldUnix,
-				rawExtraField,
-				extendedTimestamp: rawExtraFieldExtendedTimestamp.length > 0 || rawExtraFieldNTFS.length > 0,
-				extraFieldExtendedTimestampFlag: 0x1 + (lastAccessDate ? 0x2 : 0) + (creationDate ? 0x4 : 0),
-				headerArray,
-				headerView
-			});
-			return [entry.filename, entry];
-		}));
+	prependZip(reader) {
+		return watchPromiseError(this, prependZipEntries(this, reader));
+	}
+
+	appendZip(reader) {
+		return watchPromiseError(this, this.appendZipEntries(reader));
 	}
 
-	async add(name = "", reader, options = {}) {
+	async appendZipEntries(reader) {
 		const zipWriter = this;
-		options = Object.assign({}, options);
-		const { pendingAddFileCalls } = zipWriter;
-		if (workers < getConfiguration().maxWorkers) {
-			workers++;
-		} else {
-			await new Promise(resolve => pendingEntries.push(resolve));
+		const { pendingAddFileCalls, filenames, fileEntries } = zipWriter;
+		while (pendingAddFileCalls.size) {
+			await Promise.allSettled(Array.from(pendingAddFileCalls));
 		}
-		let promiseAddFile;
-		let nameAdded;
+		let resolveAppendZip;
+		const promiseAppendZip = new Promise(resolve => resolveAppendZip = resolve);
+		pendingAddFileCalls.add(promiseAppendZip);
+		const appendedFilenames = [];
+		let releaseLockWriter;
 		try {
-			name = name.trim();
-			if (getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY) && !name.endsWith(DIRECTORY_SIGNATURE)) {
-				name += DIRECTORY_SIGNATURE;
+			reader = new GenericReader(reader);
+			await initStream(reader);
+			if (reader.size === UNDEFINED_VALUE || !reader.readUint8Array) {
+				reader = new BlobReader(await streamToBlob(reader.readable));
+				await initStream(reader);
 			}
-			if (zipWriter.filenames.has(name)) {
-				throw new Error(ERR_DUPLICATED_NAME);
+			const { ZipReader } = await import("./zip-reader.js");
+			const zipReader = new ZipReader(reader);
+			const entries = await zipReader.getEntries();
+			await zipReader.close();
+			await initStream(zipWriter.writer);
+			const { directoryOffset } = zipReader;
+			entries.forEach(({ filename }) => {
+				if (filenames.has(filename)) {
+					throw new Error(ERR_DUPLICATED_NAME);
+				}
+				filenames.add(filename);
+				appendedFilenames.push(filename);
+			});
+			zipWriter.writerLocked = true;
+			const { lockWriter } = zipWriter;
+			zipWriter.lockWriter = new Promise(resolve => releaseLockWriter = () => {
+				zipWriter.writerLocked = false;
+				resolve();
+			});
+			await lockWriter;
+			if (zipWriter.addSplitZipSignature) {
+				delete zipWriter.addSplitZipSignature;
+				if (!await startsWithSplitZipSignature(reader)) {
+					await writeData(zipWriter.writer, getSplitZipSignatureArray());
+					zipWriter.offset += SPLIT_ZIP_FILE_SIGNATURE_LENGTH;
+				}
 			}
-			zipWriter.filenames.add(name);
-			nameAdded = true;
-			promiseAddFile = addFile(zipWriter, name, reader, options);
-			pendingAddFileCalls.add(promiseAddFile);
-			return await promiseAddFile;
+			const entryPositions = await copyZipData(zipWriter, reader, entries, directoryOffset);
+			entries.forEach(entry => {
+				const {
+					version,
+					rawLastModDate,
+					rawFilename,
+					bitFlag,
+					encrypted,
+					uncompressedSize,
+					compressedSize,
+					extraFieldZip64
+				} = entry;
+				let {
+					compressionMethod,
+					rawExtraField,
+				} = entry;
+				const { level, languageEncodingFlag, dataDescriptor } = bitFlag;
+				rawExtraField = removeExtraFieldZip64(rawExtraField || EMPTY_UINT8_ARRAY);
+				if (entry.extraFieldAES) {
+					compressionMethod = COMPRESSION_METHOD_AES;
+				}
+				const extraFieldLength = getLength(rawExtraField);
+				const zip64UncompressedSize = Boolean(extraFieldZip64) && extraFieldZip64.uncompressedSize !== UNDEFINED_VALUE;
+				const zip64CompressedSize = Boolean(extraFieldZip64) && extraFieldZip64.compressedSize !== UNDEFINED_VALUE;
+				const bitFlagValue = (getBitFlag(level, languageEncodingFlag, dataDescriptor, encrypted, compressionMethod) & ~BITFLAG_LEVEL) | (level << 1);
+				const {
+					headerArray,
+					headerView
+				} = getHeaderArrayData({
+					version,
+					bitFlag: bitFlagValue,
+					compressionMethod,
+					uncompressedSize,
+					compressedSize,
+					rawLastModDate,
+					rawFilename,
+					zip64CompressedSize,
+					zip64UncompressedSize,
+					extraFieldLength
+				});
+				const { crc32 } = entry;
+				if (crc32 !== UNDEFINED_VALUE) {
+					setUint32(headerView, HEADER_OFFSET_SIGNATURE, crc32);
+				}
+				const { offset, diskNumberStart } = entryPositions.get(entry);
+				Object.assign(entry, {
+					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,
+					rawExtraField,
+					rawCentralExtraField: EMPTY_UINT8_ARRAY,
+					extendedTimestamp: false,
+					headerArray,
+					headerView
+				});
+				fileEntries.set(entry.filename, entry);
+			});
 		} catch (error) {
-			if (nameAdded) {
-				zipWriter.filenames.delete(name);
-			}
+			appendedFilenames.forEach(filename => filenames.delete(filename));
 			throw error;
 		} finally {
-			pendingAddFileCalls.delete(promiseAddFile);
-			const pendingEntry = pendingEntries.shift();
-			if (pendingEntry) {
-				pendingEntry();
-			} else {
-				workers--;
+			resolveAppendZip();
+			pendingAddFileCalls.delete(promiseAppendZip);
+			if (releaseLockWriter) {
+				releaseLockWriter();
 			}
 		}
 	}
 
+	add(name = "", reader, options = {}) {
+		const zipWriter = this;
+		const { pendingAddFileCalls } = zipWriter;
+		const promiseAddFile = addFileEntry(zipWriter, name, reader, options);
+		pendingAddFileCalls.add(promiseAddFile);
+		const deletePendingAddFileCall = () => pendingAddFileCalls.delete(promiseAddFile);
+		Promise.prototype.then.call(promiseAddFile, deletePendingAddFileCall, deletePendingAddFileCall);
+		return watchPromiseError(zipWriter, promiseAddFile);
+	}
+
 	remove(entry) {
 		const { filenames, fileEntries } = this;
 		// deno-lint-ignore valid-typeof
@@ -482,6 +483,19 @@ class ZipWriter {
 		while (pendingAddFileCalls.size) {
 			await Promise.allSettled(Array.from(pendingAddFileCalls));
 		}
+		await Promise.allSettled(zipWriter.pendingErrors.map(watcher => watcher.recorded));
+		const unobservedWatchers = zipWriter.pendingErrors.filter(watcher => watcher.error && !watcher.observed);
+		if (unobservedWatchers.length) {
+			const unobservedErrors = unobservedWatchers.map(watcher => watcher.error);
+			unobservedWatchers.forEach(watcher => watcher.observed = true);
+			const [error] = unobservedErrors;
+			try {
+				error.entryErrors = unobservedErrors;
+			} catch {
+				// ignored
+			}
+			throw error;
+		}
 		await closeFile(zipWriter, comment, options);
 		const preventClose = !ownsWritable(writer) && getOptionValue(zipWriter, options, OPTION_PREVENT_CLOSE);
 		if (!preventClose) {
@@ -516,11 +530,7 @@ class ZipWriterStream {
 			try {
 				await zipWriter.close();
 			} catch (error) {
-				try {
-					await zipWriter.writer.writable.abort(error);
-				} catch {
-					// ignored
-				}
+				await abortWritable(zipWriter, error);
 			}
 		}
 	}
@@ -537,8 +547,89 @@ class ZipWriterStream {
 	}
 
 	async close(comment = UNDEFINED_VALUE, options = {}) {
-		await Promise.all(Array.from(this.pendingAddFileCalls));
-		return this.zipWriter.close(comment, options);
+		const { zipWriter } = this;
+		const results = await Promise.allSettled(Array.from(this.pendingAddFileCalls));
+		const entryErrors = results.filter(result => result.status == "rejected").map(result => result.reason);
+		if (entryErrors.length) {
+			const [error] = entryErrors;
+			try {
+				error.entryErrors = entryErrors;
+			} catch {
+				// ignored
+			}
+			await abortWritable(zipWriter, error);
+			throw error;
+		}
+		try {
+			return await zipWriter.close(comment, options);
+		} catch (error) {
+			await abortWritable(zipWriter, error);
+			throw error;
+		}
+	}
+}
+
+class WatchedPromise extends Promise {
+
+	then(onFulfilled, onRejected) {
+		const { watcher } = this;
+		if (watcher) {
+			watcher.observed = true;
+		}
+		return super.then(onFulfilled, onRejected);
+	}
+}
+
+function watchPromiseError(zipWriter, promise) {
+	const watchedPromise = new WatchedPromise((resolve, reject) => Promise.prototype.then.call(promise, resolve, reject));
+	const watcher = {};
+	watchedPromise.watcher = watcher;
+	watcher.recorded = Promise.prototype.then.call(watchedPromise, UNDEFINED_VALUE, error => watcher.error = error);
+	zipWriter.pendingErrors.push(watcher);
+	return watchedPromise;
+}
+
+async function prependZipEntries(zipWriter, reader) {
+	if (zipWriter.filenames.size) {
+		throw new Error(ERR_ZIP_NOT_EMPTY);
+	}
+	await zipWriter.appendZipEntries(reader);
+}
+
+async function addFileEntry(zipWriter, name, reader, options) {
+	options = Object.assign({}, options);
+	if (getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY) && !name.endsWith(DIRECTORY_SIGNATURE)) {
+		name += DIRECTORY_SIGNATURE;
+	}
+	if (zipWriter.filenames.has(name)) {
+		throw new Error(ERR_DUPLICATED_NAME);
+	}
+	zipWriter.filenames.add(name);
+	if (workers < getConfiguration().maxWorkers) {
+		workers++;
+	} else {
+		await new Promise(resolve => pendingEntries.push(resolve));
+	}
+	try {
+		return await addFile(zipWriter, name, reader, options);
+	} catch (error) {
+		zipWriter.filenames.delete(name);
+		throw error;
+	} finally {
+		const pendingEntry = pendingEntries.shift();
+		if (pendingEntry) {
+			pendingEntry();
+		} else {
+			workers--;
+		}
+	}
+}
+
+async function abortWritable(zipWriter, error) {
+	try {
+		await zipWriter.writer.writable.abort(error);
+	} catch {
+		// ignored
 	}
 }
 
@@ -635,7 +726,6 @@ async function addFile(zipWriter, name, reader, options) {
 }
 
 function resolveAttributes(zipWriter, name, options) {
-	name = name.trim();
 	let msDosCompatible = getOptionValue(zipWriter, options, PROPERTY_NAME_MS_DOS_COMPATIBLE);
 	let versionMadeBy = getOptionValue(zipWriter, options, PROPERTY_NAME_VERSION_MADE_BY, msDosCompatible ? VERSION_MADE_BY_MSDOS : VERSION_MADE_BY_UNIX);
 	const executable = getOptionValue(zipWriter, options, PROPERTY_NAME_EXECUTABLE);
@@ -779,11 +869,12 @@ function resolveMetadata(zipWriter, name, options) {
 	if (getLength(rawComment) > MAX_16_BITS) {
 		throw new Error(ERR_INVALID_ENTRY_COMMENT);
 	}
-	const version = getOptionValue(zipWriter, options, PROPERTY_NAME_VERSION, VERSION_DEFLATE);
-	if (version > MAX_16_BITS) {
+	const version = getOptionValue(zipWriter, options, PROPERTY_NAME_VERSION);
+	if (version !== UNDEFINED_VALUE && version > MAX_16_BITS) {
 		throw new Error(ERR_INVALID_VERSION);
 	}
 	const lastModDate = getDateOptionValue(zipWriter, options, PROPERTY_NAME_LAST_MODIFICATION_DATE, new Date());
+	const rawLastModDate = getOptionValue(zipWriter, options, PROPERTY_NAME_RAW_LAST_MODIFICATION_DATE);
 	const lastAccessDate = getDateOptionValue(zipWriter, options, PROPERTY_NAME_LAST_ACCESS_DATE);
 	const creationDate = getDateOptionValue(zipWriter, options, PROPERTY_NAME_CREATION_DATE);
 	const internalFileAttributes = getAliasedOptionValue(zipWriter, options, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES, PROPERTY_NAME_DEPRECATED_INTERNAL_FILE_ATTRIBUTES, 0);
@@ -827,7 +918,7 @@ function resolveMetadata(zipWriter, name, options) {
 	if (bufferedWrite && dataDescriptor === UNDEFINED_VALUE) {
 		dataDescriptor = false;
 	}
-	if (dataDescriptor === UNDEFINED_VALUE || zipCrypto) {
+	if (dataDescriptor === UNDEFINED_VALUE || (zipCrypto && !passThrough)) {
 		dataDescriptor = true;
 	}
 	if (level !== UNDEFINED_VALUE && level != 6) {
@@ -839,6 +930,7 @@ function resolveMetadata(zipWriter, name, options) {
 	}
 	const rawExtraField = serializeExtraField(options[PROPERTY_NAME_EXTRA_FIELD]);
 	const rawLocalExtraField = serializeExtraField(options[OPTION_LOCAL_EXTRA_FIELD]);
+	const rawCentralExtraField = serializeExtraField(options[OPTION_CENTRAL_EXTRA_FIELD]);
 	return {
 		comment,
 		resolvedOptions: {
@@ -846,6 +938,7 @@ function resolveMetadata(zipWriter, name, options) {
 			rawComment,
 			version,
 			lastModDate,
+			rawLastModDate,
 			lastAccessDate,
 			creationDate,
 			internalFileAttributes,
@@ -873,7 +966,8 @@ function resolveMetadata(zipWriter, name, options) {
 			dataDescriptor,
 			zip64,
 			rawExtraField,
-			rawLocalExtraField
+			rawLocalExtraField,
+			rawCentralExtraField
 		}
 	};
 }
@@ -1015,7 +1109,6 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 		let { name } = entry;
 		const { size } = entry;
 		const options = Object.assign({}, entry.options);
-		name = name.trim();
 		if (getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY) && !name.endsWith(DIRECTORY_SIGNATURE)) {
 			name += DIRECTORY_SIGNATURE;
 		}
@@ -1121,10 +1214,8 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		}
 		await initStream(fileWriter);
 		const diskOffset = getDiskOffset(writer);
-		if (zipWriter.addSplitZipSignature) {
-			delete zipWriter.addSplitZipSignature;
-			await writeData(writer, getSplitZipSignatureArray());
-			zipWriter.offset += SPLIT_ZIP_FILE_SIGNATURE_LENGTH;
+		if (zipWriter.addSplitZipSignature && !bufferedWrite) {
+			await writeSplitZipSignature(zipWriter, writer);
 		}
 		if (usdz && !bufferedWrite) {
 			appendExtraFieldUSDZ(entryInfo, zipWriter.offset - diskOffset);
@@ -1151,6 +1242,9 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		if (bufferedWrite) {
 			await Promise.all([fileWriter.writable.getWriter().close(), lockPreviousFileEntry]);
 			await requestLockWriter();
+			if (zipWriter.addSplitZipSignature) {
+				await writeSplitZipSignature(zipWriter, writer);
+			}
 			writingBufferedEntryData = true;
 			writerSizeBeforeEntry = writer.size;
 			await skipDiskIfNeeded();
@@ -1270,6 +1364,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		versionMadeBy,
 		rawComment,
 		rawExtraField,
+		rawCentralExtraField,
 		useWebWorkers,
 		transferStreams,
 		onstart,
@@ -1313,6 +1408,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 		rawExtraFieldUnix,
 		rawExtraFieldAES,
 		rawExtraField,
+		rawCentralExtraField,
 		extendedTimestamp,
 		msDosCompatible,
 		internalFileAttributes,
@@ -1422,6 +1518,7 @@ function getHeaderInfo(options) {
 	const {
 		rawFilename,
 		lastModDate,
+		rawLastModDate: rawLastModDateOption,
 		lastAccessDate,
 		creationDate,
 		level,
@@ -1555,6 +1652,9 @@ function getHeaderInfo(options) {
 	if (compressionMethod === UNDEFINED_VALUE) {
 		compressionMethod = compressed ? COMPRESSION_METHOD_DEFLATE : COMPRESSION_METHOD_STORE;
 	}
+	if (version === UNDEFINED_VALUE) {
+		version = compressionMethod == COMPRESSION_METHOD_STORE && !directory && !encrypted ? VERSION_STORE : VERSION_DEFLATE;
+	}
 	const { codecVersionNeeded } = options;
 	if (compressed && codecVersionNeeded !== UNDEFINED_VALUE) {
 		version = version > codecVersionNeeded ? version : codecVersionNeeded;
@@ -1587,6 +1687,7 @@ function getHeaderInfo(options) {
 		compressionMethod,
 		uncompressedSize,
 		lastModDate: dosLastModDate < MIN_DATE ? MIN_DATE : dosLastModDate > MAX_DATE ? MAX_DATE : dosLastModDate,
+		rawLastModDate: rawLastModDateOption,
 		rawFilename,
 		zip64CompressedSize,
 		zip64UncompressedSize,
@@ -1793,9 +1894,9 @@ function updateLocalHeader({
 
 async function closeFile(zipWriter, comment, options) {
 	const directoryDataLength = createDirectoryRecords(zipWriter.fileEntries);
-	const { directoryStart, directoryArray } = await writeDirectoryRecords(zipWriter, directoryDataLength, options);
+	const { directoryStart, directoryEnd, directoryArray } = await writeDirectoryRecords(zipWriter, directoryDataLength, options);
 	const signatureLength = await writeDigitalSignatureRecord(zipWriter, directoryArray, options);
-	await writeEndOfDirectoryRecord(zipWriter, comment, options, { directoryStart, directoryDataLength, signatureLength });
+	await writeEndOfDirectoryRecord(zipWriter, comment, options, { directoryStart, directoryEnd, directoryDataLength, signatureLength });
 }
 
 function createDirectoryRecords(files) {
@@ -1808,6 +1909,7 @@ function createDirectoryRecords(files) {
 			rawExtraFieldNTFS,
 			rawExtraFieldUnix,
 			rawExtraField,
+			rawCentralExtraField,
 			extendedTimestamp,
 			extraFieldExtendedTimestampFlag,
 			lastModDate,
@@ -1862,7 +1964,8 @@ function createDirectoryRecords(files) {
 			rawExtraFieldNTFS,
 			rawExtraFieldUnix,
 			rawExtraFieldTimestamp,
-			rawExtraField);
+			rawExtraField,
+			rawCentralExtraField);
 		if (extraFieldLength > MAX_16_BITS) {
 			throw new Error(ERR_INVALID_EXTRAFIELD_DATA);
 		}
@@ -1879,6 +1982,7 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 	let directoryDiskOffset = 0;
 	let directoryStartDiskNumber = getDiskNumber(writer);
 	let directoryStartDiskOffset = getDiskOffset(writer);
+	let directoryEndDiskEntriesLength = 0;
 	for (const [indexFileEntry, fileEntry] of Array.from(fileEntries.values()).entries()) {
 		const {
 			offset: fileEntryOffset,
@@ -1889,6 +1993,7 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 			rawExtraFieldNTFS,
 			rawExtraFieldUnix,
 			rawExtraField,
+			rawCentralExtraField,
 			rawComment,
 			versionMadeBy,
 			headerArray,
@@ -1903,11 +2008,12 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 			uncompressedSize,
 			compressedSize
 		} = fileEntry;
-		const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField);
+		const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, 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));
 			directoryDiskOffset = offset;
+			directoryEndDiskEntriesLength = 0;
 			await writer.closeDisk();
 		}
 		if (indexFileEntry == 0) {
@@ -1940,9 +2046,11 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 		directoryRecord.writeBytes(rawExtraFieldNTFS);
 		directoryRecord.writeBytes(rawExtraFieldUnix);
 		directoryRecord.writeBytes(rawExtraField);
+		directoryRecord.writeBytes(rawCentralExtraField);
 		directoryRecord.writeBytes(rawComment);
 		arraySet(directoryArray, directoryRecord.array, offset);
 		offset += directoryRecordLength;
+		directoryEndDiskEntriesLength++;
 		if (options.onprogress) {
 			try {
 				await options.onprogress(indexFileEntry + 1, fileEntries.size, new Entry(fileEntry));
@@ -1954,6 +2062,7 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 	await writeData(writer, directoryDiskOffset ? directoryArray.slice(directoryDiskOffset) : directoryArray);
 	return {
 		directoryStart: { diskNumber: directoryStartDiskNumber, diskOffset: directoryStartDiskOffset },
+		directoryEnd: { diskNumber: getDiskNumber(writer), entriesLength: directoryEndDiskEntriesLength },
 		directoryArray
 	};
 }
@@ -1982,16 +2091,20 @@ async function writeDigitalSignatureRecord(zipWriter, directoryArray, options) {
 
 async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 	const { writer } = zipWriter;
-	const { directoryStart, signatureLength } = cdInfo;
+	const { directoryStart, directoryEnd, signatureLength } = cdInfo;
 	let { directoryDataLength } = cdInfo;
 	let fileEntriesLength = zipWriter.fileEntries.size;
 	let diskNumber = directoryStart.diskNumber;
 	let directoryOffset = getSegmentOffset(zipWriter, directoryStart);
+	const commentLength = getLength(comment);
+	if (commentLength > MAX_16_BITS) {
+		throw new Error(ERR_INVALID_COMMENT);
+	}
+	let zip64 = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIP64);
 	let lastDiskNumber = getDiskNumber(writer);
-	if (exceedsAvailableSize(writer, END_OF_CENTRAL_DIR_LENGTH)) {
+	if (exceedsAvailableSize(writer, (zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH) + commentLength)) {
 		lastDiskNumber++;
 	}
-	let zip64 = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIP64);
 	if (directoryOffset >= MAX_32_BITS || directoryDataLength >= MAX_32_BITS || fileEntriesLength >= MAX_16_BITS || lastDiskNumber >= MAX_16_BITS) {
 		if (zip64 === false) {
 			throw new Error(ERR_UNSUPPORTED_FORMAT);
@@ -1999,15 +2112,12 @@ async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 			zip64 = true;
 		}
 	}
-	const commentLength = getLength(comment);
-	if (commentLength > MAX_16_BITS) {
-		throw new Error(ERR_INVALID_COMMENT);
-	}
 	const endOfdirectoryRecord = createRecordWriter(zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
 	if (exceedsAvailableSize(writer, getLength(endOfdirectoryRecord.array) + commentLength)) {
 		await writer.closeDisk();
 	}
 	lastDiskNumber = getDiskNumber(writer);
+	let diskFileEntriesLength = lastDiskNumber == directoryEnd.diskNumber ? directoryEnd.entriesLength : 0;
 	if (zip64) {
 		endOfdirectoryRecord.writeUint32(ZIP64_END_OF_CENTRAL_DIR_SIGNATURE);
 		endOfdirectoryRecord.writeUint64(44);
@@ -2015,7 +2125,7 @@ async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 		endOfdirectoryRecord.writeUint16(45);
 		endOfdirectoryRecord.writeUint32(lastDiskNumber);
 		endOfdirectoryRecord.writeUint32(diskNumber);
-		endOfdirectoryRecord.writeUint64(fileEntriesLength);
+		endOfdirectoryRecord.writeUint64(diskFileEntriesLength);
 		endOfdirectoryRecord.writeUint64(fileEntriesLength);
 		endOfdirectoryRecord.writeUint64(directoryDataLength);
 		endOfdirectoryRecord.writeUint64(directoryOffset);
@@ -2028,6 +2138,7 @@ async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 			lastDiskNumber = MAX_16_BITS;
 			diskNumber = MAX_16_BITS;
 		}
+		diskFileEntriesLength = MAX_16_BITS;
 		fileEntriesLength = MAX_16_BITS;
 		directoryOffset = MAX_32_BITS;
 		directoryDataLength = MAX_32_BITS;
@@ -2035,7 +2146,7 @@ async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
 	endOfdirectoryRecord.writeUint32(END_OF_CENTRAL_DIR_SIGNATURE);
 	endOfdirectoryRecord.writeUint16(lastDiskNumber);
 	endOfdirectoryRecord.writeUint16(diskNumber);
-	endOfdirectoryRecord.writeUint16(fileEntriesLength);
+	endOfdirectoryRecord.writeUint16(diskFileEntriesLength);
 	endOfdirectoryRecord.writeUint16(fileEntriesLength);
 	endOfdirectoryRecord.writeUint32(directoryDataLength);
 	endOfdirectoryRecord.writeUint32(directoryOffset);
@@ -2134,9 +2245,21 @@ async function copyZipData(zipWriter, reader, entries, directoryOffset) {
 async function copyData(zipWriter, reader, offset, size) {
 	if (size > 0) {
 		const { writer } = zipWriter;
-		await createReadable(reader, { offset, size }).pipeTo(writer.writable, { preventClose: true, preventAbort: true });
-		writer.size += size;
-		zipWriter.offset += size;
+		let copiedLength = 0;
+		try {
+			await flushBufferedData(createReadable(reader, { offset, size }), writer, UNDEFINED_VALUE, chunkLength => copiedLength += chunkLength);
+		} catch (error) {
+			zipWriter.hasCorruptedEntries = true;
+			try {
+				error.corruptedEntry = true;
+			} catch {
+				// ignored
+			}
+			throw error;
+		} finally {
+			writer.size += copiedLength;
+			zipWriter.offset += copiedLength;
+		}
 	}
 }
 
@@ -2161,6 +2284,12 @@ function getSplitZipSignatureArray() {
 	return signatureArray;
 }
 
+async function writeSplitZipSignature(zipWriter, writer) {
+	delete zipWriter.addSplitZipSignature;
+	await writeData(writer, getSplitZipSignatureArray());
+	zipWriter.offset += SPLIT_ZIP_FILE_SIGNATURE_LENGTH;
+}
+
 async function writeData(writer, array) {
 	const { writable } = writer;
 	const streamWriter = writable.getWriter();