@zip.js/zip.js 2.8.51 → 2.8.53

package/dist/zip-core.js

@@ -90,6 +90,8 @@
 	const FILE_ATTR_MSDOS_ARCHIVE_MASK = 0x20;
 	const FILE_ATTR_UNIX_TYPE_MASK = 0o170000;
 	const FILE_ATTR_UNIX_TYPE_DIR = 0o040000;
+	const FILE_ATTR_UNIX_TYPE_SYMLINK = 0o120000;
+	const FILE_ATTR_UNIX_TYPE_FILE = 0o100000;
 	const FILE_ATTR_UNIX_EXECUTABLE_MASK = 0o111;
 	const FILE_ATTR_UNIX_DEFAULT_MASK = 0o644;
 	const FILE_ATTR_UNIX_SETUID_MASK = 0o4000;
@@ -100,6 +102,9 @@
 	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;
@@ -1779,8 +1784,6 @@
 	 */
 
 
-	const HTTP_HEADER_CONTENT_TYPE = "Content-Type";
-
 	function toCompatibleReadable(readable) {
 		if (readable instanceof ReadableStream) {
 			return readable;
@@ -1803,12 +1806,9 @@
 
 	function streamToBlob(readable, contentType) {
 		readable = toCompatibleReadable(readable);
+		const blobOptions = contentType ? { type: contentType } : {};
 		if (responseSupportsGlobalReadable()) {
-			const options = {};
-			if (contentType) {
-				options.headers = [[HTTP_HEADER_CONTENT_TYPE, contentType]];
-			}
-			return new Response(readable, options).blob();
+			return new Response(readable).blob().then(blob => contentType ? new Blob([blob], blobOptions) : blob);
 		}
 		const chunks = [];
 		return readable
@@ -1817,7 +1817,7 @@
 					chunks.push(chunk);
 				}
 			}))
-			.then(() => new Blob(chunks, contentType ? { type: contentType } : {}));
+			.then(() => new Blob(chunks, blobOptions));
 	}
 
 	function responseSupportsGlobalReadable() {
@@ -2759,6 +2759,7 @@
 				worker,
 				workerAlive: false,
 				terminated: false,
+				startupError: null,
 				interface: {
 					run: async () => {
 						try {
@@ -2786,6 +2787,13 @@
 	}
 
 	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;
@@ -2999,11 +3007,12 @@
 		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();
@@ -3348,8 +3357,10 @@
 				async pull(controller) {
 					const dataSize = size === UNDEFINED_VALUE ? chunkSize : Math.min(chunkSize, size - chunkOffset);
 					const data = await readUint8Array(reader, offset + chunkOffset, dataSize);
-					controller.enqueue(data);
-					if ((chunkOffset + chunkSize > size) || (size === UNDEFINED_VALUE && !data.length && dataSize)) {
+					if (data.length) {
+						controller.enqueue(data);
+					}
+					if ((chunkOffset + chunkSize >= size) || (size === UNDEFINED_VALUE && !data.length && dataSize)) {
 						controller.close();
 					} else {
 						chunkOffset += chunkSize;
@@ -3427,6 +3438,7 @@
 		constructor(contentType) {
 			super();
 			Object.assign(this, {
+				contentType,
 				data: "data:" + (contentType || "") + ";base64,",
 				pending: []
 			});
@@ -3528,6 +3540,7 @@
 					return transformStream.writable;
 				}
 			});
+			writer.contentType = contentType;
 			writer.blob = streamToBlob(transformStream.readable, contentType);
 			writer.blob.catch(() => { });
 		}
@@ -4028,9 +4041,8 @@
 
 		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;
@@ -4207,6 +4219,10 @@
 		}
 	}
 
+	function ownsWritable(writer) {
+		return Boolean(writer && writer.getData);
+	}
+
 	function isHttpFamily(url) {
 		const { baseURI } = getConfiguration();
 		const { protocol } = new URL(url, baseURI);
@@ -4221,6 +4237,16 @@
 		}
 	}
 
