@zip.js/zip.js 2.8.51 → 2.8.53

package/dist/zip-fs-external.js

@@ -81,6 +81,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;
@@ -91,6 +93,9 @@ const VERSION_DEFLATE = 0x14;
 const VERSION_ZIP64 = 0x2D;
 const VERSION_AES = 0x33;
 
+const VERSION_MADE_BY_MSDOS = 0x0014;
+const VERSION_MADE_BY_UNIX = 0x0300;
+
 const DIRECTORY_SIGNATURE = "/";
 
 const HEADER_SIZE = 30;
@@ -1806,8 +1811,6 @@ function getInt32(number) {
  */
 
 
-const HTTP_HEADER_CONTENT_TYPE = "Content-Type";
-
 function toCompatibleReadable(readable) {
 	if (readable instanceof ReadableStream) {
 		return readable;
@@ -1830,12 +1833,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
@@ -1844,7 +1844,7 @@ function streamToBlob(readable, contentType) {
 				chunks.push(chunk);
 			}
 		}))
-		.then(() => new Blob(chunks, contentType ? { type: contentType } : {}));
+		.then(() => new Blob(chunks, blobOptions));
 }
 
 function responseSupportsGlobalReadable() {
@@ -2790,6 +2790,7 @@ function createWebWorkerInterface(workerData, config) {
 			worker,
 			workerAlive: false,
 			terminated: false,
+			startupError: null,
 			interface: {
 				run: async () => {
 					try {
@@ -2817,6 +2818,13 @@ function createWebWorkerInterface(workerData, config) {
 }
 
 async function runWebWorker(workerData, config) {
+	if (!workerData.worker) {
+		const { startupError } = workerData;
+		workerData.startupError = null;
+		const error = startupError || new Error(ERR_WORKER_STARTUP_TIMEOUT);
+		error.workerStartupFailed = true;
+		throw error;
+	}
 	let resolveResult, rejectResult;
 	const result = new Promise((resolve, reject) => {
 		resolveResult = resolve;
@@ -3030,11 +3038,12 @@ function onWorkerError(event, workerData) {
 	if (!workerAlive) {
 		workerData.worker = null;
 	}
+	let error = event.error || new Error(event.message || ERROR_EVENT_TYPE);
+	if (!workerAlive) {
+		error = Object.assign(new Error(error.message || ERROR_EVENT_TYPE), { workerStartupFailed: true });
+		workerData.startupError = error;
+	}
 	if (rejectResult) {
-		let error = event.error || new Error(event.message || ERROR_EVENT_TYPE);
-		if (!workerAlive) {
-			error = Object.assign(new Error(error.message || ERROR_EVENT_TYPE), { workerStartupFailed: true });
-		}
 		rejectResult(error);
 		if (writer) {
 			writer.releaseLock();
@@ -3379,8 +3388,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;
@@ -3458,6 +3469,7 @@ class Data64URIWriter extends Writer {
 	constructor(contentType) {
 		super();
 		Object.assign(this, {
+			contentType,
 			data: "data:" + (contentType || "") + ";base64,",
 			pending: []
 		});
@@ -3559,6 +3571,7 @@ class BlobWriter extends Stream {
 				return transformStream.writable;
 			}
 		});
+		writer.contentType = contentType;
 		writer.blob = streamToBlob(transformStream.readable, contentType);
 		writer.blob.catch(() => { });
 	}
@@ -3575,6 +3588,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) {
@@ -4059,9 +4092,8 @@ class SplitDataReader extends Reader {
 
 	async init() {
 		const reader = this;
-		const { readers } = reader;
 		reader.lastDiskNumber = 0;
-		await Promise.all(readers.map(diskReader => initStream(diskReader)));
+		const readers = reader.readers = await Promise.all(reader.readers.map(initDiskReader));
 		reader.diskOffsets = readers.map(diskReader => {
 			const diskOffset = reader.size;
 			reader.size += diskReader.size;
@@ -4238,6 +4270,10 @@ class GenericWriter {
 	}
 }
 
+function ownsWritable(writer) {
+	return Boolean(writer && writer.getData);
+}
+
 function isHttpFamily(url) {
 	const { baseURI } = getConfiguration();
 	const { protocol } = new URL(url, baseURI);
@@ -4252,6 +4288,16 @@ async function initStream(stream, initSize) {
 	}
 }
 
+async function initDiskReader(diskReader) {
+	diskReader = new GenericReader(diskReader);
+	await initStream(diskReader);
+	if (diskReader.size === UNDEFINED_VALUE || !diskReader.readUint8Array) {
+		diskReader = new BlobReader(await streamToBlob(diskReader.readable));
+		await initStream(diskReader);
+	}
+	return diskReader;
+}
+
 function readUint8Array(reader, offset, size) {
 	return reader.readUint8Array(offset, size);
 }
@@ -4382,6 +4428,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";
@@ -4392,6 +4440,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";
@@ -4407,6 +4456,10 @@ const PROPERTY_NAME_SETUID = "setuid";
 const PROPERTY_NAME_SETGID = "setgid";
 const PROPERTY_NAME_STICKY = "sticky";
 const PROPERTY_NAME_BITFLAG = "bitFlag";
+const PROPERTY_NAME_RAW_BITFLAG = "rawBitFlag";
+const PROPERTY_NAME_FILENAME_LENGTH = "filenameLength";
+const PROPERTY_NAME_EXTRA_FIELD_LENGTH = "extraFieldLength";
+const PROPERTY_NAME_UNIX_EXTERNAL_UPPER = "unixExternalUpper";
 const PROPERTY_NAME_FILENAME_UTF8 = "filenameUTF8";
 const PROPERTY_NAME_COMMENT_UTF8 = "commentUTF8";
 const PROPERTY_NAME_RAW_EXTRA_FIELD = "rawExtraField";
@@ -4435,6 +4488,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,
@@ -4445,6 +4500,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,
@@ -4456,10 +4512,14 @@ const PROPERTY_NAMES = [
 	PROPERTY_NAME_UID,
 	PROPERTY_NAME_GID,
 	PROPERTY_NAME_UNIX_MODE,
+	PROPERTY_NAME_UNIX_EXTERNAL_UPPER,
 	PROPERTY_NAME_SETUID,
 	PROPERTY_NAME_SETGID,
 	PROPERTY_NAME_STICKY,
 	PROPERTY_NAME_BITFLAG,
+	PROPERTY_NAME_RAW_BITFLAG,
+	PROPERTY_NAME_FILENAME_LENGTH,
+	PROPERTY_NAME_EXTRA_FIELD_LENGTH,
 	PROPERTY_NAME_FILENAME_UTF8,
 	PROPERTY_NAME_COMMENT_UTF8,
 	PROPERTY_NAME_RAW_EXTRA_FIELD,
@@ -4521,6 +4581,7 @@ const OPTION_CHECK_PASSWORD_ONLY = "checkPasswordOnly";
 const OPTION_CHECK_OVERLAPPING_ENTRY_ONLY = "checkOverlappingEntryOnly";
 const OPTION_CHECK_OVERLAPPING_ENTRY = "checkOverlappingEntry";
 const OPTION_CHECK_AMBIGUITY = "checkAmbiguity";
+const OPTION_CHECK_LOCAL_DIRECTORY = "checkLocalDirectory";
 const OPTION_CHECK_SIGNATURE = "checkSignature";
 const OPTION_CHECK_CRC32 = "checkCrc32";
 const OPTION_CHECK_AUTHENTICATION_CODE = "checkAuthenticationCode";
@@ -4652,7 +4713,7 @@ class ZipReader {
 		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);
@@ -4874,6 +4935,7 @@ class ZipReader {
 				index: indexFile,
 				versionMadeBy,
 				msDosCompatible,
+				zip64: false,
 				compressedSize: 0,
 				uncompressedSize: 0,
 				commentLength,
@@ -4907,15 +4969,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,
@@ -4981,6 +5046,10 @@ class ZipReader {
 	}
 
 	async close() {
+		const { reader } = this;
+		if (!reader.readUint8Array && reader.readable && !reader.readable.locked) {
+			await reader.readable.cancel();
+		}
 	}
 }
 
@@ -5077,9 +5146,12 @@ let ZipEntry$1 = class ZipEntry {
 			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);
@@ -5088,17 +5160,26 @@ let ZipEntry$1 = class ZipEntry {
 				await readUint8Array(reader, localHeaderOffset + HEADER_SIZE + filenameLength, extraFieldLength) :
 				EMPTY_UINT8_ARRAY;
 		}
+		if (checkLocalFilename) {
+			localDirectory.rawFilename = rawLocalFilename;
+		}
 		readCommonFooter(zipEntry, localDirectory, dataView, 4, true);
-		if (checkAmbiguity) {
-			checkLocalDirectory(zipEntry, localDirectory, rawLocalFilename);
+		if (checkLocalDirectory) {
+			validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename);
 		}
-		const { lastAccessDate, creationDate } = localDirectory;
+		const { lastAccessDate, creationDate, uid, gid } = localDirectory;
 		if (lastAccessDate) {
 			fileEntry.lastAccessDate = lastAccessDate;
 		}
 		if (creationDate) {
 			fileEntry.creationDate = creationDate;
 		}
+		if (uid !== UNDEFINED_VALUE && fileEntry.uid === UNDEFINED_VALUE) {
+			fileEntry.uid = uid;
+		}
+		if (gid !== UNDEFINED_VALUE && fileEntry.gid === UNDEFINED_VALUE) {
+			fileEntry.gid = gid;
+		}
 		const encrypted = zipEntry.encrypted && localDirectory.encrypted && !passThrough;
 		const zipCrypto = encrypted && !extraFieldAES;
 		if (!passThrough) {
@@ -5205,7 +5286,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) {
@@ -5334,10 +5415,12 @@ function readCommonFooter(fileEntry, directory, dataView, offset, localDirectory
 		directory.extraFieldNTFS = extraFieldNTFS;
 	}
 	const extraFieldUnix = extraField.get(EXTRAFIELD_TYPE_UNIX);
+	let unixIdsRead;
 	if (extraFieldUnix) {
-		readExtraFieldUnix(extraFieldUnix, directory, false);
+		unixIdsRead = readExtraFieldUnix(extraFieldUnix, directory, false);
 		directory.extraFieldUnix = extraFieldUnix;
-	} else {
+	}
+	if (!unixIdsRead) {
 		const extraFieldInfoZip = extraField.get(EXTRAFIELD_TYPE_INFOZIP);
 		if (extraFieldInfoZip) {
 			readExtraFieldUnix(extraFieldInfoZip, directory, true);
@@ -5440,7 +5523,7 @@ function readExtraFieldNTFS(extraFieldNTFS, directory) {
 		const creationDate = getDateNTFS(rawCreationDate);
 		const extraFieldData = { lastModDate, lastAccessDate, creationDate };
 		Object.assign(extraFieldNTFS, extraFieldData);
-		Object.assign(directory, extraFieldData);
+		Object.assign(directory, extraFieldData, { rawLastAccessDate, rawCreationDate });
 	}
 }
 
@@ -5449,8 +5532,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);
@@ -5484,6 +5567,7 @@ function readExtraFieldUnix(extraField, directory, isInfoZip) {
 		if (gid !== UNDEFINED_VALUE) {
 			directory.gid = gid;
 		}
+		return uid !== UNDEFINED_VALUE || gid !== UNDEFINED_VALUE;
 	} catch {
 		// ignored
 	}
@@ -5556,26 +5640,25 @@ async function detectOverlappingEntry({
 	}
 	if (dataDescriptorLength) {
 		const dataDescriptorArray = await readUint8Array(reader, dataOffset + compressedSize, dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH);
-		const dataDescriptorSignature = dataDescriptorArray.length == dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH &&
-			getUint32(getDataView(dataDescriptorArray), 0) == DATA_DESCRIPTOR_RECORD_SIGNATURE;
-		if (dataDescriptorSignature) {
-			const readCrc32 = getUint32(getDataView(dataDescriptorArray), 4);
-			let readCompressedSize;
-			let readUncompressedSize;
-			if (extraFieldZip64) {
-				readCompressedSize = getBigUint64(getDataView(dataDescriptorArray), 8);
-				readUncompressedSize = getBigUint64(getDataView(dataDescriptorArray), 16);
-			} else {
-				readCompressedSize = getUint32(getDataView(dataDescriptorArray), 8);
-				readUncompressedSize = getUint32(getDataView(dataDescriptorArray), 12);
-			}
-			const matchCrc32 = (fileEntry.encrypted && !fileEntry.zipCrypto) || readCrc32 == crc32;
+		const dataDescriptorView = getDataView(dataDescriptorArray);
+		let signature = dataDescriptorArray.length == dataDescriptorLength + DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH &&
+			getUint32(dataDescriptorView, 0) == DATA_DESCRIPTOR_RECORD_SIGNATURE;
+		if (signature) {
+			const signedDataDescriptor = readDataDescriptor(dataDescriptorView, DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH, extraFieldZip64);
+			const matchCrc32 = (fileEntry.encrypted && !fileEntry.zipCrypto) || signedDataDescriptor.crc32 == crc32;
 			if (matchCrc32 &&
-				readCompressedSize == compressedSize &&
-				readUncompressedSize == uncompressedSize) {
+				signedDataDescriptor.compressedSize == compressedSize &&
+				signedDataDescriptor.uncompressedSize == uncompressedSize) {
 				dataDescriptorLength += DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH;
+			} else {
+				signature = false;
 			}
 		}
+		if (dataDescriptorArray.length >= dataDescriptorLength) {
+			const localDataDescriptor = readDataDescriptor(dataDescriptorView, signature ? DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH : 0, extraFieldZip64);
+			localDataDescriptor.signature = signature;
+			fileEntry.localDirectory.dataDescriptor = localDataDescriptor;
+		}
 	}
 	const range = {
 		start: offset,
@@ -5592,6 +5675,20 @@ async function detectOverlappingEntry({
 	readRanges.set(index, range);
 }
 
+function readDataDescriptor(dataDescriptorView, offset, extraFieldZip64) {
+	const crc32 = getUint32(dataDescriptorView, offset);
+	let compressedSize;
+	let uncompressedSize;
+	if (extraFieldZip64) {
+		compressedSize = getBigUint64(dataDescriptorView, offset + 4);
+		uncompressedSize = getBigUint64(dataDescriptorView, offset + 12);
+	} else {
+		compressedSize = getUint32(dataDescriptorView, offset + 4);
+		uncompressedSize = getUint32(dataDescriptorView, offset + 8);
+	}
+	return { crc32, compressedSize, uncompressedSize };
+}
+
 function getDiskOffset$1(reader, diskNumber) {
 	return reader.getDiskOffset ? reader.getDiskOffset(diskNumber) : 0;
 }
@@ -5600,14 +5697,40 @@ function isStrictnessValue(value) {
 	return value === STRICTNESS_STRICT || value === STRICTNESS_BALANCED || value === STRICTNESS_TOLERANT;
 }
 
-function getStrictness(strictness, checkAmbiguity) {
-	if (strictness === UNDEFINED_VALUE) {
-		return checkAmbiguity ? STRICTNESS_STRICT : STRICTNESS_BALANCED;
+function getStrictness(options, inheritedOptions) {
+	return resolveStrictness(options, resolveStrictness(inheritedOptions, STRICTNESS_BALANCED));
+}
+
+function resolveStrictness(options, inheritedStrictness) {
+	const strictness = options[OPTION_STRICTNESS];
+	if (strictness !== UNDEFINED_VALUE) {
+		if (!isStrictnessValue(strictness)) {
+			throw new Error(ERR_INVALID_STRICTNESS);
+		}
+		return strictness;
 	}
-	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) {
@@ -5755,10 +5878,11 @@ async function readSignature(reader, view, anchoredOffset, signatureOffset, size
 	return UNDEFINED_VALUE;
 }
 
-function checkLocalDirectory(zipEntry, localDirectory, rawLocalFilename) {
+function validateLocalDirectory(zipEntry, localDirectory, rawLocalFilename, checkLocalFilename) {
 	const { rawFilename } = zipEntry;
-	if (rawLocalFilename.length != rawFilename.length ||
-		rawLocalFilename.some((byteValue, indexByte) => byteValue != rawFilename[indexByte])) {
+	if (checkLocalFilename &&
+		(rawLocalFilename.length != rawFilename.length ||
+			rawLocalFilename.some((byteValue, indexByte) => byteValue != rawFilename[indexByte]))) {
 		throwAmbiguousArchive("mismatched local file header (filename)");
 	}
 	if ((localDirectory.rawBitFlag & BITFLAG_AMBIGUITY_MASK) != (zipEntry.rawBitFlag & BITFLAG_AMBIGUITY_MASK)) {
@@ -5876,11 +6000,13 @@ var zipReader = /*#__PURE__*/Object.freeze({
 
 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";
@@ -5890,6 +6016,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)";
@@ -5942,6 +6069,10 @@ class ZipWriter {
 		}
 		reader = new GenericReader(reader);
 		await initStream(reader);
+		if (reader.size === UNDEFINED_VALUE || !reader.readUint8Array) {
+			reader = new BlobReader(await streamToBlob(reader.readable));
+			await initStream(reader);
+		}
 		const { ZipReader } = await Promise.resolve().then(function () { return zipReader; });
 		const zipReader$1 = new ZipReader(reader.readable);
 		const entries = await zipReader$1.getEntries();
@@ -6090,6 +6221,9 @@ class ZipWriter {
 		const zipWriter = this;
 		const { pendingAddFileCalls, writer } = this;
 		const { writable } = writer;
+		if (!(comment instanceof Uint8Array)) {
+			throw new Error(ERR_INVALID_COMMENT_TYPE);
+		}
 		if (getLength(comment) > MAX_16_BITS) {
 			throw new Error(ERR_INVALID_COMMENT);
 		}
@@ -6097,7 +6231,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();
 		}
@@ -6186,8 +6320,6 @@ async function addFile(zipWriter, name, reader, options) {
 		const diskOffset = getDiskOffset(zipWriter.writer);
 		const diskNumber = getDiskNumber(zipWriter.writer);
 		options = Object.assign({}, options, attributesInfo.resolvedOptions, metadataInfo.resolvedOptions, sizesInfo.resolvedOptions, {
-			internalFileAttribute: metadataInfo.resolvedOptions.internalFileAttributes,
-			externalFileAttribute: attributesInfo.resolvedOptions.externalFileAttributes,
 			signature: options[PROPERTY_NAME_SIGNATURE],
 			crc32: options.crc32 === UNDEFINED_VALUE ? options[PROPERTY_NAME_SIGNATURE] : options.crc32,
 			offset: zipWriter.offset - diskOffset,
@@ -6201,14 +6333,20 @@ async function addFile(zipWriter, name, reader, options) {
 		zipWriter.files.delete(name);
 		throw error;
 	}
-	Object.assign(fileEntry, { name, comment, extraField });
+	Object.assign(fileEntry, {
+		name,
+		comment,
+		extraField,
+		[PROPERTY_NAME_DEPRECATED_INTERNAL_FILE_ATTRIBUTES]: fileEntry.internalFileAttributes,
+		[PROPERTY_NAME_DEPRECATED_EXTERNAL_FILE_ATTRIBUTES]: fileEntry.externalFileAttributes
+	});
 	return new Entry(fileEntry);
 }
 
 function resolveAttributes(zipWriter, name, options) {
 	name = name.trim();
 	let msDosCompatible = getOptionValue(zipWriter, options, PROPERTY_NAME_MS_DOS_COMPATIBLE);
-	let versionMadeBy = getOptionValue(zipWriter, options, PROPERTY_NAME_VERSION_MADE_BY, msDosCompatible ? 20 : 768);
+	let versionMadeBy = getOptionValue(zipWriter, options, PROPERTY_NAME_VERSION_MADE_BY, msDosCompatible ? VERSION_MADE_BY_MSDOS : VERSION_MADE_BY_UNIX);
 	const executable = getOptionValue(zipWriter, options, PROPERTY_NAME_EXECUTABLE);
 	const uid = getNumberOptionValue(zipWriter, options, PROPERTY_NAME_UID);
 	const gid = getNumberOptionValue(zipWriter, options, PROPERTY_NAME_GID);
@@ -6242,7 +6380,7 @@ function resolveAttributes(zipWriter, name, options) {
 	const hasMsDosProvided = msdosAttributesRaw !== UNDEFINED_VALUE || msdosAttributes !== UNDEFINED_VALUE;
 	if (hasUnixMetadata) {
 		msDosCompatible = false;
-		versionMadeBy = (versionMadeBy & MAX_16_BITS) | (3 << 8);
+		versionMadeBy = (versionMadeBy & MAX_8_BITS) | VERSION_MADE_BY_UNIX;
 	} else if (hasMsDosProvided) {
 		msDosCompatible = true;
 		versionMadeBy = (versionMadeBy & MAX_8_BITS);
@@ -6256,7 +6394,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;
@@ -6282,11 +6420,10 @@ function resolveAttributes(zipWriter, name, options) {
 			externalFileAttributes = FILE_ATTR_UNIX_DEFAULT_MASK << 16;
 		}
 	}
-	let unixExternalUpper;
 	if (!msDosCompatible) {
 		const unixModeProvided = unixMode !== UNDEFINED_VALUE || Boolean(setuid || setgid || sticky);
-		unixExternalUpper = (externalFileAttributes >> 16) & MAX_16_BITS;
-		unixMode = unixMode === UNDEFINED_VALUE ? unixExternalUpper : (unixMode & MAX_16_BITS);
+		const defaultUnixMode = (externalFileAttributes >> 16) & MAX_16_BITS;
+		unixMode = unixMode === UNDEFINED_VALUE ? defaultUnixMode : (unixMode & MAX_16_BITS);
 		if (setuid) {
 			unixMode |= FILE_ATTR_UNIX_SETUID_MASK;
 		} else {
@@ -6304,7 +6441,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);
 		}
@@ -6313,17 +6452,20 @@ function resolveAttributes(zipWriter, name, options) {
 	if (hasMsDosProvided) {
 		externalFileAttributes = (externalFileAttributes & MAX_32_BITS) | (msdosAttributesRaw & MAX_8_BITS);
 	}
+	const unixExternalUpper = (externalFileAttributes >> 16) & MAX_16_BITS;
+	const symlink = unixMode !== UNDEFINED_VALUE && ((unixMode & FILE_ATTR_UNIX_TYPE_MASK) == FILE_ATTR_UNIX_TYPE_SYMLINK);
 	return {
 		name,
 		resolvedOptions: {
 			versionMadeBy,
-			msDosCompatible,
+			msDosCompatible: Boolean(msDosCompatible),
 			externalFileAttributes,
 			unixExternalUpper,
 			uid,
 			gid,
 			unixMode,
 			unixExtraFieldType,
+			symlink,
 			setuid,
 			setgid,
 			sticky,
@@ -6357,15 +6499,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);
@@ -6478,14 +6617,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);
@@ -6493,29 +6642,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;
@@ -6529,7 +6679,7 @@ async function resolveSizes(zipWriter, reader, { resolvedOptions: metadata }, op
 	}
 	zip64 = zip64 || false;
 	return {
-		reader,
+		maximumCompressedSize,
 		resolvedOptions: {
 			dataDescriptor,
 			zip64,
@@ -6543,6 +6693,81 @@ 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);
+	}
+	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,
@@ -6757,6 +6982,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		uid,
 		gid,
 		unixMode,
+		symlink,
 		setuid,
 		setgid,
 		sticky,
@@ -6793,6 +7019,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		uid,
 		gid,
 		unixMode,
+		symlink: Boolean(symlink),
 		setuid,
 		setgid,
 		sticky,
@@ -6873,8 +7100,8 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		rawLastModDate,
 		creationDate,
 		lastAccessDate,
-		encrypted,
-		zipCrypto,
+		encrypted: Boolean(encrypted),
+		zipCrypto: Boolean(zipCrypto),
 		size: metadataSize + compressedSize,
 		compressionMethod,
 		version,
@@ -6914,9 +7141,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));
@@ -7603,6 +7828,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));
 }
@@ -7615,6 +7850,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);
 }
@@ -8600,6 +8841,7 @@ configureExternalAssets();
 
 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";
@@ -8637,6 +8879,7 @@ class ZipEntry {
 			parent,
 			children: [],
 			uncompressedSize: params.uncompressedSize || 0,
+			undeterminedSize: params.undeterminedSize || params.uncompressedSize === UNDEFINED_VALUE,
 			passThrough: params.passThrough
 		});
 		if (parent || !fs.root) {
@@ -8704,16 +8947,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;
 		}
 	}
@@ -8844,7 +9088,7 @@ class ZipDirectoryEntry extends ZipEntry {
 			Reader: TextReader,
 			Writer: TextWriter,
 			options,
-			uncompressedSize: text.length
+			uncompressedSize: getTextSize(text)
 		});
 	}
 
@@ -8973,10 +9217,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 {
@@ -8998,7 +9248,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 {
@@ -9040,11 +9290,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++) {
@@ -9252,6 +9516,10 @@ class FS {
 		return this.root.exportZip(writer, options);
 	}
 
+	getExportedSize(options) {
+		return this.root.getExportedSize(options);
+	}
+
 	isPasswordProtected() {
 		return this.root.isPasswordProtected();
 	}
@@ -9263,12 +9531,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);
 		}
@@ -9276,6 +9544,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 () {
@@ -9298,10 +9575,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();
 		}
 
@@ -9315,6 +9599,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];
@@ -9347,6 +9655,7 @@ async function initReaders(entry, options) {
 		}
 		if (reader.size !== UNDEFINED_VALUE) {
 			child.uncompressedSize = reader.size;
+			child.undeterminedSize = false;
 		}
 	}));
 	return readers;
@@ -9396,6 +9705,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();
@@ -9411,8 +9804,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 {
@@ -9420,6 +9819,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 => {
@@ -9433,81 +9835,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);
+		}
 	}
 }
 
@@ -9535,7 +9879,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);
@@ -9557,15 +9901,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;
@@ -9578,6 +9936,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)));
@@ -9609,19 +9986,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;
 				}
@@ -9798,4 +10163,4 @@ function decodeMimeTypes(data) {
 	return mimeTypes;
 }
 
-export { BlobReader, BlobWriter, Data64URIReader, Data64URIWriter, ERR_ABORTED, ERR_AMBIGUOUS_ARCHIVE, ERR_BAD_FORMAT, ERR_CENTRAL_DIRECTORY_NOT_FOUND, ERR_DUPLICATED_NAME, ERR_ENCRYPTED, ERR_ENCRYPTED_CENTRAL_DIRECTORY, ERR_ENTRY_EXISTS, ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND, ERR_EOCDR_NOT_FOUND, ERR_EXTRAFIELD_ZIP64_NOT_FOUND, ERR_HTTP_RANGE, ERR_HTTP_RESOURCE_CHANGED, ERR_INVALID_AUTHENTICATION_CODE, ERR_INVALID_CODEC_DEFINITION, ERR_INVALID_CODEC_MODULE, ERR_INVALID_COMMENT, ERR_INVALID_COMPRESSED_DATA, ERR_INVALID_CRC32, ERR_INVALID_ENCRYPTION_STRENGTH, ERR_INVALID_ENTRY_COMMENT, ERR_INVALID_ENTRY_NAME, ERR_INVALID_EXTRAFIELD_DATA, ERR_INVALID_EXTRAFIELD_TYPE, ERR_INVALID_FILENAME_VALIDATION, ERR_INVALID_GID, ERR_INVALID_LEVEL, ERR_INVALID_MAX_APPENDED_DATA_SIZE, ERR_INVALID_MSDOS_ATTRIBUTES, ERR_INVALID_MSDOS_DATA, ERR_INVALID_PASSWORD, ERR_INVALID_PASSWORD_TYPE, ERR_INVALID_SIGNATURE, ERR_INVALID_SIGNATURE_DATA, ERR_INVALID_STRICTNESS, ERR_INVALID_UID, ERR_INVALID_UNCOMPRESSED_SIZE, ERR_INVALID_UNIX_EXTRA_FIELD_TYPE, ERR_INVALID_UNIX_ID_SIZE, ERR_INVALID_UNIX_MODE, ERR_INVALID_VERSION, ERR_ITERATOR_COMPLETED_TOO_SOON, ERR_LOCAL_FILE_HEADER_NOT_FOUND, ERR_OVERLAPPING_ENTRY, ERR_READABLE_CONSUMED, ERR_RESERVED_COMPRESSION_METHOD, ERR_SPLIT_ZIP_FILE, ERR_UNDEFINED_READER, ERR_UNDEFINED_UNCOMPRESSED_SIZE, ERR_UNSAFE_FILENAME, ERR_UNSUPPORTED_COMPRESSION$1 as ERR_UNSUPPORTED_COMPRESSION, ERR_UNSUPPORTED_CONTEXT, ERR_UNSUPPORTED_CRYPTO_API, ERR_UNSUPPORTED_ENCRYPTION, ERR_UNSUPPORTED_ENCRYPTION_USDZ, ERR_UNSUPPORTED_FORMAT, ERR_WORKER_STARTUP_TIMEOUT, ERR_WRITER_NOT_INITIALIZED, ERR_ZIP_NOT_EMPTY, HttpRangeReader, HttpReader, Reader, SplitDataReader, SplitDataWriter, TextReader, TextWriter, Uint8ArrayReader, Uint8ArrayWriter, Writer, ZipReader, ZipReaderStream, ZipWriter, ZipWriterStream, configure, createBlobTempStream, createOPFSTempStream, createSyncAccessHandleTempStream, fs, getMimeType, registerCodec, resetConfiguration, terminateWorkersAndModule as terminateWorkers, unregisterCodec };
+export { BlobReader, BlobWriter, Data64URIReader, Data64URIWriter, ERR_ABORTED, ERR_AMBIGUOUS_ARCHIVE, ERR_BAD_FORMAT, ERR_CENTRAL_DIRECTORY_NOT_FOUND, ERR_DUPLICATED_NAME, ERR_ENCRYPTED, ERR_ENCRYPTED_CENTRAL_DIRECTORY, ERR_ENTRY_EXISTS, ERR_EOCDR_LOCATOR_ZIP64_NOT_FOUND, ERR_EOCDR_NOT_FOUND, ERR_EXTRAFIELD_ZIP64_NOT_FOUND, ERR_HTTP_RANGE, ERR_HTTP_RESOURCE_CHANGED, ERR_INVALID_AUTHENTICATION_CODE, ERR_INVALID_CODEC_DEFINITION, ERR_INVALID_CODEC_MODULE, ERR_INVALID_COMMENT, ERR_INVALID_COMMENT_TYPE, ERR_INVALID_COMPRESSED_DATA, ERR_INVALID_CRC32, ERR_INVALID_ENCRYPTION_STRENGTH, ERR_INVALID_ENTRY_COMMENT, ERR_INVALID_ENTRY_NAME, ERR_INVALID_EXTRAFIELD_DATA, ERR_INVALID_EXTRAFIELD_TYPE, ERR_INVALID_FILENAME_VALIDATION, ERR_INVALID_GID, ERR_INVALID_LEVEL, ERR_INVALID_MAX_APPENDED_DATA_SIZE, ERR_INVALID_MSDOS_ATTRIBUTES, ERR_INVALID_MSDOS_DATA, ERR_INVALID_PASSWORD, ERR_INVALID_PASSWORD_TYPE, ERR_INVALID_PASS_THROUGH, ERR_INVALID_SIGNATURE, ERR_INVALID_SIGNATURE_DATA, ERR_INVALID_STRICTNESS, ERR_INVALID_UID, ERR_INVALID_UNCOMPRESSED_SIZE, ERR_INVALID_UNIX_EXTRA_FIELD_TYPE, ERR_INVALID_UNIX_ID_SIZE, ERR_INVALID_UNIX_MODE, ERR_INVALID_VERSION, ERR_ITERATOR_COMPLETED_TOO_SOON, ERR_LOCAL_FILE_HEADER_NOT_FOUND, ERR_OVERLAPPING_ENTRY, ERR_READABLE_CONSUMED, ERR_RESERVED_COMPRESSION_METHOD, ERR_SPLIT_ZIP_FILE, ERR_UNDEFINED_READER, ERR_UNDEFINED_UNCOMPRESSED_SIZE, ERR_UNDETERMINED_SIZE, ERR_UNSAFE_FILENAME, ERR_UNSUPPORTED_COMPRESSION$1 as ERR_UNSUPPORTED_COMPRESSION, ERR_UNSUPPORTED_CONTEXT, ERR_UNSUPPORTED_CRYPTO_API, ERR_UNSUPPORTED_ENCRYPTION, ERR_UNSUPPORTED_ENCRYPTION_PASS_THROUGH, ERR_UNSUPPORTED_ENCRYPTION_USDZ, ERR_UNSUPPORTED_FORMAT, ERR_WORKER_STARTUP_TIMEOUT, ERR_WRITER_NOT_INITIALIZED, ERR_ZIP_NOT_EMPTY, HttpRangeReader, HttpReader, Reader, SplitDataReader, SplitDataWriter, TextReader, TextWriter, Uint8ArrayReader, Uint8ArrayWriter, Writer, ZipReader, ZipReaderStream, ZipWriter, ZipWriterStream, configure, createBlobTempStream, createOPFSTempStream, createSyncAccessHandleTempStream, fs, getMimeType, registerCodec, resetConfiguration, terminateWorkersAndModule as terminateWorkers, unregisterCodec };