@zip.js/zip.js 2.8.56 → 2.8.58

package/dist/zip-core.js

@@ -101,6 +101,7 @@
 	const FILE_ATTR_UNIX_SETGID_MASK = 0o2000;
 	const FILE_ATTR_UNIX_STICKY_MASK = 0o1000;
 
+	const VERSION_STORE = 0x0A;
 	const VERSION_DEFLATE = 0x14;
 	const VERSION_ZIP64 = 0x2D;
 	const VERSION_AES = 0x33;
@@ -4707,6 +4708,7 @@
 	const ERR_INVALID_STRICTNESS = "Invalid strictness (must be 'strict', 'balanced' or 'tolerant')";
 	const ERR_INVALID_FILENAME_VALIDATION = "Invalid filenameValidation (must be 'strict', 'balanced' or 'tolerant')";
 	const ERR_INVALID_MAX_APPENDED_DATA_SIZE = "Invalid maxAppendedDataSize (must be a number greater than or equal to 0)";
+	const ERR_UNSUPPORTED_UINT64 = "64-bit value exceeds Number.MAX_SAFE_INTEGER";
 	const DRIVE_LETTER_REGEXP = /^[a-zA-Z]:/;
 	const CHARSET_UTF8 = "utf-8";
 	const PROPERTY_NAME_UTF8_SUFFIX = "UTF8";
@@ -4729,6 +4731,7 @@
 			bytes: 8
 		}
 	};
+	const MAX_SAFE_UINT64 = BigInt(Number.MAX_SAFE_INTEGER);
 	const MAX_END_OF_CENTRAL_DIR_PROBES = 64;
 	const MAX_DEFLATE_EXPANSION_RATIO = 1032;
 	const CENTRAL_DIRECTORY_UNREACHABLE = 0;
@@ -4824,7 +4827,7 @@
 					zip64EndOfDirectoryVersion2 = getBigUint64(endOfDirectoryView, 4) > ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12;
 					if (zip64EndOfDirectoryVersion2) {
 						const extensibleDataLength = Math.min(
-							Number(getBigUint64(endOfDirectoryView, 4)) - (ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12),
+							getBigUint64(endOfDirectoryView, 4) - (ZIP64_END_OF_CENTRAL_DIR_LENGTH - 12),
 							reader.size - directoryDataOffset - ZIP64_END_OF_CENTRAL_DIR_LENGTH);
 						if (extensibleDataLength > 0) {
 							zip64EndOfDirectoryLength += extensibleDataLength;
@@ -4924,6 +4927,10 @@
 			const commentEncoding = getOptionValue$1(zipReader, options, OPTION_COMMENT_ENCODING);
 			const filenames = checkAmbiguity ? new Set() : UNDEFINED_VALUE;
 			let duplicateFilename;
+			const recoverWrappedFilesLength = !checkAmbiguity && !zip64EndOfDirectory;
+			if (!filesLength && recoverWrappedFilesLength) {
+				filesLength = getWrappedFilesLength(directoryView, directoryArray, offset);
+			}
 			for (let indexFile = 0; indexFile < filesLength; indexFile++) {
 				const fileEntry = new ZipEntry(reader, zipReader.options);
 				if (offset + CENTRAL_FILE_HEADER_LENGTH > directoryArray.length || getUint32$1(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE) {
@@ -5033,7 +5040,7 @@
 					internalFileAttribute: fileEntry.internalFileAttributes,
 					externalFileAttribute: fileEntry.externalFileAttributes,
 					executable,
-					directory: modeIsDir || upperIsDir || (msDosCompatible && msdosAttributes.directory) || (fileEntry.filename.endsWith(DIRECTORY_SIGNATURE) && !fileEntry.uncompressedSize),
+					directory: modeIsDir || upperIsDir || (msDosCompatible && msdosAttributes.directory) || fileEntry.filename.endsWith(DIRECTORY_SIGNATURE),
 					zipCrypto: fileEntry.encrypted && !fileEntry.extraFieldAES
 				});
 				const entry = new Entry(fileEntry);
@@ -5046,6 +5053,9 @@
 					return arrayBufferPromise;
 				};
 				offset = endOffset;
+				if (indexFile == filesLength - 1 && recoverWrappedFilesLength) {
+					filesLength += getWrappedFilesLength(directoryView, directoryArray, offset);
+				}
 				const { onprogress } = options;
 				if (onprogress) {
 					try {
@@ -5204,6 +5214,7 @@
 				extraFieldLength,
 				filenameLength
 			} = localDirectory;
+			const dataOffset = localDirectory.dataOffset = localHeaderOffset + HEADER_SIZE + filenameLength + extraFieldLength;
 			const checkLocalDirectoryOption = getOptionValue$1(zipEntry, options, OPTION_CHECK_LOCAL_DIRECTORY);
 			const entryStrictness = getStrictness(options, zipEntry.options);
 			const checkLocalDirectory = getCheckLocalDirectory(checkLocalDirectoryOption, entryStrictness);
@@ -5257,7 +5268,6 @@
 					throw new Error(ERR_ENCRYPTED);
 				}
 			}
-			const dataOffset = localHeaderOffset + HEADER_SIZE + filenameLength + extraFieldLength;
 			if (dataOffset + compressedSize > reader.size) {
 				throw new Error(ERR_ENTRY_DATA_OUT_OF_BOUNDS);
 			}
@@ -5377,6 +5387,16 @@
 		return false;
 	}
 
