@zip.js/zip.js 2.8.26 → 2.8.29

package/lib/core/zip-writer.js

@@ -26,9 +26,56 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global TransformStream */
+/* global TransformStream, WritableStream */
 // deno-lint-ignore-file no-this-alias
 
+/*
+ * Internal state invariants
+ *
+ * Positions:
+ * - `zipWriter.offset` is the logical write position: the offset where the next entry will start
+ *   in the final archive. It includes `zipWriter.initialOffset` (see below) and is only updated
+ *   between entries, or by the recovery code in getFileEntry() when a write fails mid-entry.
+ * - `writer.size` counts the bytes actually written into the writer. Between entries,
+ *   `zipWriter.offset - writer.size` is constant and equals `initialOffset`.
+ * - `zipWriter.initialOffset` is the number of bytes assumed to be prepended to the final archive
+ *   (i.e. to the first segment when the archive is split): the `offset` option minus the data
+ *   already stored in the writer. Positions within the first segment include it; positions within
+ *   the other segments do not, see getSegmentOffset().
+ * - For split archives, `writer.diskOffset` is the total size of the closed segments and
+ *   `writer.diskNumber` the index of the current segment. `writer.availableSize` is the remaining
+ *   capacity of the current segment (Infinity otherwise); setting it to 0 and writing an empty
+ *   chunk starts a new segment. This is how header records are kept whole within a segment, as
+ *   required by APPNOTE section 8.5.2.
+ * - The segment coordinates of an entry (`diskNumberStart` and `offset`) must be read after
+ *   calling skipDiskIfNeeded() and while holding the writer lock; they are unstable otherwise.
+ *
+ * Scheduling:
+ * - The central directory order (i.e. the order in which entries are listed by getEntries()) is
+ *   the insertion order of the `files` map. addFile() reserves each entry's slot synchronously in
+ *   add() call order, before initializing the reader, so concurrent entries whose readers
+ *   initialize at different speeds are still listed in call order.
+ * - `fileEntry.lock` chains every entry to the previous one to reach getFileEntry(); awaiting it
+ *   serializes the physical writes when `keepOrder` is set. The physical layout therefore follows
+ *   the order in which the readers finish initializing, not necessarily the central directory
+ *   order; each entry records its own `offset`, so the archive stays consistent either way.
+ * - `zipWriter.lockWriter`/`writerLocked` is the mutex over the writer; only the holder may write
+ *   into it or read the position variables above.
+ * - An entry writes directly into the writer (i.e. without being buffered) only when the writer
+ *   is unlocked and no buffered entry is in flight (`bufferedWrites` == 0). This avoids a
+ *   deadlock, it is not an optimization: an entry written directly acquires the writer lock
+ *   before awaiting the lock of the previous entry, while a buffered predecessor needs the
+ *   writer lock to be flushed.
+ * - `lastFileEntry` is the tail of the lock chain (the most recently added entry).
+ *
+ * Failures:
+ * - When a write fails mid-entry, `zipWriter.offset` advances by the number of bytes written for
+ *   the entry so that the offsets of subsequent entries remain correct, and
+ *   `hasCorruptedEntries` is set on the ZipWriter.
+ * - closeFile() does not update `zipWriter.offset`; the position of the central directory and of
+ *   the end of central directory records are derived from it.
+ */
+
 import {
 	MAX_32_BITS,
 	MAX_16_BITS,
@@ -41,6 +88,7 @@ import {
 	LOCAL_FILE_HEADER_SIGNATURE,
 	DATA_DESCRIPTOR_RECORD_SIGNATURE,
 	CENTRAL_FILE_HEADER_SIGNATURE,
+	CENTRAL_FILE_HEADER_LENGTH,
 	END_OF_CENTRAL_DIR_SIGNATURE,
 	ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE,
 	ZIP64_END_OF_CENTRAL_DIR_SIGNATURE,
@@ -56,12 +104,11 @@ import {
 	EXTRAFIELD_TYPE_INFOZIP,
 	EXTRAFIELD_TYPE_UNIX,
 	END_OF_CENTRAL_DIR_LENGTH,
-	ZIP64_END_OF_CENTRAL_DIR_LENGTH,
-	ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH,
 	ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH,
 	BITFLAG_ENCRYPTED,
 	BITFLAG_DATA_DESCRIPTOR,
 	BITFLAG_LANG_ENCODING_FLAG,
+	BITFLAG_LEVEL,
 	BITFLAG_LEVEL_FAST_MASK,
 	BITFLAG_LEVEL_SUPER_FAST_MASK,
 	BITFLAG_LEVEL_MAX_MASK,
@@ -81,9 +128,11 @@ import {
 	VERSION_AES,
 	DIRECTORY_SIGNATURE,
 	HEADER_SIZE,
+	HEADER_OFFSET_VERSION,
 	HEADER_OFFSET_SIGNATURE,
 	HEADER_OFFSET_COMPRESSED_SIZE,
 	HEADER_OFFSET_UNCOMPRESSED_SIZE,
+	LOCAL_HEADER_COMMON_OFFSET,
 	MIN_DATE,
 	MAX_DATE,
 	UNDEFINED_VALUE,
@@ -169,13 +218,19 @@ const ERR_INVALID_VERSION = "Version exceeds 65535";
 const ERR_INVALID_ENCRYPTION_STRENGTH = "The strength must equal 1, 2, or 3";
 const ERR_INVALID_EXTRAFIELD_TYPE = "Extra field type exceeds 65535";
 const ERR_INVALID_EXTRAFIELD_DATA = "Extra field data exceeds 64KB";
+// same message as the constant exported by zip-reader.js
+const ERR_UNSUPPORTED_COMPRESSION = "Compression method not supported";
+const MIN_UNIX_TIME = -2147483648;
+const MAX_UNIX_TIME = 2147483647;
 const ERR_UNSUPPORTED_FORMAT = "Zip64 is not supported (set the 'zip64' option to 'true')";
 const ERR_UNDEFINED_UNCOMPRESSED_SIZE = "Undefined uncompressed size";
+const ERR_UNDEFINED_READER = "Undefined reader";
 const ERR_ZIP_NOT_EMPTY = "Zip file not empty";
 const ERR_INVALID_UID = "Invalid uid (must be integer 0..2^32-1)";
 const ERR_INVALID_GID = "Invalid gid (must be integer 0..2^32-1)";
 const ERR_INVALID_UNIX_MODE = "Invalid UNIX mode (must be integer 0..65535)";
 const ERR_INVALID_UNIX_EXTRA_FIELD_TYPE = "Invalid unixExtraFieldType (must be 'infozip' or 'unix')";
+const ERR_INVALID_UNIX_ID_SIZE = "uid/gid must be 0..65535 for unixExtraFieldType 'unix' (use 'infozip' for larger ids)";
 const ERR_INVALID_MSDOS_ATTRIBUTES = "Invalid msdosAttributesRaw (must be integer 0..255)";
 const ERR_INVALID_MSDOS_DATA = "Invalid msdosAttributes (must be an object with boolean flags)";
 
@@ -201,9 +256,10 @@ class ZipWriter {
 			files: new Map(),
 			filenames: new Set(),
 			offset: options[OPTION_OFFSET] === UNDEFINED_VALUE ? writer.size || writer.writable.size || 0 : options[OPTION_OFFSET],
-			pendingEntriesSize: 0,
+			initialOffset: options[OPTION_OFFSET] === UNDEFINED_VALUE ? 0 : options[OPTION_OFFSET] - (writer.size || writer.writable.size || 0),
 			pendingAddFileCalls: new Set(),
-			bufferedWrites: 0
+			bufferedWrites: 0,
+			lastFileEntry: UNDEFINED_VALUE
 		});
 	}
 
@@ -212,17 +268,18 @@ class ZipWriter {
 			throw new Error(ERR_ZIP_NOT_EMPTY);
 		}
 		reader = new GenericReader(reader);
+		await initStream(reader);
 		const zipReader = new ZipReader(reader.readable);
 		const entries = await zipReader.getEntries();
 		await zipReader.close();
+		await initStream(this.writer);
 		await reader.readable.pipeTo(this.writer.writable, { preventClose: true, preventAbort: true });
 		this.writer.size = this.offset = reader.size;
 		this.filenames = new Set(entries.map(entry => entry.filename));
 		this.files = new Map(entries.map(entry => {
 			const {
 				version,
-				compressionMethod,
-				lastModDate,
+				rawLastModDate,
 				lastAccessDate,
 				creationDate,
 				rawFilename,
@@ -235,6 +292,7 @@ class ZipWriter {
 				zip64
 			} = entry;
 			let {
+				compressionMethod,
 				rawExtraFieldZip64,
 				rawExtraFieldAES,
 				rawExtraFieldExtendedTimestamp,
@@ -247,31 +305,39 @@ class ZipWriter {
 			rawExtraFieldAES = rawExtraFieldAES || new Uint8Array();
 			rawExtraFieldExtendedTimestamp = rawExtraFieldExtendedTimestamp || new Uint8Array();
 			rawExtraFieldNTFS = rawExtraFieldNTFS || new Uint8Array();
-			rawExtraFieldUnix = entry.rawExtraFieldUnix || new Uint8Array();
+			rawExtraFieldUnix = rawExtraFieldUnix || new Uint8Array();
 			rawExtraField = rawExtraField || new Uint8Array();
+			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 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: getBitFlag(level, languageEncodingFlag, dataDescriptor, encrypted, compressionMethod),
+				bitFlag: bitFlagValue,
 				compressionMethod,
 				uncompressedSize,
 				compressedSize,
-				lastModDate,
+				rawLastModDate,
 				rawFilename,
 				zip64CompressedSize,
 				zip64UncompressedSize,
 				extraFieldLength
 			});
+			const { signature } = entry;
+			if (signature !== UNDEFINED_VALUE) {
+				setUint32(headerView, HEADER_OFFSET_SIGNATURE, signature);
+			}
 			Object.assign(entry, {
 				zip64UncompressedSize,
 				zip64CompressedSize,
-				zip64Offset: zip64 && this.offset - diskOffset > MAX_32_BITS,
-				zip64DiskNumberStart: zip64 && diskNumber > MAX_16_BITS,
+				zip64Offset: zip64 && this.offset - diskOffset >= MAX_32_BITS,
+				zip64DiskNumberStart: zip64 && diskNumber >= MAX_16_BITS,
 				rawExtraFieldZip64,
 				rawExtraFieldAES,
 				rawExtraFieldExtendedTimestamp,
@@ -289,6 +355,7 @@ class ZipWriter {
 
 	async add(name = "", reader, options = {}) {
 		const zipWriter = this;
+		options = Object.assign({}, options);
 		const {
 			pendingAddFileCalls,
 			config
@@ -299,17 +366,24 @@ class ZipWriter {
 			await new Promise(resolve => pendingEntries.push(resolve));
 		}
 		let promiseAddFile;
+		let nameAdded;
 		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) {
-			zipWriter.filenames.delete(name);
+			if (nameAdded) {
+				zipWriter.filenames.delete(name);
+			}
 			throw error;
 		} finally {
 			pendingAddFileCalls.delete(promiseAddFile);
@@ -342,6 +416,9 @@ class ZipWriter {
 		const zipWriter = this;
 		const { pendingAddFileCalls, writer } = this;
 		const { writable } = writer;
+		if (getLength(comment) > MAX_16_BITS) {
+			throw new Error(ERR_INVALID_COMMENT);
+		}
 		while (pendingAddFileCalls.size) {
 			await Promise.allSettled(Array.from(pendingAddFileCalls));
 		}
@@ -360,27 +437,62 @@ class ZipWriterStream {
 		const { readable, writable } = new TransformStream();
 		this.readable = readable;
 		this.zipWriter = new ZipWriter(writable, options);
+		this.pendingAddFileCalls = new Set();
 	}
 
 	transform(path) {
+		const zipWriter = this.zipWriter;
+		let streamController;
 		const { readable, writable } = new TransformStream({
-			flush: () => { this.zipWriter.close(); }
+			start(controller) {
+				streamController = controller;
+			},
+			flush: () => void closeArchive()
 		});
-		this.zipWriter.add(path, readable);
+		watchAddFileCall(this, this.zipWriter.add(path, readable), error => streamController.error(error));
 		return { readable: this.readable, writable };
+
+		async function closeArchive() {
+			try {
+				await zipWriter.close();
+			} catch (error) {
+				try {
+					await zipWriter.writer.writable.abort(error);
+				} catch {
+					// ignored
+				}
+			}
+		}
 	}
 
 	writable(path) {
-		const { readable, writable } = new TransformStream();
-		this.zipWriter.add(path, readable);
+		let streamController;
+		const { readable, writable } = new TransformStream({
+			start(controller) {
+				streamController = controller;
+			}
+		});
+		watchAddFileCall(this, this.zipWriter.add(path, readable), error => streamController.error(error));
 		return writable;
 	}
 
-	close(comment = UNDEFINED_VALUE, options = {}) {
+	async close(comment = UNDEFINED_VALUE, options = {}) {
+		await Promise.all(Array.from(this.pendingAddFileCalls));
 		return this.zipWriter.close(comment, options);
 	}
 }
 
+function watchAddFileCall(zipWriterStream, promiseAddFile, onerror) {
+	zipWriterStream.pendingAddFileCalls.add(promiseAddFile);
+	promiseAddFile.catch(error => {
+		try {
+			onerror(error);
+		} catch {
+			// ignored
+		}
+	});
+}
+
 export {
 	ZipWriter,
 	ZipWriterStream,
@@ -394,10 +506,42 @@ export {
 	ERR_INVALID_ENCRYPTION_STRENGTH,
 	ERR_UNSUPPORTED_FORMAT,
 	ERR_UNDEFINED_UNCOMPRESSED_SIZE,
+	ERR_UNDEFINED_READER,
 	ERR_ZIP_NOT_EMPTY
 };
 
 async function addFile(zipWriter, name, reader, options) {
+	const attributesInfo = resolveAttributes(zipWriter, name, options);
+	({ name } = attributesInfo);
+	const metadataInfo = resolveMetadata(zipWriter, name, options);
+	const { comment } = metadataInfo;
+	const extraField = options[PROPERTY_NAME_EXTRA_FIELD];
+	zipWriter.files.set(name, UNDEFINED_VALUE);
+	let fileEntry;
+	try {
+		const sizesInfo = await resolveSizes(zipWriter, reader, metadataInfo, options);
+		({ reader } = sizesInfo);
+		const { diskOffset, diskNumber } = zipWriter.writer;
+		options = Object.assign({}, options, attributesInfo.resolvedOptions, metadataInfo.resolvedOptions, sizesInfo.resolvedOptions, {
+			internalFileAttribute: metadataInfo.resolvedOptions.internalFileAttributes,
+			externalFileAttribute: attributesInfo.resolvedOptions.externalFileAttributes,
+			signature: options[PROPERTY_NAME_SIGNATURE],
+			offset: zipWriter.offset - diskOffset,
+			diskNumberStart: diskNumber
+		});
+		const headerInfo = getHeaderInfo(options);
+		const dataDescriptorInfo = getDataDescriptorInfo(options);
+		const metadataSize = getLength(headerInfo.localHeaderArray, dataDescriptorInfo.dataDescriptorArray);
+		fileEntry = await getFileEntry(zipWriter, name, reader, { headerInfo, dataDescriptorInfo, metadataSize }, options);
+	} catch (error) {
+		zipWriter.files.delete(name);
+		throw error;
+	}
+	Object.assign(fileEntry, { name, comment, extraField });
+	return new Entry(fileEntry);
+}
+
+function resolveAttributes(zipWriter, name, options) {
 	name = name.trim();
 	let msDosCompatible = getOptionValue(zipWriter, options, PROPERTY_NAME_MS_DOS_COMPATIBLE);
 	let versionMadeBy = getOptionValue(zipWriter, options, PROPERTY_NAME_VERSION_MADE_BY, msDosCompatible ? 20 : 768);
@@ -405,7 +549,7 @@ async function addFile(zipWriter, name, reader, options) {
 	const uid = getOptionValue(zipWriter, options, PROPERTY_NAME_UID);
 	const gid = getOptionValue(zipWriter, options, PROPERTY_NAME_GID);
 	let unixMode = getOptionValue(zipWriter, options, PROPERTY_NAME_UNIX_MODE);
-	const unixExtraFieldType = getOptionValue(zipWriter, options, OPTION_UNIX_EXTRA_FIELD_TYPE);
+	let unixExtraFieldType = getOptionValue(zipWriter, options, OPTION_UNIX_EXTRA_FIELD_TYPE);
 	let setuid = getOptionValue(zipWriter, options, PROPERTY_NAME_SETUID);
 	let setgid = getOptionValue(zipWriter, options, PROPERTY_NAME_SETGID);
 	let sticky = getOptionValue(zipWriter, options, PROPERTY_NAME_STICKY);
@@ -421,6 +565,13 @@ async function addFile(zipWriter, name, reader, options) {
 	if (unixExtraFieldType !== UNDEFINED_VALUE && unixExtraFieldType !== INFOZIP_EXTRA_FIELD_TYPE && unixExtraFieldType !== UNIX_EXTRA_FIELD_TYPE) {
 		throw new Error(ERR_INVALID_UNIX_EXTRA_FIELD_TYPE);
 	}
+	if (unixExtraFieldType === UNIX_EXTRA_FIELD_TYPE &&
+		((uid !== UNDEFINED_VALUE && uid > MAX_16_BITS) || (gid !== UNDEFINED_VALUE && gid > MAX_16_BITS))) {
+		throw new Error(ERR_INVALID_UNIX_ID_SIZE);
+	}
+	if (unixExtraFieldType === UNDEFINED_VALUE && (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE)) {
+		unixExtraFieldType = INFOZIP_EXTRA_FIELD_TYPE;
+	}
 	let msdosAttributesRaw = getOptionValue(zipWriter, options, PROPERTY_NAME_MSDOS_ATTRIBUTES_RAW);
 	let msdosAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_MSDOS_ATTRIBUTES);
 	const hasUnixMetadata = uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE || unixMode !== UNDEFINED_VALUE || unixExtraFieldType;
@@ -491,6 +642,27 @@ async function addFile(zipWriter, name, reader, options) {
 	if (hasMsDosProvided) {
 		externalFileAttributes = (externalFileAttributes & MAX_32_BITS) | (msdosAttributesRaw & MAX_8_BITS);
 	}
+	return {
+		name,
+		resolvedOptions: {
+			versionMadeBy,
+			msDosCompatible,
+			externalFileAttributes,
+			unixExternalUpper,
+			uid,
+			gid,
+			unixMode,
+			unixExtraFieldType,
+			setuid,
+			setgid,
+			sticky,
+			msdosAttributesRaw,
+			msdosAttributes
+		}
+	};
+}
+
+function resolveMetadata(zipWriter, name, options) {
 	const encode = getOptionValue(zipWriter, options, OPTION_ENCODE_TEXT, encodeText);
 	let rawFilename = encode(name);
 	if (rawFilename === UNDEFINED_VALUE) {
@@ -529,10 +701,14 @@ async function addFile(zipWriter, name, reader, options) {
 	const transferStreams = getOptionValue(zipWriter, options, OPTION_TRANSFER_STREAMS, true);
 	const bufferedWrite = getOptionValue(zipWriter, options, OPTION_BUFFERED_WRITE);
 	const createTempStream = getOptionValue(zipWriter, options, OPTION_CREATE_TEMP_STREAM);
-	const dataDescriptorSignature = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR_SIGNATURE, false);
+	const dataDescriptorSignature = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR_SIGNATURE, true);
 	const signal = getOptionValue(zipWriter, options, OPTION_SIGNAL);
 	const useUnicodeFileNames = getOptionValue(zipWriter, options, OPTION_USE_UNICODE_FILE_NAMES, true);
 	const compressionMethod = getOptionValue(zipWriter, options, PROPERTY_NAME_COMPRESSION_METHOD);
+	if (!passThrough && compressionMethod !== UNDEFINED_VALUE &&
+		compressionMethod !== COMPRESSION_METHOD_STORE && compressionMethod !== COMPRESSION_METHOD_DEFLATE) {
+		throw new Error(ERR_UNSUPPORTED_COMPRESSION);
+	}
 	let level = getOptionValue(zipWriter, options, OPTION_LEVEL);
 	let useCompressionStream = getOptionValue(zipWriter, options, OPTION_USE_COMPRESSION_STREAM);
 	let dataDescriptor = getOptionValue(zipWriter, options, OPTION_DATA_DESCRIPTOR);
@@ -548,7 +724,7 @@ async function addFile(zipWriter, name, reader, options) {
 	if (!useCompressionStream && (zipWriter.config.CompressionStream === UNDEFINED_VALUE && zipWriter.config.CompressionStreamZlib === UNDEFINED_VALUE)) {
 		level = 0;
 	}
-	let zip64 = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIP64);
+	const zip64 = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIP64);
 	if (!zipCrypto && (password !== UNDEFINED_VALUE || rawPassword !== UNDEFINED_VALUE) && !(encryptionStrength >= 1 && encryptionStrength <= 3)) {
 		throw new Error(ERR_INVALID_ENCRYPTION_STRENGTH);
 	}
@@ -559,6 +735,7 @@ async function addFile(zipWriter, name, reader, options) {
 		let offset = 0;
 		extraField.forEach(data => extraFieldSize += 4 + getLength(data));
 		rawExtraField = new Uint8Array(extraFieldSize);
+		const rawExtraFieldView = getDataView(rawExtraField);
 		extraField.forEach((data, type) => {
 			if (type > MAX_16_BITS) {
 				throw new Error(ERR_INVALID_EXTRAFIELD_TYPE);
@@ -566,22 +743,72 @@ async function addFile(zipWriter, name, reader, options) {
 			if (getLength(data) > MAX_16_BITS) {
 				throw new Error(ERR_INVALID_EXTRAFIELD_DATA);
 			}
-			arraySet(rawExtraField, new Uint16Array([type]), offset);
-			arraySet(rawExtraField, new Uint16Array([getLength(data)]), offset + 2);
+			setUint16(rawExtraFieldView, offset, type);
+			setUint16(rawExtraFieldView, offset + 2, getLength(data));
 			arraySet(rawExtraField, data, offset + 4);
 			offset += 4 + getLength(data);
 		});
 	}
+	return {
+		comment,
+		resolvedOptions: {
+			rawFilename,
+			rawComment,
+			version,
+			lastModDate,
+			lastAccessDate,
+			creationDate,
+			internalFileAttributes,
+			passThrough,
+			password,
+			rawPassword,
+			encryptionStrength,
+			zipCrypto,
+			extendedTimestamp,
+			keepOrder,
+			useWebWorkers,
+			transferStreams,
+			bufferedWrite,
+			createTempStream,
+			dataDescriptorSignature,
+			signal,
+			useUnicodeFileNames,
+			compressionMethod,
+			level,
+			useCompressionStream,
+			dataDescriptor,
+			zip64,
+			rawExtraField
+		}
+	};
+}
+
+async function resolveSizes(zipWriter, reader, { resolvedOptions: metadata }, options) {
+	const { passThrough, zipCrypto, password, rawPassword, encryptionStrength } = metadata;
+	let { dataDescriptor, zip64, level, compressionMethod } = metadata;
 	let maximumCompressedSize = 0;
-	let maximumEntrySize = 0;
 	let uncompressedSize = 0;
 	if (passThrough) {
+		// the headers of a passThrough entry describe the payload verbatim: without a
+		// reader they would declare content that is not there
+		if (!reader) {
+			throw new Error(ERR_UNDEFINED_READER);
+		}
 		uncompressedSize = options[PROPERTY_NAME_UNCOMPRESSED_SIZE];
 		if (uncompressedSize === UNDEFINED_VALUE) {
 			throw new Error(ERR_UNDEFINED_UNCOMPRESSED_SIZE);
 		}
 	}
 	const zip64Enabled = zip64 === true;
+	const encrypted = getOptionValue(zipWriter, options, PROPERTY_NAME_ENCRYPTED);
+	// entries without a reader have no payload: write them as empty stored files instead of
+	// declaring a compressed or encrypted content that does not exist
+	const encryptedEntry = Boolean(reader) && (Boolean((password && getLength(password)) || (rawPassword && getLength(rawPassword))) || (passThrough && encrypted));
+	if (!reader) {
+		level = 0;
+		compressionMethod = COMPRESSION_METHOD_STORE;
+	}
+	const encryptionOverhead = encryptedEntry ? (zipCrypto ? 12 : 16 + encryptionStrength * 4) : 0;
 	if (reader) {
 		reader = new GenericReader(reader);
 		await initStream(reader);
@@ -594,16 +821,15 @@ async function addFile(zipWriter, name, reader, options) {
 				}
 			} else {
 				options.uncompressedSize = uncompressedSize = reader.size;
-				maximumCompressedSize = getMaximumCompressedSize(uncompressedSize);
+				maximumCompressedSize = getMaximumCompressedSize(uncompressedSize) + encryptionOverhead;
 			}
 		} else {
 			options.uncompressedSize = uncompressedSize;
-			maximumCompressedSize = getMaximumCompressedSize(uncompressedSize);
+			maximumCompressedSize = getMaximumCompressedSize(uncompressedSize) + encryptionOverhead;
 		}
 	}
-	const { diskOffset, diskNumber } = zipWriter.writer;
-	const zip64UncompressedSize = zip64Enabled || uncompressedSize > MAX_32_BITS;
-	const zip64CompressedSize = zip64Enabled || maximumCompressedSize > MAX_32_BITS;
+	const zip64UncompressedSize = zip64Enabled || uncompressedSize >= MAX_32_BITS;
+	const zip64CompressedSize = zip64Enabled || maximumCompressedSize >= MAX_32_BITS;
 	if (zip64UncompressedSize || zip64CompressedSize) {
 		if (zip64 === false) {
 			throw new Error(ERR_UNSUPPORTED_FORMAT);
@@ -612,73 +838,19 @@ async function addFile(zipWriter, name, reader, options) {
 		}
 	}
 	zip64 = zip64 || false;
-	const encrypted = getOptionValue(zipWriter, options, PROPERTY_NAME_ENCRYPTED);
-	options = Object.assign({}, options, {
-		rawFilename,
-		rawComment,
-		version,
-		versionMadeBy,
-		lastModDate,
-		lastAccessDate,
-		creationDate,
-		rawExtraField,
-		zip64,
-		zip64UncompressedSize,
-		zip64CompressedSize,
-		password,
-		rawPassword,
-		level,
-		useWebWorkers,
-		transferStreams,
-		encryptionStrength,
-		extendedTimestamp,
-		zipCrypto,
-		bufferedWrite,
-		createTempStream,
-		keepOrder,
-		useUnicodeFileNames,
-		dataDescriptor,
-		dataDescriptorSignature,
-		signal,
-		msDosCompatible,
-		internalFileAttribute: internalFileAttributes,
-		internalFileAttributes,
-		externalFileAttribute: externalFileAttributes,
-		externalFileAttributes,
-		useCompressionStream,
-		passThrough,
-		encrypted: Boolean((password && getLength(password)) || (rawPassword && getLength(rawPassword))) || (passThrough && encrypted),
-		signature: options[PROPERTY_NAME_SIGNATURE],
-		compressionMethod,
-		uncompressedSize,
-		offset: zipWriter.offset - diskOffset,
-		diskNumberStart: diskNumber,
-		uid,
-		gid,
-		setuid,
-		setgid,
-		sticky,
-		unixMode,
-		msdosAttributesRaw,
-		msdosAttributes,
-		unixExternalUpper
-	});
-	const headerInfo = getHeaderInfo(options);
-	const dataDescriptorInfo = getDataDescriptorInfo(options);
-	const metadataSize = getLength(headerInfo.localHeaderArray, dataDescriptorInfo.dataDescriptorArray);
-	maximumEntrySize = metadataSize + maximumCompressedSize;
-	if (zipWriter.options[OPTION_USDZ]) {
-		maximumEntrySize += maximumEntrySize + 64;
-	}
-	zipWriter.pendingEntriesSize += maximumEntrySize;
-	let fileEntry;
-	try {
-		fileEntry = await getFileEntry(zipWriter, name, reader, { headerInfo, dataDescriptorInfo, metadataSize }, options);
-	} finally {
-		zipWriter.pendingEntriesSize -= maximumEntrySize;
-	}
-	Object.assign(fileEntry, { name, comment, extraField });
-	return new Entry(fileEntry);
+	return {
+		reader,
+		resolvedOptions: {
+			dataDescriptor,
+			zip64,
+			zip64UncompressedSize,
+			zip64CompressedSize,
+			uncompressedSize,
+			level,
+			compressionMethod,
+			encrypted: encryptedEntry
+		}
+	};
 }
 
 async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
@@ -695,37 +867,40 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		headerInfo
 	} = entryInfo;
 	const usdz = zipWriter.options[OPTION_USDZ];
-	const previousFileEntry = Array.from(files.values()).pop();
+	const previousFileEntry = zipWriter.lastFileEntry;
 	let fileEntry = {};
 	let bufferedWrite;
 	let releaseLockWriter;
 	let releaseLockCurrentFileEntry;
 	let writingBufferedEntryData;
 	let writingEntryData;
+	let writerSizeBeforeEntry;
+	let flushedBufferedSize = 0;
 	let fileWriter;
 	files.set(name, fileEntry);
+	zipWriter.lastFileEntry = fileEntry;
 	try {
 		let lockPreviousFileEntry;
 		if (keepOrder) {
 			lockPreviousFileEntry = previousFileEntry && previousFileEntry.lock;
 			requestLockCurrentFileEntry();
 		}
-		if ((options.bufferedWrite || !keepOrder || zipWriter.writerLocked || zipWriter.bufferedWrites || !dataDescriptor) && !usdz) {
+		if (options.bufferedWrite || !keepOrder || zipWriter.writerLocked || zipWriter.bufferedWrites || !dataDescriptor) {
+			bufferedWrite = true;
+			zipWriter.bufferedWrites++;
 			if (options.createTempStream) {
 				fileWriter = await options.createTempStream();
 			} else {
 				fileWriter = new TransformStream(UNDEFINED_VALUE, UNDEFINED_VALUE, { highWaterMark: INFINITY_VALUE });
 			}
 			fileWriter.size = 0;
-			bufferedWrite = true;
-			zipWriter.bufferedWrites++;
 			await initStream(writer);
 		} else {
 			fileWriter = writer;
 			await requestLockWriter();
 		}
 		await initStream(fileWriter);
-		const { writable, diskOffset } = writer;
+		const { diskOffset } = writer;
 		if (zipWriter.addSplitZipSignature) {
 			delete zipWriter.addSplitZipSignature;
 			const signatureArray = new Uint8Array(4);
@@ -734,21 +909,20 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			await writeData(writer, signatureArray);
 			zipWriter.offset += 4;
 		}
-		if (usdz) {
+		if (usdz && !bufferedWrite) {
 			appendExtraFieldUSDZ(entryInfo, zipWriter.offset - diskOffset);
 		}
-		const {
-			localHeaderView,
-			localHeaderArray
-		} = headerInfo;
+		const { localHeaderArray } = headerInfo;
 		if (!bufferedWrite) {
 			await lockPreviousFileEntry;
-			await skipDiskIfNeeded(writable);
+			await skipDiskIfNeeded();
 		}
-		const { diskNumber } = writer;
-		fileEntry.diskNumberStart = diskNumber;
+		const diskNumberStart = writer.diskNumber;
+		const entryOffset = getSegmentOffset(zipWriter, writer);
+		fileEntry.diskNumberStart = diskNumberStart;
 		if (!bufferedWrite) {
 			writingEntryData = true;
+			writerSizeBeforeEntry = writer.size;
 			await writeData(fileWriter, localHeaderArray);
 		}
 		fileEntry = await createFileEntry(reader, fileWriter, fileEntry, entryInfo, zipWriter.config, options);
@@ -761,16 +935,24 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 			await Promise.all([fileWriter.writable.getWriter().close(), lockPreviousFileEntry]);
 			await requestLockWriter();
 			writingBufferedEntryData = true;
+			writerSizeBeforeEntry = writer.size;
+			await skipDiskIfNeeded();
 			fileEntry.diskNumberStart = writer.diskNumber;
-			fileEntry.offset = zipWriter.offset - writer.diskOffset;
-			updateLocalHeader(fileEntry, localHeaderView, options);
-			await skipDiskIfNeeded(writable);
-			await writeData(writer, localHeaderArray);
-			await fileWriter.readable.pipeTo(writable, { preventClose: true, preventAbort: true, signal });
+			fileEntry.offset = getSegmentOffset(zipWriter, writer);
+			if (usdz) {
+				// the padding depends on the entry offset, only known now that the writer is locked
+				const previousMetadataSize = entryInfo.metadataSize;
+				appendExtraFieldUSDZ(entryInfo, zipWriter.offset - writer.diskOffset);
+				fileEntry.size += entryInfo.metadataSize - previousMetadataSize;
+			}
+			updateLocalHeader(fileEntry, headerInfo.localHeaderView, options);
+			await writeData(writer, headerInfo.localHeaderArray);
+			await flushBufferedData(fileWriter.readable, writer, signal, chunkLength => flushedBufferedSize += chunkLength);
 			writer.size += fileWriter.size;
 			writingBufferedEntryData = false;
 		} else {
-			fileEntry.offset = zipWriter.offset - diskOffset;
+			fileEntry.diskNumberStart = diskNumberStart;
+			fileEntry.offset = entryOffset;
 		}
 		zipWriter.offset += fileEntry.size;
 		return fileEntry;
@@ -784,10 +966,9 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 					// ignored
 				}
 			}
+			zipWriter.offset += writer.size - writerSizeBeforeEntry;
 			if (bufferedWrite) {
-				zipWriter.offset += fileWriter.size;
-			} else {
-				zipWriter.offset = fileWriter.size;
+				zipWriter.offset += flushedBufferedSize;
 			}
 		}
 		files.delete(name);
@@ -818,10 +999,10 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		await lockWriter;
 	}
 
-	async function skipDiskIfNeeded(writable) {
+	async function skipDiskIfNeeded() {
 		if (getLength(headerInfo.localHeaderArray) > writer.availableSize) {
 			writer.availableSize = 0;
-			await writeData(writable, new Uint8Array());
+			await writeData(writer, new Uint8Array());
 		}
 	}
 }
@@ -962,6 +1143,10 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 				uncompressedSize = result.inputSize;
 				signature = result.signature;
 			}
+			if ((!zip64CompressedSize && compressedSize >= MAX_32_BITS) ||
+				(!zip64UncompressedSize && uncompressedSize >= MAX_32_BITS)) {
+				throw new Error(ERR_UNSUPPORTED_FORMAT);
+			}
 		} catch (error) {
 			if (error.outputSize !== UNDEFINED_VALUE) {
 				writer.size += error.outputSize;
@@ -1024,35 +1209,28 @@ function getHeaderInfo(options) {
 		uncompressedSize
 	} = options;
 	let { version, compressionMethod } = options;
-	const compressed = !directory && (level > 0 || (level === UNDEFINED_VALUE && compressionMethod !== 0));
+	const compressed = !directory && (compressionMethod === UNDEFINED_VALUE
+		? (level === UNDEFINED_VALUE || level > 0)
+		: compressionMethod !== COMPRESSION_METHOD_STORE);
 	let rawLocalExtraFieldZip64;
 	const uncompressedFile = passThrough || !compressed;
-	const zip64ExtraFieldComplete = zip64 && (options.bufferedWrite || ((!zip64UncompressedSize && !zip64CompressedSize) || uncompressedFile));
-	if (zip64) {
-		let rawLocalExtraFieldZip64Length = 4;
-		if (zip64UncompressedSize) {
-			rawLocalExtraFieldZip64Length += 8;
-		}
-		if (zip64CompressedSize) {
-			rawLocalExtraFieldZip64Length += 8;
-		}
-		rawLocalExtraFieldZip64 = new Uint8Array(rawLocalExtraFieldZip64Length);
-		const rawLocalExtraFieldZip64View = getDataView(rawLocalExtraFieldZip64);
-		setUint16(rawLocalExtraFieldZip64View, 0, EXTRAFIELD_TYPE_ZIP64);
-		setUint16(rawLocalExtraFieldZip64View, 2, getLength(rawLocalExtraFieldZip64) - 4);
+	// entries without a data descriptor are always buffered (cf. getFileEntry), so the
+	// zip64 extra field values can be patched into the local header before flushing it
+	const zip64ExtraFieldComplete = zip64 && (options.bufferedWrite || !dataDescriptor || ((!zip64UncompressedSize && !zip64CompressedSize) || uncompressedFile));
+	const writeLocalExtraFieldZip64 = zip64ExtraFieldComplete || (zip64 && dataDescriptor && (zip64UncompressedSize || zip64CompressedSize));
+	if (zip64 && (zip64UncompressedSize || zip64CompressedSize)) {
+		// APPNOTE 4.5.3: the zip64 extra field of a local header must include both the
+		// uncompressed and compressed size fields
+		const length = 4 + 16;
+		const extraFieldZip64 = createRecordWriter(length);
+		extraFieldZip64.uint16(EXTRAFIELD_TYPE_ZIP64);
+		extraFieldZip64.uint16(length - 4);
+		rawLocalExtraFieldZip64 = extraFieldZip64.array;
 		if (zip64ExtraFieldComplete) {
-			const rawLocalExtraFieldZip64View = getDataView(rawLocalExtraFieldZip64);
-			let rawLocalExtraFieldZip64Offset = 4;
-			if (zip64UncompressedSize) {
-				setBigUint64(rawLocalExtraFieldZip64View, rawLocalExtraFieldZip64Offset, BigInt(uncompressedSize));
-				rawLocalExtraFieldZip64Offset += 8;
-			}
-			if (zip64CompressedSize && uncompressedFile) {
-				setBigUint64(rawLocalExtraFieldZip64View, rawLocalExtraFieldZip64Offset, BigInt(uncompressedSize));
-				rawLocalExtraFieldZip64Offset += 8;
-			}
-			if (rawLocalExtraFieldZip64Offset == 4) {
-				rawLocalExtraFieldZip64 = new Uint8Array();
+			extraFieldZip64.uint64(uncompressedSize);
+			if (uncompressedFile) {
+				const encryptionOverhead = encrypted ? (zipCrypto ? 12 : 16 + encryptionStrength * 4) : 0;
+				extraFieldZip64.uint64(passThrough ? 0 : uncompressedSize + encryptionOverhead);
 			}
 		}
 	} else {
@@ -1060,11 +1238,11 @@ function getHeaderInfo(options) {
 	}
 	let rawExtraFieldAES;
 	if (encrypted && !zipCrypto) {
-		rawExtraFieldAES = new Uint8Array(getLength(EXTRAFIELD_DATA_AES) + 2);
-		const extraFieldAESView = getDataView(rawExtraFieldAES);
-		setUint16(extraFieldAESView, 0, EXTRAFIELD_TYPE_AES);
-		arraySet(rawExtraFieldAES, EXTRAFIELD_DATA_AES, 2);
-		setUint8(extraFieldAESView, 8, encryptionStrength);
+		const extraFieldAES = createRecordWriter(getLength(EXTRAFIELD_DATA_AES) + 2);
+		extraFieldAES.uint16(EXTRAFIELD_TYPE_AES);
+		extraFieldAES.bytes(EXTRAFIELD_DATA_AES);
+		rawExtraFieldAES = extraFieldAES.array;
+		rawExtraFieldAES[8] = encryptionStrength;
 	} else {
 		rawExtraFieldAES = new Uint8Array();
 	}
@@ -1072,33 +1250,38 @@ function getHeaderInfo(options) {
 	let rawExtraFieldExtendedTimestamp;
 	let extraFieldExtendedTimestampFlag;
 	if (extendedTimestamp) {
-		rawExtraFieldExtendedTimestamp = new Uint8Array(9 + (lastAccessDate ? 4 : 0) + (creationDate ? 4 : 0));
-		const extraFieldExtendedTimestampView = getDataView(rawExtraFieldExtendedTimestamp);
-		setUint16(extraFieldExtendedTimestampView, 0, EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
-		setUint16(extraFieldExtendedTimestampView, 2, getLength(rawExtraFieldExtendedTimestamp) - 4);
-		extraFieldExtendedTimestampFlag = 0x1 + (lastAccessDate ? 0x2 : 0) + (creationDate ? 0x4 : 0);
-		setUint8(extraFieldExtendedTimestampView, 4, extraFieldExtendedTimestampFlag);
-		let offset = 5;
-		setUint32(extraFieldExtendedTimestampView, offset, Math.floor(lastModDate.getTime() / 1000));
-		offset += 4;
-		if (lastAccessDate) {
-			setUint32(extraFieldExtendedTimestampView, offset, Math.floor(lastAccessDate.getTime() / 1000));
-			offset += 4;
-		}
-		if (creationDate) {
-			setUint32(extraFieldExtendedTimestampView, offset, Math.floor(creationDate.getTime() / 1000));
+		const lastModTimeUnix = getTimeUnix(lastModDate);
+		if (inUnixTimeRange(lastModTimeUnix)) {
+			const extraFieldTimestampLength = 9 + (lastAccessDate ? 4 : 0) + (creationDate ? 4 : 0);
+			const extraFieldTimestamp = createRecordWriter(extraFieldTimestampLength);
+			extraFieldExtendedTimestampFlag = 0x1 + (lastAccessDate ? 0x2 : 0) + (creationDate ? 0x4 : 0);
+			extraFieldTimestamp.uint16(EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
+			extraFieldTimestamp.uint16(extraFieldTimestampLength - 4);
+			extraFieldTimestamp.uint8(extraFieldExtendedTimestampFlag);
+			extraFieldTimestamp.uint32(lastModTimeUnix);
+			if (lastAccessDate) {
+				extraFieldTimestamp.uint32(clampUnixTime(getTimeUnix(lastAccessDate)));
+			}
+			if (creationDate) {
+				extraFieldTimestamp.uint32(clampUnixTime(getTimeUnix(creationDate)));
+			}
+			rawExtraFieldExtendedTimestamp = extraFieldTimestamp.array;
+		} else {
+			// the date cannot be stored as a 32-bit time_t; the NTFS field replaces it
+			rawExtraFieldExtendedTimestamp = new Uint8Array();
 		}
 		try {
-			rawExtraFieldNTFS = new Uint8Array(36);
-			const extraFieldNTFSView = getDataView(rawExtraFieldNTFS);
 			const lastModTimeNTFS = getTimeNTFS(lastModDate);
-			setUint16(extraFieldNTFSView, 0, EXTRAFIELD_TYPE_NTFS);
-			setUint16(extraFieldNTFSView, 2, 32);
-			setUint16(extraFieldNTFSView, 8, EXTRAFIELD_TYPE_NTFS_TAG1);
-			setUint16(extraFieldNTFSView, 10, 24);
-			setBigUint64(extraFieldNTFSView, 12, lastModTimeNTFS);
-			setBigUint64(extraFieldNTFSView, 20, getTimeNTFS(lastAccessDate) || lastModTimeNTFS);
-			setBigUint64(extraFieldNTFSView, 28, getTimeNTFS(creationDate) || lastModTimeNTFS);
+			const extraFieldNTFS = createRecordWriter(36);
+			extraFieldNTFS.uint16(EXTRAFIELD_TYPE_NTFS);
+			extraFieldNTFS.uint16(32);
+			extraFieldNTFS.skip(4);
+			extraFieldNTFS.uint16(EXTRAFIELD_TYPE_NTFS_TAG1);
+			extraFieldNTFS.uint16(24);
+			extraFieldNTFS.uint64(lastModTimeNTFS);
+			extraFieldNTFS.uint64(getTimeNTFS(lastAccessDate) || lastModTimeNTFS);
+			extraFieldNTFS.uint64(getTimeNTFS(creationDate) || lastModTimeNTFS);
+			rawExtraFieldNTFS = extraFieldNTFS.array;
 		} catch {
 			rawExtraFieldNTFS = new Uint8Array();
 		}
@@ -1107,41 +1290,27 @@ function getHeaderInfo(options) {
 	}
 	let rawExtraFieldUnix;
 	try {
-		const { uid, gid, unixMode, setuid, setgid, sticky, unixExtraFieldType } = options;
-		if (unixExtraFieldType && (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE || unixMode !== UNDEFINED_VALUE)) {
+		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);
-			let modeArray = new Uint8Array();
-			if (unixExtraFieldType == UNIX_EXTRA_FIELD_TYPE && unixMode !== UNDEFINED_VALUE) {
-				let modeToWrite = unixMode & MAX_16_BITS;
-				if (setuid) {
-					modeToWrite |= FILE_ATTR_UNIX_SETUID_MASK;
-				}
-				if (setgid) {
-					modeToWrite |= FILE_ATTR_UNIX_SETGID_MASK;
-				}
-				if (sticky) {
-					modeToWrite |= FILE_ATTR_UNIX_STICKY_MASK;
-				}
-				modeArray = new Uint8Array(2);
-				const modeDataView = new DataView(modeArray.buffer);
-				modeDataView.setUint16(0, modeToWrite, true);
-			}
-			const payloadLength = 3 + uidBytes.length + gidBytes.length + modeArray.length;
-			rawExtraFieldUnix = new Uint8Array(4 + payloadLength);
-			const rawExtraFieldUnixView = getDataView(rawExtraFieldUnix);
-			setUint16(rawExtraFieldUnixView, 0, unixExtraFieldType == INFOZIP_EXTRA_FIELD_TYPE ? EXTRAFIELD_TYPE_INFOZIP : EXTRAFIELD_TYPE_UNIX);
-			setUint16(rawExtraFieldUnixView, 2, payloadLength);
-			setUint8(rawExtraFieldUnixView, 4, 1);
-			setUint8(rawExtraFieldUnixView, 5, uidBytes.length);
-			let offset = 6;
-			arraySet(rawExtraFieldUnix, uidBytes, offset);
-			offset += uidBytes.length;
-			setUint8(rawExtraFieldUnixView, offset, gidBytes.length);
-			offset++;
-			arraySet(rawExtraFieldUnix, gidBytes, offset);
-			offset += gidBytes.length;
-			arraySet(rawExtraFieldUnix, modeArray, offset);
+			const payloadLength = 3 + uidBytes.length + gidBytes.length;
+			const extraFieldUnix = createRecordWriter(4 + payloadLength);
+			extraFieldUnix.uint16(EXTRAFIELD_TYPE_INFOZIP);
+			extraFieldUnix.uint16(payloadLength);
+			extraFieldUnix.uint8(1);
+			extraFieldUnix.uint8(uidBytes.length);
+			extraFieldUnix.bytes(uidBytes);
+			extraFieldUnix.uint8(gidBytes.length);
+			extraFieldUnix.bytes(gidBytes);
+			rawExtraFieldUnix = extraFieldUnix.array;
+		} else if (unixExtraFieldType == UNIX_EXTRA_FIELD_TYPE && (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE)) {
+			const extraFieldUnix = createRecordWriter(8);
+			extraFieldUnix.uint16(EXTRAFIELD_TYPE_UNIX);
+			extraFieldUnix.uint16(4);
+			extraFieldUnix.uint16((uid === UNDEFINED_VALUE ? 0 : uid) & MAX_16_BITS);
+			extraFieldUnix.uint16((gid === UNDEFINED_VALUE ? 0 : gid) & MAX_16_BITS);
+			rawExtraFieldUnix = extraFieldUnix.array;
 		} else {
 			rawExtraFieldUnix = new Uint8Array();
 		}
@@ -1159,8 +1328,11 @@ function getHeaderInfo(options) {
 		rawExtraFieldAES[9] = compressionMethod;
 		compressionMethod = COMPRESSION_METHOD_AES;
 	}
-	const localExtraFieldZip64Length = zip64ExtraFieldComplete ? getLength(rawLocalExtraFieldZip64) : 0;
+	const localExtraFieldZip64Length = writeLocalExtraFieldZip64 ? getLength(rawLocalExtraFieldZip64) : 0;
 	const extraFieldLength = localExtraFieldZip64Length + getLength(rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField);
+	if (extraFieldLength > MAX_16_BITS) {
+		throw new Error(ERR_INVALID_EXTRAFIELD_DATA);
+	}
 	const {
 		headerArray,
 		headerView,
@@ -1176,29 +1348,27 @@ function getHeaderInfo(options) {
 		zip64UncompressedSize,
 		extraFieldLength
 	});
-	let localHeaderOffset = HEADER_SIZE;
-	const localHeaderArray = new Uint8Array(localHeaderOffset + getLength(rawFilename) + extraFieldLength);
+	const localHeader = createRecordWriter(HEADER_SIZE + getLength(rawFilename) + extraFieldLength);
+	const localHeaderArray = localHeader.array;
 	const localHeaderView = getDataView(localHeaderArray);
-	setUint32(localHeaderView, 0, LOCAL_FILE_HEADER_SIGNATURE);
-	arraySet(localHeaderArray, headerArray, 4);
-	arraySet(localHeaderArray, rawFilename, localHeaderOffset);
-	localHeaderOffset += getLength(rawFilename);
-	if (zip64ExtraFieldComplete) {
-		arraySet(localHeaderArray, rawLocalExtraFieldZip64, localHeaderOffset);
-	}
-	localHeaderOffset += localExtraFieldZip64Length;
-	arraySet(localHeaderArray, rawExtraFieldAES, localHeaderOffset);
-	localHeaderOffset += getLength(rawExtraFieldAES);
-	arraySet(localHeaderArray, rawExtraFieldExtendedTimestamp, localHeaderOffset);
-	localHeaderOffset += getLength(rawExtraFieldExtendedTimestamp);
-	arraySet(localHeaderArray, rawExtraFieldNTFS, localHeaderOffset);
-	localHeaderOffset += getLength(rawExtraFieldNTFS);
-	arraySet(localHeaderArray, rawExtraFieldUnix, localHeaderOffset);
-	localHeaderOffset += getLength(rawExtraFieldUnix);
-	arraySet(localHeaderArray, rawExtraField, localHeaderOffset);
+	localHeader.uint32(LOCAL_FILE_HEADER_SIGNATURE);
+	localHeader.bytes(headerArray);
+	localHeader.bytes(rawFilename);
+	if (writeLocalExtraFieldZip64) {
+		localHeader.bytes(rawLocalExtraFieldZip64);
+	}
+	localHeader.bytes(rawExtraFieldAES);
+	localHeader.bytes(rawExtraFieldExtendedTimestamp);
+	localHeader.bytes(rawExtraFieldNTFS);
+	localHeader.bytes(rawExtraFieldUnix);
+	localHeader.bytes(rawExtraField);
 	if (dataDescriptor) {
-		setUint32(localHeaderView, HEADER_OFFSET_COMPRESSED_SIZE + 4, 0);
-		setUint32(localHeaderView, HEADER_OFFSET_UNCOMPRESSED_SIZE + 4, 0);
+		if (!zip64CompressedSize) {
+			setUint32(localHeaderView, HEADER_OFFSET_COMPRESSED_SIZE + LOCAL_HEADER_COMMON_OFFSET, 0);
+		}
+		if (!zip64UncompressedSize) {
+			setUint32(localHeaderView, HEADER_OFFSET_UNCOMPRESSED_SIZE + LOCAL_HEADER_COMMON_OFFSET, 0);
+		}
 	}
 	return {
 		localHeaderArray,
@@ -1225,7 +1395,7 @@ function getHeaderInfo(options) {
 function appendExtraFieldUSDZ(entryInfo, zipWriterOffset) {
 	const { headerInfo } = entryInfo;
 	let { localHeaderArray, extraFieldLength } = headerInfo;
-	let localHeaderArrayView = getDataView(localHeaderArray);
+	let localHeaderArrayView;
 	let extraBytesLength = 64 - ((zipWriterOffset + getLength(localHeaderArray)) % 64);
 	if (extraBytesLength < 4) {
 		extraBytesLength += 64;
@@ -1233,13 +1403,14 @@ function appendExtraFieldUSDZ(entryInfo, zipWriterOffset) {
 	const rawExtraFieldUSDZ = new Uint8Array(extraBytesLength);
 	const extraFieldUSDZView = getDataView(rawExtraFieldUSDZ);
 	setUint16(extraFieldUSDZView, 0, EXTRAFIELD_TYPE_USDZ);
-	setUint16(extraFieldUSDZView, 2, extraBytesLength - 2);
+	setUint16(extraFieldUSDZView, 2, extraBytesLength - 4);
 	const previousLocalHeaderArray = localHeaderArray;
 	headerInfo.localHeaderArray = localHeaderArray = new Uint8Array(getLength(previousLocalHeaderArray) + extraBytesLength);
 	arraySet(localHeaderArray, previousLocalHeaderArray);
 	arraySet(localHeaderArray, rawExtraFieldUSDZ, getLength(previousLocalHeaderArray));
 	localHeaderArrayView = getDataView(localHeaderArray);
 	setUint16(localHeaderArrayView, 28, extraFieldLength + extraBytesLength);
+	headerInfo.localHeaderView = localHeaderArrayView;
 	entryInfo.metadataSize += extraBytesLength;
 }
 
@@ -1362,37 +1533,32 @@ function updateLocalHeader({
 }, localHeaderView, { dataDescriptor }) {
 	if (!dataDescriptor) {
 		if (!encrypted) {
-			setUint32(localHeaderView, HEADER_OFFSET_SIGNATURE + 4, signature);
+			setUint32(localHeaderView, HEADER_OFFSET_SIGNATURE + LOCAL_HEADER_COMMON_OFFSET, signature);
 		}
 		if (!zip64CompressedSize) {
-			setUint32(localHeaderView, HEADER_OFFSET_COMPRESSED_SIZE + 4, compressedSize);
+			setUint32(localHeaderView, HEADER_OFFSET_COMPRESSED_SIZE + LOCAL_HEADER_COMMON_OFFSET, compressedSize);
 		}
 		if (!zip64UncompressedSize) {
-			setUint32(localHeaderView, HEADER_OFFSET_UNCOMPRESSED_SIZE + 4, uncompressedSize);
+			setUint32(localHeaderView, HEADER_OFFSET_UNCOMPRESSED_SIZE + LOCAL_HEADER_COMMON_OFFSET, uncompressedSize);
 		}
 	}
 	if (zip64 && localExtraFieldZip64Length) {
-		let localHeaderOffset = HEADER_SIZE + getLength(rawFilename) + 4;
-		if (zip64UncompressedSize) {
-			setBigUint64(localHeaderView, localHeaderOffset, BigInt(uncompressedSize));
-			localHeaderOffset += 8;
-		}
-		if (zip64CompressedSize) {
-			setBigUint64(localHeaderView, localHeaderOffset, BigInt(compressedSize));
-			localHeaderOffset += 8;
-		}
+		// the local zip64 extra field always contains both size slots
+		const localHeaderOffset = HEADER_SIZE + getLength(rawFilename) + 4;
+		setBigUint64(localHeaderView, localHeaderOffset, BigInt(uncompressedSize));
+		setBigUint64(localHeaderView, localHeaderOffset + 8, BigInt(compressedSize));
 	}
 }
 
 
 async function closeFile(zipWriter, comment, options) {
-	const { files, writer } = zipWriter;
-	const { diskOffset } = writer;
-	let { diskNumber } = writer;
-	let offset = 0;
+	const directoryDataLength = createDirectoryRecords(zipWriter.files);
+	const { cdStartDiskNumber, cdStartDiskOffset } = await writeDirectoryRecords(zipWriter, directoryDataLength, options);
+	await writeEndOfDirectoryRecord(zipWriter, comment, options, { cdStartDiskNumber, cdStartDiskOffset, directoryDataLength });
+}
+
+function createDirectoryRecords(files) {
 	let directoryDataLength = 0;
-	let directoryOffset = zipWriter.offset - diskOffset;
-	let filesLength = files.size;
 	for (const [, fileEntry] of files) {
 		const {
 			rawFilename,
@@ -1409,24 +1575,27 @@ async function closeFile(zipWriter, comment, options) {
 			uncompressedSize,
 			compressedSize
 		} = fileEntry;
-		const zip64Offset = fileEntry.offset > MAX_32_BITS;
-		const zip64DiskNumberStart = fileEntry.diskNumberStart > MAX_16_BITS;
+		const zip64Offset = fileEntry.offset >= MAX_32_BITS;
+		const zip64DiskNumberStart = fileEntry.diskNumberStart >= MAX_16_BITS;
 		let rawExtraFieldZip64;
 		if (zip64Offset || zip64DiskNumberStart || zip64UncompressedSize || zip64CompressedSize) {
-			let length = 4;
-			if (zip64UncompressedSize) length += 8;
-			if (zip64CompressedSize) length += 8;
-			if (zip64Offset) length += 8;
-			if (zip64DiskNumberStart) length += 4;
-			rawExtraFieldZip64 = new Uint8Array(length);
-			const zip64View = getDataView(rawExtraFieldZip64);
-			setUint16(zip64View, 0, EXTRAFIELD_TYPE_ZIP64);
-			setUint16(zip64View, 2, length - 4);
-			let zip64FieldOffset = 4;
-			if (zip64UncompressedSize) { setBigUint64(zip64View, zip64FieldOffset, BigInt(uncompressedSize)); zip64FieldOffset += 8; }
-			if (zip64CompressedSize) { setBigUint64(zip64View, zip64FieldOffset, BigInt(compressedSize)); zip64FieldOffset += 8; }
-			if (zip64Offset) { setBigUint64(zip64View, zip64FieldOffset, BigInt(fileEntry.offset)); zip64FieldOffset += 8; }
-			if (zip64DiskNumberStart) { setUint32(zip64View, zip64FieldOffset, fileEntry.diskNumberStart); }
+			const length = 4 + (zip64UncompressedSize ? 8 : 0) + (zip64CompressedSize ? 8 : 0) + (zip64Offset ? 8 : 0) + (zip64DiskNumberStart ? 4 : 0);
+			const extraFieldZip64 = createRecordWriter(length);
+			extraFieldZip64.uint16(EXTRAFIELD_TYPE_ZIP64);
+			extraFieldZip64.uint16(length - 4);
+			if (zip64UncompressedSize) {
+				extraFieldZip64.uint64(uncompressedSize);
+			}
+			if (zip64CompressedSize) {
+				extraFieldZip64.uint64(compressedSize);
+			}
+			if (zip64Offset) {
+				extraFieldZip64.uint64(fileEntry.offset);
+			}
+			if (zip64DiskNumberStart) {
+				extraFieldZip64.uint32(fileEntry.diskNumberStart);
+			}
+			rawExtraFieldZip64 = extraFieldZip64.array;
 		} else {
 			rawExtraFieldZip64 = new Uint8Array();
 		}
@@ -1434,32 +1603,41 @@ async function closeFile(zipWriter, comment, options) {
 		fileEntry.zip64Offset = zip64Offset;
 		fileEntry.zip64DiskNumberStart = zip64DiskNumberStart;
 		let rawExtraFieldTimestamp;
-		if (extendedTimestamp) {
-			rawExtraFieldTimestamp = new Uint8Array(9);
-			const extraFieldExtendedTimestampView = getDataView(rawExtraFieldTimestamp);
-			setUint16(extraFieldExtendedTimestampView, 0, EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
-			setUint16(extraFieldExtendedTimestampView, 2, 5);
-			setUint8(extraFieldExtendedTimestampView, 4, extraFieldExtendedTimestampFlag);
-			setUint32(extraFieldExtendedTimestampView, 5, Math.floor(lastModDate.getTime() / 1000));
+		const lastModTimeUnix = getTimeUnix(lastModDate);
+		if (extendedTimestamp && inUnixTimeRange(lastModTimeUnix)) {
+			const extraFieldTimestamp = createRecordWriter(9);
+			extraFieldTimestamp.uint16(EXTRAFIELD_TYPE_EXTENDED_TIMESTAMP);
+			extraFieldTimestamp.uint16(5);
+			extraFieldTimestamp.uint8(extraFieldExtendedTimestampFlag);
+			extraFieldTimestamp.uint32(lastModTimeUnix);
+			rawExtraFieldTimestamp = extraFieldTimestamp.array;
 		} else {
 			rawExtraFieldTimestamp = new Uint8Array();
 		}
 		fileEntry.rawExtraFieldExtendedTimestamp = rawExtraFieldTimestamp;
-		directoryDataLength += 46 +
-			getLength(
-				rawFilename,
-				rawComment,
-				rawExtraFieldZip64,
-				rawExtraFieldAES,
-				rawExtraFieldNTFS,
-				rawExtraFieldUnix,
-				rawExtraFieldTimestamp,
-				rawExtraField);
+		const extraFieldLength = getLength(
+			rawExtraFieldZip64,
+			rawExtraFieldAES,
+			rawExtraFieldNTFS,
+			rawExtraFieldUnix,
+			rawExtraFieldTimestamp,
+			rawExtraField);
+		if (extraFieldLength > MAX_16_BITS) {
+			throw new Error(ERR_INVALID_EXTRAFIELD_DATA);
+		}
+		directoryDataLength += CENTRAL_FILE_HEADER_LENGTH + getLength(rawFilename, rawComment) + extraFieldLength;
 	}
+	return directoryDataLength;
+}
+
+async function writeDirectoryRecords(zipWriter, directoryDataLength, options) {
+	const { files, writer } = zipWriter;
 	const directoryArray = new Uint8Array(directoryDataLength);
-	const directoryView = getDataView(directoryArray);
 	await initStream(writer);
+	let offset = 0;
 	let directoryDiskOffset = 0;
+	let cdStartDiskNumber = writer.diskNumber;
+	let cdStartDiskOffset = writer.diskOffset;
 	for (const [indexFileEntry, fileEntry] of Array.from(files.values()).entries()) {
 		const {
 			offset: fileEntryOffset,
@@ -1485,52 +1663,46 @@ async function closeFile(zipWriter, comment, options) {
 			compressedSize
 		} = fileEntry;
 		const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField);
-		setUint32(directoryView, offset, CENTRAL_FILE_HEADER_SIGNATURE);
-		setUint16(directoryView, offset + 4, versionMadeBy);
+		const directoryRecordLength = CENTRAL_FILE_HEADER_LENGTH + getLength(rawFilename, rawComment) + extraFieldLength;
+		if (offset + directoryRecordLength - directoryDiskOffset > writer.availableSize) {
+			await writeData(writer, directoryArray.slice(directoryDiskOffset, offset));
+			directoryDiskOffset = offset;
+			writer.availableSize = 0;
+			await writeData(writer, new Uint8Array());
+		}
+		if (indexFileEntry == 0) {
+			cdStartDiskNumber = writer.diskNumber;
+			cdStartDiskOffset = writer.diskOffset;
+		}
 		if (!zip64UncompressedSize) {
 			setUint32(headerView, HEADER_OFFSET_UNCOMPRESSED_SIZE, uncompressedSize);
 		}
 		if (!zip64CompressedSize) {
 			setUint32(headerView, HEADER_OFFSET_COMPRESSED_SIZE, compressedSize);
 		}
-		arraySet(directoryArray, headerArray, offset + 6);
-		let directoryOffset = offset + HEADER_SIZE;
-		setUint16(directoryView, directoryOffset, extraFieldLength);
-		directoryOffset += 2;
-		setUint16(directoryView, directoryOffset, getLength(rawComment));
-		directoryOffset += 2;
-		setUint16(directoryView, directoryOffset, zip64DiskNumberStart ? MAX_16_BITS : diskNumberStart);
-		directoryOffset += 2;
-		setUint16(directoryView, directoryOffset, internalFileAttributes);
-		directoryOffset += 2;
-		if (externalFileAttributes) {
-			setUint32(directoryView, directoryOffset, externalFileAttributes);
-		}
-		directoryOffset += 4;
-		setUint32(directoryView, directoryOffset, zip64Offset ? MAX_32_BITS : fileEntryOffset);
-		directoryOffset += 4;
-		arraySet(directoryArray, rawFilename, directoryOffset);
-		directoryOffset += getLength(rawFilename);
-		arraySet(directoryArray, rawExtraFieldZip64, directoryOffset);
-		directoryOffset += getLength(rawExtraFieldZip64);
-		arraySet(directoryArray, rawExtraFieldAES, directoryOffset);
-		directoryOffset += getLength(rawExtraFieldAES);
-		arraySet(directoryArray, rawExtraFieldExtendedTimestamp, directoryOffset);
-		directoryOffset += getLength(rawExtraFieldExtendedTimestamp);
-		arraySet(directoryArray, rawExtraFieldNTFS, directoryOffset);
-		directoryOffset += getLength(rawExtraFieldNTFS);
-		arraySet(directoryArray, rawExtraFieldUnix, directoryOffset);
-		directoryOffset += getLength(rawExtraFieldUnix);
-		arraySet(directoryArray, rawExtraField, directoryOffset);
-		directoryOffset += getLength(rawExtraField);
-		arraySet(directoryArray, rawComment, directoryOffset);
-		directoryOffset += getLength(rawComment);
-		if (offset - directoryDiskOffset > writer.availableSize) {
-			writer.availableSize = 0;
-			await writeData(writer, directoryArray.slice(directoryDiskOffset, offset));
-			directoryDiskOffset = offset;
+		if ((zip64Offset || zip64DiskNumberStart) && fileEntry.version < VERSION_ZIP64) {
+			setUint16(headerView, HEADER_OFFSET_VERSION, VERSION_ZIP64);
 		}
-		offset = directoryOffset;
+		const directoryRecord = createRecordWriter(directoryRecordLength);
+		directoryRecord.uint32(CENTRAL_FILE_HEADER_SIGNATURE);
+		directoryRecord.uint16(versionMadeBy);
+		directoryRecord.bytes(headerArray.subarray(0, HEADER_SIZE - 4 - 2));
+		directoryRecord.uint16(extraFieldLength);
+		directoryRecord.uint16(getLength(rawComment));
+		directoryRecord.uint16(zip64DiskNumberStart ? MAX_16_BITS : diskNumberStart);
+		directoryRecord.uint16(internalFileAttributes);
+		directoryRecord.uint32(externalFileAttributes);
+		directoryRecord.uint32(zip64Offset ? MAX_32_BITS : fileEntryOffset);
+		directoryRecord.bytes(rawFilename);
+		directoryRecord.bytes(rawExtraFieldZip64);
+		directoryRecord.bytes(rawExtraFieldAES);
+		directoryRecord.bytes(rawExtraFieldExtendedTimestamp);
+		directoryRecord.bytes(rawExtraFieldNTFS);
+		directoryRecord.bytes(rawExtraFieldUnix);
+		directoryRecord.bytes(rawExtraField);
+		directoryRecord.bytes(rawComment);
+		arraySet(directoryArray, directoryRecord.array, offset);
+		offset += directoryRecordLength;
 		if (options.onprogress) {
 			try {
 				await options.onprogress(indexFileEntry + 1, files.size, new Entry(fileEntry));
@@ -1540,36 +1712,53 @@ async function closeFile(zipWriter, comment, options) {
 		}
 	}
 	await writeData(writer, directoryDiskOffset ? directoryArray.slice(directoryDiskOffset) : directoryArray);
+	return { cdStartDiskNumber, cdStartDiskOffset };
+}
+
+async function writeEndOfDirectoryRecord(zipWriter, comment, options, cdInfo) {
+	const { writer } = zipWriter;
+	const { cdStartDiskNumber, cdStartDiskOffset } = cdInfo;
+	let { directoryDataLength } = cdInfo;
+	let filesLength = zipWriter.files.size;
+	let diskNumber = cdStartDiskNumber;
+	let directoryOffset = zipWriter.offset - cdStartDiskOffset - (cdStartDiskNumber ? zipWriter.initialOffset : 0);
 	let lastDiskNumber = writer.diskNumber;
-	const { availableSize } = writer;
-	if (availableSize < END_OF_CENTRAL_DIR_LENGTH) {
+	if (writer.availableSize < END_OF_CENTRAL_DIR_LENGTH) {
 		lastDiskNumber++;
 	}
 	let zip64 = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIP64);
-	if (directoryOffset > MAX_32_BITS || directoryDataLength > MAX_32_BITS || filesLength > MAX_16_BITS || lastDiskNumber > MAX_16_BITS) {
+	if (directoryOffset >= MAX_32_BITS || directoryDataLength >= MAX_32_BITS || filesLength >= MAX_16_BITS || lastDiskNumber >= MAX_16_BITS) {
 		if (zip64 === false) {
 			throw new Error(ERR_UNSUPPORTED_FORMAT);
 		} else {
 			zip64 = true;
 		}
 	}
-	const endOfdirectoryArray = new Uint8Array(zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
-	const endOfdirectoryView = getDataView(endOfdirectoryArray);
-	offset = 0;
+	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 (getLength(endOfdirectoryRecord.array) + commentLength > writer.availableSize) {
+		writer.availableSize = 0;
+		await writeData(writer, new Uint8Array());
+	}
+	lastDiskNumber = writer.diskNumber;
 	if (zip64) {
-		setUint32(endOfdirectoryView, 0, ZIP64_END_OF_CENTRAL_DIR_SIGNATURE);
-		setBigUint64(endOfdirectoryView, 4, BigInt(44));
-		setUint16(endOfdirectoryView, 12, 45);
-		setUint16(endOfdirectoryView, 14, 45);
-		setUint32(endOfdirectoryView, 16, lastDiskNumber);
-		setUint32(endOfdirectoryView, 20, diskNumber);
-		setBigUint64(endOfdirectoryView, 24, BigInt(filesLength));
-		setBigUint64(endOfdirectoryView, 32, BigInt(filesLength));
-		setBigUint64(endOfdirectoryView, 40, BigInt(directoryDataLength));
-		setBigUint64(endOfdirectoryView, 48, BigInt(directoryOffset));
-		setUint32(endOfdirectoryView, 56, ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE);
-		setBigUint64(endOfdirectoryView, 64, BigInt(directoryOffset) + BigInt(directoryDataLength));
-		setUint32(endOfdirectoryView, 72, lastDiskNumber + 1);
+		endOfdirectoryRecord.uint32(ZIP64_END_OF_CENTRAL_DIR_SIGNATURE);
+		endOfdirectoryRecord.uint64(44);
+		endOfdirectoryRecord.uint16(45);
+		endOfdirectoryRecord.uint16(45);
+		endOfdirectoryRecord.uint32(lastDiskNumber);
+		endOfdirectoryRecord.uint32(diskNumber);
+		endOfdirectoryRecord.uint64(filesLength);
+		endOfdirectoryRecord.uint64(filesLength);
+		endOfdirectoryRecord.uint64(directoryDataLength);
+		endOfdirectoryRecord.uint64(directoryOffset);
+		endOfdirectoryRecord.uint32(ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIGNATURE);
+		endOfdirectoryRecord.uint32(lastDiskNumber);
+		endOfdirectoryRecord.uint64(BigInt(zipWriter.offset) + BigInt(directoryDataLength) - BigInt(writer.diskOffset) - BigInt(writer.diskNumber ? zipWriter.initialOffset : 0));
+		endOfdirectoryRecord.uint32(lastDiskNumber + 1);
 		const supportZip64SplitFile = getOptionValue(zipWriter, options, OPTION_SUPPORT_ZIP64_SPLIT_FILE, true);
 		if (supportZip64SplitFile) {
 			lastDiskNumber = MAX_16_BITS;
@@ -1578,29 +1767,40 @@ async function closeFile(zipWriter, comment, options) {
 		filesLength = MAX_16_BITS;
 		directoryOffset = MAX_32_BITS;
 		directoryDataLength = MAX_32_BITS;
-		offset += ZIP64_END_OF_CENTRAL_DIR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH;
-	}
-	setUint32(endOfdirectoryView, offset, END_OF_CENTRAL_DIR_SIGNATURE);
-	setUint16(endOfdirectoryView, offset + 4, lastDiskNumber);
-	setUint16(endOfdirectoryView, offset + 6, diskNumber);
-	setUint16(endOfdirectoryView, offset + 8, filesLength);
-	setUint16(endOfdirectoryView, offset + 10, filesLength);
-	setUint32(endOfdirectoryView, offset + 12, directoryDataLength);
-	setUint32(endOfdirectoryView, offset + 16, directoryOffset);
-	const commentLength = getLength(comment);
-	if (commentLength) {
-		if (commentLength <= MAX_16_BITS) {
-			setUint16(endOfdirectoryView, offset + 20, commentLength);
-		} else {
-			throw new Error(ERR_INVALID_COMMENT);
-		}
 	}
-	await writeData(writer, endOfdirectoryArray);
+	endOfdirectoryRecord.uint32(END_OF_CENTRAL_DIR_SIGNATURE);
+	endOfdirectoryRecord.uint16(lastDiskNumber);
+	endOfdirectoryRecord.uint16(diskNumber);
+	endOfdirectoryRecord.uint16(filesLength);
+	endOfdirectoryRecord.uint16(filesLength);
+	endOfdirectoryRecord.uint32(directoryDataLength);
+	endOfdirectoryRecord.uint32(directoryOffset);
+	endOfdirectoryRecord.uint16(commentLength);
+	await writeData(writer, endOfdirectoryRecord.array);
 	if (commentLength) {
 		await writeData(writer, comment);
 	}
 }
 
+function createRecordWriter(length) {
+	const array = new Uint8Array(length);
+	const view = getDataView(array);
+	let offset = 0;
+	return {
+		array,
+		uint8: value => { setUint8(view, offset, value); offset += 1; },
+		uint16: value => { setUint16(view, offset, value); offset += 2; },
+		uint32: value => { setUint32(view, offset, value); offset += 4; },
+		uint64: value => { setBigUint64(view, offset, BigInt(value)); offset += 8; },
+		bytes: value => { arraySet(array, value, offset); offset += getLength(value); },
+		skip: count => offset += count
+	};
+}
+
+function getSegmentOffset(zipWriter, writer) {
+	return zipWriter.offset - writer.diskOffset - (writer.diskNumber ? zipWriter.initialOffset : 0);
+}
+
 async function writeData(writer, array) {
 	const { writable } = writer;
 	const streamWriter = writable.getWriter();
@@ -1613,12 +1813,40 @@ async function writeData(writer, array) {
 	}
 }
 
+async function flushBufferedData(readable, writer, signal, onChunkWritten) {
+	const streamWriter = writer.writable.getWriter();
+	try {
+		await readable.pipeTo(new WritableStream({
+			async write(chunk) {
+				await streamWriter.ready;
+				await streamWriter.write(chunk);
+				onChunkWritten(getLength(chunk));
+			}
+		}), { preventClose: true, preventAbort: true, signal });
+	} finally {
+		streamWriter.releaseLock();
+	}
+}
+
 function getTimeNTFS(date) {
 	if (date) {
 		return ((BigInt(date.getTime()) + BigInt(11644473600000)) * BigInt(10000));
 	}
 }
 
+function getTimeUnix(date) {
+	return Math.floor(date.getTime() / 1000);
+}
+
+// the extended timestamp extra field stores dates as signed 32-bit time_t values
+function inUnixTimeRange(timeUnix) {
+	return timeUnix >= MIN_UNIX_TIME && timeUnix <= MAX_UNIX_TIME;
+}
+
+function clampUnixTime(timeUnix) {
+	return Math.min(MAX_UNIX_TIME, Math.max(MIN_UNIX_TIME, timeUnix));
+}
+
 function getOptionValue(zipWriter, options, name, defaultValue) {
 	const result = options[name] === UNDEFINED_VALUE ? zipWriter.options[name] : options[name];
 	return result === UNDEFINED_VALUE ? defaultValue : result;
@@ -1649,7 +1877,7 @@ function arraySet(array, typedArray, offset) {
 }
 
 function getDataView(array) {
-	return new DataView(array.buffer);
+	return new DataView(array.buffer, array.byteOffset, array.byteLength);
 }
 
 function getLength(...arrayLikes) {
@@ -1665,30 +1893,39 @@ function getHeaderArrayData({
 	uncompressedSize,
 	compressedSize,
 	lastModDate,
+	rawLastModDate,
 	rawFilename,
 	zip64CompressedSize,
 	zip64UncompressedSize,
 	extraFieldLength
 }) {
-	const headerArray = new Uint8Array(HEADER_SIZE - 4);
+	const headerRecord = createRecordWriter(HEADER_SIZE - 4);
+	const headerArray = headerRecord.array;
 	const headerView = getDataView(headerArray);
-	setUint16(headerView, 0, version);
-	setUint16(headerView, 2, bitFlag);
-	setUint16(headerView, 4, compressionMethod);
-	const dateArray = new Uint32Array(1);
-	const dateView = getDataView(dateArray);
-	setUint16(dateView, 0, (((lastModDate.getHours() << 6) | lastModDate.getMinutes()) << 5) | lastModDate.getSeconds() / 2);
-	setUint16(dateView, 2, ((((lastModDate.getFullYear() - 1980) << 4) | (lastModDate.getMonth() + 1)) << 5) | lastModDate.getDate());
-	const rawLastModDate = dateArray[0];
-	setUint32(headerView, 6, rawLastModDate);
+	headerRecord.uint16(version);
+	headerRecord.uint16(bitFlag);
+	headerRecord.uint16(compressionMethod);
+	if (rawLastModDate === UNDEFINED_VALUE) {
+		const dateArray = new Uint32Array(1);
+		const dateView = getDataView(dateArray);
+		setUint16(dateView, 0, (((lastModDate.getHours() << 6) | lastModDate.getMinutes()) << 5) | lastModDate.getSeconds() / 2);
+		setUint16(dateView, 2, ((((lastModDate.getFullYear() - 1980) << 4) | (lastModDate.getMonth() + 1)) << 5) | lastModDate.getDate());
+		rawLastModDate = dateArray[0];
+	}
+	headerRecord.uint32(rawLastModDate);
+	headerRecord.skip(4);
 	if (zip64CompressedSize || compressedSize !== UNDEFINED_VALUE) {
-		setUint32(headerView, HEADER_OFFSET_COMPRESSED_SIZE, zip64CompressedSize ? MAX_32_BITS : compressedSize);
+		headerRecord.uint32(zip64CompressedSize ? MAX_32_BITS : compressedSize);
+	} else {
+		headerRecord.skip(4);
 	}
 	if (zip64UncompressedSize || uncompressedSize !== UNDEFINED_VALUE) {
-		setUint32(headerView, HEADER_OFFSET_UNCOMPRESSED_SIZE, zip64UncompressedSize ? MAX_32_BITS : uncompressedSize);
+		headerRecord.uint32(zip64UncompressedSize ? MAX_32_BITS : uncompressedSize);
+	} else {
+		headerRecord.skip(4);
 	}
-	setUint16(headerView, 22, getLength(rawFilename));
-	setUint16(headerView, 24, extraFieldLength);
+	headerRecord.uint16(getLength(rawFilename));
+	headerRecord.uint16(extraFieldLength);
 	return {
 		headerArray,
 		headerView,