@zip.js/zip.js 2.15.0 → 2.16.1

package/dist/zip-fs-external.js

@@ -214,7 +214,7 @@ const ERR_INVALID_SIGNAL = "Invalid signal (must be an AbortSignal instance)";
 const ERR_INVALID_PASSWORD_TYPE = "Invalid password (password must be a string, rawPassword must be a Uint8Array)";
 const ERR_INVALID_PASS_THROUGH_VALUE = "Invalid passThrough option (must be a boolean or 'compressed')";
 const ERR_ABORTED = "The operation was aborted";
-const ABORT_ERROR_NAME = "AbortError";
+const ABORT_ERROR_NAME$1 = "AbortError";
 
 function checkFunctionOption(value) {
 	if (value && typeof value != FUNCTION_TYPE) {
@@ -232,7 +232,7 @@ function checkSignalOption(signal) {
 
 function throwIfAborted(signal) {
 	if (signal && signal.aborted) {
-		throw signal.reason === UNDEFINED_VALUE ? new DOMException(ERR_ABORTED, ABORT_ERROR_NAME) : signal.reason;
+		throw signal.reason === UNDEFINED_VALUE ? new DOMException(ERR_ABORTED, ABORT_ERROR_NAME$1) : signal.reason;
 	}
 }
 
@@ -1310,12 +1310,12 @@ let createEngine$1 = createEngine$2;
 class AESDecryptionStream extends TransformStream {
 
 	constructor({ password, rawPassword, encryptionStrength, checkPasswordOnly, checkAuthenticationCode = true }) {
+		const aesCrypto = {};
 		super({
 			start() {
-				initAesCrypto(this, password, rawPassword, encryptionStrength);
+				initAesCrypto(aesCrypto, password, rawPassword, encryptionStrength);
 			},
 			async transform(chunk, controller) {
-				const aesCrypto = this;
 				const {
 					password,
 					strength,
@@ -1334,6 +1334,9 @@ class AESDecryptionStream extends TransformStream {
 				} else {
 					await ready;
 				}
+				if (aesCrypto.discarded) {
+					return;
+				}
 				const output = new Uint8Array(chunk.length - AUTHENTICATION_CODE_LENGTH - ((chunk.length - AUTHENTICATION_CODE_LENGTH) % BLOCK_LENGTH));
 				controller.enqueue(append(aesCrypto, chunk, output, 0, AUTHENTICATION_CODE_LENGTH, true));
 			},
@@ -1342,9 +1345,12 @@ class AESDecryptionStream extends TransformStream {
 					engine,
 					pendingInput,
 					ready
-				} = this;
+				} = aesCrypto;
 				if (engine) {
 					await ready;
+					if (aesCrypto.discarded) {
+						return;
+					}
 					const originalAuthenticationCode = subarray(pendingInput, pendingInput.length - AUTHENTICATION_CODE_LENGTH);
 					const decryptedChunkArray = new Uint8Array(subarray(pendingInput, 0, pendingInput.length - AUTHENTICATION_CODE_LENGTH));
 					engine.process(decryptedChunkArray, true);
@@ -1354,27 +1360,26 @@ class AESDecryptionStream extends TransformStream {
 						invalidAuthenticationCode |= authenticationCode[indexByte] ^ originalAuthenticationCode[indexByte];
 					}
 					if (invalidAuthenticationCode && checkAuthenticationCode) {
-						throw new Error(ERR_INVALID_AUTHENTICATION_CODE);
+						controller.error(new Error(ERR_INVALID_AUTHENTICATION_CODE));
+						return;
 					}
 					controller.enqueue(decryptedChunkArray);
 				}
-			},
-			cancel() {
-				disposeEngine(this);
 			}
 		});
+		setDisposingReadable(this, aesCrypto);
 	}
 }
 
 class AESEncryptionStream extends TransformStream {
 
 	constructor({ password, rawPassword, encryptionStrength }) {
+		const aesCrypto = {};
 		super({
 			start() {
-				initAesCrypto(this, password, rawPassword, encryptionStrength);
+				initAesCrypto(aesCrypto, password, rawPassword, encryptionStrength);
 			},
 			async transform(chunk, controller) {
-				const aesCrypto = this;
 				const {
 					password,
 					strength,
@@ -1388,6 +1393,9 @@ class AESEncryptionStream extends TransformStream {
 				} else {
 					await ready;
 				}
+				if (aesCrypto.discarded) {
+					return;
+				}
 				const output = new Uint8Array(preamble.length + chunk.length - (chunk.length % BLOCK_LENGTH));
 				output.set(preamble, 0);
 				controller.enqueue(append(aesCrypto, chunk, output, preamble.length, 0, false));
@@ -1397,19 +1405,20 @@ class AESEncryptionStream extends TransformStream {
 					engine,
 					pendingInput,
 					ready
-				} = this;
+				} = aesCrypto;
 				if (engine) {
 					await ready;
+					if (aesCrypto.discarded) {
+						return;
+					}
 					const encryptedChunkArray = new Uint8Array(pendingInput);
 					engine.process(encryptedChunkArray, false);
 					const authenticationCode = subarray(engine.digest(), 0, AUTHENTICATION_CODE_LENGTH);
 					controller.enqueue(concat(encryptedChunkArray, authenticationCode));
 				}
-			},
-			cancel() {
-				disposeEngine(this);
 			}
 		});
+		setDisposingReadable(this, aesCrypto);
 	}
 }
 
@@ -1422,7 +1431,37 @@ function initAesCrypto(aesCrypto, password, rawPassword, encryptionStrength) {
 		ready: new Promise(resolve => aesCrypto.resolveReady = resolve),
 		password: encodePassword(password, rawPassword),
 		strength: encryptionStrength - 1,
-		pendingInput: EMPTY_UINT8_ARRAY
+		pendingInput: EMPTY_UINT8_ARRAY,
+		discarded: false
+	});
+}
+
+function setDisposingReadable(stream, aesCrypto) {
+	const reader = stream.readable.getReader();
+	const readable = new ReadableStream({
+		async pull(controller) {
+			try {
+				const { value, done } = await reader.read();
+				if (done) {
+					controller.close();
+				} else {
+					controller.enqueue(value);
+				}
+			} catch (error) {
+				disposeEngine(aesCrypto);
+				reader.cancel(error).catch(() => { });
+				throw error;
+			}
+		},
+		cancel(reason) {
+			disposeEngine(aesCrypto);
+			return reader.cancel(reason);
+		}
+	});
+	Object.defineProperty(stream, "readable", {
+		get() {
+			return readable;
+		}
 	});
 }
 
@@ -1455,7 +1494,9 @@ async function createDecryptionKeys(decrypt, strength, password, preamble) {
 	}
 }
 