+	function getWrappedFilesLength(directoryView, directoryArray, offset) {
+		let wrappedFilesLength = 0;
+		while (offset + CENTRAL_FILE_HEADER_LENGTH <= directoryArray.length && getUint32$1(directoryView, offset) == CENTRAL_FILE_HEADER_SIGNATURE) {
+			offset += CENTRAL_FILE_HEADER_LENGTH +
+				getUint16$1(directoryView, offset + 28) + getUint16$1(directoryView, offset + 30) + getUint16$1(directoryView, offset + 32);
+			wrappedFilesLength++;
+		}
+		return wrappedFilesLength % (MAX_16_BITS + 1) ? 0 : wrappedFilesLength;
+	}
+
 	function readDigitalSignature(signatureRecordArray) {
 		if (signatureRecordArray.length >= 6) {
 			const signatureRecordView = getDataView(signatureRecordArray);
@@ -5405,8 +5425,8 @@
 			const hashDataLength = getUint16$1(extensibleDataView, 26);
 			Object.assign(directoryEncryptionInfo, {
 				compressionMethod: getUint16$1(extensibleDataView, 0),
-				compressedSize: Number(getBigUint64(extensibleDataView, 2)),
-				uncompressedSize: Number(getBigUint64(extensibleDataView, 10)),
+				compressedSize: getBigUint64(extensibleDataView, 2),
+				uncompressedSize: getBigUint64(extensibleDataView, 10),
 				encryptionAlgorithm: getUint16$1(extensibleDataView, 18),
 				bitLength: getUint16$1(extensibleDataView, 20),
 				flags: getUint16$1(extensibleDataView, 22),
@@ -5549,10 +5569,11 @@
 		const computedCrc32View = getDataView(new Uint8Array(4));
 		computedCrc32View.setUint32(0, computedCrc32.get(), true);
 		const nameCrc32 = getUint32$1(extraFieldView, 1);
+		const version = getUint8(extraFieldView, 0);
 		Object.assign(extraFieldUnicode, {
-			version: getUint8(extraFieldView, 0),
+			version,
 			[propertyName]: decodeText(extraFieldUnicode.data.subarray(5)),
-			valid: !fileEntry.bitFlag.languageEncodingFlag && nameCrc32 == getUint32$1(computedCrc32View, 0)
+			valid: version == 1 && !fileEntry.bitFlag.languageEncodingFlag && nameCrc32 == getUint32$1(computedCrc32View, 0)
 		});
 		if (extraFieldUnicode.valid) {
 			directory[propertyName] = extraFieldUnicode[propertyName];
@@ -6021,7 +6042,8 @@
 
 	function getDate(timeRaw) {
 		const date = (timeRaw & 0xffff0000) >> 16, time = timeRaw & MAX_16_BITS;
-		return new Date(1980 + ((date & 0xFE00) >> 9), ((date & 0x01E0) >> 5) - 1, date & 0x001F, (time & 0xF800) >> 11, (time & 0x07E0) >> 5, (time & 0x001F) * 2, 0);
+		const result = new Date(1980 + ((date & 0xFE00) >> 9), ((date & 0x01E0) >> 5) - 1, date & 0x001F, (time & 0xF800) >> 11, (time & 0x07E0) >> 5, (time & 0x001F) * 2, 0);
+		return result < MIN_DATE ? MIN_DATE : result;
 	}
 
 	function getDateNTFS(timeRaw) {
@@ -6041,7 +6063,11 @@
 	}
 
 	function getBigUint64(view, offset) {
-		return Number(view.getBigUint64(offset, true));
+		const value = view.getBigUint64(offset, true);
+		if (value > MAX_SAFE_UINT64) {
+			throw new Error(ERR_UNSUPPORTED_UINT64);
+		}
+		return Number(value);
 	}
 
 	var zipReader = /*#__PURE__*/Object.freeze({
@@ -6070,6 +6096,7 @@
 		ERR_UNSAFE_FILENAME: ERR_UNSAFE_FILENAME,
 		ERR_UNSUPPORTED_COMPRESSION: ERR_UNSUPPORTED_COMPRESSION$1,
 		ERR_UNSUPPORTED_ENCRYPTION: ERR_UNSUPPORTED_ENCRYPTION,
+		ERR_UNSUPPORTED_UINT64: ERR_UNSUPPORTED_UINT64,
 		ERR_WORKER_STARTUP_TIMEOUT: ERR_WORKER_STARTUP_TIMEOUT,
 		ZipReader: ZipReader,
 		ZipReaderStream: ZipReaderStream
@@ -6169,153 +6196,150 @@
 				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 Promise.resolve().then(function () { return zipReader; });
-			const zipReader$1 = new ZipReader(reader);
-			const entries = await zipReader$1.getEntries();
-			await zipReader$1.close();
-			await initStream(this.writer);
-			const { directoryOffset } = zipReader$1;
-			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,
-					zip64
-				} = 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 = rawExtraField || EMPTY_UINT8_ARRAY;
-				if (entry.extraFieldAES) {
-					compressionMethod = COMPRESSION_METHOD_AES;
-				}
-				const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField);
-				const zip64UncompressedSize = zip64 && uncompressedSize >= MAX_32_BITS;
-				const zip64CompressedSize = zip64 && compressedSize >= MAX_32_BITS;
-				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;
-				}
-				if (zipWriter.filenames.has(name)) {
-					throw new Error(ERR_DUPLICATED_NAME);
-				}
-				zipWriter.filenames.add(name);
-				nameAdded = true;
-				promiseAddFile = addFile(zipWriter, name, reader, options);
-				pendingAddFileCalls.add(promiseAddFile);
-				return await promiseAddFile;
-			} catch (error) {
-				if (nameAdded) {
-					zipWriter.filenames.delete(name);
+				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();
+				await zipReader$1.close();
+				await initStream(zipWriter.writer);
+				const { directoryOffset } = zipReader$1;
+				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;
+					}
 				}
+				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,
+						extendedTimestamp: false,
+						headerArray,
+						headerView
+					});
+					fileEntries.set(entry.filename, entry);
+				});
+			} catch (error) {
+				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
@@ -6346,6 +6370,19 @@
 			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) {
@@ -6380,11 +6417,7 @@
 				try {
 					await zipWriter.close();
 				} catch (error) {
-					try {
-						await zipWriter.writer.writable.abort(error);
-					} catch {
-						// ignored
-					}
+					await abortWritable(zipWriter, error);
 				}
 			}
 		}
