@zip.js/zip.js 2.8.50 → 2.8.52

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;
@@ -1781,8 +1783,6 @@
 	 */
 
 
-	const HTTP_HEADER_CONTENT_TYPE = "Content-Type";
-
 	function toCompatibleReadable(readable) {
 		if (readable instanceof ReadableStream) {
 			return readable;
@@ -1805,12 +1805,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 +1816,7 @@
 					chunks.push(chunk);
 				}
 			}))
-			.then(() => new Blob(chunks, contentType ? { type: contentType } : {}));
+			.then(() => new Blob(chunks, blobOptions));
 	}
 
 	function responseSupportsGlobalReadable() {
@@ -3350,8 +3347,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 +3428,7 @@
 		constructor(contentType) {
 			super();
 			Object.assign(this, {
+				contentType,
 				data: "data:" + (contentType || "") + ";base64,",
 				pending: []
 			});
@@ -3530,6 +3530,7 @@
 					return transformStream.writable;
 				}
 			});
+			writer.contentType = contentType;
 			writer.blob = streamToBlob(transformStream.readable, contentType);
 			writer.blob.catch(() => { });
 		}
@@ -3546,6 +3547,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) {
@@ -4209,6 +4230,10 @@
 		}
 	}
 
+	function ownsWritable(writer) {
+		return Boolean(writer && writer.getData);
+	}
+
 	function isHttpFamily(url) {
 		const { baseURI } = getConfiguration();
 		const { protocol } = new URL(url, baseURI);
@@ -4353,6 +4378,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 +4390,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";
@@ -4406,6 +4434,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 +4446,7 @@
 		PROPERTY_NAME_ZIPCRYPTO,
 		PROPERTY_NAME_DIRECTORY,
 		PROPERTY_NAME_EXECUTABLE,
+		PROPERTY_NAME_SYMLINK,
 		PROPERTY_NAME_COMPRESSION_METHOD,
 		PROPERTY_NAME_SIGNATURE,
 		PROPERTY_NAME_CRC32,
@@ -4878,15 +4909,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 +4986,10 @@
 		}
 
 		async close() {
+			const { reader } = this;
+			if (!reader.readUint8Array && reader.readable && !reader.readable.locked) {
+				await reader.readable.cancel();
+			}
 		}
 	}
 
@@ -5176,7 +5214,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) {
@@ -5420,8 +5458,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);
@@ -5852,6 +5890,7 @@
 	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 +5900,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)";
@@ -6068,7 +6108,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();
 			}
@@ -6227,7 +6267,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;
@@ -6275,7 +6315,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);
 			}
@@ -6328,15 +6370,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 +6488,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 +6513,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 +6550,7 @@
 		}
 		zip64 = zip64 || false;
 		return {
-			reader,
+			maximumCompressedSize,
 			resolvedOptions: {
 				dataDescriptor,
 				zip64,
@@ -6514,6 +6564,78 @@
 		};
 	}
 
+	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,
@@ -6885,9 +7007,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 +7694,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 +7716,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,7 +8370,10 @@
 
 	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";
 	const INFOZIP_EXTRA_FIELD_TYPE = "infozip";
 	const INTERPRETED_EXTRA_FIELD_TYPES = new Set([
 		EXTRAFIELD_TYPE_ZIP64,
@@ -8269,6 +8408,7 @@
 				parent,
 				children: [],
 				uncompressedSize: params.uncompressedSize || 0,
+				undeterminedSize: params.undeterminedSize || params.uncompressedSize === UNDEFINED_VALUE,
 				passThrough: params.passThrough
 			});
 			if (parent || !fs.root) {
@@ -8336,16 +8476,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;
 			}
 		}
@@ -8476,7 +8617,7 @@
 				Reader: TextReader,
 				Writer: TextWriter,
 				options,
-				uncompressedSize: text.length
+				uncompressedSize: getTextSize(text)
 			});
 		}
 
@@ -8605,10 +8746,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 {
@@ -8630,7 +8777,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 {
@@ -8672,11 +8819,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++) {
@@ -8687,6 +8848,10 @@
 			}
 		}
 
+		getChildren(options = {}) {
+			return collectChildren(this, options.recursive);
+		}
+
 		isPasswordProtected() {
 			const children = this.children;
 			for (let childIndex = 0; childIndex < children.length; childIndex++) {
@@ -8778,6 +8943,10 @@
 			return this.root.getChildByName(name);
 		}
 
+		getChildren(options) {
+			return this.root.getChildren(options);
+		}
+
 		addDirectory(name, options) {
 			return this.root.addDirectory(name, options);
 		}
@@ -8876,6 +9045,10 @@
 			return this.root.exportZip(writer, options);
 		}
 
+		getExportedSize(options) {
+			return this.root.getExportedSize(options);
+		}
+
 		isPasswordProtected() {
 			return this.root.isPasswordProtected();
 		}
@@ -8887,12 +9060,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);
 			}
@@ -8900,6 +9073,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 () {
@@ -8922,10 +9104,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();
 			}
 
