@zip.js/zip.js 2.8.56 → 2.8.58

package/dist/zip-fs-core.js

@@ -100,6 +100,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;
@@ -3608,6 +3609,8 @@
 	 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 	 */
 
+
+	const ERR_WORKER_STARTUP_TIMEOUT = "Worker startup timeout";
 	let initModule = () => { };
 
 	async function supportsDeflate(config) {
@@ -4122,6 +4125,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";
@@ -4144,6 +4148,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;
@@ -4239,7 +4244,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;
@@ -4339,6 +4344,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$1(reader, zipReader.options);
 				if (offset + CENTRAL_FILE_HEADER_LENGTH > directoryArray.length || getUint32$1(directoryView, offset) != CENTRAL_FILE_HEADER_SIGNATURE) {
@@ -4448,7 +4457,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);
@@ -4461,6 +4470,9 @@
 					return arrayBufferPromise;
 				};
 				offset = endOffset;
+				if (indexFile == filesLength - 1 && recoverWrappedFilesLength) {
+					filesLength += getWrappedFilesLength(directoryView, directoryArray, offset);
+				}
 				const { onprogress } = options;
 				if (onprogress) {
 					try {
@@ -4526,6 +4538,46 @@
 		}
 	}
 
+	class ZipReaderStream {
+
+		constructor(options = {}) {
+			const { readable, writable } = new TransformStream();
+			const gen = new ZipReader(readable, options).getEntriesGenerator();
+			this.readable = new ReadableStream({
+				async pull(controller) {
+					const { done, value } = await gen.next();
+					if (done)
+						return controller.close();
+					const chunk = {
+						...value,
+						readable: (function () {
+							const { readable, writable } = new TransformStream();
+							if (value.getData) {
+								getData();
+								return readable;
+							}
+
+							async function getData() {
+								try {
+									await value.getData(writable);
+								} catch (error) {
+									try {
+										await writable.abort(error);
+									} catch {
+										// ignored
+									}
+								}
+							}
+						})()
+					};
+					delete chunk.getData;
+					controller.enqueue(chunk);
+				}
+			});
+			this.writable = writable;
+		}
+	}
+
 	let ZipEntry$1 = class ZipEntry {
 
 		constructor(reader, options) {
@@ -4579,6 +4631,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);
@@ -4632,7 +4685,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);
 			}
