@zip.js/zip.js 2.8.6 → 2.8.8

package/lib/core/zip-writer.js

@@ -32,6 +32,7 @@
 import {
 	MAX_32_BITS,
 	MAX_16_BITS,
+	MAX_8_BITS,
 	COMPRESSION_METHOD_DEFLATE,
 	COMPRESSION_METHOD_DEFLATE_64,
 	COMPRESSION_METHOD_STORE,
@@ -52,6 +53,8 @@ import {
 	EXTRAFIELD_TYPE_NTFS,
 	EXTRAFIELD_TYPE_NTFS_TAG1,
 	EXTRAFIELD_TYPE_USDZ,
+	EXTRAFIELD_TYPE_INFOZIP,
+	EXTRAFIELD_TYPE_UNIX,
 	END_OF_CENTRAL_DIR_LENGTH,
 	ZIP64_END_OF_CENTRAL_DIR_LENGTH,
 	ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH,
@@ -63,9 +66,16 @@ import {
 	BITFLAG_LEVEL_SUPER_FAST_MASK,
 	BITFLAG_LEVEL_MAX_MASK,
 	FILE_ATTR_MSDOS_DIR_MASK,
+	FILE_ATTR_MSDOS_READONLY_MASK,
+	FILE_ATTR_MSDOS_HIDDEN_MASK,
+	FILE_ATTR_MSDOS_SYSTEM_MASK,
+	FILE_ATTR_MSDOS_ARCHIVE_MASK,
 	FILE_ATTR_UNIX_TYPE_DIR,
 	FILE_ATTR_UNIX_EXECUTABLE_MASK,
 	FILE_ATTR_UNIX_DEFAULT_MASK,
+	FILE_ATTR_UNIX_SETUID_MASK,
+	FILE_ATTR_UNIX_SETGID_MASK,
+	FILE_ATTR_UNIX_STICKY_MASK,
 	VERSION_DEFLATE,
 	VERSION_ZIP64,
 	VERSION_AES,
@@ -76,7 +86,8 @@ import {
 	HEADER_OFFSET_UNCOMPRESSED_SIZE,
 	MIN_DATE,
 	MAX_DATE,
-	UNDEFINED_VALUE
+	UNDEFINED_VALUE,
+	OBJECT_TYPE
 } from "./constants.js";
 import {
 	getConfiguration,
@@ -111,6 +122,14 @@ import {
 	PROPERTY_NAME_COMMENT,
 	PROPERTY_NAME_UNCOMPRESSED_SIZE,
 	PROPERTY_NAME_EXTRA_FIELD,
+	PROPERTY_NAME_UID,
+	PROPERTY_NAME_GID,
+	PROPERTY_NAME_UNIX_MODE,
+	PROPERTY_NAME_SETUID,
+	PROPERTY_NAME_SETGID,
+	PROPERTY_NAME_STICKY,
+	PROPERTY_NAME_MSDOS_ATTRIBUTES,
+	PROPERTY_NAME_MSDOS_ATTRIBUTES_RAW,
 	Entry
 } from "./zip-entry.js";
 import {
@@ -132,7 +151,8 @@ import {
 	OPTION_SUPPORT_ZIP64_SPLIT_FILE,
 	OPTION_ENCODE_TEXT,
 	OPTION_OFFSET,
-	OPTION_USDZ
+	OPTION_USDZ,
+	OPTION_UNIX_EXTRA_FIELD_TYPE
 } from "./options.js";
 import {
 	ZipReader
@@ -149,8 +169,16 @@ const ERR_INVALID_EXTRAFIELD_DATA = "Extra field data exceeds 64KB";
 const ERR_UNSUPPORTED_FORMAT = "Zip64 is not supported (make sure 'keepOrder' is set to 'true')";
 const ERR_UNDEFINED_UNCOMPRESSED_SIZE = "Undefined uncompressed size";
 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_MSDOS_ATTRIBUTES = "Invalid msdosAttributesRaw (must be integer 0..255)";
+const ERR_INVALID_MSDOS_DATA = "Invalid msdosAttributes (must be an object with boolean flags)";
 
 const EXTRAFIELD_DATA_AES = new Uint8Array([0x07, 0x00, 0x02, 0x00, 0x41, 0x45, 0x03, 0x00, 0x00]);
+const INFOZIP_EXTRA_FIELD_TYPE = "infozip";
+const UNIX_EXTRA_FIELD_TYPE = "unix";
 
 let workers = 0;
 const pendingEntries = [];
@@ -208,15 +236,17 @@ class ZipWriter {
 				rawExtraFieldAES,
 				rawExtraFieldExtendedTimestamp,
 				rawExtraFieldNTFS,
-				rawExtraField
+				rawExtraFieldUnix,
+				rawExtraField,
 			} = entry;
 			const { level, languageEncodingFlag, dataDescriptor } = bitFlag;
 			rawExtraFieldZip64 = rawExtraFieldZip64 || new Uint8Array();
 			rawExtraFieldAES = rawExtraFieldAES || new Uint8Array();
 			rawExtraFieldExtendedTimestamp = rawExtraFieldExtendedTimestamp || new Uint8Array();
 			rawExtraFieldNTFS = rawExtraFieldNTFS || new Uint8Array();
+			rawExtraFieldUnix = entry.rawExtraFieldUnix || new Uint8Array();
 			rawExtraField = rawExtraField || new Uint8Array();
-			const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraField);
+			const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField);
 			const zip64UncompressedSize = zip64 && uncompressedSize > MAX_32_BITS;
 			const zip64CompressedSize = zip64 && compressedSize > MAX_32_BITS;
 			const {
@@ -243,6 +273,7 @@ class ZipWriter {
 				rawExtraFieldAES,
 				rawExtraFieldExtendedTimestamp,
 				rawExtraFieldNTFS,
+				rawExtraFieldUnix,
 				rawExtraField,
 				extendedTimestamp: rawExtraFieldExtendedTimestamp.length > 0 || rawExtraFieldNTFS.length > 0,
 				extraFieldExtendedTimestampFlag: 0x1 + (lastAccessDate ? 0x2 : 0) + (creationDate ? 0x4 : 0),
@@ -311,7 +342,7 @@ class ZipWriter {
 		while (pendingAddFileCalls.size) {
 			await Promise.allSettled(Array.from(pendingAddFileCalls));
 		}
-		await closeFile(this, comment, options);
+		await closeFile(zipWriter, comment, options);
 		const preventClose = getOptionValue(zipWriter, options, OPTION_PREVENT_CLOSE);
 		if (!preventClose) {
 			await writable.getWriter().close();
@@ -342,7 +373,7 @@ class ZipWriterStream {
 		return writable;
 	}
 
-	close(comment = undefined, options = {}) {
+	close(comment = UNDEFINED_VALUE, options = {}) {
 		return this.zipWriter.close(comment, options);
 	}
 }
@@ -365,9 +396,45 @@ export {
 
 async function addFile(zipWriter, name, reader, options) {
 	name = name.trim();
-	const msDosCompatible = getOptionValue(zipWriter, options, PROPERTY_NAME_MS_DOS_COMPATIBLE);
-	const versionMadeBy = getOptionValue(zipWriter, options, PROPERTY_NAME_VERSION_MADE_BY, msDosCompatible ? 20 : 768);
+	let msDosCompatible = getOptionValue(zipWriter, options, PROPERTY_NAME_MS_DOS_COMPATIBLE);
+	let versionMadeBy = getOptionValue(zipWriter, options, PROPERTY_NAME_VERSION_MADE_BY, msDosCompatible ? 20 : 768);
 	const executable = getOptionValue(zipWriter, options, PROPERTY_NAME_EXECUTABLE);
+	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 setuid = getOptionValue(zipWriter, options, PROPERTY_NAME_SETUID);
+	let setgid = getOptionValue(zipWriter, options, PROPERTY_NAME_SETGID);
+	let sticky = getOptionValue(zipWriter, options, PROPERTY_NAME_STICKY);
+	if (uid !== UNDEFINED_VALUE && (uid < 0 || uid > MAX_32_BITS)) {
+		throw new Error(ERR_INVALID_UID);
+	}
+	if (gid !== UNDEFINED_VALUE && (gid < 0 || gid > MAX_32_BITS)) {
+		throw new Error(ERR_INVALID_GID);
+	}
+	if (unixMode !== UNDEFINED_VALUE && (unixMode < 0 || unixMode > MAX_16_BITS)) {
+		throw new Error(ERR_INVALID_UNIX_MODE);
+	}
+	if (unixExtraFieldType !== UNDEFINED_VALUE && unixExtraFieldType !== INFOZIP_EXTRA_FIELD_TYPE && unixExtraFieldType !== UNIX_EXTRA_FIELD_TYPE) {
+		throw new Error(ERR_INVALID_UNIX_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;
+	const hasMsDosProvided = msdosAttributesRaw !== UNDEFINED_VALUE || msdosAttributes !== UNDEFINED_VALUE;
+	if (hasUnixMetadata) {
+		msDosCompatible = false;
+		versionMadeBy = (versionMadeBy & MAX_16_BITS) | (3 << 8);
+	} else if (hasMsDosProvided) {
+		msDosCompatible = true;
+		versionMadeBy = (versionMadeBy & MAX_8_BITS);
+	}
+	if (msdosAttributesRaw !== UNDEFINED_VALUE && (msdosAttributesRaw < 0 || msdosAttributesRaw > MAX_8_BITS)) {
+		throw new Error(ERR_INVALID_MSDOS_ATTRIBUTES);
+	}
+	if (msdosAttributes && typeof msdosAttributes !== OBJECT_TYPE) {
+		throw new Error(ERR_INVALID_MSDOS_DATA);
+	}
 	if (versionMadeBy > MAX_16_BITS) {
 		throw new Error(ERR_INVALID_VERSION);
 	}
@@ -393,6 +460,34 @@ async function addFile(zipWriter, name, reader, options) {
 			externalFileAttributes = FILE_ATTR_UNIX_DEFAULT_MASK << 16;
 		}
 	}
+	let unixExternalUpper;
+	if (!msDosCompatible) {
+		unixExternalUpper = (externalFileAttributes >> 16) & MAX_16_BITS;
+		unixMode = unixMode === UNDEFINED_VALUE ? unixExternalUpper : (unixMode & MAX_16_BITS);
+		if (setuid) {
+			unixMode |= FILE_ATTR_UNIX_SETUID_MASK;
+		} else {
+			setuid = Boolean(unixMode & FILE_ATTR_UNIX_SETUID_MASK);
+		}
+		if (setgid) {
+			unixMode |= FILE_ATTR_UNIX_SETGID_MASK;
+		} else {
+			setgid = Boolean(unixMode & FILE_ATTR_UNIX_SETGID_MASK);
+		}
+		if (sticky) {
+			unixMode |= FILE_ATTR_UNIX_STICKY_MASK;
+		} else {
+			sticky = Boolean(unixMode & FILE_ATTR_UNIX_STICKY_MASK);
+		}
+		if (directory) {
+			unixMode |= FILE_ATTR_UNIX_TYPE_DIR;
+		}
+		externalFileAttributes = ((unixMode & MAX_16_BITS) << 16) | (externalFileAttributes & MAX_8_BITS);
+	}
+	({ msdosAttributesRaw, msdosAttributes } = normalizeMsdosAttributes(msdosAttributesRaw, msdosAttributes));
+	if (hasMsDosProvided) {
+		externalFileAttributes = (externalFileAttributes & MAX_32_BITS) | (msdosAttributesRaw & MAX_8_BITS);
+	}
 	const encode = getOptionValue(zipWriter, options, OPTION_ENCODE_TEXT, encodeText);
 	let rawFilename = encode(name);
 	if (rawFilename === UNDEFINED_VALUE) {
@@ -555,7 +650,16 @@ async function addFile(zipWriter, name, reader, options) {
 		compressionMethod,
 		uncompressedSize,
 		offset: zipWriter.offset - diskOffset,
-		diskNumberStart: diskNumber
+		diskNumberStart: diskNumber,
+		uid,
+		gid,
+		setuid,
+		setgid,
+		sticky,
+		unixMode,
+		msdosAttributesRaw,
+		msdosAttributes,
+		unixExternalUpper
 	});
 	const headerInfo = getHeaderInfo(options);
 	const dataDescriptorInfo = getDataDescriptorInfo(options);
@@ -747,7 +851,8 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		rawExtraFieldExtendedTimestamp,
 		extraFieldExtendedTimestampFlag,
 		rawExtraFieldNTFS,
-		rawExtraFieldAES
+		rawExtraFieldUnix,
+		rawExtraFieldAES,
 	} = headerInfo;
 	const { dataDescriptorArray } = dataDescriptorInfo;
 	const {
@@ -779,6 +884,15 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		msDosCompatible,
 		internalFileAttributes,
 		externalFileAttributes,
+		uid,
+		gid,
+		unixMode,
+		setuid,
+		setgid,
+		sticky,
+		unixExternalUpper,
+		msdosAttributesRaw,
+		msdosAttributes,
 		useCompressionStream,
 		passThrough
 	} = options;
@@ -796,13 +910,23 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		localExtraFieldZip64Length,
 		rawExtraFieldExtendedTimestamp,
 		rawExtraFieldNTFS,
+		rawExtraFieldUnix,
 		rawExtraFieldAES,
 		rawExtraField,
 		extendedTimestamp,
 		msDosCompatible,
 		internalFileAttributes,
 		externalFileAttributes,
-		diskNumberStart
+		diskNumberStart,
+		uid,
+		gid,
+		unixMode,
+		setuid,
+		setgid,
+		sticky,
+		unixExternalUpper,
+		msdosAttributesRaw,
+		msdosAttributes
 	};
 	let {
 		signature,
@@ -825,7 +949,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 				password,
 				encryptionStrength,
 				zipCrypto: encrypted && zipCrypto,
-				passwordVerification: encrypted && zipCrypto && (rawLastModDate >> 8) & 0xFF,
+				passwordVerification: encrypted && zipCrypto && (rawLastModDate >> 8) & MAX_8_BITS,
 				signed: !passThrough,
 				compressed: compressed && !passThrough,
 				encrypted: encrypted && !passThrough,
@@ -1004,6 +1128,49 @@ function getHeaderInfo(options) {
 	} else {
 		rawExtraFieldNTFS = rawExtraFieldExtendedTimestamp = new Uint8Array();
 	}
+	let rawExtraFieldUnix;
+	try {
+		const { uid, gid, unixMode, setuid, setgid, sticky, unixExtraFieldType } = options;
+		if (unixExtraFieldType && (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE || unixMode !== 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);
+		} else {
+			rawExtraFieldUnix = new Uint8Array();
+		}
+	} catch {
+		rawExtraFieldUnix = new Uint8Array();
+	}
 	if (compressionMethod === UNDEFINED_VALUE) {
 		compressionMethod = compressed ? COMPRESSION_METHOD_DEFLATE : COMPRESSION_METHOD_STORE;
 	}
@@ -1016,7 +1183,7 @@ function getHeaderInfo(options) {
 		compressionMethod = COMPRESSION_METHOD_AES;
 	}
 	const localExtraFieldZip64Length = zip64ExtraFieldComplete ? getLength(rawExtraFieldZip64) : 0;
-	const extraFieldLength = localExtraFieldZip64Length + getLength(rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraField);
+	const extraFieldLength = localExtraFieldZip64Length + getLength(rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField);
 	const {
 		headerArray,
 		headerView,
@@ -1049,6 +1216,8 @@ function getHeaderInfo(options) {
 	localHeaderOffset += getLength(rawExtraFieldExtendedTimestamp);
 	arraySet(localHeaderArray, rawExtraFieldNTFS, localHeaderOffset);
 	localHeaderOffset += getLength(rawExtraFieldNTFS);
+	arraySet(localHeaderArray, rawExtraFieldUnix, localHeaderOffset);
+	localHeaderOffset += getLength(rawExtraFieldUnix);
 	arraySet(localHeaderArray, rawExtraField, localHeaderOffset);
 	if (dataDescriptor) {
 		setUint32(localHeaderView, HEADER_OFFSET_COMPRESSED_SIZE + 4, 0);
@@ -1070,6 +1239,7 @@ function getHeaderInfo(options) {
 		localExtraFieldZip64Length,
 		rawExtraFieldExtendedTimestamp,
 		rawExtraFieldNTFS,
+		rawExtraFieldUnix,
 		rawExtraFieldAES,
 		extraFieldLength
 	};
@@ -1096,6 +1266,46 @@ function appendExtraFieldUSDZ(entryInfo, zipWriterOffset) {
 	entryInfo.metadataSize += extraBytesLength;
 }
 
+function packUnixId(id) {
+	if (id === UNDEFINED_VALUE) {
+		return new Uint8Array();
+	} else {
+		const dataArray = new Uint8Array(4);
+		const dataView = getDataView(dataArray);
+		dataView.setUint32(0, id, true);
+		let length = 4;
+		while (length > 1 && dataArray[length - 1] === 0) {
+			length--;
+		}
+		return dataArray.subarray(0, length);
+	}
+}
+
+function normalizeMsdosAttributes(msdosAttributesRaw, msdosAttributes) {
+	if (msdosAttributesRaw !== UNDEFINED_VALUE) {
+		msdosAttributesRaw = msdosAttributesRaw & MAX_8_BITS;
+	} else if (msdosAttributes !== UNDEFINED_VALUE) {
+		const { readOnly, hidden, system, directory: msdDir, archive } = msdosAttributes;
+		let raw = 0;
+		if (readOnly) raw |= FILE_ATTR_MSDOS_READONLY_MASK;
+		if (hidden) raw |= FILE_ATTR_MSDOS_HIDDEN_MASK;
+		if (system) raw |= FILE_ATTR_MSDOS_SYSTEM_MASK;
+		if (msdDir) raw |= FILE_ATTR_MSDOS_DIR_MASK;
+		if (archive) raw |= FILE_ATTR_MSDOS_ARCHIVE_MASK;
+		msdosAttributesRaw = raw & MAX_8_BITS;
+	}
+	if (msdosAttributes === UNDEFINED_VALUE) {
+		msdosAttributes = {
+			readOnly: Boolean(msdosAttributesRaw & FILE_ATTR_MSDOS_READONLY_MASK),
+			hidden: Boolean(msdosAttributesRaw & FILE_ATTR_MSDOS_HIDDEN_MASK),
+			system: Boolean(msdosAttributesRaw & FILE_ATTR_MSDOS_SYSTEM_MASK),
+			directory: Boolean(msdosAttributesRaw & FILE_ATTR_MSDOS_DIR_MASK),
+			archive: Boolean(msdosAttributesRaw & FILE_ATTR_MSDOS_ARCHIVE_MASK)
+		};
+	}
+	return { msdosAttributesRaw, msdosAttributes };
+}
+
 function getDataDescriptorInfo({
 	zip64,
 	dataDescriptor,
@@ -1253,6 +1463,7 @@ async function closeFile(zipWriter, comment, options) {
 			rawExtraFieldAES,
 			rawComment,
 			rawExtraFieldNTFS,
+			rawExtraFieldUnix,
 			rawExtraField,
 			extendedTimestamp,
 			extraFieldExtendedTimestampFlag,
@@ -1277,6 +1488,7 @@ async function closeFile(zipWriter, comment, options) {
 				rawExtraFieldZip64,
 				rawExtraFieldAES,
 				rawExtraFieldNTFS,
+				rawExtraFieldUnix,
 				rawExtraFieldTimestamp,
 				rawExtraField);
 	}
@@ -1292,6 +1504,7 @@ async function closeFile(zipWriter, comment, options) {
 			rawExtraFieldAES,
 			rawExtraFieldExtendedTimestamp,
 			rawExtraFieldNTFS,
+			rawExtraFieldUnix,
 			rawExtraField,
 			rawComment,
 			versionMadeBy,
@@ -1308,7 +1521,7 @@ async function closeFile(zipWriter, comment, options) {
 			uncompressedSize,
 			compressedSize
 		} = fileEntry;
-		const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraField);
+		const extraFieldLength = getLength(rawExtraFieldZip64, rawExtraFieldAES, rawExtraFieldExtendedTimestamp, rawExtraFieldNTFS, rawExtraFieldUnix, rawExtraField);
 		setUint32(directoryView, offset, CENTRAL_FILE_HEADER_SIGNATURE);
 		setUint16(directoryView, offset + 4, versionMadeBy);
 		if (!zip64UncompressedSize) {
@@ -1343,9 +1556,12 @@ async function closeFile(zipWriter, comment, options) {
 		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));

package/package.json

@@ -3,7 +3,7 @@
   "description": "A JavaScript library to zip and unzip files in the browser, Deno and Node.js",
   "author": "Gildas Lormeau",
   "license": "BSD-3-Clause",
-  "version": "2.8.6",
+  "version": "2.8.8",
   "type": "module",
   "keywords": [
     "zip",
@@ -156,10 +156,10 @@
   "devDependencies": {
     "@rollup/plugin-replace": "^6.0.2",
     "@rollup/plugin-terser": "^0.4.4",
-    "eslint": "^9.36.0",
+    "eslint": "^9.37.0",
     "http-server": "^14.1.1",
-    "rollup": "^4.52.3",
-    "typedoc": "^0.28.13",
+    "rollup": "^4.52.4",
+    "typedoc": "^0.28.14",
     "typedoc-plugin-markdown": "^4.9.0"
   }
 }