@@ -6401,8 +6434,90 @@
 		}
 
 		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);
+		name = name.trim();
+		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
 		}
 	}
 
@@ -6605,11 +6720,12 @@
 		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);
@@ -6653,7 +6769,7 @@
 		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) {
@@ -6672,6 +6788,7 @@
 				rawComment,
 				version,
 				lastModDate,
+				rawLastModDate,
 				lastAccessDate,
 				creationDate,
 				internalFileAttributes,
@@ -6789,6 +6906,10 @@
 				maximumCompressedSize = contentSize === UNDEFINED_VALUE ? getMaximumCompressedSize(uncompressedSize) + encryptionOverhead : contentSize;
 			}
 		}
+		const emptyEntry = !encryptedEntry && (!hasContent || (contentSize === 0 && !passThrough)) && !isCompressed(compressionMethod, level);
+		if (emptyEntry && !zipCrypto && getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR) === UNDEFINED_VALUE) {
+			dataDescriptor = false;
+		}
 		const zip64UncompressedSize = zip64Enabled || uncompressedSize >= MAX_32_BITS;
 		const zip64CompressedSize = zip64Enabled || maximumCompressedSize >= MAX_32_BITS;
 		if (zip64UncompressedSize || zip64CompressedSize) {
@@ -6803,6 +6924,7 @@
 			maximumCompressedSize,
 			resolvedOptions: {
 				dataDescriptor,
+				emptyEntry,
 				zip64,
 				zip64UncompressedSize,
 				zip64CompressedSize,
@@ -6822,6 +6944,7 @@
 		const {
 			keepOrder,
 			dataDescriptor,
+			emptyEntry,
 			signal
 		} = options;
 		const {
@@ -6846,7 +6969,7 @@
 				lockPreviousFileEntry = previousFileEntry && previousFileEntry.lockFileEntry;
 				requestLockCurrentFileEntry();
 			}
-			if (options.bufferedWrite || !keepOrder || zipWriter.writerLocked || zipWriter.bufferedWrites || !dataDescriptor) {
+			if (options.bufferedWrite || !keepOrder || zipWriter.writerLocked || zipWriter.bufferedWrites || (!dataDescriptor && !emptyEntry)) {
 				bufferedWrite = true;
 				zipWriter.bufferedWrites++;
 				if (options.createTempStream) {
@@ -6862,10 +6985,8 @@
 			}
 			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);
@@ -6892,6 +7013,9 @@
 			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();
@@ -7163,6 +7287,7 @@
 		const {
 			rawFilename,
 			lastModDate,
+			rawLastModDate: rawLastModDateOption,
 			lastAccessDate,
 			creationDate,
 			level,
@@ -7268,8 +7393,8 @@
 		try {
 			const { uid, gid, unixExtraFieldType } = options;
 			if (unixExtraFieldType == INFOZIP_EXTRA_FIELD_TYPE && (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE)) {
-				const uidBytes = packUnixId(uid);
-				const gidBytes = packUnixId(gid);
+				const uidBytes = packUnixId(uid === UNDEFINED_VALUE ? 0 : uid);
+				const gidBytes = packUnixId(gid === UNDEFINED_VALUE ? 0 : gid);
 				const payloadLength = 3 + uidBytes.length + gidBytes.length;
 				const extraFieldUnix = createRecordWriter(4 + payloadLength);
 				extraFieldUnix.writeUint16(EXTRAFIELD_TYPE_INFOZIP);
@@ -7296,6 +7421,9 @@
 		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;
@@ -7328,6 +7456,7 @@
 			compressionMethod,
 			uncompressedSize,
 			lastModDate: dosLastModDate < MIN_DATE ? MIN_DATE : dosLastModDate > MAX_DATE ? MAX_DATE : dosLastModDate,
+			rawLastModDate: rawLastModDateOption,
 			rawFilename,
 			zip64CompressedSize,
 			zip64UncompressedSize,
@@ -7400,18 +7529,14 @@
 	}
 
 	function packUnixId(id) {
-		if (id === UNDEFINED_VALUE) {
-			return EMPTY_UINT8_ARRAY;
-		} else {
-			const dataArray = new Uint8Array(4);
-			const dataView = getDataView(dataArray);
-			dataView.setUint32(0, id, true);
-			let length = 4;
-			while (length > 1 && dataArray[length - 1] === 0) {
-				length--;
-			}
-			return dataArray.subarray(0, length);
+		const dataArray = new Uint8Array(4);
+		const dataView = getDataView(dataArray);
+		dataView.setUint32(0, id, true);
+		let length = 4;
+		while (length > 1 && dataArray[length - 1] === 0) {
+			length--;
 		}
+		return dataArray.subarray(0, length);
 	}
 
 	function normalizeMsdosAttributes(msdosAttributesRaw, msdosAttributes) {
@@ -7538,9 +7663,9 @@
 
 	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) {
@@ -7624,6 +7749,7 @@
 		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,
@@ -7653,6 +7779,7 @@
 			if (exceedsAvailableSize(writer, offset + directoryRecordLength - directoryDiskOffset)) {
 				await writeData(writer, directoryArray.slice(directoryDiskOffset, offset));
 				directoryDiskOffset = offset;
+				directoryEndDiskEntriesLength = 0;
 				await writer.closeDisk();
 			}
 			if (indexFileEntry == 0) {
@@ -7688,6 +7815,7 @@
 			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));
@@ -7699,6 +7827,7 @@
 		await writeData(writer, directoryDiskOffset ? directoryArray.slice(directoryDiskOffset) : directoryArray);
 		return {
 			directoryStart: { diskNumber: directoryStartDiskNumber, diskOffset: directoryStartDiskOffset },
+			directoryEnd: { diskNumber: getDiskNumber(writer), entriesLength: directoryEndDiskEntriesLength },
 			directoryArray
 		};
 	}
@@ -7727,16 +7856,20 @@
 
 	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);
@@ -7744,15 +7877,12 @@
 				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);
@@ -7760,7 +7890,7 @@
 			endOfdirectoryRecord.writeUint16(45);
 			endOfdirectoryRecord.writeUint32(lastDiskNumber);
 			endOfdirectoryRecord.writeUint32(diskNumber);
-			endOfdirectoryRecord.writeUint64(fileEntriesLength);
+			endOfdirectoryRecord.writeUint64(diskFileEntriesLength);
 			endOfdirectoryRecord.writeUint64(fileEntriesLength);
 			endOfdirectoryRecord.writeUint64(directoryDataLength);
 			endOfdirectoryRecord.writeUint64(directoryOffset);
@@ -7773,6 +7903,7 @@
 				lastDiskNumber = MAX_16_BITS;
 				diskNumber = MAX_16_BITS;
 			}
+			diskFileEntriesLength = MAX_16_BITS;
 			fileEntriesLength = MAX_16_BITS;
 			directoryOffset = MAX_32_BITS;
 			directoryDataLength = MAX_32_BITS;
@@ -7780,7 +7911,7 @@
 		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);
@@ -7830,6 +7961,21 @@
 		return getUint32(getDataView(signatureArray), 0) == SPLIT_ZIP_FILE_SIGNATURE;
 	}
 
