@zip.js/zip.js 2.16.0 → 2.17.0

package/dist/zip-core-external.js

@@ -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) {
@@ -1882,7 +1931,9 @@ async function ensureCodecStreams(format, codecURI) {
 
 const ERR_INVALID_UNCOMPRESSED_SIZE = "Invalid uncompressed size";
 const ERR_INVALID_COMPRESSED_DATA = "Invalid compressed data";
+const ERR_CODEC_OUT_OF_MEMORY = "Codec out of memory";
 const ERR_INVALID_CRC32 = "Invalid CRC32";
+const Z_MEM_ERROR_CODE$1 = "Z_MEM_ERROR";
 const FORMAT_DEFLATE_RAW$1 = "deflate-raw";
 const FORMAT_DEFLATE64_RAW$1 = "deflate64-raw";
 const FORMAT_GZIP$1 = "gzip";
@@ -1917,13 +1968,13 @@ class DeflateStream extends TransformStream {
 					readable = pipeThroughCompressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamFallback);
 				} catch (error) {
 					if (!useCompressionStream && CompressionStreamFallback) {
-						throw error;
+						throw mapMemoryError(error);
 					}
 					let gzipStream;
 					try {
 						gzipStream = new CompressionStream(FORMAT_GZIP$1);
 					} catch {
-						throw error;
+						throw mapMemoryError(error);
 					}
 					readable = pipeThroughBackpressured(readable, gzipStream);
 					readable = pipeThrough(readable, new GzipToRawDeflateStream());
@@ -1987,53 +2038,30 @@ class GzipToRawDeflateStream extends TransformStream {
 	}
 }
 
-function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, crc32) {
+function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, crc32, sourceErrors) {
 	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 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(() => { });
-	pump();
-	return new ReadableStream({
-		async pull(controller) {
-			let result;
-			try {
-				result = await read();
-			} catch (error) {
-				throw trailerWritten ? getTrailerError(error) : error;
-			}
-			const { value, done } = result;
-			if (done) {
-				controller.close();
-			} else {
-				outputLength += value.length;
-				if (outputLength > outputSize) {
-					const error = new Error(ERR_INVALID_UNCOMPRESSED_SIZE);
-					rejectTrailerReady(error);
-					await cancel(reader, error);
-					throw error;
-				}
-				if (outputCrc32) {
-					outputCrc32.append(value);
-				}
-				controller.enqueue(value);
-			}
+	let settled = false;
+	let resolvePull, controller;
+	const output = new ReadableStream({
+		start(streamController) {
+			controller = streamController;
+		},
+		pull() {
+			resumePump();
 		},
 		cancel(reason) {
-			rejectTrailerReady(reason);
+			settled = true;
+			resumePump();
 			return reader.cancel(reason);
 		}
 	});
+	pump();
+	drain();
+	return output;
 
 	async function pump() {
 		const inputReader = readable.getReader();
@@ -2042,19 +2070,16 @@ function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, cr
 			header.set(GZIP_HEADER_BYTES);
 			await writer.write(header);
 			for (; ;) {
+				await outputCapacity();
 				await writer.ready;
-				const { value, done } = await inputReader.read();
+				const { value, done } = await readSource(inputReader, sourceErrors);
 				if (done) {
 					break;
 				}
 				await writer.write(value);
 			}
-			inputDone = true;
 			if (outputCrc32) {
-				if (readPending) {
-					armIdleCheck();
-				}
-				await trailerReady;
+				await writer.write(new Uint8Array(0));
 			}
 			const trailer = new Uint8Array(GZIP_TRAILER_LENGTH);
 			const dataView = getDataView(trailer);
@@ -2069,54 +2094,68 @@ function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, cr
 		}
 	}
 
-	function read() {
-		readCount++;
-		readPending = true;
-		const result = reader.read();
-		result.then(onReadSettled, onReadSettled);
-		if (inputDone && outputCrc32) {
-			armIdleCheck();
+	async function drain() {
+		try {
+			for (; ;) {
+				const { value, done } = await read();
+				if (done) {
+					break;
+				}
+				outputLength += value.length;
+				if (outputLength > outputSize) {
+					throw new Error(ERR_INVALID_UNCOMPRESSED_SIZE);
+				}
+				if (outputCrc32) {
+					outputCrc32.append(value);
+				}
+				controller.enqueue(value);
+			}
+			if (!settled) {
+				settled = true;
+				controller.close();
+			}
+		} catch (error) {
+			fail(error);
+			await cancel(reader, error);
 		}
-		return result;
 	}
 
-	function onReadSettled() {
-		readPending = false;
-	}
-
-	async function armIdleCheck() {
-		if (!idleCheckArmed) {
-			idleCheckArmed = true;
-			const count = readCount;
-			await nextTask();
-			idleCheckArmed = false;
-			if (readPending) {
-				if (readCount == count) {
-					resolveTrailerReady();
-				} else {
-					armIdleCheck();
+	function read() {
+		return reader.read().catch(error => {
+			if (trailerWritten) {
+				if (!outputCrc32) {
+					throw mapError(error, ERR_INVALID_CRC32);
+				}
+				if (outputLength != outputSize) {
+					throw mapError(error, ERR_INVALID_UNCOMPRESSED_SIZE);
 				}
+				return { done: true };
 			}
-		}
+			throw mapCodecError(error, sourceErrors);
+		});
 	}
 
-	function getTrailerError(error) {
-		const trailerError = new Error(outputLength == outputSize ? ERR_INVALID_CRC32 : ERR_INVALID_UNCOMPRESSED_SIZE);
-		trailerError.cause = error;
-		return trailerError;
+	function outputCapacity() {
+		if (!settled && controller.desiredSize <= 0) {
+			return new Promise(resolve => resolvePull = resolve);
+		}
 	}
-}
 
-function nextTask() {
-	return new Promise(resolve => {
-		const { port1, port2 } = new MessageChannel();
-		port2.onmessage = () => {
-			port1.close();
-			port2.close();
+	function resumePump() {
+		if (resolvePull) {
+			const resolve = resolvePull;
+			resolvePull = UNDEFINED_VALUE;
 			resolve();
-		};
-		port1.postMessage(UNDEFINED_VALUE);
-	});
+		}
+	}
+
+	function fail(error) {
+		if (!settled) {
+			settled = true;
+			controller.error(error);
+			resumePump();
+		}
+	}
 }
 
 class InflateStream extends TransformStream {
@@ -2135,11 +2174,12 @@ class InflateStream extends TransformStream {
 			}
 		}
 		if (compressed) {
+			const sourceErrors = new Set();
 			const codecStreams = format && getCodecStreams(format);
+			let gzipStream;
 			if (codecStreams) {
-				readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.DecompressionStream, format, { chunkSize, compressionMethod, rawBitFlag, uncompressedSize: outputSize }));
+				readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.DecompressionStream, format, { chunkSize, compressionMethod, rawBitFlag, uncompressedSize: outputSize }), sourceErrors);
 			} else {
-				let gzipStream;
 				const GzipDecompressionStream = getGzipCodecStream(useCompressionStream, DecompressionStream, DecompressionStreamFallback);
 				if (checkCrc32 && !deflate64 && crc32 !== UNDEFINED_VALUE && outputSize !== UNDEFINED_VALUE && GzipDecompressionStream) {
 					try {
@@ -2150,24 +2190,25 @@ class InflateStream extends TransformStream {
 				}
 				if (!gzipStream) {
 					try {
-						readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamFallback);
+						readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamFallback, sourceErrors);
 					} catch (error) {
 						if (deflate64 || outputSize === UNDEFINED_VALUE || (!useCompressionStream && DecompressionStreamFallback)) {
-							throw error;
+							throw mapMemoryError(error);
 						}
 						try {
 							gzipStream = new DecompressionStream(FORMAT_GZIP$1);
 						} catch {
-							throw error;
+							throw mapMemoryError(error);
 						}
 					}
 				}
-				if (gzipStream) {
-					gzipCrc32 = true;
-					readable = pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, crc32);
-				}
 			}
-			readable = mapInflateStreamError(readable);
+			if (gzipStream) {
+				gzipCrc32 = true;
+				readable = pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, crc32, sourceErrors);
+			} else {
+				readable = mapInflateStreamError(readable, sourceErrors);
+			}
 		}
 		if (checkCrc32 && !gzipCrc32) {
 			crc32Stream = new Crc32Stream();
@@ -2240,7 +2281,7 @@ function getGzipCodecStream(useCompressionStream, CodecStreamNative, CodecStream
 	}
 }
 
-function pipeThroughCompressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamFallback) {
+function pipeThroughCompressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamFallback, sourceErrors) {
 	const Stream = useCompressionStream && CompressionStreamNative ?
 		CompressionStreamNative :
 		CompressionStreamFallback || CompressionStreamNative;
@@ -2255,14 +2296,14 @@ function pipeThroughCompressionStream(readable, useCompressionStream, options, C
 			throw error;
 		}
 	}
-	return pipeThroughBackpressured(readable, codecStream);
+	return pipeThroughBackpressured(readable, codecStream, sourceErrors);
 }
 
 function pipeThrough(readable, transformStream) {
 	return toCompatibleReadable(readable).pipeThrough(transformStream);
 }
 
