@zip.js/zip.js 2.8.51 → 2.8.53

package/dist/zip-fs-native.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;
@@ -1781,8 +1786,6 @@
 	 */
 
 
-	const HTTP_HEADER_CONTENT_TYPE = "Content-Type";
-
 	function toCompatibleReadable(readable) {
 		if (readable instanceof ReadableStream) {
 			return readable;
@@ -1805,12 +1808,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
@@ -1819,7 +1819,7 @@
 					chunks.push(chunk);
 				}
 			}))
-			.then(() => new Blob(chunks, contentType ? { type: contentType } : {}));
+			.then(() => new Blob(chunks, blobOptions));
 	}
 
 	function responseSupportsGlobalReadable() {
@@ -2761,6 +2761,7 @@
 				worker,
 				workerAlive: false,
 				terminated: false,
+				startupError: null,
 				interface: {
 					run: async () => {
 						try {
@@ -2788,6 +2789,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;
@@ -3001,11 +3009,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();
@@ -3350,8 +3359,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;
@@ -3429,6 +3440,7 @@
 		constructor(contentType) {
 			super();
 			Object.assign(this, {
+				contentType,
 				data: "data:" + (contentType || "") + ";base64,",
 				pending: []
 			});
@@ -3530,6 +3542,7 @@
 					return transformStream.writable;
 				}
 			});
+			writer.contentType = contentType;
 			writer.blob = streamToBlob(transformStream.readable, contentType);
 			writer.blob.catch(() => { });
 		}
@@ -3546,6 +3559,26 @@
 		}
 	}
 
+	function getTextSize(text) {
+		let size = 0;
+		for (let indexCharacter = 0; indexCharacter < text.length; indexCharacter++) {
+			const characterCode = text.charCodeAt(indexCharacter);
+			if (characterCode < 0x80) {
+				size += 1;
+			} else if (characterCode < 0x800) {
+				size += 2;
+			} else if (characterCode < 0xd800 || characterCode >= 0xe000) {
+				size += 3;
+			} else if (characterCode < 0xdc00 && (text.charCodeAt(indexCharacter + 1) & 0xfc00) == 0xdc00) {
+				size += 4;
+				indexCharacter++;
+			} else {
+				size += 3;
+			}
+		}
+		return size;
+	}
+
 	class TextWriter extends BlobWriter {
 
 		constructor(encoding) {
@@ -4030,9 +4063,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;
@@ -4209,6 +4241,10 @@
 		}
 	}
 
+	function ownsWritable(writer) {
+		return Boolean(writer && writer.getData);
+	}
+
 	function isHttpFamily(url) {
 		const { baseURI } = getConfiguration();
 		const { protocol } = new URL(url, baseURI);
@@ -4223,6 +4259,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);
 	}
@@ -4353,6 +4399,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";
@@ -4363,6 +4411,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";
@@ -4378,6 +4427,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";
@@ -4406,6 +4459,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,
@@ -4416,6 +4471,7 @@
 		PROPERTY_NAME_ZIPCRYPTO,
 		PROPERTY_NAME_DIRECTORY,
 		PROPERTY_NAME_EXECUTABLE,
+		PROPERTY_NAME_SYMLINK,
 		PROPERTY_NAME_COMPRESSION_METHOD,
 		PROPERTY_NAME_SIGNATURE,
 		PROPERTY_NAME_CRC32,
@@ -4427,10 +4483,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,
@@ -4492,6 +4552,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";
@@ -4623,7 +4684,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);
@@ -4845,6 +4906,7 @@
 					index: indexFile,
 					versionMadeBy,
 					msDosCompatible,
+					zip64: false,
 					compressedSize: 0,
 					uncompressedSize: 0,
 					commentLength,
@@ -4878,15 +4940,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,
@@ -4952,6 +5017,10 @@
 		}
 
 		async close() {
+			const { reader } = this;
+			if (!reader.readUint8Array && reader.readable && !reader.readable.locked) {
+				await reader.readable.cancel();
+			}
 		}
 	}
 
@@ -5048,9 +5117,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);
@@ -5059,17 +5131,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) {
@@ -5176,7 +5257,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) {
@@ -5305,10 +5386,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);
@@ -5411,7 +5494,7 @@
 			const creationDate = getDateNTFS(rawCreationDate);
 			const extraFieldData = { lastModDate, lastAccessDate, creationDate };
 			Object.assign(extraFieldNTFS, extraFieldData);