@@ -4752,6 +4804,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);
@@ -4780,8 +4842,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),
@@ -4924,10 +4986,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];
@@ -5396,7 +5459,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) {
@@ -5416,7 +5480,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({
@@ -5445,7 +5513,10 @@
 		ERR_UNSAFE_FILENAME: ERR_UNSAFE_FILENAME,
 		ERR_UNSUPPORTED_COMPRESSION: ERR_UNSUPPORTED_COMPRESSION$1,
 		ERR_UNSUPPORTED_ENCRYPTION: ERR_UNSUPPORTED_ENCRYPTION,
-		ZipReader: ZipReader
+		ERR_UNSUPPORTED_UINT64: ERR_UNSUPPORTED_UINT64,
+		ERR_WORKER_STARTUP_TIMEOUT: ERR_WORKER_STARTUP_TIMEOUT,
+		ZipReader: ZipReader,
+		ZipReaderStream: ZipReaderStream
 	});
 
 	/*
@@ -5542,153 +5613,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
@@ -5719,6 +5787,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) {
@@ -5728,6 +5809,63 @@
 		}
 	}
 
+	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 addFile(zipWriter, name, reader, options) {
 		const attributesInfo = resolveAttributes(zipWriter, name, options);
 		({ name } = attributesInfo);
@@ -5916,11 +6054,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);
@@ -5964,7 +6103,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) {
@@ -5983,6 +6122,7 @@
 				rawComment,
 				version,
 				lastModDate,
+				rawLastModDate,
 				lastAccessDate,
 				creationDate,
 				internalFileAttributes,
@@ -6100,6 +6240,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) {
@@ -6114,6 +6258,7 @@
 			maximumCompressedSize,
 			resolvedOptions: {
 				dataDescriptor,
+				emptyEntry,
 				zip64,
 				zip64UncompressedSize,
 				zip64CompressedSize,
@@ -6212,6 +6357,7 @@
 		const {
 			keepOrder,
 			dataDescriptor,
+			emptyEntry,
 			signal
 		} = options;
 		const {
@@ -6236,7 +6382,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) {
@@ -6252,10 +6398,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);
@@ -6282,6 +6426,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();
@@ -6553,6 +6700,7 @@
 		const {
 			rawFilename,
 			lastModDate,
+			rawLastModDate: rawLastModDateOption,
 			lastAccessDate,
 			creationDate,
 			level,
@@ -6658,8 +6806,8 @@
 		try {
 			const { uid, gid, unixExtraFieldType } = options;
 			if (unixExtraFieldType == INFOZIP_EXTRA_FIELD_TYPE$1 && (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);
@@ -6686,6 +6834,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;
@@ -6718,6 +6869,7 @@
 			compressionMethod,
 			uncompressedSize,
 			lastModDate: dosLastModDate < MIN_DATE ? MIN_DATE : dosLastModDate > MAX_DATE ? MAX_DATE : dosLastModDate,
+			rawLastModDate: rawLastModDateOption,
 			rawFilename,
 			zip64CompressedSize,
 			zip64UncompressedSize,
@@ -6790,18 +6942,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) {
@@ -6928,9 +7076,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) {
@@ -7014,6 +7162,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,
@@ -7043,6 +7192,7 @@
 			if (exceedsAvailableSize(writer, offset + directoryRecordLength - directoryDiskOffset)) {
 				await writeData(writer, directoryArray.slice(directoryDiskOffset, offset));
 				directoryDiskOffset = offset;
+				directoryEndDiskEntriesLength = 0;
 				await writer.closeDisk();
 			}
 			if (indexFileEntry == 0) {
@@ -7078,6 +7228,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));
@@ -7089,6 +7240,7 @@
 		await writeData(writer, directoryDiskOffset ? directoryArray.slice(directoryDiskOffset) : directoryArray);
 		return {
 			directoryStart: { diskNumber: directoryStartDiskNumber, diskOffset: directoryStartDiskOffset },
+			directoryEnd: { diskNumber: getDiskNumber(writer), entriesLength: directoryEndDiskEntriesLength },
 			directoryArray
 		};
 	}
@@ -7117,16 +7269,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);
@@ -7134,15 +7290,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);
@@ -7150,7 +7303,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);
@@ -7163,6 +7316,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;
@@ -7170,7 +7324,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);
@@ -7220,6 +7374,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();
@@ -7254,9 +7423,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;
+			}
 		}
 	}
 
@@ -7281,6 +7462,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();
@@ -7512,6 +7699,7 @@
 	const ERR_READABLE_CONSUMED = "Readable stream already consumed";
 	const ERR_INVALID_PASS_THROUGH = "Invalid passThrough option (use readerOptions.passThrough or set uncompressedSize for each entry)";
 	const ERR_INVALID_READER_OPTIONS = "Invalid readerOptions (must be an object)";
+	const ERR_ZIP_CRYPTO_LAST_MOD_DATE = "The last modification date of an entry encrypted with ZipCrypto cannot be changed when passThrough is set";
 	const ERR_ABORT_EXPORT = "zipjs-abort-export";
 	const ERR_ABORTED = "The operation was aborted";
 	const ABORT_ERROR_NAME = "AbortError";
@@ -8269,7 +8457,7 @@
 		} else if (writer.constructor == BlobWriter) {
 			return data.type == contentType;
 		} else if (writer.constructor == Data64URIWriter) {
-			return data.startsWith(writer.data);
+			return data.startsWith("data:" + (contentType || "") + ";base64,");
 		} else {
 			return true;
 		}
@@ -8379,6 +8567,7 @@
 				versionMadeBy,
 				comment,
 				lastModDate,
+				rawLastModDate,
 				creationDate,
 				lastAccessDate,
 				uncompressedSize,
@@ -8389,6 +8578,7 @@
 				extraFieldAES,
 				internalFileAttributes,
 				extraField,
+				bitFlag,
 				uid,
 				gid
 			} = child.data;
@@ -8426,6 +8616,16 @@
 					encryptionStrength,
 					compressionMethod
 				};
+				if (bitFlag) {
+					passThroughOptions.dataDescriptor = bitFlag.dataDescriptor;
+				}
+				const lastModDateOverride = childOptions.lastModDate === UNDEFINED_VALUE ? options.lastModDate : childOptions.lastModDate;
+				if (lastModDateOverride === UNDEFINED_VALUE) {
+					passThroughOptions.rawLastModDate = rawLastModDate;
+				} else if (zipCrypto && (!bitFlag || bitFlag.dataDescriptor) && lastModDateOverride instanceof Date &&
+					getDosTimeHighByte(lastModDateOverride) != ((rawLastModDate >>> 8) & MAX_8_BITS)) {
+					throw new Error(ERR_ZIP_CRYPTO_LAST_MOD_DATE);
+				}
 			}
 		}
 		const entryOptions = Object.assign({ lastModDate: child.defaultLastModDate }, zipEntryMetadata, options, childOptions, passThroughOptions, { directory: child.directory });
@@ -8435,6 +8635,16 @@
 		return { name, entryOptions };
 	}
 
+	function getDosTimeHighByte(lastModDate) {
+		let dosLastModDate = new Date(Math.ceil(Math.floor(lastModDate.getTime() / 1000) / 2) * 2000);
+		if (dosLastModDate < MIN_DATE) {
+			dosLastModDate = MIN_DATE;
+		} else if (dosLastModDate > MAX_DATE) {
+			dosLastModDate = MAX_DATE;
+		}
+		return ((dosLastModDate.getHours() << 3) | (dosLastModDate.getMinutes() >> 3)) & MAX_8_BITS;
+	}
+
 	function getDeterminedSize(child, passThrough) {
 		const { reader } = child;
 		if (reader && reader.size !== UNDEFINED_VALUE) {
@@ -8778,6 +8988,7 @@
 	exports.ERR_INVALID_PASS_THROUGH = ERR_INVALID_PASS_THROUGH;
 	exports.ERR_INVALID_READER_OPTIONS = ERR_INVALID_READER_OPTIONS;
 	exports.ERR_READABLE_CONSUMED = ERR_READABLE_CONSUMED;
+	exports.ERR_ZIP_CRYPTO_LAST_MOD_DATE = ERR_ZIP_CRYPTO_LAST_MOD_DATE;
 	exports.ZipDirectoryEntry = ZipDirectoryEntry;
 	exports.ZipEntry = ZipEntry;
 	exports.ZipFS = ZipFS;