+	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);
 	}
@@ -4351,6 +4377,8 @@
 	const PROPERTY_NAME_RAW_CREATION_DATE = "rawCreationDate";
 	const PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES = "internalFileAttributes";
 	const PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES = "externalFileAttributes";
+	const PROPERTY_NAME_DEPRECATED_INTERNAL_FILE_ATTRIBUTES = "internalFileAttribute";
+	const PROPERTY_NAME_DEPRECATED_EXTERNAL_FILE_ATTRIBUTES = "externalFileAttribute";
 	const PROPERTY_NAME_MSDOS_ATTRIBUTES_RAW = "msdosAttributesRaw";
 	const PROPERTY_NAME_MSDOS_ATTRIBUTES = "msdosAttributes";
 	const PROPERTY_NAME_MS_DOS_COMPATIBLE = "msDosCompatible";
@@ -4361,6 +4389,7 @@
 	const PROPERTY_NAME_ZIPCRYPTO = "zipCrypto";
 	const PROPERTY_NAME_DIRECTORY = "directory";
 	const PROPERTY_NAME_EXECUTABLE = "executable";
+	const PROPERTY_NAME_SYMLINK = "symlink";
 	const PROPERTY_NAME_COMPRESSION_METHOD = "compressionMethod";
 	const PROPERTY_NAME_SIGNATURE = "signature";
 	const PROPERTY_NAME_CRC32 = "crc32";
@@ -4376,6 +4405,10 @@
 	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";
@@ -4404,6 +4437,8 @@
 		PROPERTY_NAME_DISK_NUMBER_START,
 		PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES,
 		PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES,
+		PROPERTY_NAME_DEPRECATED_INTERNAL_FILE_ATTRIBUTES,
+		PROPERTY_NAME_DEPRECATED_EXTERNAL_FILE_ATTRIBUTES,
 		PROPERTY_NAME_MSDOS_ATTRIBUTES_RAW,
 		PROPERTY_NAME_MSDOS_ATTRIBUTES,
 		PROPERTY_NAME_MS_DOS_COMPATIBLE,
@@ -4414,6 +4449,7 @@
 		PROPERTY_NAME_ZIPCRYPTO,
 		PROPERTY_NAME_DIRECTORY,
 		PROPERTY_NAME_EXECUTABLE,
+		PROPERTY_NAME_SYMLINK,
 		PROPERTY_NAME_COMPRESSION_METHOD,
 		PROPERTY_NAME_SIGNATURE,
 		PROPERTY_NAME_CRC32,
@@ -4425,10 +4461,14 @@
 		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,
@@ -4490,6 +4530,7 @@
 	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";
@@ -4621,7 +4662,7 @@
 			if (reader.size < END_OF_CENTRAL_DIR_LENGTH) {
 				throw new Error(ERR_BAD_FORMAT);
 			}