-function disposeEngine({ engine }) {
+function disposeEngine(aesCrypto) {
+	const { engine } = aesCrypto;
+	aesCrypto.discarded = true;
 	if (engine && engine.dispose) {
 		engine.dispose();
 	}
@@ -1472,6 +1513,9 @@ async function createKeys$1(aesCrypto, strength, password, salt) {
 	const keyLength = KEY_LENGTH[strength];
 	const compositeKey = await deriveKey(password, salt, keyLength * 2 + PASSWORD_VERIFICATION_LENGTH);
 	aesCrypto.engine = createEngine$1(subarray(compositeKey, 0, keyLength), subarray(compositeKey, keyLength, keyLength * 2));
+	if (aesCrypto.discarded) {
+		disposeEngine(aesCrypto);
+	}
 	return subarray(compositeKey, keyLength * 2);
 }
 
@@ -1623,11 +1667,11 @@ function encrypt(target, input) {
 }
 
 function createKeys(target, password, rawPassword) {
-	const keys = [0x12345678, 0x23456789, 0x34567890];
+	const cryptoKeys = [0x12345678, 0x23456789, 0x34567890];
 	Object.assign(target, {
-		keys,
-		crcKey0: new Crc32(keys[0]),
-		crcKey2: new Crc32(keys[2])
+		cryptoKeys,
+		crcKey0: new Crc32(cryptoKeys[0]),
+		crcKey2: new Crc32(cryptoKeys[2])
 	});
 	if (rawPassword) {
 		for (let index = 0; index < rawPassword.length; index++) {
@@ -1641,17 +1685,17 @@ function createKeys(target, password, rawPassword) {
 }
 
 function updateKeys(target, byte) {
-	let [, key1] = target.keys;
+	let [, key1] = target.cryptoKeys;
 	target.crcKey0.append([byte]);
 	const key0 = ~target.crcKey0.get();
 	key1 = getInt32(Math.imul(getInt32(key1 + getInt8(key0)), 134775813) + 1);
 	target.crcKey2.append([key1 >>> 24]);
 	const key2 = ~target.crcKey2.get();
-	target.keys = [key0, key1, key2];
+	target.cryptoKeys = [key0, key1, key2];
 }
 
 function getByte(target) {
-	const temp = target.keys[2] | 2;
+	const temp = target.cryptoKeys[2] | 2;
 	return getInt8(Math.imul(temp, (temp ^ 1)) >>> 8);
 }
 
@@ -1699,11 +1743,16 @@ function toCompatibleReadable(readable) {
 	const reader = readable.getReader();
 	return new ReadableStream({
 		async pull(controller) {
-			const { value, done } = await reader.read();
-			if (done) {
-				controller.close();
-			} else {
-				controller.enqueue(value);
+			try {
+				const { value, done } = await reader.read();
+				if (done) {
+					controller.close();
+				} else {
+					controller.enqueue(value);
+				}
+			} catch (error) {
+				reader.cancel(error).catch(() => { });
+				throw error;
 			}
 		},
 		cancel(reason) {
@@ -1889,7 +1938,6 @@ const FORMAT_GZIP$1 = "gzip";
 const GZIP_HEADER_LENGTH = 10;
 const GZIP_TRAILER_LENGTH = 8;
 const GZIP_HEADER_BYTES = [0x1f, 0x8b, 0x08];
-const GZIP_OUTPUT_STALL_TIMEOUT = 5000;
 
 class DeflateStream extends TransformStream {
 
@@ -1900,7 +1948,7 @@ class DeflateStream extends TransformStream {
 		let crc32Stream, encryptionStream, gzipCrc32Stream;
 		let readable = super.readable;
 		const codecStreams = format && getCodecStreams(format);
-		const GzipCompressionStream = getGzipCompressionStream(useCompressionStream, CompressionStream, CompressionStreamFallback);
+		const GzipCompressionStream = getGzipCodecStream(useCompressionStream, CompressionStream, CompressionStreamFallback);
 		const useGzipCrc32 = computeCrc32 && compressed && !deflate64 && !codecStreams && (!encrypted || zipCrypto) && Boolean(GzipCompressionStream);
 		if ((!encrypted || zipCrypto) && computeCrc32 && !useGzipCrc32) {
 			crc32Stream = new Crc32Stream();
@@ -1917,6 +1965,9 @@ class DeflateStream extends TransformStream {
 				try {
 					readable = pipeThroughCompressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamFallback);
 				} catch (error) {
+					if (!useCompressionStream && CompressionStreamFallback) {
+						throw error;
+					}
 					let gzipStream;
 					try {
 						gzipStream = new CompressionStream(FORMAT_GZIP$1);
@@ -1986,74 +2037,134 @@ class GzipToRawDeflateStream extends TransformStream {
 }
 
 function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, crc32) {
+	const writer = gzipStream.writable.getWriter();
+	const reader = gzipStream.readable.getReader();
+	const outputCrc32 = crc32 === UNDEFINED_VALUE ? new Crc32() : UNDEFINED_VALUE;
 	let outputLength = 0;
 	let inputDone = false;
-	let watchdogTimeout;
+	let trailerWritten = false;
+	let idleCheckArmed = false;
+	let readCount = 0;
+	let readPending = false;
 	let resolveTrailerReady, rejectTrailerReady;
 	const trailerReady = new Promise((resolve, reject) => {
 		resolveTrailerReady = resolve;
 		rejectTrailerReady = reject;
 	});
 	trailerReady.catch(() => { });
-	if (!outputSize) {
-		resolveTrailerReady();
-	}
-	const gzipWrapStream = new TransformStream({
-		start(controller) {
+	pump();
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const { value, done } = await read();
+				if (done) {
+					controller.close();
+				} else {
+					outputLength += value.length;
+					if (outputLength > outputSize) {
+						throw new Error(ERR_INVALID_UNCOMPRESSED_SIZE);
+					}
+					if (outputCrc32) {
+						outputCrc32.append(value);
+					}
+					controller.enqueue(value);
+				}
+			} catch (error) {
+				rejectTrailerReady(error);
+				await cancel(reader, error);
+				throw trailerWritten ? getTrailerError(error) : error;
+			}
+		},
+		cancel(reason) {
+			rejectTrailerReady(reason);
+			return reader.cancel(reason);
+		}
+	});
+
+	async function pump() {
+		const inputReader = readable.getReader();
+		try {
 			const header = new Uint8Array(GZIP_HEADER_LENGTH);
 			header.set(GZIP_HEADER_BYTES);
-			controller.enqueue(header);
-		},
-		transform(chunk, controller) {
-			controller.enqueue(chunk);
-		},
-		async flush(controller) {
+			await writer.write(header);
+			for (; ;) {
+				await writer.ready;
+				const { value, done } = await inputReader.read();
+				if (done) {
+					break;
+				}
+				await writer.write(value);
+			}
 			inputDone = true;
-			startWatchdog();
-			try {
+			if (outputCrc32) {
+				if (readPending) {
+					armIdleCheck();
+				}
 				await trailerReady;
-			} finally {
-				stopWatchdog();
 			}
 			const trailer = new Uint8Array(GZIP_TRAILER_LENGTH);
 			const dataView = getDataView(trailer);
-			dataView.setUint32(0, crc32.get(), true);
+			dataView.setUint32(0, outputCrc32 ? outputCrc32.get() : crc32, true);
 			dataView.setUint32(4, outputSize, true);
-			controller.enqueue(trailer);
-		},
-		cancel(reason) {
-			rejectTrailerReady(reason);
+			trailerWritten = true;
+			await writer.write(trailer);
+			await writer.close();
+		} catch (error) {
+			await abort(writer, error);
+			await cancel(inputReader, error);
 		}
-	});
-	const outputStream = new TransformStream({
-		transform(chunk, controller) {
-			crc32.append(chunk);
-			outputLength += chunk.length;
-			if (outputLength >= outputSize) {
-				resolveTrailerReady();
-			} else if (inputDone) {
-				startWatchdog();
-			}
-			controller.enqueue(chunk);
-		},
-		cancel(reason) {
-			rejectTrailerReady(reason);
+	}
+
+	function read() {
+		readCount++;
+		readPending = true;
+		const result = reader.read();
+		result.then(onReadSettled, onReadSettled);
+		if (inputDone && outputCrc32) {
+			armIdleCheck();
 		}
-	});
-	readable = pipeThrough(readable, gzipWrapStream);
-	readable = pipeThroughBackpressured(readable, gzipStream);
-	return pipeThrough(readable, outputStream);
+		return result;
+	}
+
+	function onReadSettled() {
+		readPending = false;
+	}
 
-	function startWatchdog() {
-		stopWatchdog();
-		watchdogTimeout = setTimeout(() => rejectTrailerReady(new Error(ERR_INVALID_UNCOMPRESSED_SIZE)), GZIP_OUTPUT_STALL_TIMEOUT);
+	async function armIdleCheck() {
+		if (!idleCheckArmed) {
+			idleCheckArmed = true;
+			const count = readCount;
+			await nextTask();
+			idleCheckArmed = false;
+			if (readPending) {
+				if (readCount == count) {
+					resolveTrailerReady();
+				} else {
+					armIdleCheck();
+				}
+			}
+		}
 	}
 
-	function stopWatchdog() {
-		clearTimeout(watchdogTimeout);
+	function getTrailerError(error) {
+		const trailerError = new Error(outputLength == outputSize ? ERR_INVALID_CRC32 : ERR_INVALID_UNCOMPRESSED_SIZE);
+		trailerError.cause = error;
+		return trailerError;
 	}
 }
 
+function nextTask() {
+	return new Promise(resolve => {
+		const { port1, port2 } = new MessageChannel();
+		port2.onmessage = () => {
+			port1.close();
+			port2.close();
+			resolve();
+		};
+		port1.postMessage(UNDEFINED_VALUE);
+	});
+}
+
 class InflateStream extends TransformStream {
 
 	constructor(options, { chunkSize, DecompressionStreamFallback, DecompressionStream }) {
@@ -2074,20 +2185,32 @@ class InflateStream extends TransformStream {
 			if (codecStreams) {
 				readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.DecompressionStream, format, { chunkSize, compressionMethod, rawBitFlag, uncompressedSize: outputSize }));
 			} else {
-				try {
-					readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamFallback);
-				} catch (error) {
-					if (deflate64 || outputSize === UNDEFINED_VALUE) {
-						throw error;
-					}
-					let gzipStream;
+				let gzipStream;
+				const GzipDecompressionStream = getGzipCodecStream(useCompressionStream, DecompressionStream, DecompressionStreamFallback);
+				if (checkCrc32 && !deflate64 && crc32 !== UNDEFINED_VALUE && outputSize !== UNDEFINED_VALUE && GzipDecompressionStream) {
 					try {
-						gzipStream = new DecompressionStream(FORMAT_GZIP$1);
+						gzipStream = new GzipDecompressionStream(FORMAT_GZIP$1, { chunkSize });
 					} catch {
-						throw error;
+						gzipStream = UNDEFINED_VALUE;
+					}
+				}
+				if (!gzipStream) {
+					try {
+						readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamFallback);
+					} catch (error) {
+						if (deflate64 || outputSize === UNDEFINED_VALUE || (!useCompressionStream && DecompressionStreamFallback)) {
+							throw error;
+						}
+						try {
+							gzipStream = new DecompressionStream(FORMAT_GZIP$1);
+						} catch {
+							throw error;
+						}
 					}
-					gzipCrc32 = new Crc32();
-					readable = pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, gzipCrc32);
+				}
+				if (gzipStream) {
+					gzipCrc32 = true;
+					readable = pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, crc32);
 				}
 			}
 			readable = mapInflateStreamError(readable);
@@ -2097,8 +2220,8 @@ class InflateStream extends TransformStream {
 			readable = pipeThrough(readable, crc32Stream);
 		}
 		setReadable(this, readable, () => {
-			if (checkCrc32) {
-				const computedCrc32 = gzipCrc32 ? gzipCrc32.get() >>> 0 : new DataView(crc32Stream.value.buffer).getUint32(0, false);
+			if (crc32Stream) {
+				const computedCrc32 = new DataView(crc32Stream.value.buffer).getUint32(0, false);
 				if (crc32 != computedCrc32) {
 					throw new Error(ERR_INVALID_CRC32);
 				}
@@ -2155,11 +2278,11 @@ function createCodecStream(CodecStreamClass, format, options) {
 	return new CodecStreamClass(format, options);
 }
 
-function getGzipCompressionStream(useCompressionStream, CompressionStreamNative, CompressionStreamFallback) {
-	if (useCompressionStream && CompressionStreamNative) {
-		return CompressionStreamNative;
-	} else if (CompressionStreamFallback && CompressionStreamFallback.requiresModule) {
-		return CompressionStreamFallback;
+function getGzipCodecStream(useCompressionStream, CodecStreamNative, CodecStreamFallback) {
+	if (useCompressionStream && CodecStreamNative) {
+		return CodecStreamNative;
+	} else if (CodecStreamFallback && CodecStreamFallback.requiresModule) {
+		return CodecStreamFallback;
 	}
 }
 
@@ -2229,10 +2352,15 @@ function mapInflateStreamError(readable) {
 	const reader = readable.getReader();
 	return new ReadableStream({
 		async pull(controller) {
-			let result;
 			try {
-				result = await reader.read();
+				const { value, done } = await reader.read();
+				if (done) {
+					controller.close();
+				} else {
+					controller.enqueue(value);
+				}
 			} catch (error) {
+				await cancel(reader, error);
 				if (error && error.message) {
 					throw error;
 				}
@@ -2240,12 +2368,6 @@ function mapInflateStreamError(readable) {
 				mappedError.cause = error;
 				throw mappedError;
 			}
-			const { value, done } = result;
-			if (done) {
-				controller.close();
-			} else {
-				controller.enqueue(value);
-			}
 		},
 		cancel(reason) {
 			return reader.cancel(reason);
@@ -3761,10 +3883,11 @@ class FetchReader extends Reader {
 
 	createReadable(options) {
 		const reader = this;
-		const { useRangeHeader, forceRangeRequests, size } = reader;
+		const { useRangeHeader, forceRangeRequests, size, eocdCache } = reader;
 		if ((useRangeHeader || forceRangeRequests) && size !== UNDEFINED_VALUE) {
 			const { offset = 0, size: readSize = size - offset } = options || {};
-			if (readSize > 0 && offset < size) {
+			const cached = eocdCache && offset >= size - eocdCache.length;
+			if (readSize > 0 && offset < size && !cached) {
 				return createRangeReadable(reader, offset, Math.min(readSize, size - offset));
 			}
 		}
@@ -5323,8 +5446,8 @@ let ZipEntry$1 = class ZipEntry {
 		const passThroughCompression = Boolean(passThrough);
 		const passThroughEncryption = passThrough === true;
 		checkPasswordOption(password, rawPassword);
-		password = password && password.length && password;
-		rawPassword = rawPassword && rawPassword.length && rawPassword;
+		password = password && password.length ? password : UNDEFINED_VALUE;
+		rawPassword = rawPassword && rawPassword.length ? rawPassword : UNDEFINED_VALUE;
 		if (extraFieldAES) {
 			if (extraFieldAES.originalCompressionMethod != COMPRESSION_METHOD_AES) {
 				throw new Error(ERR_UNSUPPORTED_COMPRESSION);
@@ -6085,7 +6208,7 @@ function getMaxAppendedDataSize(maxAppendedDataSize, strictness) {
 async function findEndOfCentralDirectory(reader, rejectAmbiguous, maxAppendedDataSize) {
 	const { size } = reader;
 	const anchoredLength = Math.min(size, END_OF_CENTRAL_DIR_LENGTH + MAX_16_BITS);
-	const remoteProbeBudget = { count: MAX_END_OF_CENTRAL_DIR_PROBES };
+	const remoteProbeBudget = { remaining: MAX_END_OF_CENTRAL_DIR_PROBES };
 	let endOfDirectoryInfo;
 	let plausibleEndOfDirectoryInfo;
 	let endOfDirectoryReachingEndCount = 0;
@@ -6178,8 +6301,8 @@ async function readSignature(reader, view, anchoredOffset, signatureOffset, size
 	if (signatureOffset >= anchoredOffset) {
 		return getUint32$1(view, signatureOffset - anchoredOffset);
 	}
-	if (remoteProbeBudget.count > 0) {
-		remoteProbeBudget.count--;
+	if (remoteProbeBudget.remaining > 0) {
+		remoteProbeBudget.remaining--;
 		const signatureArray = await readUint8Array(reader, signatureOffset, 4);
 		return getUint32$1(getDataView(signatureArray), 0);
 	}
@@ -7095,9 +7218,11 @@ function resolveMetadata(zipWriter, name, options) {
 	const passThrough = checkPassThroughOption(getOptionValue(zipWriter, options, OPTION_PASS_THROUGH));
 	const passThroughCompression = Boolean(passThrough);
 	const passThroughEncryption = passThrough === true;
-	const password = getOptionValue(zipWriter, options, OPTION_PASSWORD);
-	const rawPassword = getOptionValue(zipWriter, options, OPTION_RAW_PASSWORD);
+	let password = getOptionValue(zipWriter, options, OPTION_PASSWORD);
+	let rawPassword = getOptionValue(zipWriter, options, OPTION_RAW_PASSWORD);
 	checkPasswordOption(password, rawPassword);
+	password = password && password.length ? password : UNDEFINED_VALUE;
+	rawPassword = rawPassword && rawPassword.length ? rawPassword : UNDEFINED_VALUE;
 	const encryptionStrength = getNumberOptionValue(zipWriter, options, OPTION_ENCRYPTION_STRENGTH, 3);
 	const zipCrypto = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIPCRYPTO);
 	const extendedTimestamp = getOptionValue(zipWriter, options, OPTION_EXTENDED_TIMESTAMP, true);
@@ -8893,7 +9018,7 @@ function formatSupported(StreamClass, format) {
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const VERSION = "2.15.0";
+const VERSION = "2.16.1";
 
 /*
  Copyright (c) 2025 Gildas Lormeau. All rights reserved.
@@ -9370,7 +9495,7 @@ try {
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global TransformStream */
+/* global ReadableStream, WritableStream */
 
 const FORMAT_DEFLATE = "deflate";
 const FORMAT_DEFLATE_RAW = "deflate-raw";
@@ -9405,137 +9530,195 @@ function _make(isCompress, type, options = {}) {
 	const level = (typeof options.level === "number") ? options.level : -1;
 	const outBufferSize = (typeof options.outBuffer === "number") ? options.outBuffer : 64 * 1024;
 	const inBufferSize = (typeof options.inBufferSize === "number") ? options.inBufferSize : 64 * 1024;
-
-	return new TransformStream({
-		start() {
+	const state = { out: 0, in: 0, inBufferSize: 0, streamHandle: 0 };
+	let readableController, writableController, resolveWrite, cancelReason;
+	let backpressure = true;
+	let cancelled = false;
+	initStream();
+	const readable = new ReadableStream({
+		start(controller) {
+			readableController = controller;
+		},
+		pull() {
+			backpressure = false;
+			resumeWrite();
+		},
+		cancel(reason) {
+			cancelled = true;
+			cancelReason = reason;
+			disposeStream(state);
+			writableController.error(reason);
+			resumeWrite();
+		}
+	}, { highWaterMark: 0 });
+	const writable = new WritableStream({
+		start(controller) {
+			writableController = controller;
+		},
+		async write(chunk) {
+			if (backpressure) {
+				await new Promise(resolve => resolveWrite = resolve);
+			}
+			if (cancelled) {
+				throw cancelReason;
+			}
 			try {
-				let result;
-				this.out = malloc(outBufferSize);
-				this.in = malloc(inBufferSize);
-				this.inBufferSize = inBufferSize;
-				if (!this.out || !this.in) {
-					throw new Error("allocation failed");
-				}
-				if (isCompress) {
-					this._process = wasm$1.deflate_process;
-					this._last_consumed = wasm$1.deflate_last_consumed;
-					this._end = wasm$1.deflate_end;
-					this.streamHandle = wasm$1.deflate_new();
-					if (type === FORMAT_GZIP) {
-						result = wasm$1.deflate_init_gzip(this.streamHandle, level);
-					} else if (type === FORMAT_DEFLATE_RAW) {
-						result = wasm$1.deflate_init_raw(this.streamHandle, level);
-					} else {
-						result = wasm$1.deflate_init(this.streamHandle, level);
-					}
-				} else {
-					if (type === FORMAT_DEFLATE64_RAW) {
-						this._process = wasm$1.inflate9_process;
-						this._last_consumed = wasm$1.inflate9_last_consumed;
-						this._end = wasm$1.inflate9_end;
-						this.streamHandle = wasm$1.inflate9_new();
-						result = wasm$1.inflate9_init_raw(this.streamHandle);
-					} else {
-						this._process = wasm$1.inflate_process;
-						this._last_consumed = wasm$1.inflate_last_consumed;
-						this._end = wasm$1.inflate_end;
-						this.streamHandle = wasm$1.inflate_new();
-						if (type === FORMAT_DEFLATE_RAW) {
-							result = wasm$1.inflate_init_raw(this.streamHandle);
-						} else if (type === FORMAT_GZIP) {
-							result = wasm$1.inflate_init_gzip(this.streamHandle);
-						} else {
-							result = wasm$1.inflate_init(this.streamHandle);
-						}
-					}
-				}
-				if (result !== 0) {
-					throw new Error("init failed:" + result);
-				}
+				processChunk(chunk);
 			} catch (error) {
-				disposeStream(this);
+				disposeStream(state);
+				readableController.error(error);
 				throw error;
 			}
 		},
-		transform(chunk, controller) {
+		close() {
+			if (cancelled) {
+				return;
+			}
 			try {
-				const buffer = chunk;
-				const heap = new Uint8Array(memory.buffer);
-				const process = this._process;
-				const last_consumed = this._last_consumed;
-				const out = this.out;
-				let offset = 0;
-				while (offset < buffer.length) {
-					const toRead = Math.min(buffer.length - offset, 32 * 1024);
-					if (!this.in || this.inBufferSize < toRead) {
-						if (this.in && free) {
-							free(this.in);
-							this.in = 0;
-						}
-						this.in = malloc(toRead);
-						this.inBufferSize = toRead;
-						if (!this.in) {
-							throw new Error("allocation failed");
-						}
-					}
-					heap.set(buffer.subarray(offset, offset + toRead), this.in);
-					const result = process(this.streamHandle, this.in, toRead, out, outBufferSize, 0);
-					// checked before the byte count is used, so a status code can never be read as one
-					const code = (result >> 24) & 0xff;
-					const signedCode = (code & 0x80) ? code - 256 : code;
-					if (signedCode < 0) {
-						throw new Error("process error:" + signedCode);
-					}
-					const prod = result & 0x00ffffff;
-					if (prod) {
-						controller.enqueue(heap.slice(out, out + prod));
-					}
-					const consumed = last_consumed(this.streamHandle);
-					if (consumed === 0 && prod === 0) {
-						break;
-					}
-					offset += consumed;
-				}
+				flushStream();
 			} catch (error) {
-				disposeStream(this);
-				controller.error(error);
+				disposeStream(state);
+				readableController.error(error);
+				throw error;
+			}
+			const result = disposeStream(state);
+			if (result !== 0) {
+				const error = new Error("end error:" + result);
+				readableController.error(error);
+				throw error;
 			}
+			readableController.close();
 		},
-		flush(controller) {
-			try {
-				const heap = new Uint8Array(memory.buffer);
-				const process = this._process;
-				const out = this.out;
-				while (true) {
-					const result = process(this.streamHandle, 0, 0, out, outBufferSize, 4);
-					const code = (result >> 24) & 0xff;
-					const signedCode = (code & 0x80) ? code - 256 : code;
-					if (signedCode < 0) {
-						throw new Error("process error:" + signedCode);
-					}
-					const produced = result & 0x00ffffff;
-					if (produced) {
-						controller.enqueue(heap.slice(out, out + produced));
-					}
-					if (code === 1 || produced === 0) {
-						break;
+		abort(reason) {
+			disposeStream(state);
+			readableController.error(reason);
+		}
+	}, { highWaterMark: 1 });
+	return { readable, writable };
+
+	function initStream() {
+		try {
+			let result;
+			state.out = malloc(outBufferSize);
+			state.in = malloc(inBufferSize);
+			state.inBufferSize = inBufferSize;
+			if (!state.out || !state.in) {
+				throw new Error("allocation failed");
+			}
+			if (isCompress) {
+				state._process = wasm$1.deflate_process;
+				state._last_consumed = wasm$1.deflate_last_consumed;
+				state._end = wasm$1.deflate_end;
+				state.streamHandle = wasm$1.deflate_new();
+				if (type === FORMAT_GZIP) {
+					result = wasm$1.deflate_init_gzip(state.streamHandle, level);
+				} else if (type === FORMAT_DEFLATE_RAW) {
+					result = wasm$1.deflate_init_raw(state.streamHandle, level);
+				} else {
+					result = wasm$1.deflate_init(state.streamHandle, level);
+				}
+			} else {
+				if (type === FORMAT_DEFLATE64_RAW) {
+					state._process = wasm$1.inflate9_process;
+					state._last_consumed = wasm$1.inflate9_last_consumed;
+					state._end = wasm$1.inflate9_end;
+					state.streamHandle = wasm$1.inflate9_new();
+					result = wasm$1.inflate9_init_raw(state.streamHandle);
+				} else {
+					state._process = wasm$1.inflate_process;
+					state._last_consumed = wasm$1.inflate_last_consumed;
+					state._end = wasm$1.inflate_end;
+					state.streamHandle = wasm$1.inflate_new();
+					if (type === FORMAT_DEFLATE_RAW) {
+						result = wasm$1.inflate_init_raw(state.streamHandle);
+					} else if (type === FORMAT_GZIP) {
+						result = wasm$1.inflate_init_gzip(state.streamHandle);
+					} else {
+						result = wasm$1.inflate_init(state.streamHandle);
 					}
 				}
-			} catch (error) {
-				controller.error(error);
-			} finally {
-				const result = disposeStream(this);
-				if (result !== 0) {
-					controller.error(new Error("end error:" + result));
+			}
+			if (result !== 0) {
+				throw new Error("init failed:" + result);
+			}
+		} catch (error) {
+			disposeStream(state);
+			throw error;
+		}
+	}
+
+	function processChunk(chunk) {
+		const heap = new Uint8Array(memory.buffer);
+		const process = state._process;
+		const last_consumed = state._last_consumed;
+		const out = state.out;
+		let offset = 0;
+		while (offset < chunk.length) {
+			const toRead = Math.min(chunk.length - offset, 32 * 1024);
+			if (!state.in || state.inBufferSize < toRead) {
+				if (state.in && free) {
+					free(state.in);
+					state.in = 0;
+				}
+				state.in = malloc(toRead);
+				state.inBufferSize = toRead;
+				if (!state.in) {
+					throw new Error("allocation failed");
 				}
 			}
-		},
-		cancel() {
-			// release the stream handle and buffers when the pipeline is aborted,
-			// they would be leaked in the process-lifetime wasm heap otherwise
-			disposeStream(this);
+			heap.set(chunk.subarray(offset, offset + toRead), state.in);
+			const result = process(state.streamHandle, state.in, toRead, out, outBufferSize, 0);
+			// checked before the byte count is used, so a status code can never be read as one
+			const code = (result >> 24) & 0xff;
+			const signedCode = (code & 0x80) ? code - 256 : code;
+			if (signedCode < 0) {
+				throw new Error("process error:" + signedCode);
+			}
+			const prod = result & 0x00ffffff;
+			if (prod) {
+				enqueue(heap.slice(out, out + prod));
+			}
+			const consumed = last_consumed(state.streamHandle);
+			if (consumed === 0 && prod === 0) {
+				break;
+			}
+			offset += consumed;
 		}
-	});
+	}
+
+	function flushStream() {
+		const heap = new Uint8Array(memory.buffer);
+		const process = state._process;
+		const out = state.out;
+		while (true) {
+			const result = process(state.streamHandle, 0, 0, out, outBufferSize, 4);
+			const code = (result >> 24) & 0xff;
+			const signedCode = (code & 0x80) ? code - 256 : code;
+			if (signedCode < 0) {
+				throw new Error("process error:" + signedCode);
+			}
+			const produced = result & 0x00ffffff;
+			if (produced) {
+				enqueue(heap.slice(out, out + produced));
+			}
+			if (code === 1 || produced === 0) {
+				break;
+			}
+		}
+	}
+
+	function enqueue(chunk) {
+		backpressure = true;
+		readableController.enqueue(chunk);
+	}
+
+	function resumeWrite() {
+		if (resolveWrite) {
+			const resolve = resolveWrite;
+			resolveWrite = null;
+			resolve();
+		}
+	}
 
 	function disposeStream(state) {
 		let endResult = 0;
@@ -9865,7 +10048,11 @@ const DUPLICATES_VALUES = new Set([DUPLICATES_THROW, DUPLICATES_KEEP_FIRST, DUPL
 const ERR_INVALID_PASS_THROUGH = "Invalid passThrough option (use readerOptions.passThrough or set uncompressedSize for each entry)";
 const ERR_INVALID_READER_OPTIONS = "Invalid readerOptions (must be an object)";
 const ERR_UNSUPPORTED_PASS_THROUGH_VALUE = "The 'compressed' passThrough option is only supported by Entry#getData() and ZipWriter#add()";
+const ERR_INVALID_PASSWORDS = "Invalid passwords option (must be an array of strings)";
+const ERR_INVALID_REQUEST_PASSWORD = "Invalid requestPassword option (must be a function returning a string or undefined)";
 const ERR_ABORT_EXPORT = "zipjs-abort-export";
+const ABORT_ERROR_NAME = "AbortError";
+const EMPTY_RAW_PASSWORD = new Uint8Array(0);
 
 class ZipEntry {
 
@@ -10238,8 +10425,10 @@ class ZipDirectoryEntry extends ZipEntry {
 			zipReader = new ZipReader(reader, options);
 		}
 		checkPassThroughValue(options.passThrough);
+		checkPasswordCandidatesOptions(options);
 		const duplicates = checkDuplicatesOption(options.duplicates);
 		const importedEntries = [];
+		const passwordState = { known: [] };
 		const entries = await zipReader.getEntries(options);
 		for (const entry of entries) {
 			let parent = this;
@@ -10284,7 +10473,7 @@ class ZipDirectoryEntry extends ZipEntry {
 					}
 					importedEntries.push(addChild(parent, name, {
 						data: entry,
-						Reader: getZipBlobReader(Object.assign({}, options)),
+						Reader: getZipBlobReader(Object.assign({}, options), passwordState),
 						uncompressedSize: options.passThrough ? entry.compressedSize : entry.uncompressedSize,
 						passThrough: options.passThrough
 					}));
@@ -10613,7 +10802,7 @@ function getReadableReader(readable) {
 	};
 }
 
-function getZipBlobReader(options) {
+function getZipBlobReader(options, passwordState) {
 	return class extends Reader {
 
 		constructor(entry, options = {}) {
@@ -10626,12 +10815,12 @@ function getZipBlobReader(options) {
 			const zipBlobReader = this;
 			const readerOptions = Object.assign({}, options, zipBlobReader.options);
 			const { checkOverlappingEntry, checkOverlappingEntryOnly } = readerOptions;
-			const data = await zipBlobReader.entry.getData(new BlobWriter(), Object.assign(readerOptions, {
+			const data = await readEntryData(zipBlobReader.entry, Object.assign(readerOptions, {
 				checkPasswordOnly: false,
 				checkOverlappingEntry: checkOverlappingEntryOnly || checkOverlappingEntry,
 				checkOverlappingEntryOnly: false,
 				preventClose: false
-			}));
+			}), passwordState);
 			zipBlobReader.data = data;
 			zipBlobReader.blobReader = new BlobReader(data);
 			zipBlobReader.size = data.size;
@@ -10693,10 +10882,9 @@ async function initReaders(entry, options) {
 			await initStream(reader);
 		} catch (error) {
 			try {
+				error.entry = child;
 				error.entryId = child.id;
-				error.cause = {
-					entry: child
-				};
+				error.entryName = child.getRelativeName(entry);
 			} catch {
 				// ignored
 			}
@@ -10788,10 +10976,136 @@ function checkReaderOptions(readerOptions) {
 	}
 	if (readerOptions) {
 		checkPassThroughValue(readerOptions.passThrough);
+		checkPasswordCandidatesOptions(readerOptions);
 	}
 	return readerOptions;
 }
 
+function checkPasswordCandidatesOptions(options) {
+	const { passwords, requestPassword } = options;
+	if (passwords && (!Array.isArray(passwords) || passwords.some(password => typeof password != STRING_TYPE))) {
+		throw new Error(ERR_INVALID_PASSWORDS);
+	}
+	if (requestPassword && typeof requestPassword != FUNCTION_TYPE) {
+		throw new Error(ERR_INVALID_REQUEST_PASSWORD);
+	}
+}
+
+async function readEntryData(entry, options, passwordState) {
+	checkPasswordCandidatesOptions(options);
+	const { passwords, requestPassword, signal } = options;
+	options = Object.assign({}, options);
+	delete options.passwords;
+	delete options.requestPassword;
+	if (!entry.encrypted || options.passThrough || (!passwords && !requestPassword)) {
+		return entry.getData(new BlobWriter(), options);
+	}
+	const tried = new Set();
+	let error;
+	while (true) {
+		for (const candidate of getPasswordCandidates(options, passwordState, passwords)) {
+			if (!tried.has(candidate.key)) {
+				const result = await tryPasswordCandidate(candidate);
+				if (result.done) {
+					return result.data;
+				}
+				error = result.error;
+			}
+		}
+		if (!requestPassword) {
+			break;
+		}
+		if (passwordState.pendingPrompt) {
+			await passwordState.pendingPrompt;
+			continue;
+		}
+		let release;
+		passwordState.pendingPrompt = new Promise(resolve => release = resolve);
+		try {
+			const answer = await requestPassword(entry, error);
+			if (answer === UNDEFINED_VALUE || answer === null) {
+				break;
+			}
+			// deno-lint-ignore valid-typeof
+			if (typeof answer != STRING_TYPE) {
+				throw new Error(ERR_INVALID_REQUEST_PASSWORD);
+			}
+			const result = await tryPasswordCandidate(getPasswordCandidate(answer));
+			if (result.done) {
+				return result.data;
+			}
+			error = result.error;
+		} finally {
+			passwordState.pendingPrompt = UNDEFINED_VALUE;
+			release();
+		}
+	}
+	throw new Error(tried.size ? ERR_INVALID_PASSWORD : ERR_ENCRYPTED);
+
+	async function tryPasswordCandidate(candidate) {
+		tried.add(candidate.key);
+		const candidateOptions = Object.assign({}, options, candidate.options);
+		if (entry.zipCrypto) {
+			candidateOptions.checkCrc32 = true;
+			try {
+				await entry.getData(null, Object.assign({}, candidateOptions, { checkPasswordOnly: true }));
+			} catch (probeError) {
+				if (isInvalidPasswordError(probeError)) {
+					return { done: false, error: probeError };
+				}
+				throw probeError;
+			}
+		}
+		try {
+			const data = await entry.getData(new BlobWriter(), candidateOptions);
+			rememberPassword(passwordState, candidate);
+			return { done: true, data };
+		} catch (readError) {
+			if (isAbortError(readError, signal) || (!entry.zipCrypto && !isInvalidPasswordError(readError))) {
+				throw readError;
+			}
+			return { done: false, error: readError };
+		}
+	}
+}
+
+function isInvalidPasswordError(error) {
+	return isErrorObject(error) && error.message == ERR_INVALID_PASSWORD;
+}
+
+function isAbortError(error, signal) {
+	return Boolean(signal && signal.aborted) || (isErrorObject(error) && error.name == ABORT_ERROR_NAME);
+}
+
+function getPasswordCandidates(options, passwordState, passwords) {
+	const candidates = [];
+	const { password, rawPassword } = options;
+	if (rawPassword && rawPassword.length) {
+		candidates.push({ key: rawPassword, options: { password: "", rawPassword } });
+	}
+	if (password) {
+		candidates.push(getPasswordCandidate(password));
+	}
+	candidates.push(...passwordState.known);
+	if (passwords) {
+		candidates.push(...passwords.filter(password => password).map(getPasswordCandidate));
+	}
+	return candidates;
+}
+
+function getPasswordCandidate(password) {
+	return { key: password, options: { password, rawPassword: EMPTY_RAW_PASSWORD } };
+}
+
+function rememberPassword(passwordState, candidate) {
+	const { known } = passwordState;
+	const index = known.findIndex(knownCandidate => knownCandidate.key === candidate.key);
+	if (index != -1) {
+		known.splice(index, 1);
+	}
+	known.unshift(candidate);
+}
+
 function checkPassThroughValue(passThrough) {
 	if (checkPassThroughOption(passThrough) === PASS_THROUGH_COMPRESSED) {
 		throw new Error(ERR_UNSUPPORTED_PASS_THROUGH_VALUE);
@@ -10929,6 +11243,7 @@ function addFileSystemHandle(zipEntry, handle, options) {
 async function exportFileSystemHandle(zipEntry, directoryHandle, options) {
 	const { onstart, onprogress, onend } = options;
 	checkPassThroughValue(options.passThrough);
+	checkPasswordCandidatesOptions(options);
 	const readerOptions = checkReaderOptions(options.readerOptions);
 	const abortController = new AbortController();
 	const { signal } = abortController;
@@ -11242,4 +11557,4 @@ function decodeMimeTypes(data) {
 	return mimeTypes;
 }
 
-export { BlobReader, BlobWriter, Data64URIReader, Data64URIWriter, ERR_ABORTED, ERR_AMBIGUOUS_ARCHIVE, ERR_ANCESTOR_ENTRY, ERR_BAD_FORMAT, ERR_CENTRAL_DIRECTORY_NOT_FOUND, ERR_DUPLICATED_NAME, ERR_DUPLICATE_IMPORTED_ENTRY, ERR_ENCRYPTED, ERR_ENCRYPTED_CENTRAL_DIRECTORY, ERR_ENTRY_DATA_OUT_OF_BOUNDS, 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_HTTP_STATUS, ERR_INVALID_AUTHENTICATION_CODE, ERR_INVALID_BASE_URI, ERR_INVALID_CODEC_DEFINITION, ERR_INVALID_CODEC_MODULE, ERR_INVALID_COMMENT, ERR_INVALID_COMMENT_TYPE, ERR_INVALID_COMPRESSED_DATA, ERR_INVALID_CRC32, ERR_INVALID_DATE, ERR_INVALID_DUPLICATES, ERR_INVALID_ENCRYPTION_STRENGTH, ERR_INVALID_ENTRY, ERR_INVALID_ENTRY_COMMENT, ERR_INVALID_ENTRY_COMMENT_TYPE, ERR_INVALID_ENTRY_NAME, ERR_INVALID_EXTRAFIELD, ERR_INVALID_EXTRAFIELD_DATA, ERR_INVALID_EXTRAFIELD_DATA_TYPE, ERR_INVALID_EXTRAFIELD_TYPE, ERR_INVALID_FILENAME_VALIDATION, ERR_INVALID_FUNCTION_OPTION, ERR_INVALID_GID, ERR_INVALID_LEVEL, ERR_INVALID_MAX_APPENDED_DATA_SIZE, ERR_INVALID_MAX_WORKERS, ERR_INVALID_MSDOS_ATTRIBUTES, ERR_INVALID_MSDOS_DATA, ERR_INVALID_PASSWORD, ERR_INVALID_PASSWORD_TYPE, ERR_INVALID_PASS_THROUGH, ERR_INVALID_PASS_THROUGH_VALUE, ERR_INVALID_READER, ERR_INVALID_READER_OPTIONS, ERR_INVALID_SIGNAL, 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_URI, ERR_INVALID_VERSION, ERR_ITERATOR_COMPLETED_TOO_SOON, ERR_LOCAL_FILE_HEADER_NOT_FOUND, ERR_OVERLAPPING_ENTRY, ERR_PARENT_NOT_DIRECTORY, ERR_READABLE_CONSUMED, ERR_RESERVED_COMPRESSION_METHOD, ERR_ROOT_DIRECTORY_NOT_MOVABLE, ERR_SPLIT_ZIP_FILE, ERR_TARGET_NOT_DIRECTORY, ERR_UNDEFINED_COMPRESSION_METHOD, ERR_UNDEFINED_CRC32, ERR_UNDEFINED_READER, ERR_UNDEFINED_UNCOMPRESSED_SIZE, ERR_UNDETERMINED_SIZE, ERR_UNSAFE_FILENAME, 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_UNSUPPORTED_PASS_THROUGH_VALUE, ERR_UNSUPPORTED_SPLIT_USDZ, ERR_UNSUPPORTED_UINT64, ERR_WORKER_STARTUP_TIMEOUT, ERR_WRITER_NOT_INITIALIZED, ERR_WRITER_SIZE_NOT_WRITABLE, ERR_ZIP_CRYPTO_LAST_MOD_DATE, ERR_ZIP_NOT_EMPTY, HttpRangeReader, HttpReader, Reader, SplitDataReader, SplitDataWriter, TextReader, TextWriter, Uint8ArrayReader, Uint8ArrayWriter, VERSION, WARNING_APPENDED_DATA, WARNING_CLAMPED_LAST_MODIFICATION_DATE, WARNING_COMPRESSED_PATCHED_DATA, WARNING_COMPRESSION_UNAVAILABLE, WARNING_DUPLICATE_FILENAME, WARNING_MALFORMED_EXTRA_FIELD, WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG, WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD, WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES, WARNING_MISMATCHED_LOCAL_FILE_HEADER_FILENAME, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY, WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY, WARNING_PREPENDED_CENTRAL_DIRECTORY, WARNING_PREPENDED_DATA, WARNING_TRAILING_CENTRAL_DIRECTORY_DATA, WARNING_UNKNOWN_VERSION, WARNING_UNKNOWN_ZIP64_EXTENSIBLE_DATA, WARNING_UNSORTED_CENTRAL_DIRECTORY, WARNING_WRAPPED_ENTRIES_COUNT, Writer, ZipDirectoryEntry, ZipEntry, ZipFS, ZipFileEntry, ZipReader, ZipReaderStream, ZipWriter, ZipWriterStream, configure, createBlobTempStream, createOPFSTempStream, createSyncAccessHandleTempStream, fs, getMimeType, getRegisteredCodecs, getSupportedCompressionMethods, isZipFile, registerCodec, resetConfiguration, terminateWorkersAndModule as terminateWorkers, unregisterCodec };
+export { BlobReader, BlobWriter, Data64URIReader, Data64URIWriter, ERR_ABORTED, ERR_AMBIGUOUS_ARCHIVE, ERR_ANCESTOR_ENTRY, ERR_BAD_FORMAT, ERR_CENTRAL_DIRECTORY_NOT_FOUND, ERR_DUPLICATED_NAME, ERR_DUPLICATE_IMPORTED_ENTRY, ERR_ENCRYPTED, ERR_ENCRYPTED_CENTRAL_DIRECTORY, ERR_ENTRY_DATA_OUT_OF_BOUNDS, 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_HTTP_STATUS, ERR_INVALID_AUTHENTICATION_CODE, ERR_INVALID_BASE_URI, ERR_INVALID_CODEC_DEFINITION, ERR_INVALID_CODEC_MODULE, ERR_INVALID_COMMENT, ERR_INVALID_COMMENT_TYPE, ERR_INVALID_COMPRESSED_DATA, ERR_INVALID_CRC32, ERR_INVALID_DATE, ERR_INVALID_DUPLICATES, ERR_INVALID_ENCRYPTION_STRENGTH, ERR_INVALID_ENTRY, ERR_INVALID_ENTRY_COMMENT, ERR_INVALID_ENTRY_COMMENT_TYPE, ERR_INVALID_ENTRY_NAME, ERR_INVALID_EXTRAFIELD, ERR_INVALID_EXTRAFIELD_DATA, ERR_INVALID_EXTRAFIELD_DATA_TYPE, ERR_INVALID_EXTRAFIELD_TYPE, ERR_INVALID_FILENAME_VALIDATION, ERR_INVALID_FUNCTION_OPTION, ERR_INVALID_GID, ERR_INVALID_LEVEL, ERR_INVALID_MAX_APPENDED_DATA_SIZE, ERR_INVALID_MAX_WORKERS, ERR_INVALID_MSDOS_ATTRIBUTES, ERR_INVALID_MSDOS_DATA, ERR_INVALID_PASSWORD, ERR_INVALID_PASSWORDS, ERR_INVALID_PASSWORD_TYPE, ERR_INVALID_PASS_THROUGH, ERR_INVALID_PASS_THROUGH_VALUE, ERR_INVALID_READER, ERR_INVALID_READER_OPTIONS, ERR_INVALID_REQUEST_PASSWORD, ERR_INVALID_SIGNAL, 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_URI, ERR_INVALID_VERSION, ERR_ITERATOR_COMPLETED_TOO_SOON, ERR_LOCAL_FILE_HEADER_NOT_FOUND, ERR_OVERLAPPING_ENTRY, ERR_PARENT_NOT_DIRECTORY, ERR_READABLE_CONSUMED, ERR_RESERVED_COMPRESSION_METHOD, ERR_ROOT_DIRECTORY_NOT_MOVABLE, ERR_SPLIT_ZIP_FILE, ERR_TARGET_NOT_DIRECTORY, ERR_UNDEFINED_COMPRESSION_METHOD, ERR_UNDEFINED_CRC32, ERR_UNDEFINED_READER, ERR_UNDEFINED_UNCOMPRESSED_SIZE, ERR_UNDETERMINED_SIZE, ERR_UNSAFE_FILENAME, 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_UNSUPPORTED_PASS_THROUGH_VALUE, ERR_UNSUPPORTED_SPLIT_USDZ, ERR_UNSUPPORTED_UINT64, ERR_WORKER_STARTUP_TIMEOUT, ERR_WRITER_NOT_INITIALIZED, ERR_WRITER_SIZE_NOT_WRITABLE, ERR_ZIP_CRYPTO_LAST_MOD_DATE, ERR_ZIP_NOT_EMPTY, HttpRangeReader, HttpReader, Reader, SplitDataReader, SplitDataWriter, TextReader, TextWriter, Uint8ArrayReader, Uint8ArrayWriter, VERSION, WARNING_APPENDED_DATA, WARNING_CLAMPED_LAST_MODIFICATION_DATE, WARNING_COMPRESSED_PATCHED_DATA, WARNING_COMPRESSION_UNAVAILABLE, WARNING_DUPLICATE_FILENAME, WARNING_MALFORMED_EXTRA_FIELD, WARNING_MISMATCHED_LOCAL_FILE_HEADER_BIT_FLAG, WARNING_MISMATCHED_LOCAL_FILE_HEADER_COMPRESSION_METHOD, WARNING_MISMATCHED_LOCAL_FILE_HEADER_CRC32_OR_SIZES, WARNING_MISMATCHED_LOCAL_FILE_HEADER_FILENAME, WARNING_MISMATCHED_ZIP64_END_OF_CENTRAL_DIRECTORY, WARNING_MULTIPLE_END_OF_CENTRAL_DIRECTORY, WARNING_PREPENDED_CENTRAL_DIRECTORY, WARNING_PREPENDED_DATA, WARNING_TRAILING_CENTRAL_DIRECTORY_DATA, WARNING_UNKNOWN_VERSION, WARNING_UNKNOWN_ZIP64_EXTENSIBLE_DATA, WARNING_UNSORTED_CENTRAL_DIRECTORY, WARNING_WRAPPED_ENTRIES_COUNT, Writer, ZipDirectoryEntry, ZipEntry, ZipFS, ZipFileEntry, ZipReader, ZipReaderStream, ZipWriter, ZipWriterStream, configure, createBlobTempStream, createOPFSTempStream, createSyncAccessHandleTempStream, fs, getMimeType, getRegisteredCodecs, getSupportedCompressionMethods, isZipFile, registerCodec, resetConfiguration, terminateWorkersAndModule as terminateWorkers, unregisterCodec };