-			Object.assign(directory, extraFieldData);
+			Object.assign(directory, extraFieldData, { rawLastAccessDate, rawCreationDate });
 		}
 	}
 
@@ -5420,8 +5503,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);
@@ -5455,6 +5538,7 @@
 			if (gid !== UNDEFINED_VALUE) {
 				directory.gid = gid;
 			}
+			return uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE;
 		} catch {
 			// ignored
 		}
@@ -5527,26 +5611,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,
@@ -5563,6 +5646,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;
 	}
@@ -5571,14 +5668,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;
 		}
-		return strictness;
+		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 Boolean(checkLocalDirectory);
+	}
+
+	function getCheckLocalFilename(checkLocalFilename, strictness) {
+		if (checkLocalFilename === UNDEFINED_VALUE) {
+			return strictness == STRICTNESS_STRICT;
+		}
+		return Boolean(checkLocalFilename);
 	}
 
 	function getFilenameValidation(filenameValidation, strictness) {
@@ -5726,10 +5849,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)) {
@@ -5847,11 +5971,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";
@@ -5861,6 +5987,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)";
@@ -5913,6 +6040,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();
@@ -6061,6 +6192,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);
 			}
@@ -6068,7 +6202,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();
 			}
@@ -6157,8 +6291,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,
@@ -6172,14 +6304,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);
@@ -6213,7 +6351,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);
@@ -6227,7 +6365,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;
@@ -6253,11 +6391,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 {
@@ -6275,7 +6412,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);
 			}
@@ -6284,17 +6423,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,
@@ -6328,15 +6470,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);
@@ -6449,14 +6588,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);
@@ -6464,29 +6613,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;
@@ -6500,7 +6650,7 @@
 		}
 		zip64 = zip64 || false;
 		return {
-			reader,
+			maximumCompressedSize,
 			resolvedOptions: {
 				dataDescriptor,
 				zip64,
@@ -6514,6 +6664,81 @@
 		};
 	}
 
+	async function getEntriesSize(writerOptions, entries, writeOrderGuaranteed, comment) {
+		const zipWriter = { options: writerOptions, config: getConfiguration() };
+		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);
+		}
+		const usdz = writerOptions[OPTION_USDZ];
+		const files = new Map();
+		let layoutDependsOnWriteOrder = Boolean(usdz);
+		let offset = 0;
+		for (const entry of entries) {
+			let { name } = entry;
+			const { size } = entry;
+			const options = Object.assign({}, entry.options);
+			name = name.trim();
+			if (getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY) && !name.endsWith(DIRECTORY_SIGNATURE)) {
+				name += DIRECTORY_SIGNATURE;
+			}
+			const attributesInfo = resolveAttributes(zipWriter, name, options);
+			({ name } = attributesInfo);
+			const { resolvedOptions: metadata } = resolveMetadata(zipWriter, name, options);
+			if (metadata.level != 0 && metadata.compressionMethod === UNDEFINED_VALUE &&
+				!metadata.passThrough && !(await supportsDeflate(zipWriter.config))) {
+				metadata.level = 0;
+			}
+			const hasContent = !getOptionValue(zipWriter, options, PROPERTY_NAME_DIRECTORY);
+			if (hasContent && size === UNDEFINED_VALUE) {
+				throw new Error(ERR_UNDETERMINED_SIZE);
+			}
+			const { maximumCompressedSize, resolvedOptions: sizes } = resolveEntrySizes(zipWriter, hasContent, size, metadata, options);
+			if (hasContent && !metadata.passThrough && isCompressed(sizes.compressionMethod, sizes.level)) {
+				throw new Error(ERR_UNDETERMINED_SIZE);
+			}
+			const entryOptions = Object.assign({}, options, attributesInfo.resolvedOptions, metadata, sizes);
+			const headerInfo = getHeaderInfo(entryOptions);
+			const dataDescriptorInfo = getDataDescriptorInfo(entryOptions);
+			const entryInfo = {
+				headerInfo,
+				metadataSize: getLength(headerInfo.localHeaderArray, dataDescriptorInfo.dataDescriptorArray)
+			};
+			if (usdz) {
+				appendExtraFieldUSDZ(entryInfo, offset);
+			}
+			const compressedSize = hasContent ? maximumCompressedSize : 0;
+			if (offset >= MAX_32_BITS) {
+				layoutDependsOnWriteOrder = true;
+			}
+			files.set(name, Object.assign({}, entryOptions, headerInfo, {
+				offset,
+				diskNumberStart: 0,
+				compressedSize
+			}));
+			offset += entryInfo.metadataSize + compressedSize;
+		}
+		if (layoutDependsOnWriteOrder && !writeOrderGuaranteed) {
+			throw new Error(ERR_UNDETERMINED_SIZE);
+		}
+		const directoryDataLength = createDirectoryRecords(files);
+		let zip64 = getOptionValue(zipWriter, writerOptions, PROPERTY_NAME_ZIP64);
+		if (offset >= MAX_32_BITS || directoryDataLength >= MAX_32_BITS || files.size >= MAX_16_BITS) {
+			if (zip64 === false) {
+				throw new Error(ERR_UNSUPPORTED_FORMAT);
+			} else {
+				zip64 = true;
+			}
+		}
+		return offset + directoryDataLength + commentLength + (zip64 ? ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH : END_OF_CENTRAL_DIR_LENGTH);
+	}
+
 	async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		const {
 			files,
@@ -6728,6 +6953,7 @@
 			uid,
 			gid,
 			unixMode,
+			symlink,
 			setuid,
 			setgid,
 			sticky,
@@ -6764,6 +6990,7 @@
 			uid,
 			gid,
 			unixMode,
+			symlink: Boolean(symlink),
 			setuid,
 			setgid,
 			sticky,
@@ -6844,8 +7071,8 @@
 			rawLastModDate,
 			creationDate,
 			lastAccessDate,
-			encrypted,
-			zipCrypto,
+			encrypted: Boolean(encrypted),
+			zipCrypto: Boolean(zipCrypto),
 			size: metadataSize + compressedSize,
 			compressionMethod,
 			version,
@@ -6885,9 +7112,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));
@@ -7574,6 +7799,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));
 	}