-			const strictness = getStrictness(getOptionValue$1(zipReader, options, OPTION_STRICTNESS), getOptionValue$1(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$1(zipReader, options, OPTION_MAX_APPENDED_DATA_SIZE), strictness);
@@ -4843,6 +4884,7 @@
 					index: indexFile,
 					versionMadeBy,
 					msDosCompatible,
+					zip64: false,
 					compressedSize: 0,
 					uncompressedSize: 0,
 					commentLength,
@@ -4876,15 +4918,18 @@
 				const setuid = Boolean(fileEntry.unixMode & FILE_ATTR_UNIX_SETUID_MASK);
 				const setgid = Boolean(fileEntry.unixMode & FILE_ATTR_UNIX_SETGID_MASK);
 				const sticky = Boolean(fileEntry.unixMode & FILE_ATTR_UNIX_STICKY_MASK);
-				const executable = (fileEntry.unixMode !== UNDEFINED_VALUE)
+				const unixType = fileEntry.unixMode === UNDEFINED_VALUE ? unixExternalUpper : fileEntry.unixMode;
+				const symlink = (unixType & FILE_ATTR_UNIX_TYPE_MASK) == FILE_ATTR_UNIX_TYPE_SYMLINK;
+				const executable = !symlink && ((fileEntry.unixMode !== UNDEFINED_VALUE)
 					? ((fileEntry.unixMode & FILE_ATTR_UNIX_EXECUTABLE_MASK) != 0)
-					: (unixCompatible && ((unixExternalUpper & FILE_ATTR_UNIX_EXECUTABLE_MASK) != 0));
+					: (unixCompatible && ((unixExternalUpper & FILE_ATTR_UNIX_EXECUTABLE_MASK) != 0)));
 				const modeIsDir = fileEntry.unixMode !== UNDEFINED_VALUE && ((fileEntry.unixMode & FILE_ATTR_UNIX_TYPE_MASK) == FILE_ATTR_UNIX_TYPE_DIR);
 				const upperIsDir = ((unixExternalUpper & FILE_ATTR_UNIX_TYPE_MASK) == FILE_ATTR_UNIX_TYPE_DIR);
 				Object.assign(fileEntry, {
 					setuid,
 					setgid,
 					sticky,
+					symlink,
 					unixExternalUpper,
 					internalFileAttribute: fileEntry.internalFileAttributes,
 					externalFileAttribute: fileEntry.externalFileAttributes,
@@ -4950,6 +4995,10 @@
 		}
 
 		async close() {
+			const { reader } = this;
+			if (!reader.readUint8Array && reader.readable && !reader.readable.locked) {
+				await reader.readable.cancel();
+			}
 		}
 	}
 
@@ -5046,9 +5095,12 @@
 				extraFieldLength,
 				filenameLength
 			} = localDirectory;
-			const checkAmbiguity = getStrictness(getOptionValue$1(zipEntry, options, OPTION_STRICTNESS), getOptionValue$1(zipEntry, options, OPTION_CHECK_AMBIGUITY)) == STRICTNESS_STRICT;
+			const checkLocalDirectoryOption = getOptionValue$1(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);
@@ -5057,17 +5109,26 @@
 					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) {
@@ -5174,7 +5235,7 @@
 					throw error;
 				}
 			} finally {
-				const preventClose = getOptionValue$1(zipEntry, options, OPTION_PREVENT_CLOSE);
+				const preventClose = !ownsWritable(writer) && getOptionValue$1(zipEntry, options, OPTION_PREVENT_CLOSE);
 				if (!preventClose && writable && !writable.locked) {
 					const writableWriter = writable.getWriter();
 					if (abortError) {
@@ -5303,10 +5364,12 @@
 			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);
@@ -5409,7 +5472,7 @@
 			const creationDate = getDateNTFS(rawCreationDate);
 			const extraFieldData = { lastModDate, lastAccessDate, creationDate };
 			Object.assign(extraFieldNTFS, extraFieldData);
-			Object.assign(directory, extraFieldData);
+			Object.assign(directory, extraFieldData, { rawLastAccessDate, rawCreationDate });
 		}
 	}
 
@@ -5418,8 +5481,8 @@
 			return;
 		}
 		const extraFieldView = getDataView(extraField.data);
-		const lastAccessDate = new Date(getUint32(extraFieldView, 0) * 1000);
-		const lastModDate = new Date(getUint32(extraFieldView, 4) * 1000);
+		const lastAccessDate = new Date((getUint32(extraFieldView, 0) | 0) * 1000);
+		const lastModDate = new Date((getUint32(extraFieldView, 4) | 0) * 1000);
 		const extraFieldData = { lastAccessDate, lastModDate };
 		if (extraField.data.length >= 12) {
 			extraFieldData.uid = getUint16(extraFieldView, 8);
@@ -5453,6 +5516,7 @@
 			if (gid !== UNDEFINED_VALUE) {
 				directory.gid = gid;
 			}
+			return uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE;
 		} catch {
 			// ignored
 		}