+	function removeExtraFieldZip64(rawExtraField) {
+		const rawExtraFieldView = getDataView(rawExtraField);
+		let offsetExtraField = 0;
+		while (offsetExtraField + 4 <= getLength(rawExtraField)) {
+			const size = 4 + getUint16(rawExtraFieldView, offsetExtraField + 2);
+			if (getUint16(rawExtraFieldView, offsetExtraField) == EXTRAFIELD_TYPE_ZIP64) {
+				return removeExtraFieldZip64(concat(
+					rawExtraField.subarray(0, offsetExtraField),
+					rawExtraField.subarray(Math.min(offsetExtraField + size, getLength(rawExtraField)))));
+			}
+			offsetExtraField += size;
+		}
+		return rawExtraField;
+	}
+
 	async function copyZipData(zipWriter, reader, entries, directoryOffset) {
 		const { writer } = zipWriter;
 		const entryPositions = new Map();
@@ -7864,9 +8010,21 @@
 	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;
+			}
 		}
 	}
 
@@ -7891,6 +8049,12 @@
 		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();
@@ -8638,6 +8802,7 @@
 	exports.ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH = ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH;
 	exports.ERR_UNSUPPORTED_ENCRYPTION_USDZ = ERR_UNSUPPORTED_ENCRYPTION_USDZ;
 	exports.ERR_UNSUPPORTED_FORMAT = ERR_UNSUPPORTED_FORMAT;
+	exports.ERR_UNSUPPORTED_UINT64 = ERR_UNSUPPORTED_UINT64;
 	exports.ERR_WORKER_STARTUP_TIMEOUT = ERR_WORKER_STARTUP_TIMEOUT;
 	exports.ERR_WRITER_NOT_INITIALIZED = ERR_WRITER_NOT_INITIALIZED;
 	exports.ERR_ZIP_NOT_EMPTY = ERR_ZIP_NOT_EMPTY;