@@ -7586,6 +7821,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);
 	}
@@ -8234,6 +8475,7 @@
 
 	const ERR_ENTRY_EXISTS = "Entry filename already exists";
 	const ERR_READABLE_CONSUMED = "Readable stream already consumed";
+	const ERR_INVALID_PASS_THROUGH = "Invalid passThrough option (use readerOptions.passThrough or set uncompressedSize for each entry)";
 	const ERR_ABORT_EXPORT = "zipjs-abort-export";
 	const ERR_ABORTED = "The operation was aborted";
 	const ABORT_ERROR_NAME = "AbortError";
@@ -8271,6 +8513,7 @@
 				parent,
 				children: [],
 				uncompressedSize: params.uncompressedSize || 0,
+				undeterminedSize: params.undeterminedSize || params.uncompressedSize === UNDEFINED_VALUE,
 				passThrough: params.passThrough
 			});
 			if (parent || !fs.root) {
@@ -8338,16 +8581,17 @@
 
 		async getData(writer, options = {}) {
 			const zipEntry = this;
-			if (!writer || (writer.constructor == zipEntry.Writer && zipEntry.data)) {
+			if (!writer || (writer.constructor == zipEntry.Writer && zipEntry.data && keepsContentType(writer, zipEntry.data))) {
 				return zipEntry.data;
 			} else {
 				const reader = zipEntry.reader = createReader(zipEntry.Reader, zipEntry.data, options);
-				const uncompressedSize = zipEntry.data ? zipEntry.data.uncompressedSize : reader.size;
-				await Promise.all([initStream(reader), initStream(writer, uncompressedSize)]);
-				const { readable } = reader;
+				const dataSize = zipEntry.uncompressedSize || reader.size;
+				await Promise.all([initStream(reader), initStream(writer, dataSize)]);
 				const { signal } = options;
+				const readable = createProgressReadable(zipEntry, reader, options, signal);
+				const preventClose = !ownsWritable(writer) && Boolean(options.preventClose);
 				zipEntry.uncompressedSize = reader.size;
-				await toCompatibleReadable(readable).pipeTo(toCompatibleWritable(writer.writable), { signal });
+				await toCompatibleReadable(readable).pipeTo(toCompatibleWritable(writer.writable), { signal, preventClose, preventAbort: preventClose });
 				return writer.getData ? writer.getData() : writer.writable;
 			}
 		}
@@ -8478,7 +8722,7 @@
 				Reader: TextReader,
 				Writer: TextWriter,
 				options,
-				uncompressedSize: text.length
+				uncompressedSize: getTextSize(text)
 			});
 		}
 