@@ -8939,6 +9128,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];
@@ -8971,6 +9184,7 @@
 			}
 			if (reader.size !== UNDEFINED_VALUE) {
 				child.uncompressedSize = reader.size;
+				child.undeterminedSize = false;
 			}
 		}));
 		return readers;
@@ -9020,6 +9234,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();
@@ -9035,104 +9333,53 @@
 	}
 
 	async function exportZip(zipWriter, entry, totalSize, options, readers) {
+		const { onstart, onprogress, onend, onentryprogress } = options;
 		const selectedEntry = entry;
-		const entryOffsets = new Map();
-		await process(zipWriter, entry);
-
-		async function process(zipWriter, entry) {
-			await exportChild();
-
-			async function exportChild() {
-				if (options.bufferedWrite) {
-					const results = await Promise.allSettled(entry.children.map(processChild));
-					const errorResult = results.find(result => result.status == "rejected");
-					if (errorResult) {
-						throw errorResult.reason;
-					}
-				} else {
-					for (const child of entry.children) {
-						await processChild(child);
-					}
-				}
+		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 {
+			for (const child of entry.getChildren({ recursive: true })) {
+				await addChild(child);
 			}
+		}
+		if (onend) {
+			await callHandler(onend, writtenSize);
+		}
 
-			async function processChild(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
-						});
+		async function processChildren(entry) {
+			const results = await Promise.allSettled(entry.children.map(async child => {
+				await addChild(child);
+				await processChildren(child);
+			}));
+			const errorResult = results.find(result => result.status == "rejected");
+			if (errorResult) {
+				throw errorResult.reason;
+			}
+		}
+
+		async function addChild(child) {
+			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 => {
+					writtenSize += indexProgress - entryWrittenSize;
+					entryWrittenSize = indexProgress;
+					if (onprogress) {
+						await callHandler(onprogress, writtenSize, totalSize);
 					}
 				}
-				await zipWriter.add(name, readers.get(child), Object.assign({}, options, zipEntryOptions, childOptions, {
-					directory: child.directory,
-					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
-							}
-						}
-					}
-				}));
-				await process(zipWriter, child);
+			}));
+			writtenEntries++;
+			if (onentryprogress) {
+				await callHandler(onentryprogress, writtenEntries, totalEntries, entryMetadata);
 			}
 		}
 	}
@@ -9161,7 +9408,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);
@@ -9183,14 +9430,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;
@@ -9203,6 +9465,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)));
@@ -9221,10 +9502,10 @@
 
 		async function exportChild(child, parentHandle) {
 			if (signal.aborted) {
-				if (isExportAborted(signal.reason)) {
+				if (exportAborted || isExportAborted(signal.reason)) {
 					return;
 				}
-				throw signal.reason;
+				throw signal.reason === UNDEFINED_VALUE ? new DOMException(ERR_ABORTED, ABORT_ERROR_NAME) : signal.reason;
 			}
 			try {
 				if (child.directory) {
@@ -9233,22 +9514,15 @@
 				} else {
 					const fileHandle = await parentHandle.getFileHandle(child.name, { create: true });
 					const writable = await fileHandle.createWritable();
-					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
-								}
-							}
-						}
-					}));
+					try {
+						await child.getData({ writable: createProgressWritable(writable) }, getDataOptions);
+					} catch (error) {
+						throw exportAborted ? new Error(ERR_ABORT_EXPORT) : error;
+					}
 					exportedEntryNames.push(child.getRelativeName(zipEntry));
 				}
 			} catch (error) {
+				exportAborted = true;
 				abortController.abort(new Error(ERR_ABORT_EXPORT));
 				try {
 					if (error.entryName === UNDEFINED_VALUE) {
@@ -9320,6 +9594,21 @@
 		fs.root = new ZipDirectoryEntry(fs);
 	}
 
+	function collectChildren(directory, recursive) {
+		const children = [];
+		const pendingDirectories = [directory];
+		let directoryIndex = 0;
+		while (directoryIndex < pendingDirectories.length) {
+			for (const child of pendingDirectories[directoryIndex++].children) {
+				children.push(child);
+				if (recursive) {
+					pendingDirectories.push(child);
+				}
+			}
+		}
+		return children;
+	}
+
 	function registerEntries(fs, entry) {
 		const pendingEntries = [entry];
 		while (pendingEntries.length) {
@@ -9438,6 +9727,7 @@
 	exports.BlobWriter = BlobWriter;
 	exports.Data64URIReader = Data64URIReader;
 	exports.Data64URIWriter = Data64URIWriter;
+	exports.ERR_ABORTED = ERR_ABORTED;
 	exports.ERR_AMBIGUOUS_ARCHIVE = ERR_AMBIGUOUS_ARCHIVE;
 	exports.ERR_BAD_FORMAT = ERR_BAD_FORMAT;
 	exports.ERR_CENTRAL_DIRECTORY_NOT_FOUND = ERR_CENTRAL_DIRECTORY_NOT_FOUND;
@@ -9469,6 +9759,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;
@@ -9486,11 +9777,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;