-function pipeThroughBackpressured(readable, transformStream) {
+function pipeThroughBackpressured(readable, transformStream, sourceErrors) {
 	const writer = transformStream.writable.getWriter();
 	const reader = readable.getReader();
 	pump();
@@ -2272,7 +2313,7 @@ function pipeThroughBackpressured(readable, transformStream) {
 		try {
 			for (; ;) {
 				await writer.ready;
-				const result = await reader.read();
+				const result = await readSource(reader, sourceErrors);
 				if (result.done) {
 					await writer.close();
 					break;
@@ -2302,26 +2343,49 @@ async function cancel(reader, error) {
 	}
 }
 
-function mapInflateStreamError(readable) {
+function readSource(reader, sourceErrors) {
+	const result = reader.read();
+	return sourceErrors ? result.catch(error => {
+		sourceErrors.add(error);
+		throw error;
+	}) : result;
+}
+
+function mapCodecError(error, sourceErrors) {
+	if (sourceErrors.has(error)) {
+		return error;
+	}
+	return mapError(error, isMemoryError(error) ? ERR_CODEC_OUT_OF_MEMORY : ERR_INVALID_COMPRESSED_DATA);
+}
+
+function mapMemoryError(error) {
+	return isMemoryError(error) ? mapError(error, ERR_CODEC_OUT_OF_MEMORY) : error;
+}
+
+function isMemoryError(error) {
+	return isErrorObject(error) && error.code == Z_MEM_ERROR_CODE$1;
+}
+
+function mapError(error, message) {
+	const mappedError = new Error(message);
+	mappedError.cause = error;
+	return mappedError;
+}
+
+function mapInflateStreamError(readable, sourceErrors) {
 	const reader = readable.getReader();
 	return new ReadableStream({
 		async pull(controller) {
-			let result;
 			try {
-				result = await reader.read();
-			} catch (error) {
-				if (error && error.message) {
-					throw error;
+				const { value, done } = await reader.read();
+				if (done) {
+					controller.close();
+				} else {
+					controller.enqueue(value);
 				}
-				const mappedError = new Error(ERR_INVALID_COMPRESSED_DATA);
-				mappedError.cause = error;
-				throw mappedError;
-			}
-			const { value, done } = result;
-			if (done) {
-				controller.close();
-			} else {
-				controller.enqueue(value);
+			} catch (error) {
+				await cancel(reader, error);
+				throw mapCodecError(error, sourceErrors);
 			}
 		},
 		cancel(reason) {
@@ -2689,10 +2753,11 @@ async function runWorker$1({ options, readable, writable, onTaskFinished, worker
 		}
 		codecStream = new CodecStream(options, config);
 		chunkStream = new ChunkStream(getChunkSize(config));
+		const { signal } = workerOptions.streamOptions;
 		await readable
 			.pipeThrough(codecStream)
 			.pipeThrough(chunkStream)
-			.pipeTo(writable, { preventClose: true, preventAbort: true });
+			.pipeTo(writable, { preventClose: true, preventAbort: true, signal });
 		const {
 			crc32,
 			inputSize,
@@ -2760,6 +2825,7 @@ async function runWorker$1({ options, readable, writable, onTaskFinished, worker
 const MODULE_WORKER_OPTIONS = { type: "module" };
 const ERROR_EVENT_TYPE = "error";
 const MESSAGE_ERROR_EVENT_TYPE = "messageerror";
+const ABORT_EVENT_TYPE = "abort";
 
 let webWorkerSource, webWorkerURI, webWorkerOptions;
 let transferStreamsSupported = true;
@@ -2936,6 +3002,13 @@ function watchClosedStream(writableSource, workerData) {
 			Object.assign(workerData, { destinationFailed: true, destinationError: error });
 		}
 	});
+	const { signal } = workerData.workerOptions.streamOptions;
+	if (signal) {
+		const onAbort = () => abortController.abort(signal.reason);
+		const removeAbortListener = () => signal.removeEventListener(ABORT_EVENT_TYPE, onAbort);
+		signal.addEventListener(ABORT_EVENT_TYPE, onAbort);
+		closed.then(removeAbortListener, removeAbortListener);
+	}
 	return {
 		writable, closed, abortPipe: () => {
 			aborting = true;
@@ -3198,9 +3271,6 @@ function getResponseError(errorData, errorValue) {
 		responseError = errorValue.value;
 	} else {
 		responseError = Object.assign(new Error(message), { stack, code, name });
-		if (cause) {
-			responseError.cause = Object.assign(new Error(cause.message), { name: cause.name });
-		}
 	}
 	if (isErrorObject(responseError)) {
 		try {
@@ -3210,6 +3280,9 @@ function getResponseError(errorData, errorValue) {
 			if (codecImportFailed) {
 				responseError.codecImportFailed = true;
 			}
+			if (cause && !isErrorObject(responseError.cause)) {
+				responseError.cause = Object.assign(new Error(cause.message), { name: cause.name });
+			}
 			if (errorValue) {
 				if (responseError.name !== name) {
 					responseError.name = name;
@@ -5381,8 +5454,8 @@ 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);
@@ -5532,6 +5605,7 @@ class ZipEntry {
 				({ writable } = writer);
 				const readable = toCompatibleReadable(reader.createReadable({ offset: dataOffset, size }));
 				const { outputSize: writtenSize } = await runWorker({ readable, writable }, workerOptions);
+				throwIfAborted(signal);
 				if (writtenSize != outputSize) {
 					throw Object.assign(new Error(ERR_INVALID_UNCOMPRESSED_SIZE), { outputSize: writtenSize });
 				}
@@ -6143,7 +6217,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;
@@ -6236,8 +6310,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);
 	}
@@ -6327,6 +6401,7 @@ var zipReader = /*#__PURE__*/Object.freeze({
 	ERR_AMBIGUOUS_ARCHIVE: ERR_AMBIGUOUS_ARCHIVE,
 	ERR_BAD_FORMAT: ERR_BAD_FORMAT,
 	ERR_CENTRAL_DIRECTORY_NOT_FOUND: ERR_CENTRAL_DIRECTORY_NOT_FOUND,
+	ERR_CODEC_OUT_OF_MEMORY: ERR_CODEC_OUT_OF_MEMORY,
 	ERR_ENCRYPTED: ERR_ENCRYPTED,
 	ERR_ENCRYPTED_CENTRAL_DIRECTORY: ERR_ENCRYPTED_CENTRAL_DIRECTORY,
 	ERR_ENTRY_DATA_OUT_OF_BOUNDS: ERR_ENTRY_DATA_OUT_OF_BOUNDS,
@@ -7153,9 +7228,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);
@@ -7674,6 +7751,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 			const result = await runWorker({ readable, writable }, workerOptions);
 			compressedSize = result.outputSize;
 			writer.size += compressedSize;
+			throwIfAborted(signal);
 			if (!passThroughCompression) {
 				uncompressedSize = result.inputSize;
 				if (!encrypted || zipCrypto) {
@@ -8853,7 +8931,7 @@ function formatSupported(StreamClass, format) {
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const VERSION = "2.16.0";
+const VERSION = "2.17.0";
 
 /*
  Copyright (c) 2025 Gildas Lormeau. All rights reserved.
@@ -9330,12 +9408,16 @@ 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";
 const FORMAT_DEFLATE64_RAW = "deflate64-raw";
 const FORMAT_GZIP = "gzip";
+const Z_MEM_ERROR = -4;
+const Z_MEM_ERROR_CODE = "Z_MEM_ERROR";
+const COMPRESSION_FORMATS = [FORMAT_DEFLATE, FORMAT_DEFLATE_RAW, FORMAT_GZIP];
+const DECOMPRESSION_FORMATS = [FORMAT_DEFLATE, FORMAT_DEFLATE_RAW, FORMAT_GZIP, FORMAT_DEFLATE64_RAW];
 
 let wasm$1, malloc, free, memory, initError;
 
@@ -9356,7 +9438,17 @@ function resetWasmExports$1() {
 	wasm$1 = malloc = free = memory = initError = null;
 }
 
+function setZlibCode(error, result) {
+	if (result === Z_MEM_ERROR) {
+		error.code = Z_MEM_ERROR_CODE;
+	}
+	return error;
+}
+
 function _make(isCompress, type, options = {}) {
+	if (!(isCompress ? COMPRESSION_FORMATS : DECOMPRESSION_FORMATS).includes(type)) {
+		throw new TypeError("Unsupported format: " + type);
+	}
 	if (!wasm$1) {
 		const error = new Error("WASM module not loaded");
 		error.cause = initError;
@@ -9365,137 +9457,200 @@ 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, streamEnded: false };
+	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 = setZlibCode(new Error("end error:" + result), 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 setZlibCode(new Error("allocation failed"), Z_MEM_ERROR);
+			}
+			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 setZlibCode(new Error("init failed:" + result), 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) {
+			if (state.streamEnded) {
+				throw new Error("trailing data after the end of the stream");
+			}
+			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 setZlibCode(new Error("allocation failed"), Z_MEM_ERROR);
 				}
 			}
-		},
-		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 setZlibCode(new Error("process error:" + signedCode), signedCode);
+			}
+			const prod = result & 0x00ffffff;
+			if (prod) {
+				enqueue(heap.slice(out, out + prod));
+			}
+			const consumed = last_consumed(state.streamHandle);
+			if (code === 1) {
+				state.streamEnded = true;
+			} else 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 setZlibCode(new Error("process error:" + signedCode), 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;
@@ -9531,10 +9686,10 @@ class DecompressionStreamZlib {
 CompressionStreamZlib.requiresModule = true;
 DecompressionStreamZlib.requiresModule = true;
 // Constructing these classes before the module is loaded throws, so capability probes cannot rely
-// on trying the constructor; the formats are declared instead, next to the branches implementing
-// them in _make().
-CompressionStreamZlib.supportedFormats = [FORMAT_DEFLATE, FORMAT_DEFLATE_RAW, FORMAT_GZIP];
-DecompressionStreamZlib.supportedFormats = [FORMAT_DEFLATE, FORMAT_DEFLATE_RAW, FORMAT_GZIP, FORMAT_DEFLATE64_RAW];
+// on trying the constructor; the formats are declared instead, the lists _make() checks a format
+// against before anything else.
+CompressionStreamZlib.supportedFormats = COMPRESSION_FORMATS;
+DecompressionStreamZlib.supportedFormats = DECOMPRESSION_FORMATS;
 
 /*
  Copyright (c) 2026 Gildas Lormeau. All rights reserved.
@@ -9781,4 +9936,4 @@ async function terminateWorkersAndModule() {
 
 configureExternalAssets();
 
-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_DATA_OUT_OF_BOUNDS, 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_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_VALUE, ERR_INVALID_READER, 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_RESERVED_COMPRESSION_METHOD, ERR_SPLIT_ZIP_FILE, 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_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, ZipReader, ZipReaderStream, ZipWriter, ZipWriterStream, configure, createBlobTempStream, createOPFSTempStream, createSyncAccessHandleTempStream, getMimeType, getRegisteredCodecs, getSupportedCompressionMethods, isZipFile, 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_CODEC_OUT_OF_MEMORY, ERR_DUPLICATED_NAME, ERR_ENCRYPTED, ERR_ENCRYPTED_CENTRAL_DIRECTORY, ERR_ENTRY_DATA_OUT_OF_BOUNDS, 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_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_VALUE, ERR_INVALID_READER, 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_RESERVED_COMPRESSION_METHOD, ERR_SPLIT_ZIP_FILE, 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_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, ZipReader, ZipReaderStream, ZipWriter, ZipWriterStream, configure, createBlobTempStream, createOPFSTempStream, createSyncAccessHandleTempStream, getMimeType, getRegisteredCodecs, getSupportedCompressionMethods, isZipFile, registerCodec, resetConfiguration, terminateWorkersAndModule as terminateWorkers, unregisterCodec };