@zip.js/zip.js 2.8.52 → 2.8.53

package/lib/core/codec-worker-web.js

@@ -83,6 +83,7 @@ function createWebWorkerInterface(workerData, config) {
 			worker,
 			workerAlive: false,
 			terminated: false,
+			startupError: null,
 			interface: {
 				run: async () => {
 					try {
@@ -110,6 +111,13 @@ function createWebWorkerInterface(workerData, config) {
 }
 
 async function runWebWorker(workerData, config) {
+	if (!workerData.worker) {
+		const { startupError } = workerData;
+		workerData.startupError = null;
+		const error = startupError || new Error(ERR_WORKER_STARTUP_TIMEOUT);
+		error.workerStartupFailed = true;
+		throw error;
+	}
 	let resolveResult, rejectResult;
 	const result = new Promise((resolve, reject) => {
 		resolveResult = resolve;
@@ -323,11 +331,12 @@ function onWorkerError(event, workerData) {
 	if (!workerAlive) {
 		workerData.worker = null;
 	}
+	let error = event.error || new Error(event.message || ERROR_EVENT_TYPE);
+	if (!workerAlive) {
+		error = Object.assign(new Error(error.message || ERROR_EVENT_TYPE), { workerStartupFailed: true });
+		workerData.startupError = error;
+	}
 	if (rejectResult) {
-		let error = event.error || new Error(event.message || ERROR_EVENT_TYPE);
-		if (!workerAlive) {
-			error = Object.assign(new Error(error.message || ERROR_EVENT_TYPE), { workerStartupFailed: true });
-		}
 		rejectResult(error);
 		if (writer) {
 			writer.releaseLock();

package/lib/core/constants.js

@@ -93,6 +93,9 @@ const VERSION_DEFLATE = 0x14;
 const VERSION_ZIP64 = 0x2D;
 const VERSION_AES = 0x33;
 
+const VERSION_MADE_BY_MSDOS = 0x0014;
+const VERSION_MADE_BY_UNIX = 0x0300;
+
 const DIRECTORY_SIGNATURE = "/";
 
 const HEADER_SIZE = 30;
@@ -176,6 +179,8 @@ export {
 	FILE_ATTR_UNIX_SETGID_MASK,
 	FILE_ATTR_UNIX_STICKY_MASK,
 	VERSION_DEFLATE,
+	VERSION_MADE_BY_MSDOS,
+	VERSION_MADE_BY_UNIX,
 	VERSION_ZIP64,
 	VERSION_AES,
 	HEADER_SIZE,

package/lib/core/io.js

@@ -791,9 +791,8 @@ class SplitDataReader extends Reader {
 
 	async init() {
 		const reader = this;
-		const { readers } = reader;
 		reader.lastDiskNumber = 0;
-		await Promise.all(readers.map(diskReader => initStream(diskReader)));
+		const readers = reader.readers = await Promise.all(reader.readers.map(initDiskReader));
 		reader.diskOffsets = readers.map(diskReader => {
 			const diskOffset = reader.size;
 			reader.size += diskReader.size;
@@ -988,6 +987,16 @@ async function initStream(stream, initSize) {
 	}
 }
 
+async function initDiskReader(diskReader) {
+	diskReader = new GenericReader(diskReader);
+	await initStream(diskReader);
+	if (diskReader.size === UNDEFINED_VALUE || !diskReader.readUint8Array) {
+		diskReader = new BlobReader(await streamToBlob(diskReader.readable));
+		await initStream(diskReader);
+	}
+	return diskReader;
+}
+
 function readUint8Array(reader, offset, size) {
 	return reader.readUint8Array(offset, size);
 }

package/lib/core/options.js

@@ -39,6 +39,7 @@ const OPTION_CHECK_PASSWORD_ONLY = "checkPasswordOnly";
 const OPTION_CHECK_OVERLAPPING_ENTRY_ONLY = "checkOverlappingEntryOnly";
 const OPTION_CHECK_OVERLAPPING_ENTRY = "checkOverlappingEntry";
 const OPTION_CHECK_AMBIGUITY = "checkAmbiguity";
+const OPTION_CHECK_LOCAL_DIRECTORY = "checkLocalDirectory";
 const OPTION_CHECK_SIGNATURE = "checkSignature";
 const OPTION_CHECK_CRC32 = "checkCrc32";
 const OPTION_CHECK_AUTHENTICATION_CODE = "checkAuthenticationCode";
@@ -88,6 +89,7 @@ export {
 	OPTION_CHECK_OVERLAPPING_ENTRY_ONLY,
 	OPTION_CHECK_OVERLAPPING_ENTRY,
 	OPTION_CHECK_AMBIGUITY,
+	OPTION_CHECK_LOCAL_DIRECTORY,
 	OPTION_CHECK_SIGNATURE,
 	OPTION_CHECK_CRC32,
 	OPTION_CHECK_AUTHENTICATION_CODE,

package/lib/core/zip-entry.js

@@ -70,6 +70,10 @@ const PROPERTY_NAME_SETUID = "setuid";
 const PROPERTY_NAME_SETGID = "setgid";
 const PROPERTY_NAME_STICKY = "sticky";
 const PROPERTY_NAME_BITFLAG = "bitFlag";
+const PROPERTY_NAME_RAW_BITFLAG = "rawBitFlag";
+const PROPERTY_NAME_FILENAME_LENGTH = "filenameLength";
+const PROPERTY_NAME_EXTRA_FIELD_LENGTH = "extraFieldLength";
+const PROPERTY_NAME_UNIX_EXTERNAL_UPPER = "unixExternalUpper";
 const PROPERTY_NAME_FILENAME_UTF8 = "filenameUTF8";
 const PROPERTY_NAME_COMMENT_UTF8 = "commentUTF8";
 const PROPERTY_NAME_RAW_EXTRA_FIELD = "rawExtraField";
@@ -122,10 +126,14 @@ const PROPERTY_NAMES = [
 	PROPERTY_NAME_UID,
 	PROPERTY_NAME_GID,
 	PROPERTY_NAME_UNIX_MODE,
+	PROPERTY_NAME_UNIX_EXTERNAL_UPPER,
 	PROPERTY_NAME_SETUID,
 	PROPERTY_NAME_SETGID,
 	PROPERTY_NAME_STICKY,
 	PROPERTY_NAME_BITFLAG,
+	PROPERTY_NAME_RAW_BITFLAG,
+	PROPERTY_NAME_FILENAME_LENGTH,
+	PROPERTY_NAME_EXTRA_FIELD_LENGTH,
 	PROPERTY_NAME_FILENAME_UTF8,
 	PROPERTY_NAME_COMMENT_UTF8,
 	PROPERTY_NAME_RAW_EXTRA_FIELD,

package/lib/core/zip-reader.js

@@ -150,6 +150,7 @@ import {
 	OPTION_CHECK_OVERLAPPING_ENTRY_ONLY,
 	OPTION_CHECK_OVERLAPPING_ENTRY,
 	OPTION_CHECK_AMBIGUITY,
+	OPTION_CHECK_LOCAL_DIRECTORY,
 	OPTION_CHECK_SIGNATURE,
 	OPTION_CHECK_CRC32,
 	OPTION_CHECK_AUTHENTICATION_CODE,
@@ -236,7 +237,7 @@ class ZipReader {
 		if (reader.size < END_OF_CENTRAL_DIR_LENGTH) {
 			throw new Error(ERR_BAD_FORMAT);
 		}
-		const strictness = getStrictness(getOptionValue(zipReader, options, OPTION_STRICTNESS), getOptionValue(zipReader, options, OPTION_CHECK_AMBIGUITY));
+		const strictness = getStrictness(options, zipReader.options);
 		const checkAmbiguity = strictness == STRICTNESS_STRICT;
 		const rejectAmbiguousEndOfDirectory = strictness != STRICTNESS_TOLERANT;
 		const maxAppendedDataSize = getMaxAppendedDataSize(getOptionValue(zipReader, options, OPTION_MAX_APPENDED_DATA_SIZE), strictness);
@@ -458,6 +459,7 @@ class ZipReader {
 				index: indexFile,
 				versionMadeBy,
 				msDosCompatible,
+				zip64: false,
 				compressedSize: 0,
 				uncompressedSize: 0,
 				commentLength,
@@ -697,9 +699,12 @@ class ZipEntry {
 			extraFieldLength,
 			filenameLength
 		} = localDirectory;
-		const checkAmbiguity = getStrictness(getOptionValue(zipEntry, options, OPTION_STRICTNESS), getOptionValue(zipEntry, options, OPTION_CHECK_AMBIGUITY)) == STRICTNESS_STRICT;
+		const checkLocalDirectoryOption = getOptionValue(zipEntry, options, OPTION_CHECK_LOCAL_DIRECTORY);
+		const entryStrictness = getStrictness(options, zipEntry.options);
+		const checkLocalDirectory = getCheckLocalDirectory(checkLocalDirectoryOption, entryStrictness);
+		const checkLocalFilename = getCheckLocalFilename(checkLocalDirectoryOption, entryStrictness);
 		let rawLocalFilename = EMPTY_UINT8_ARRAY;
-		if (checkAmbiguity && (filenameLength || extraFieldLength)) {
+		if (checkLocalFilename && (filenameLength || extraFieldLength)) {
 			const trailingDataArray = await readUint8Array(reader, localHeaderOffset + HEADER_SIZE, filenameLength + extraFieldLength);
 			rawLocalFilename = trailingDataArray.subarray(0, filenameLength);
 			localDirectory.rawExtraField = trailingDataArray.subarray(filenameLength);
@@ -708,17 +713,26 @@ class ZipEntry {
 				await readUint8Array(reader, localHeaderOffset + HEADER_SIZE + filenameLength, extraFieldLength) :
 				EMPTY_UINT8_ARRAY;
 		}
+		if (checkLocalFilename) {
+			localDirectory.rawFilename = rawLocalFilename;
+		}
 		readCommonFooter(zipEntry, localDirectory, dataView, 4, true);
-		if (checkAmbiguity) {
-			checkLocalDirectory(zipEntry, localDirectory, rawLocalFilename);
+		if (checkLocalDirectory) {
+			validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename);
 		}
-		const { lastAccessDate, creationDate } = localDirectory;
+		const { lastAccessDate, creationDate, uid, gid } = localDirectory;
 		if (lastAccessDate) {
 			fileEntry.lastAccessDate = lastAccessDate;
 		}
 		if (creationDate) {
 			fileEntry.creationDate = creationDate;
 		}
+		if (uid !== UNDEFINED_VALUE && fileEntry.uid === UNDEFINED_VALUE) {
+			fileEntry.uid = uid;
+		}
+		if (gid !== UNDEFINED_VALUE && fileEntry.gid === UNDEFINED_VALUE) {
+			fileEntry.gid = gid;
+		}
 		const encrypted = zipEntry.encrypted && localDirectory.encrypted && !passThrough;
 		const zipCrypto = encrypted && !extraFieldAES;
 		if (!passThrough) {
@@ -954,10 +968,12 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 		directory.extraFieldNTFS = extraFieldNTFS;
 	}
 	const extraFieldUnix = extraField.get(EXTRAFIELD_TYPE_UNIX);
+	let unixIdsRead;
 	if (extraFieldUnix) {
-		readExtraFieldUnix(extraFieldUnix, directory, false);
+		unixIdsRead = readExtraFieldUnix(extraFieldUnix, directory, false);
 		directory.extraFieldUnix = extraFieldUnix;
-	} else {
+	}
+	if (!unixIdsRead) {
 		const extraFieldInfoZip = extraField.get(EXTRAFIELD_TYPE_INFOZIP);
 		if (extraFieldInfoZip) {
 			readExtraFieldUnix(extraFieldInfoZip, directory, true);
@@ -1060,7 +1076,7 @@ function readExtraFieldNTFS(extraFieldNTFS, directory) {
 		const creationDate = getDateNTFS(rawCreationDate);
 		const extraFieldData = { lastModDate, lastAccessDate, creationDate };
 		Object.assign(extraFieldNTFS, extraFieldData);
-		Object.assign(directory, extraFieldData);
+		Object.assign(directory, extraFieldData, { rawLastAccessDate, rawCreationDate });
 	}
 }
 
@@ -1104,6 +1120,7 @@ function readExtraFieldUnix(extraField, directory, isInfoZip) {
 		if (gid !== UNDEFINED_VALUE) {
 			directory.gid = gid;
 		}
+		return uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE;
 	} catch {
 		// ignored
 	}
@@ -1176,26 +1193,25 @@ async function detectOverlappingEntry({
 	}
 	if (dataDescriptorLength) {
 		const dataDescriptorArray = await readUint8Array(reader, dataOffset + compressedSize, dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH);
-		const dataDescriptorSignature = dataDescriptorArray.length == dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH &&
-			getUint32(getDataView(dataDescriptorArray), 0) == DATA_DESCRIPTOR_RECORD_SIGNATURE;
-		if (dataDescriptorSignature) {
-			const readCrc32 = getUint32(getDataView(dataDescriptorArray), 4);
-			let readCompressedSize;
-			let readUncompressedSize;
-			if (extraFieldZip64) {
-				readCompressedSize = getBigUint64(getDataView(dataDescriptorArray), 8);
-				readUncompressedSize = getBigUint64(getDataView(dataDescriptorArray), 16);
-			} else {
-				readCompressedSize = getUint32(getDataView(dataDescriptorArray), 8);
-				readUncompressedSize = getUint32(getDataView(dataDescriptorArray), 12);
-			}
-			const matchCrc32 = (fileEntry.encrypted && !fileEntry.zipCrypto) || readCrc32 == crc32;
+		const dataDescriptorView = getDataView(dataDescriptorArray);
+		let signature = dataDescriptorArray.length == dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH &&
+			getUint32(dataDescriptorView, 0) == DATA_DESCRIPTOR_RECORD_SIGNATURE;
+		if (signature) {
+			const signedDataDescriptor = readDataDescriptor(dataDescriptorView, DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH, extraFieldZip64);
+			const matchCrc32 = (fileEntry.encrypted && !fileEntry.zipCrypto) || signedDataDescriptor.crc32 == crc32;
 			if (matchCrc32 &&
-				readCompressedSize == compressedSize &&
-				readUncompressedSize == uncompressedSize) {
+				signedDataDescriptor.compressedSize == compressedSize &&
+				signedDataDescriptor.uncompressedSize == uncompressedSize) {
 				dataDescriptorLength += DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH;
+			} else {
+				signature = false;
 			}
 		}
+		if (dataDescriptorArray.length >= dataDescriptorLength) {
+			const localDataDescriptor = readDataDescriptor(dataDescriptorView, signature ? DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH : 0, extraFieldZip64);
+			localDataDescriptor.signature = signature;
+			fileEntry.localDirectory.dataDescriptor = localDataDescriptor;
+		}
 	}
 	const range = {
 		start: offset,
@@ -1212,6 +1228,20 @@ async function detectOverlappingEntry({
 	readRanges.set(index, range);
 }
 
+function readDataDescriptor(dataDescriptorView, offset, extraFieldZip64) {
+	const crc32 = getUint32(dataDescriptorView, offset);
+	let compressedSize;
+	let uncompressedSize;
+	if (extraFieldZip64) {
+		compressedSize = getBigUint64(dataDescriptorView, offset + 4);
+		uncompressedSize = getBigUint64(dataDescriptorView, offset + 12);
+	} else {
+		compressedSize = getUint32(dataDescriptorView, offset + 4);
+		uncompressedSize = getUint32(dataDescriptorView, offset + 8);
+	}
+	return { crc32, compressedSize, uncompressedSize };
+}
+
 function getDiskOffset(reader, diskNumber) {
 	return reader.getDiskOffset ? reader.getDiskOffset(diskNumber) : 0;
 }
@@ -1220,14 +1250,40 @@ function isStrictnessValue(value) {
 	return value === STRICTNESS_STRICT || value === STRICTNESS_BALANCED || value === STRICTNESS_TOLERANT;
 }
 
-function getStrictness(strictness, checkAmbiguity) {
-	if (strictness === UNDEFINED_VALUE) {
-		return checkAmbiguity ? STRICTNESS_STRICT : STRICTNESS_BALANCED;
+function getStrictness(options, inheritedOptions) {
+	return resolveStrictness(options, resolveStrictness(inheritedOptions, STRICTNESS_BALANCED));
+}
+
+function resolveStrictness(options, inheritedStrictness) {
+	const strictness = options[OPTION_STRICTNESS];
+	if (strictness !== UNDEFINED_VALUE) {
+		if (!isStrictnessValue(strictness)) {
+			throw new Error(ERR_INVALID_STRICTNESS);
+		}
+		return strictness;
+	}
+	const checkAmbiguity = options[OPTION_CHECK_AMBIGUITY];
+	if (checkAmbiguity === UNDEFINED_VALUE) {
+		return inheritedStrictness;
+	}
+	if (checkAmbiguity) {
+		return STRICTNESS_STRICT;
+	}
+	return inheritedStrictness == STRICTNESS_TOLERANT ? STRICTNESS_TOLERANT : STRICTNESS_BALANCED;
+}
+
+function getCheckLocalDirectory(checkLocalDirectory, strictness) {
+	if (checkLocalDirectory === UNDEFINED_VALUE) {
+		return strictness != STRICTNESS_TOLERANT;
 	}
-	if (!isStrictnessValue(strictness)) {
-		throw new Error(ERR_INVALID_STRICTNESS);
+	return Boolean(checkLocalDirectory);
+}
+
+function getCheckLocalFilename(checkLocalFilename, strictness) {
+	if (checkLocalFilename === UNDEFINED_VALUE) {
+		return strictness == STRICTNESS_STRICT;
 	}
-	return strictness;
+	return Boolean(checkLocalFilename);
 }
 
 function getFilenameValidation(filenameValidation, strictness) {
@@ -1375,10 +1431,11 @@ async function readSignature(reader, view, anchoredOffset, signatureOffset, size
 	return UNDEFINED_VALUE;
 }
 
-function checkLocalDirectory(zipEntry, localDirectory, rawLocalFilename) {
+function validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename) {
 	const { rawFilename } = zipEntry;
-	if (rawLocalFilename.length != rawFilename.length ||
-		rawLocalFilename.some((byteValue, indexByte) => byteValue != rawFilename[indexByte])) {
+	if (checkLocalFilename &&
+		(rawLocalFilename.length != rawFilename.length ||
+			rawLocalFilename.some((byteValue, indexByte) => byteValue != rawFilename[indexByte]))) {
 		throwAmbiguousArchive("mismatched local file header (filename)");
 	}
 	if ((localDirectory.rawBitFlag & BITFLAG_AMBIGUITY_MASK) != (zipEntry.rawBitFlag & BITFLAG_AMBIGUITY_MASK)) {

package/lib/core/zip-writer.js

@@ -122,12 +122,15 @@ import {
 	FILE_ATTR_UNIX_TYPE_DIR,
 	FILE_ATTR_UNIX_TYPE_FILE,
 	FILE_ATTR_UNIX_TYPE_MASK,
+	FILE_ATTR_UNIX_TYPE_SYMLINK,
 	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_MADE_BY_MSDOS,
+	VERSION_MADE_BY_UNIX,
 	VERSION_ZIP64,
 	VERSION_AES,
 	DIRECTORY_SIGNATURE,
@@ -157,11 +160,12 @@ import {
 	initStream,
 	GenericWriter,
 	GenericReader,
+	BlobReader,
 	ownsWritable
 } from "./io.js";
 import { encodeText } from "./util/encode-text.js";
 import { getDataView } from "./util/array.js";
-import { toCompatibleReadable } from "./util/compatible-streams.js";
+import { toCompatibleReadable, streamToBlob } from "./util/compatible-streams.js";
 import {
 	PROPERTY_NAME_LAST_MODIFICATION_DATE,
 	PROPERTY_NAME_LAST_ACCESS_DATE,
@@ -225,6 +229,7 @@ import {
 
 const ERR_DUPLICATED_NAME = "File already exists";
 const ERR_INVALID_COMMENT = "Zip file comment exceeds 64KB";
+const ERR_INVALID_COMMENT_TYPE = "Invalid zip file comment (must be a Uint8Array)";
 const ERR_INVALID_ENTRY_COMMENT = "File entry comment exceeds 64KB";
 const ERR_INVALID_ENTRY_NAME = "File entry name exceeds 64KB";
 const ERR_INVALID_VERSION = "Version exceeds 65535";
@@ -293,6 +298,10 @@ class ZipWriter {
 		}
 		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 import("./zip-reader.js");
 		const zipReader = new ZipReader(reader.readable);
 		const entries = await zipReader.getEntries();
@@ -441,6 +450,9 @@ class ZipWriter {
 		const zipWriter = this;
 		const { pendingAddFileCalls, writer } = this;
 		const { writable } = writer;
+		if (!(comment instanceof Uint8Array)) {
+			throw new Error(ERR_INVALID_COMMENT_TYPE);
+		}
 		if (getLength(comment) > MAX_16_BITS) {
 			throw new Error(ERR_INVALID_COMMENT);
 		}
@@ -524,6 +536,7 @@ export {
 	getEntriesSize,
 	ERR_DUPLICATED_NAME,
 	ERR_INVALID_COMMENT,
+	ERR_INVALID_COMMENT_TYPE,
 	ERR_INVALID_ENTRY_NAME,
 	ERR_INVALID_ENTRY_COMMENT,
 	ERR_INVALID_VERSION,
@@ -569,8 +582,6 @@ async function addFile(zipWriter, name, reader, options) {
 		const diskOffset = getDiskOffset(zipWriter.writer);
 		const diskNumber = getDiskNumber(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],
 			crc32: options.crc32 === UNDEFINED_VALUE ? options[PROPERTY_NAME_SIGNATURE] : options.crc32,
 			offset: zipWriter.offset - diskOffset,
@@ -584,14 +595,20 @@ async function addFile(zipWriter, name, reader, options) {
 		zipWriter.files.delete(name);
 		throw error;
 	}
-	Object.assign(fileEntry, { name, comment, extraField });
+	Object.assign(fileEntry, {
+		name,
+		comment,
+		extraField,
+		[PROPERTY_NAME_DEPRECATED_INTERNAL_FILE_ATTRIBUTES]: fileEntry.internalFileAttributes,
+		[PROPERTY_NAME_DEPRECATED_EXTERNAL_FILE_ATTRIBUTES]: fileEntry.externalFileAttributes
+	});
 	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);
+	let versionMadeBy = getOptionValue(zipWriter, options, PROPERTY_NAME_VERSION_MADE_BY, msDosCompatible ? VERSION_MADE_BY_MSDOS : VERSION_MADE_BY_UNIX);
 	const executable = getOptionValue(zipWriter, options, PROPERTY_NAME_EXECUTABLE);
 	const uid = getNumberOptionValue(zipWriter, options, PROPERTY_NAME_UID);
 	const gid = getNumberOptionValue(zipWriter, options, PROPERTY_NAME_GID);
@@ -625,7 +642,7 @@ function resolveAttributes(zipWriter, name, options) {
 	const hasMsDosProvided = msdosAttributesRaw !== UNDEFINED_VALUE || msdosAttributes !== UNDEFINED_VALUE;
 	if (hasUnixMetadata) {
 		msDosCompatible = false;
-		versionMadeBy = (versionMadeBy & MAX_16_BITS) | (3 << 8);
+		versionMadeBy = (versionMadeBy & MAX_8_BITS) | VERSION_MADE_BY_UNIX;
 	} else if (hasMsDosProvided) {
 		msDosCompatible = true;
 		versionMadeBy = (versionMadeBy & MAX_8_BITS);
@@ -665,11 +682,10 @@ function resolveAttributes(zipWriter, name, options) {
 			externalFileAttributes = FILE_ATTR_UNIX_DEFAULT_MASK << 16;
 		}
 	}
-	let unixExternalUpper;
 	if (!msDosCompatible) {
 		const unixModeProvided = unixMode !== UNDEFINED_VALUE || Boolean(setuid || setgid || sticky);
-		unixExternalUpper = (externalFileAttributes >> 16) & MAX_16_BITS;
-		unixMode = unixMode === UNDEFINED_VALUE ? unixExternalUpper : (unixMode & MAX_16_BITS);
+		const defaultUnixMode = (externalFileAttributes >> 16) & MAX_16_BITS;
+		unixMode = unixMode === UNDEFINED_VALUE ? defaultUnixMode : (unixMode & MAX_16_BITS);
 		if (setuid) {
 			unixMode |= FILE_ATTR_UNIX_SETUID_MASK;
 		} else {
@@ -698,17 +714,20 @@ function resolveAttributes(zipWriter, name, options) {
 	if (hasMsDosProvided) {
 		externalFileAttributes = (externalFileAttributes & MAX_32_BITS) | (msdosAttributesRaw & MAX_8_BITS);
 	}
+	const unixExternalUpper = (externalFileAttributes >> 16) & MAX_16_BITS;
+	const symlink = unixMode !== UNDEFINED_VALUE && ((unixMode & FILE_ATTR_UNIX_TYPE_MASK) == FILE_ATTR_UNIX_TYPE_SYMLINK);
 	return {
 		name,
 		resolvedOptions: {
 			versionMadeBy,
-			msDosCompatible,
+			msDosCompatible: Boolean(msDosCompatible),
 			externalFileAttributes,
 			unixExternalUpper,
 			uid,
 			gid,
 			unixMode,
 			unixExtraFieldType,
+			symlink,
 			setuid,
 			setgid,
 			sticky,
@@ -941,6 +960,9 @@ async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comm
 	if (writerOptions[OPTION_SIGN_CENTRAL_DIRECTORY]) {
 		throw new Error(ERR_UNDETERMINED_SIZE);
 	}
+	if (comment !== UNDEFINED_VALUE && !(comment instanceof Uint8Array)) {
+		throw new Error(ERR_INVALID_COMMENT_TYPE);
+	}
 	const commentLength = getLength(comment);
 	if (commentLength > MAX_16_BITS) {
 		throw new Error(ERR_INVALID_COMMENT);
@@ -1222,6 +1244,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		uid,
 		gid,
 		unixMode,
+		symlink,
 		setuid,
 		setgid,
 		sticky,
@@ -1258,6 +1281,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		uid,
 		gid,
 		unixMode,
+		symlink: Boolean(symlink),
 		setuid,
 		setgid,
 		sticky,
@@ -1338,8 +1362,8 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		rawLastModDate,
 		creationDate,
 		lastAccessDate,
-		encrypted,
-		zipCrypto,
+		encrypted: Boolean(encrypted),
+		zipCrypto: Boolean(zipCrypto),
 		size: metadataSize + compressedSize,
 		compressionMethod,
 		version,

package/lib/zip-core-writer.js

@@ -33,6 +33,7 @@ export {
 	ZipWriterStream,
 	ERR_DUPLICATED_NAME,
 	ERR_INVALID_COMMENT,
+	ERR_INVALID_COMMENT_TYPE,
 	ERR_INVALID_ENTRY_NAME,
 	ERR_INVALID_ENTRY_COMMENT,
 	ERR_INVALID_VERSION,

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.52",
+  "version": "2.8.53",
   "type": "module",
   "keywords": [
     "zip",
@@ -35,7 +35,7 @@
   },
   "scripts": {
     "lint": "npx eslint . && deno lint",
-    "test": "npm run test-node && npm run test-deno && npm run test-bun && npm run test-node-dist && npm run test-deno-dist && npm run test-bun-dist && npm run test-web-streams-polyfill && npm run test-types",
+    "test": "npm run test-node && npm run test-deno && npm run test-bun && npm run test-node-dist && npm run test-deno-dist && npm run test-bun-dist && npm run test-web-streams-polyfill && npm run test-types && npm run test-api-symmetry && npm run test-api-shape",
     "test-browsers": "npm run test-chrome && npm run test-firefox && npm run test-safari",
     "serve-tests": "http-server -p 8888 -c-1 .",
     "test-all": "npm run lint && npm run test && npm run test-browsers",
@@ -46,11 +46,13 @@
     "test-deno": "cd ./tests && deno test --allow-read ./deno-runner.js",
     "test-web-streams-polyfill": "cd ./tests && deno run --allow-read ./web-streams-polyfill-runner.js",
     "test-node": "cd ./tests && node ./node-runner.js",
-    "test-bun": "cd ./tests && bun test ./bun-runner.js --timeout 30000",
+    "test-bun": "cd ./tests && bun test ./bun-runner.js",
     "test-deno-dist": "./tests/dist-runner.sh deno",
     "test-node-dist": "./tests/dist-runner.sh node",
     "test-bun-dist": "./tests/dist-runner.sh bun",
     "test-types": "tsc -p ./tests/types/tsconfig.json",
+    "test-api-symmetry": "node ./tests/api-symmetry/audit.js",
+    "test-api-shape": "node ./tests/api-symmetry/shape.js",
     "test-firefox": "node ./tests/browser-runner.js firefox",
     "test-chrome": "node ./tests/browser-runner.js chrome",
     "test-safari": "node ./tests/browser-runner.js safari"