@zip.js/zip.js 2.8.57 → 2.8.58

package/dist/zip-core-external.js

@@ -92,6 +92,7 @@ const FILE_ATTR_UNIX_SETUID_MASK = 0o4000;
 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;
@@ -4957,6 +4958,10 @@ class ZipReader {
 		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) {
@@ -5066,7 +5071,7 @@ class ZipReader {
 				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);
@@ -5079,6 +5084,9 @@ class ZipReader {
 				return arrayBufferPromise;
 			};
 			offset = endOffset;
+			if (indexFile == filesLength - 1 && recoverWrappedFilesLength) {
+				filesLength += getWrappedFilesLength(directoryView, directoryArray, offset);
+			}
 			const { onprogress } = options;
 			if (onprogress) {
 				try {
@@ -5237,6 +5245,7 @@ class ZipEntry {
 			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);
@@ -5290,7 +5299,6 @@ class ZipEntry {
 				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);
 		}
@@ -5410,6 +5418,16 @@ function detectEncryptedCentralDirectory(directoryView) {
 	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);
@@ -5582,10 +5600,11 @@ function readExtraFieldUnicode(extraFieldUnicode, propertyName, rawPropertyName,
 	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];
@@ -6054,7 +6073,8 @@ function getFunctionOptionValue$1(zipReader, options, name) {
 
 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) {
@@ -6207,153 +6227,150 @@ 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 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,
-				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));
 	}
 
-	async add(name = "", reader, options = {}) {
+	appendZip(reader) {
+		return watchPromiseError(this, this.appendZipEntries(reader));
+	}
+
+	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
@@ -6384,6 +6401,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) {
@@ -6418,11 +6448,7 @@ class ZipWriterStream {
 			try {
 				await zipWriter.close();
 			} catch (error) {
-				try {
-					await zipWriter.writer.writable.abort(error);
-				} catch {
-					// ignored
-				}
+				await abortWritable(zipWriter, error);
 			}
 		}
 	}
@@ -6439,8 +6465,90 @@ 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);
+	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
 	}
 }
 
@@ -6643,11 +6751,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);
@@ -6691,7 +6800,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) {
@@ -6710,6 +6819,7 @@ function resolveMetadata(zipWriter, name, options) {
 			rawComment,
 			version,
 			lastModDate,
+			rawLastModDate,
 			lastAccessDate,
 			creationDate,
 			internalFileAttributes,
@@ -6906,10 +7016,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);
@@ -6936,6 +7044,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();
@@ -7207,6 +7318,7 @@ function getHeaderInfo(options) {
 	const {
 		rawFilename,
 		lastModDate,
+		rawLastModDate: rawLastModDateOption,
 		lastAccessDate,
 		creationDate,
 		level,
@@ -7340,6 +7452,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;
@@ -7372,6 +7487,7 @@ function getHeaderInfo(options) {
 		compressionMethod,
 		uncompressedSize,
 		lastModDate: dosLastModDate < MIN_DATE ? MIN_DATE : dosLastModDate > MAX_DATE ? MAX_DATE : dosLastModDate,
+		rawLastModDate: rawLastModDateOption,
 		rawFilename,
 		zip64CompressedSize,
 		zip64UncompressedSize,
@@ -7578,9 +7694,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) {
@@ -7664,6 +7780,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,
@@ -7693,6 +7810,7 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 		if (exceedsAvailableSize(writer, offset + directoryRecordLength - directoryDiskOffset)) {
 			await writeData(writer, directoryArray.slice(directoryDiskOffset, offset));
 			directoryDiskOffset = offset;
+			directoryEndDiskEntriesLength = 0;
 			await writer.closeDisk();
 		}
 		if (indexFileEntry == 0) {
@@ -7728,6 +7846,7 @@ async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
 		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));
@@ -7739,6 +7858,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
 	};
 }
@@ -7767,16 +7887,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);
@@ -7784,15 +7908,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);
@@ -7800,7 +7921,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);
@@ -7813,6 +7934,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;
@@ -7820,7 +7942,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);
@@ -7919,9 +8041,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;
+		}
 	}
 }
 
@@ -7946,6 +8080,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();