@@ -5525,26 +5589,25 @@
 		}
 		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,
@@ -5561,6 +5624,20 @@
 		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$1(reader, diskNumber) {
 		return reader.getDiskOffset ? reader.getDiskOffset(diskNumber) : 0;
 	}
@@ -5569,14 +5646,40 @@
 		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;
 		}
-		if (!isStrictnessValue(strictness)) {
-			throw new Error(ERR_INVALID_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;
 		}
-		return strictness;
+		return Boolean(checkLocalDirectory);
+	}
+
+	function getCheckLocalFilename(checkLocalFilename, strictness) {
+		if (checkLocalFilename === UNDEFINED_VALUE) {
+			return strictness == STRICTNESS_STRICT;
+		}
+		return Boolean(checkLocalFilename);
 	}
 
 	function getFilenameValidation(filenameValidation, strictness) {
@@ -5724,10 +5827,11 @@
 		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)) {
@@ -5845,11 +5949,13 @@
 
 	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";
 	const ERR_INVALID_ENCRYPTION_STRENGTH = "The strength must equal 1, 2, or 3";
 	const ERR_UNSUPPORTED_ENCRYPTION_USDZ = "Encryption is not supported in USDZ files";
+	const ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH = "Encryption is not supported when the 'passThrough' option is set";
 	const ERR_INVALID_EXTRAFIELD_TYPE = "Extra field type exceeds 65535";
 	const ERR_INVALID_EXTRAFIELD_DATA = "Extra field data exceeds 64KB";
 	const ERR_UNSUPPORTED_COMPRESSION = "Compression method not supported";
@@ -5859,6 +5965,7 @@
 	const MAX_NTFS_TIME = BigInt("0x7fffffffffffffff");
 	const ERR_UNSUPPORTED_FORMAT = "Zip64 is not supported (set the 'zip64' option to 'true')";
 	const ERR_UNDEFINED_UNCOMPRESSED_SIZE = "Undefined uncompressed size";
+	const ERR_UNDETERMINED_SIZE = "Undetermined 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)";
@@ -5911,6 +6018,10 @@
 			}
 			reader = new GenericReader(reader);
 			await initStream(reader);
+			if (reader.size === UNDEFINED_VALUE || !reader.readUint8Array) {
+				reader = new BlobReader(await streamToBlob(reader.readable));
+				await initStream(reader);
+			}
 			const { ZipReader } = await Promise.resolve().then(function () { return zipReader; });
 			const zipReader$1 = new ZipReader(reader.readable);
 			const entries = await zipReader$1.getEntries();
@@ -6059,6 +6170,9 @@
 			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);
 			}
@@ -6066,7 +6180,7 @@
 				await Promise.allSettled(Array.from(pendingAddFileCalls));
 			}
 			await closeFile(zipWriter, comment, options);
-			const preventClose = getOptionValue(zipWriter, options, OPTION_PREVENT_CLOSE);
+			const preventClose = !ownsWritable(writer) && getOptionValue(zipWriter, options, OPTION_PREVENT_CLOSE);
 			if (!preventClose) {
 				await writable.getWriter().close();
 			}
@@ -6155,8 +6269,6 @@
 			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,
@@ -6170,14 +6282,20 @@
 			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);
@@ -6211,7 +6329,7 @@
 		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);
@@ -6225,7 +6343,7 @@
 		if (versionMadeBy > MAX_16_BITS) {
 			throw new Error(ERR_INVALID_VERSION);
 		}