@@ -8607,10 +8851,16 @@
 		}
 
 		async importZip(reader, options = {}) {
-			await initStream(reader);
-			const zipReader = new ZipReader(reader, options);
+			let zipReader;
+			if (reader && typeof reader.getEntries == FUNCTION_TYPE) {
+				zipReader = reader;
+				options = Object.assign({}, zipReader.options, options);
+			} else {
+				await initStream(reader);
+				zipReader = new ZipReader(reader, options);
+			}
 			const importedEntries = [];
-			const entries = await zipReader.getEntries();
+			const entries = await zipReader.getEntries(options);
 			for (const entry of entries) {
 				let parent = this;
 				try {
@@ -8632,7 +8882,7 @@
 						importedEntries.push(addChild(parent, name, {
 							data: entry,
 							Reader: getZipBlobReader(Object.assign({}, options)),
-							uncompressedSize: entry.uncompressedSize,
+							uncompressedSize: options.passThrough ? entry.compressedSize : entry.uncompressedSize,
 							passThrough: options.passThrough
 						}));
 					} else {
@@ -8674,11 +8924,25 @@
 			}
 			const [readers] = await Promise.all([initReaders(zipEntry, options.readerOptions), initStream(writer)]);
 			const zipWriter = new ZipWriter(writer, options);
-			await exportZip(zipWriter, zipEntry, getTotalSize([zipEntry], "uncompressedSize"), options, readers);
-			await zipWriter.close();
+			await exportZip(zipWriter, zipEntry, getTotalSize([zipEntry], getUncompressedSize), options, readers);
+			await zipWriter.close(options.globalComment);
 			return writer.getData ? writer.getData() : writer.writable;
 		}
 
+		getExportedSize(options = {}) {
+			const zipEntry = this;
+			options = Object.assign({}, options);
+			if (options.bufferedWrite === UNDEFINED_VALUE) {
+				options.bufferedWrite = true;
+			}
+			const writeOrderGuaranteed = !options.bufferedWrite ||
+				(options.keepOrder !== false && zipEntry.children.every(child => !child.children.length));
+			return getEntriesSize(options, Array.from(zipEntry.getChildren({ recursive: true }), child => {
+				const { name, entryOptions } = getChildEntryOptions(child, zipEntry, options);
+				return { name, size: child.directory ? 0 : getDeterminedSize(child, isPassThrough(child, options)), options: entryOptions };
+			}), writeOrderGuaranteed, options.globalComment);
+		}
+
 		getChildByName(name) {
 			const children = this.children;
 			for (let childIndex = 0; childIndex < children.length; childIndex++) {
@@ -8886,6 +9150,10 @@
 			return this.root.exportZip(writer, options);
 		}
 
+		getExportedSize(options) {
+			return this.root.getExportedSize(options);
+		}
+
 		isPasswordProtected() {
 			return this.root.isPasswordProtected();
 		}
@@ -8897,12 +9165,12 @@
 
 	const fs = { FS, ZipDirectoryEntry, ZipFileEntry };
 
-	function getTotalSize(entries, propertyName) {
+	function getTotalSize(entries, getEntrySize) {
 		let size = 0;
 		const pendingEntries = Array.from(entries);
 		while (pendingEntries.length) {
 			const entry = pendingEntries.pop();
-			size += entry[propertyName] || 0;
+			size += getEntrySize(entry) || 0;
 			for (const child of entry.children) {
 				pendingEntries.push(child);
 			}
@@ -8910,6 +9178,15 @@
 		return size;
 	}
 
+	function getUncompressedSize(entry) {
+		return entry.uncompressedSize;
+	}
+
+	function getExtractedSize(entry, passThrough) {
+		const { data } = entry;
+		return passThrough && data instanceof Entry ? data.compressedSize : entry.uncompressedSize;
+	}
+
 	function getReadableReader(readable) {
 		let consumed;
 		return function () {
@@ -8932,10 +9209,17 @@
 
 			async init() {
 				const zipBlobReader = this;
-				zipBlobReader.size = zipBlobReader.entry.uncompressedSize;
-				const data = await zipBlobReader.entry.getData(new BlobWriter(), Object.assign({}, options, zipBlobReader.options));
+				const readerOptions = Object.assign({}, options, zipBlobReader.options);
+				const { checkOverlappingEntry, checkOverlappingEntryOnly } = readerOptions;
+				const data = await zipBlobReader.entry.getData(new BlobWriter(), Object.assign(readerOptions, {
+					checkPasswordOnly: false,
+					checkOverlappingEntry: checkOverlappingEntryOnly || checkOverlappingEntry,
+					checkOverlappingEntryOnly: false,
+					preventClose: false
+				}));
 				zipBlobReader.data = data;
 				zipBlobReader.blobReader = new BlobReader(data);
+				zipBlobReader.size = data.size;
 				super.init();
 			}
 
@@ -8949,6 +9233,30 @@
 		return Reader.prototype ? new Reader(data, options) : Reader(data, options);
 	}
 
+	function keepsContentType(writer, data) {
+		const { contentType } = writer;
+		if (contentType === UNDEFINED_VALUE) {
+			return true;
+		} else if (writer.constructor == BlobWriter) {
+			return data.type == contentType;
+		} else if (writer.constructor == Data64URIWriter) {
+			return data.startsWith(writer.data);
+		} else {
+			return true;
+		}
+	}
+
+	function createProgressReadable(zipEntry, reader, options, signal) {
+		const { onstart, onprogress, onend } = options;
+		const { readable } = reader;
+		const coreReaderReportsProgress = zipEntry.data instanceof Entry;
+		if (coreReaderReportsProgress || (!onstart && !onprogress && !onend)) {
+			return readable;
+		} else {
+			return toCompatibleReadable(readable).pipeThrough(new ProgressWatcherStream({ onstart, onprogress, onend, size: reader.size }), { signal });
+		}
+	}
+
 	async function initReaders(entry, options) {
 		const fileEntries = [];
 		const pendingEntries = [entry];
@@ -8981,6 +9289,7 @@
 			}
 			if (reader.size !== UNDEFINED_VALUE) {
 				child.uncompressedSize = reader.size;
+				child.undeterminedSize = false;
 			}
 		}));
 		return readers;
@@ -9030,6 +9339,90 @@
 		return error;
 	}
 
+	function getChildEntryOptions(child, selectedEntry, options) {
+		const name = options.relativePath ? child.getRelativeName(selectedEntry) : child.getFullname();
+		const childOptions = child.options || {};
+		let zipEntryMetadata = {};
+		let passThroughOptions = {};
+		if (child.data instanceof Entry) {
+			const {
+				externalFileAttributes,
+				versionMadeBy,
+				comment,
+				lastModDate,
+				creationDate,
+				lastAccessDate,
+				uncompressedSize,
+				encrypted,
+				zipCrypto,
+				crc32,
+				compressionMethod,
+				extraFieldAES,
+				internalFileAttributes,
+				extraField,
+				uid,
+				gid
+			} = child.data;
+			zipEntryMetadata = {
+				externalFileAttributes,
+				versionMadeBy,
+				comment,
+				lastModDate,
+				creationDate,
+				lastAccessDate,
+				internalFileAttributes
+			};
+			const userExtraField = getUserExtraField(extraField);
+			if (userExtraField) {
+				zipEntryMetadata.extraField = userExtraField;
+			}
+			if (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE) {
+				Object.assign(zipEntryMetadata, {
+					uid,
+					gid,
+					unixExtraFieldType: INFOZIP_EXTRA_FIELD_TYPE
+				});
+			}
+			if (isPassThrough(child, options)) {
+				let level, encryptionStrength;
+				if (compressionMethod === 0) {
+					level = 0;
+				}
+				if (extraFieldAES) {
+					encryptionStrength = extraFieldAES.strength;
+				}
+				passThroughOptions = {
+					passThrough: true,
+					encrypted,
+					zipCrypto,
+					crc32,
+					uncompressedSize,
+					level,
+					encryptionStrength,
+					compressionMethod
+				};
+			}
+		}
+		const entryOptions = Object.assign({}, zipEntryMetadata, options, passThroughOptions, childOptions, { directory: child.directory });
+		if (!child.directory && entryOptions.passThrough && entryOptions.uncompressedSize === UNDEFINED_VALUE) {
+			throw new Error(ERR_INVALID_PASS_THROUGH);
+		}
+		return { name, entryOptions };
+	}
+
+	function getDeterminedSize(child, passThrough) {
+		const { reader } = child;
+		if (reader && reader.size !== UNDEFINED_VALUE) {
+			return reader.size;
+		}
+		return child.undeterminedSize ? UNDEFINED_VALUE : getExtractedSize(child, passThrough);
+	}
+
+	function isPassThrough(child, options) {
+		const { readerOptions } = options;
+		return Boolean(!child.directory && (child.passThrough || (readerOptions && readerOptions.passThrough)));
+	}
+
 	function getUserExtraField(extraField) {
 		if (extraField) {
 			const userExtraField = new Map();
@@ -9045,8 +9438,14 @@
 	}
 
 	async function exportZip(zipWriter, entry, totalSize, options, readers) {
+		const { onstart, onprogress, onend, onentryprogress } = options;
 		const selectedEntry = entry;
-		const entryOffsets = new Map();
+		const totalEntries = getTotalSize(entry.children, () => 1);
+		let writtenSize = 0;
+		let writtenEntries = 0;
+		if (onstart) {
+			await callHandler(onstart, totalSize);
+		}
 		if (options.bufferedWrite) {
 			await processChildren(entry);
 		} else {
@@ -9054,6 +9453,9 @@
 				await addChild(child);
 			}
 		}
+		if (onend) {
+			await callHandler(onend, writtenSize);
+		}
 
 		async function processChildren(entry) {
 			const results = await Promise.allSettled(entry.children.map(async child => {
@@ -9067,81 +9469,23 @@
 		}
 
 		async function addChild(child) {
-			const name = options.relativePath ? child.getRelativeName(selectedEntry) : child.getFullname();
-			const childOptions = child.options || {};
-			let zipEntryOptions = {};
-			if (child.data instanceof Entry) {
-				const {
-					externalFileAttributes,
-					versionMadeBy,
-					comment,
-					lastModDate,
-					creationDate,
-					lastAccessDate,
-					uncompressedSize,
-					encrypted,
-					zipCrypto,
-					crc32,
-					compressionMethod,
-					extraFieldAES,
-					internalFileAttributes,
-					extraField,
-					uid,
-					gid
-				} = child.data;
-				zipEntryOptions = {
-					externalFileAttributes,
-					versionMadeBy,
-					comment,
-					lastModDate,
-					creationDate,
-					lastAccessDate,
-					internalFileAttributes
-				};
-				const userExtraField = getUserExtraField(extraField);
-				if (userExtraField) {
-					zipEntryOptions.extraField = userExtraField;
-				}
-				if (uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE) {
-					Object.assign(zipEntryOptions, {
-						uid,
-						gid,
-						unixExtraFieldType: options.unixExtraFieldType || INFOZIP_EXTRA_FIELD_TYPE
-					});
-				}
-				if (child.passThrough) {
-					let level, encryptionStrength;
-					if (compressionMethod === 0) {
-						level = 0;
-					}
-					if (extraFieldAES) {
-						encryptionStrength = extraFieldAES.strength;
-					}
-					zipEntryOptions = Object.assign(zipEntryOptions, {
-						passThrough: true,
-						encrypted,
-						zipCrypto,
-						crc32,
-						uncompressedSize,
-						level,
-						encryptionStrength,
-						compressionMethod
-					});
-				}
-			}
-			await zipWriter.add(name, readers.get(child), Object.assign({}, options, zipEntryOptions, childOptions, {
-				directory: child.directory,
+			const { name, entryOptions } = getChildEntryOptions(child, selectedEntry, options);
+			let entryWrittenSize = 0;
+			const entryMetadata = await zipWriter.add(name, readers.get(child), Object.assign(entryOptions, {
+				onstart: UNDEFINED_VALUE,
+				onend: UNDEFINED_VALUE,
 				onprogress: async indexProgress => {
-					if (options.onprogress) {
-						entryOffsets.set(name, indexProgress);
-						try {
-							await options.onprogress(Array.from(entryOffsets.values()).reduce((previousValue, currentValue) => previousValue + currentValue), totalSize);
-						} catch {
-							// ignored
-						}
+					writtenSize += indexProgress - entryWrittenSize;
+					entryWrittenSize = indexProgress;
+					if (onprogress) {
+						await callHandler(onprogress, writtenSize, totalSize);
 					}
 				}
 			}));
+			writtenEntries++;
+			if (onentryprogress) {
+				await callHandler(onentryprogress, writtenEntries, totalEntries, entryMetadata);
+			}
 		}
 	}
 
@@ -9169,7 +9513,7 @@
 							})
 						);
 					} else if (handle.kind == "directory") {
-						const directoryEntry = parentEntry.addDirectory(handle.name);
+						const directoryEntry = parentEntry.addDirectory(handle.name, options);
 						addedEntries.push(directoryEntry);
 						for await (const childHandle of handle.values()) {
 							await addFile(directoryEntry, childHandle, addedEntries, entryName);
@@ -9191,15 +9535,29 @@
 	}
 
 	async function exportFileSystemHandle(zipEntry, directoryHandle, options) {
-		const totalSize = getTotalSize([zipEntry], "uncompressedSize");
-		const writtenSizes = new Map();
+		const { onstart, onprogress, onend } = options;
 		const abortController = new AbortController();
 		const { signal } = abortController;
 		const releaseSignal = forwardAbort(options.signal, abortController);
+		const getDataOptions = Object.assign({}, options, options.readerOptions, {
+			signal,
+			onstart: UNDEFINED_VALUE,
+			onprogress: UNDEFINED_VALUE,
+			onend: UNDEFINED_VALUE,
+			preventClose: false
+		});
+		const totalSize = getTotalSize([zipEntry], entry => getExtractedSize(entry, getDataOptions.passThrough));
 		const exportedEntryNames = [];
 		let exportAborted = false;
+		let writtenSize = 0;
 		try {
+			if (onstart) {
+				await callHandler(onstart, totalSize);
+			}
 			await exportChildren(zipEntry, directoryHandle);
+			if (onend) {
+				await callHandler(onend, writtenSize);
+			}
 		} catch (error) {
 			try {
 				error.exportedEntryNames = exportedEntryNames;
@@ -9212,6 +9570,25 @@
 		}
 		return directoryHandle;
 
+		function createProgressWritable(writable) {
+			const writer = writable.getWriter();
+			return new WritableStream({
+				async write(chunk) {
+					await writer.write(chunk);
+					writtenSize += chunk.length;
+					if (onprogress) {
+						await callHandler(onprogress, writtenSize, totalSize);
+					}
+				},
+				close() {
+					return writer.close();
+				},
+				abort(reason) {
+					return writer.abort(reason);
+				}
+			});
+		}
+
 		async function exportChildren(entry, parentHandle) {
 			if (options.concurrent) {
 				const results = await Promise.allSettled(entry.children.map(child => exportChild(child, parentHandle)));
@@ -9243,19 +9620,7 @@
 					const fileHandle = await parentHandle.getFileHandle(child.name, { create: true });
 					const writable = await fileHandle.createWritable();
 					try {
-						await child.getData({ writable }, Object.assign({}, options, {
-							signal,
-							onprogress: async progress => {
-								if (options.onprogress) {
-									writtenSizes.set(child.id, progress);
-									try {
-										await options.onprogress(Array.from(writtenSizes.values()).reduce((previousValue, currentValue) => previousValue + currentValue, 0), totalSize);
-									} catch {
-										// ignored
-									}
-								}
-							}
-						}));
+						await child.getData({ writable: createProgressWritable(writable) }, getDataOptions);
 					} catch (error) {
 						throw exportAborted ? new Error(ERR_ABORT_EXPORT) : error;
 					}
@@ -9484,6 +9849,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;
@@ -9499,6 +9865,7 @@
 	exports.ERR_INVALID_MSDOS_DATA = ERR_INVALID_MSDOS_DATA;
 	exports.ERR_INVALID_PASSWORD = ERR_INVALID_PASSWORD;
 	exports.ERR_INVALID_PASSWORD_TYPE = ERR_INVALID_PASSWORD_TYPE;
+	exports.ERR_INVALID_PASS_THROUGH = ERR_INVALID_PASS_THROUGH;
 	exports.ERR_INVALID_SIGNATURE = ERR_INVALID_SIGNATURE;
 	exports.ERR_INVALID_SIGNATURE_DATA = ERR_INVALID_SIGNATURE_DATA;
 	exports.ERR_INVALID_STRICTNESS = ERR_INVALID_STRICTNESS;
@@ -9516,11 +9883,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;