@zip.js/zip.js 2.8.51 → 2.8.52

package/index.cjs

@@ -84,6 +84,8 @@ const FILE_ATTR_MSDOS_SYSTEM_MASK = 0x04;
 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;
@@ -1775,8 +1777,6 @@ function getInt32(number) {
  */
 
 
-const HTTP_HEADER_CONTENT_TYPE = "Content-Type";
-
 function toCompatibleReadable(readable) {
 	if (readable instanceof ReadableStream) {
 		return readable;
@@ -1799,12 +1799,9 @@ function toCompatibleReadable(readable) {
 
 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
@@ -1813,7 +1810,7 @@ function streamToBlob(readable, contentType) {
 				chunks.push(chunk);
 			}
 		}))
-		.then(() => new Blob(chunks, contentType ? { type: contentType } : {}));
+		.then(() => new Blob(chunks, blobOptions));
 }
 
 function responseSupportsGlobalReadable() {
@@ -3348,8 +3345,10 @@ class Reader extends Stream {
 			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 +3426,7 @@ class Data64URIWriter extends Writer {
 	constructor(contentType) {
 		super();
 		Object.assign(this, {
+			contentType,
 			data: "data:" + (contentType || "") + ";base64,",
 			pending: []
 		});
@@ -3528,6 +3528,7 @@ class BlobWriter extends Stream {
 				return transformStream.writable;
 			}
 		});
+		writer.contentType = contentType;
 		writer.blob = streamToBlob(transformStream.readable, contentType);
 		writer.blob.catch(() => { });
 	}
@@ -3544,6 +3545,26 @@ class TextReader extends BlobReader {
 	}
 }
 
+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) {
@@ -4207,6 +4228,10 @@ class GenericWriter {
 	}
 }
 
+function ownsWritable(writer) {
+	return Boolean(writer && writer.getData);
+}
+
 function isHttpFamily(url) {
 	const { baseURI } = getConfiguration();
 	const { protocol } = new URL(url, baseURI);
@@ -4351,6 +4376,8 @@ const PROPERTY_NAME_CREATION_DATE = "creationDate";
 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 +4388,7 @@ const PROPERTY_NAME_VERSION_MADE_BY = "versionMadeBy";
 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";
@@ -4404,6 +4432,8 @@ const PROPERTY_NAMES = [
 	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 +4444,7 @@ const PROPERTY_NAMES = [
 	PROPERTY_NAME_ZIPCRYPTO,
 	PROPERTY_NAME_DIRECTORY,
 	PROPERTY_NAME_EXECUTABLE,
+	PROPERTY_NAME_SYMLINK,
 	PROPERTY_NAME_COMPRESSION_METHOD,
 	PROPERTY_NAME_SIGNATURE,
 	PROPERTY_NAME_CRC32,
@@ -4876,15 +4907,18 @@ class ZipReader {
 			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 +4984,10 @@ class ZipReader {
 	}
 
 	async close() {
+		const { reader } = this;
+		if (!reader.readUint8Array && reader.readable && !reader.readable.locked) {
+			await reader.readable.cancel();
+		}
 	}
 }
 
@@ -5174,7 +5212,7 @@ let ZipEntry$1 = class ZipEntry {
 				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) {
@@ -5418,8 +5456,8 @@ function readExtraFieldUnixDates(extraField, directory) {
 		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);
@@ -5850,6 +5888,7 @@ 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 +5898,7 @@ const MIN_NTFS_TIME = BigInt(0);
 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)";
@@ -6066,7 +6106,7 @@ class ZipWriter {
 			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();
 		}
@@ -6225,7 +6265,7 @@ function resolveAttributes(zipWriter, name, options) {
 	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;
@@ -6273,7 +6313,9 @@ function resolveAttributes(zipWriter, name, options) {
 		}
 		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);
 		}
@@ -6326,15 +6368,12 @@ function resolveMetadata(zipWriter, name, options) {
 	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 +6486,24 @@ function serializeExtraField(extraField) {
 }
 
 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 +6511,30 @@ async function resolveSizes(zipWriter, reader, { resolvedOptions: metadata }, op
 	}
 	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 +6548,7 @@ async function resolveSizes(zipWriter, reader, { resolvedOptions: metadata }, op
 	}
 	zip64 = zip64 || false;
 	return {
-		reader,
+		maximumCompressedSize,
 		resolvedOptions: {
 			dataDescriptor,
 			zip64,
@@ -6512,6 +6562,78 @@ async function resolveSizes(zipWriter, reader, { resolvedOptions: metadata }, op
 	};
 }
 
+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);
+	}
+	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,
@@ -6883,9 +7005,7 @@ function getHeaderInfo(options) {
 		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 +7692,16 @@ function getOptionValue(zipWriter, options, name, defaultValue) {
 	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 +7714,12 @@ function getMaximumCompressedSize(uncompressedSize) {
 	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);
 }
@@ -8597,6 +8733,7 @@ U(setDefaultConfiguration);
 
 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";
@@ -8634,6 +8771,7 @@ class ZipEntry {
 			parent,
 			children: [],
 			uncompressedSize: params.uncompressedSize || 0,
+			undeterminedSize: params.undeterminedSize || params.uncompressedSize === UNDEFINED_VALUE,
 			passThrough: params.passThrough
 		});
 		if (parent || !fs.root) {
@@ -8701,16 +8839,17 @@ class ZipFileEntry extends ZipEntry {
 
 	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;
 		}
 	}
@@ -8841,7 +8980,7 @@ class ZipDirectoryEntry extends ZipEntry {
 			Reader: TextReader,
 			Writer: TextWriter,
 			options,
-			uncompressedSize: text.length
+			uncompressedSize: getTextSize(text)
 		});
 	}
 