-		let externalFileAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES);
+		let externalFileAttributes = getAliasedOptionValue(zipWriter, options, PROPERTY_NAME_EXTERNAL_FILE_ATTRIBUTES, PROPERTY_NAME_DEPRECATED_EXTERNAL_FILE_ATTRIBUTES);
 		const externalFileAttributesProvided = externalFileAttributes !== UNDEFINED_VALUE;
 		if (!externalFileAttributesProvided) {
 			externalFileAttributes = 0;
@@ -6251,11 +6369,10 @@
 				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 {
@@ -6273,7 +6390,9 @@
 			}
 			if (!externalFileAttributesProvided || unixModeProvided) {
 				if (directory) {
-					unixMode |= FILE_ATTR_UNIX_TYPE_DIR;
+					unixMode = (unixMode & ~FILE_ATTR_UNIX_TYPE_MASK) | FILE_ATTR_UNIX_TYPE_DIR;
+				} else if (!(unixMode & FILE_ATTR_UNIX_TYPE_MASK)) {
+					unixMode |= FILE_ATTR_UNIX_TYPE_FILE;
 				}
 				externalFileAttributes = ((unixMode & MAX_16_BITS) << 16) | (externalFileAttributes & MAX_16_BITS);
 			}
@@ -6282,17 +6401,20 @@
 		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,
@@ -6326,15 +6448,12 @@
 		const lastModDate = getOptionValue(zipWriter, options, PROPERTY_NAME_LAST_MODIFICATION_DATE, new Date());
 		const lastAccessDate = getOptionValue(zipWriter, options, PROPERTY_NAME_LAST_ACCESS_DATE);
 		const creationDate = getOptionValue(zipWriter, options, PROPERTY_NAME_CREATION_DATE);
-		const internalFileAttributes = getOptionValue(zipWriter, options, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES, 0);
+		const internalFileAttributes = getAliasedOptionValue(zipWriter, options, PROPERTY_NAME_INTERNAL_FILE_ATTRIBUTES, PROPERTY_NAME_DEPRECATED_INTERNAL_FILE_ATTRIBUTES, 0);
 		const passThrough = getOptionValue(zipWriter, options, OPTION_PASS_THROUGH);
-		let password, rawPassword;
-		if (!passThrough) {
-			password = getOptionValue(zipWriter, options, OPTION_PASSWORD);
-			rawPassword = getOptionValue(zipWriter, options, OPTION_RAW_PASSWORD);
-			if ((password && typeof password != STRING_TYPE) || (rawPassword && !(rawPassword instanceof Uint8Array))) {
-				throw new Error(ERR_INVALID_PASSWORD_TYPE);
-			}
+		const password = getOptionValue(zipWriter, options, OPTION_PASSWORD);
+		const rawPassword = getOptionValue(zipWriter, options, OPTION_RAW_PASSWORD);
+		if ((password && typeof password != STRING_TYPE) || (rawPassword && !(rawPassword instanceof Uint8Array))) {
+			throw new Error(ERR_INVALID_PASSWORD_TYPE);
 		}
 		const encryptionStrength = getNumberOptionValue(zipWriter, options, OPTION_ENCRYPTION_STRENGTH, 3);
 		const zipCrypto = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIPCRYPTO);
@@ -6447,14 +6566,24 @@
 	}
 
 	async function resolveSizes(zipWriter, reader, { resolvedOptions: metadata }, options) {
+		if (metadata.passThrough && !reader && !getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY)) {
+			throw new Error(ERR_UNDEFINED_READER);
+		}
+		let contentSize;
+		if (reader) {
+			reader = new GenericReader(reader);
+			await initStream(reader);
+			({ size: contentSize } = reader);
+		}
+		return Object.assign({ reader }, resolveEntrySizes(zipWriter, Boolean(reader), contentSize, metadata, options));
+	}
+
+	function resolveEntrySizes(zipWriter, hasContent, contentSize, metadata, options) {
 		const { passThrough, zipCrypto, password, rawPassword, encryptionStrength } = metadata;
 		let { dataDescriptor, zip64, level, compressionMethod } = metadata;
 		let maximumCompressedSize = 0;
 		let uncompressedSize = 0;
-		if (passThrough) {
-			if (!reader) {
-				throw new Error(ERR_UNDEFINED_READER);
-			}
+		if (passThrough && hasContent) {
 			uncompressedSize = options[PROPERTY_NAME_UNCOMPRESSED_SIZE];
 			if (uncompressedSize === UNDEFINED_VALUE) {
 				throw new Error(ERR_UNDEFINED_UNCOMPRESSED_SIZE);
@@ -6462,29 +6591,30 @@
 		}
 		const zip64Enabled = zip64 === true;
 		const encrypted = getOptionValue(zipWriter, options, PROPERTY_NAME_ENCRYPTED);
-		const encryptedEntry = Boolean(reader) && (Boolean((password && getLength(password)) || (rawPassword && getLength(rawPassword))) || (passThrough && encrypted));
-		if (!reader) {
+		if (hasContent && passThrough && !encrypted && getLength(password, rawPassword)) {
+			throw new Error(ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH);
+		}
+		const encryptedEntry = hasContent && (Boolean((password && getLength(password)) || (rawPassword && getLength(rawPassword))) || (passThrough && encrypted));
+		if (!hasContent) {
 			level = 0;
 			compressionMethod = COMPRESSION_METHOD_STORE;
 		}
 		const encryptionOverhead = encryptedEntry ? (zipCrypto ? 12 : 16 + encryptionStrength * 4) : 0;
-		if (reader) {
-			reader = new GenericReader(reader);
-			await initStream(reader);
+		if (hasContent) {
 			if (!passThrough) {
-				if (reader.size === UNDEFINED_VALUE) {
+				if (contentSize === UNDEFINED_VALUE) {
 					dataDescriptor = true;
 					if (zip64 || zip64 === UNDEFINED_VALUE) {
 						zip64 = true;
 						uncompressedSize = maximumCompressedSize = MAX_32_BITS + 1;
 					}
 				} else {
-					options.uncompressedSize = uncompressedSize = reader.size;
-					maximumCompressedSize = getMaximumCompressedSize(uncompressedSize) + encryptionOverhead;
+					options.uncompressedSize = uncompressedSize = contentSize;
+					maximumCompressedSize = (isCompressed(compressionMethod, level) ? getMaximumCompressedSize(uncompressedSize) : uncompressedSize) + encryptionOverhead;
 				}
 			} else {
 				options.uncompressedSize = uncompressedSize;
-				maximumCompressedSize = getMaximumCompressedSize(uncompressedSize) + encryptionOverhead;
+				maximumCompressedSize = contentSize === UNDEFINED_VALUE ? getMaximumCompressedSize(uncompressedSize) + encryptionOverhead : contentSize;
 			}
 		}
 		const zip64UncompressedSize = zip64Enabled || uncompressedSize >= MAX_32_BITS;
@@ -6498,7 +6628,7 @@
 		}
 		zip64 = zip64 || false;
 		return {
-			reader,
+			maximumCompressedSize,
 			resolvedOptions: {
 				dataDescriptor,
 				zip64,
@@ -6726,6 +6856,7 @@
 			uid,
 			gid,
 			unixMode,
+			symlink,
 			setuid,
 			setgid,
 			sticky,
@@ -6762,6 +6893,7 @@
 			uid,
 			gid,
 			unixMode,
+			symlink: Boolean(symlink),
 			setuid,
 			setgid,
 			sticky,
@@ -6842,8 +6974,8 @@
 			rawLastModDate,
 			creationDate,
 			lastAccessDate,
-			encrypted,
-			zipCrypto,
+			encrypted: Boolean(encrypted),
+			zipCrypto: Boolean(zipCrypto),
 			size: metadataSize + compressedSize,
 			compressionMethod,
 			version,
@@ -6883,9 +7015,7 @@
 			crc32
 		} = options;
 		let { version, compressionMethod } = options;
-		const compressed = !directory && (compressionMethod === UNDEFINED_VALUE
-			? (level === UNDEFINED_VALUE || level > 0)
-			: compressionMethod !== COMPRESSION_METHOD_STORE);
+		const compressed = !directory && isCompressed(compressionMethod, level);
 		let rawLocalExtraFieldZip64;
 		const uncompressedFile = passThrough || !compressed;
 		const zip64ExtraFieldComplete = zip64 && (options.bufferedWrite || !dataDescriptor || ((!zip64UncompressedSize && !zip64CompressedSize) || uncompressedFile));
@@ -7572,6 +7702,16 @@
 		return result === UNDEFINED_VALUE ? defaultValue : result;
 	}
 
+	function getAliasedOptionValue(zipWriter, options, name, deprecatedName, defaultValue) {
+		const value = getAliasedValue(options, name, deprecatedName);
+		const result = value === UNDEFINED_VALUE ? getAliasedValue(zipWriter.options, name, deprecatedName) : value;
+		return result === UNDEFINED_VALUE ? defaultValue : result;
+	}
+
+	function getAliasedValue(options, name, deprecatedName) {
+		return options[name] === UNDEFINED_VALUE ? options[deprecatedName] : options[name];
+	}
+
 	function getNumberOptionValue(zipWriter, options, name, defaultValue) {
 		return toNumber(getOptionValue(zipWriter, options, name, defaultValue));
 	}
@@ -7584,6 +7724,12 @@
 		return uncompressedSize + (5 * (Math.floor(uncompressedSize / 16383) + 1));
 	}
 
+	function isCompressed(compressionMethod, level) {
+		return compressionMethod === UNDEFINED_VALUE
+			? (level === UNDEFINED_VALUE || level > 0)
+			: compressionMethod !== COMPRESSION_METHOD_STORE;
+	}
+
 	function setUint8(view, offset, value) {
 		view.setUint8(offset, value);
 	}
@@ -8182,6 +8328,7 @@
 	exports.ERR_INVALID_CODEC_DEFINITION = ERR_INVALID_CODEC_DEFINITION;
 	exports.ERR_INVALID_CODEC_MODULE = ERR_INVALID_CODEC_MODULE;
 	exports.ERR_INVALID_COMMENT = ERR_INVALID_COMMENT;
+	exports.ERR_INVALID_COMMENT_TYPE = ERR_INVALID_COMMENT_TYPE;
 	exports.ERR_INVALID_COMPRESSED_DATA = ERR_INVALID_COMPRESSED_DATA;
 	exports.ERR_INVALID_CRC32 = ERR_INVALID_CRC32;
 	exports.ERR_INVALID_ENCRYPTION_STRENGTH = ERR_INVALID_ENCRYPTION_STRENGTH;
@@ -8213,11 +8360,13 @@
 	exports.ERR_SPLIT_ZIP_FILE = ERR_SPLIT_ZIP_FILE;
 	exports.ERR_UNDEFINED_READER = ERR_UNDEFINED_READER;
 	exports.ERR_UNDEFINED_UNCOMPRESSED_SIZE = ERR_UNDEFINED_UNCOMPRESSED_SIZE;
+	exports.ERR_UNDETERMINED_SIZE = ERR_UNDETERMINED_SIZE;
 	exports.ERR_UNSAFE_FILENAME = ERR_UNSAFE_FILENAME;
 	exports.ERR_UNSUPPORTED_COMPRESSION = ERR_UNSUPPORTED_COMPRESSION$1;
 	exports.ERR_UNSUPPORTED_CONTEXT = ERR_UNSUPPORTED_CONTEXT;
 	exports.ERR_UNSUPPORTED_CRYPTO_API = ERR_UNSUPPORTED_CRYPTO_API;
 	exports.ERR_UNSUPPORTED_ENCRYPTION = ERR_UNSUPPORTED_ENCRYPTION;
+	exports.ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH = ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH;
 	exports.ERR_UNSUPPORTED_ENCRYPTION_USDZ = ERR_UNSUPPORTED_ENCRYPTION_USDZ;
 	exports.ERR_UNSUPPORTED_FORMAT = ERR_UNSUPPORTED_FORMAT;
 	exports.ERR_WORKER_STARTUP_TIMEOUT = ERR_WORKER_STARTUP_TIMEOUT;