@@ -8970,10 +9109,16 @@ class ZipDirectoryEntry extends ZipEntry {
 	}
 
 	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 {
@@ -8995,7 +9140,7 @@ class ZipDirectoryEntry extends ZipEntry {
 					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 {
@@ -9037,11 +9182,25 @@ class ZipDirectoryEntry extends ZipEntry {
 		}
 		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++) {
@@ -9249,6 +9408,10 @@ class FS {
 		return this.root.exportZip(writer, options);
 	}
 
+	getExportedSize(options) {
+		return this.root.getExportedSize(options);
+	}
+
 	isPasswordProtected() {
 		return this.root.isPasswordProtected();
 	}
@@ -9260,12 +9423,12 @@ class FS {
 
 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);
 		}
@@ -9273,6 +9436,15 @@ function getTotalSize(entries, propertyName) {
 	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 () {
@@ -9295,10 +9467,17 @@ function getZipBlobReader(options) {
 
 		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();
 		}
 
@@ -9312,6 +9491,30 @@ function createReader(Reader, data, options) {
 	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];
@@ -9344,6 +9547,7 @@ async function initReaders(entry, options) {
 		}
 		if (reader.size !== UNDEFINED_VALUE) {
 			child.uncompressedSize = reader.size;
+			child.undeterminedSize = false;
 		}
 	}));
 	return readers;
@@ -9393,6 +9597,90 @@ function aggregateEntryErrors(errors) {
 	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();
@@ -9408,8 +9696,14 @@ function getUserExtraField(extraField) {
 }
 
 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 {
@@ -9417,6 +9711,9 @@ async function exportZip(zipWriter, entry, totalSize, options, readers) {
 			await addChild(child);
 		}
 	}
+	if (onend) {
+		await callHandler(onend, writtenSize);
+	}
 
 	async function processChildren(entry) {
 		const results = await Promise.allSettled(entry.children.map(async child => {
@@ -9430,81 +9727,23 @@ async function exportZip(zipWriter, entry, totalSize, options, readers) {
 	}
 
 	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);
+		}
 	}
 }
 
@@ -9532,7 +9771,7 @@ function addFileSystemHandle(zipEntry, handle, options) {
 						})
 					);
 				} 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);
@@ -9554,15 +9793,29 @@ function addFileSystemHandle(zipEntry, handle, options) {
 }
 
 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;
@@ -9575,6 +9828,25 @@ async function exportFileSystemHandle(zipEntry, directoryHandle, options) {
 	}
 	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)));
@@ -9606,19 +9878,7 @@ async function exportFileSystemHandle(zipEntry, directoryHandle, options) {
 				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;
 				}
@@ -9862,6 +10122,7 @@ exports.ERR_INVALID_MSDOS_ATTRIBUTES = ERR_INVALID_MSDOS_ATTRIBUTES;
 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;
@@ -9879,11 +10140,13 @@ exports.ERR_RESERVED_COMPRESSION_METHOD = ERR_RESERVED_COMPRESSION_METHOD;
 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;