@zip.js/zip.js 2.8.49 → 2.8.50

package/lib/core/codec-registry.js

@@ -32,14 +32,14 @@ import {
 	COMPRESSION_METHOD_DEFLATE,
 	COMPRESSION_METHOD_DEFLATE_64,
 	COMPRESSION_METHOD_AES,
-	FUNCTION_TYPE
+	FUNCTION_TYPE,
+	STRING_TYPE
 } from "./constants.js";
 
 const ERR_INVALID_CODEC_DEFINITION = "Invalid codec definition";
 const ERR_RESERVED_COMPRESSION_METHOD = "Reserved compression method";
 const ERR_INVALID_CODEC_MODULE = "Invalid codec module";
 
-const STRING_TYPE = "string";
 const RESERVED_COMPRESSION_METHODS = [
 	COMPRESSION_METHOD_STORE,
 	COMPRESSION_METHOD_DEFLATE,

package/lib/core/codec-worker-web.js

@@ -0,0 +1,436 @@
+/*
+ Copyright (c) 2025 Gildas Lormeau. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+ INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* global Worker, URL, TransformStream, AbortController, structuredClone, DOMException, setTimeout, clearTimeout */
+
+import {
+	UNDEFINED_VALUE,
+	FUNCTION_TYPE
+} from "./constants.js";
+import { toExactUint8Array } from "./util/array.js";
+import {
+	MESSAGE_EVENT_TYPE,
+	MESSAGE_START,
+	MESSAGE_PULL,
+	MESSAGE_DATA,
+	MESSAGE_ACK_DATA,
+	MESSAGE_CLOSE
+} from "./streams/codec-stream.js";
+import {
+	setWebWorkerBackend,
+	disableWebWorker,
+	createWorkerInterface,
+	runWorker,
+	ERR_WORKER_STARTUP_TIMEOUT
+} from "./codec-worker.js";
+
+const MODULE_WORKER_OPTIONS = { type: "module" };
+const ERROR_EVENT_TYPE = "error";
+const MESSAGE_ERROR_EVENT_TYPE = "messageerror";
+
+let webWorkerSource, webWorkerURI, webWorkerOptions;
+let transferStreamsSupported = true;
+try {
+	transferStreamsSupported = typeof structuredClone == FUNCTION_TYPE && structuredClone(new DOMException("", "AbortError")).code !== UNDEFINED_VALUE;
+} catch {
+	// ignored
+}
+
+setWebWorkerBackend(createWebWorkerInterface);
+
+function createWebWorkerInterface(workerData, config) {
+	const { baseURI, chunkSize, workerStartupTimeout } = config;
+	let { wasmURI } = config;
+
+	if (!workerData.interface) {
+		// deno-lint-ignore valid-typeof
+		if (typeof wasmURI == FUNCTION_TYPE) {
+			wasmURI = wasmURI();
+		}
+		let worker;
+		try {
+			worker = getWebWorker(workerData.workerURI, baseURI, workerData);
+		} catch {
+			disableWebWorker(workerData);
+			return createWorkerInterface(workerData, config);
+		}
+		Object.assign(workerData, {
+			worker,
+			workerAlive: false,
+			terminated: false,
+			interface: {
+				run: async () => {
+					try {
+						return await runWebWorker(workerData, { chunkSize, wasmURI, baseURI, workerStartupTimeout });
+					} catch (error) {
+						if (error && error.workerStartupFailed) {
+							disableWebWorker(workerData);
+							releaseWorkerStreams(workerData);
+							return runWorker(workerData, config);
+						}
+						if (error && error.codecImportFailed) {
+							if (workerData.reader) {
+								releaseWorkerStreams(workerData);
+								return runWorker(workerData, config);
+							}
+							workerData.onTaskFinished();
+						}
+						throw error;
+					}
+				}
+			}
+		});
+	}
+	return workerData.interface;
+}
+
+async function runWebWorker(workerData, config) {
+	let resolveResult, rejectResult;
+	const result = new Promise((resolve, reject) => {
+		resolveResult = resolve;
+		rejectResult = reject;
+	});
+	Object.assign(workerData, {
+		reader: null,
+		writer: null,
+		resolveResult,
+		rejectResult,
+		result
+	});
+	const { readable, options } = workerData;
+	const { writable, closed, abortPipe } = watchClosedStream(workerData.writable);
+	let streamsTransferred;
+	try {
+		streamsTransferred = sendMessage({
+			type: MESSAGE_START,
+			options,
+			config,
+			readable,
+			writable
+		}, workerData);
+	} catch (error) {
+		abortPipe();
+		try {
+			await closed;
+		} catch {
+			// ignored
+		}
+		workerData.onTaskFinished();
+		throw error;
+	}
+	if (!streamsTransferred) {
+		Object.assign(workerData, {
+			reader: readable.getReader(),
+			writer: writable.getWriter()
+		});
+	}
+	const { workerStartupTimeout } = config;
+	if (!workerData.workerAlive && Number.isFinite(workerStartupTimeout) && workerStartupTimeout >= 0) {
+		workerData.startupTimeout = setTimeout(() => onStartupTimeout(workerData), workerStartupTimeout);
+	}
+	try {
+		const resultValue = await result;
+		await closeWritable();
+		await closed;
+		return resultValue;
+	} catch (error) {
+		await closeWritable();
+		abortPipe();
+		try {
+			await closed;
+		} catch {
+			// ignored
+		}
+		throw error;
+	}
+
+	async function closeWritable() {
+		if (!streamsTransferred && !writable.locked) {
+			try {
+				await writable.getWriter().close();
+			} catch {
+				// ignored
+			}
+		}
+	}
+}
+
+function watchClosedStream(writableSource) {
+	const abortController = new AbortController();
+	const { writable, readable } = new TransformStream();
+	const closed = readable.pipeTo(writableSource, { preventClose: true, preventAbort: true, signal: abortController.signal });
+	closed.catch(() => { });
+	return { writable, closed, abortPipe: () => abortController.abort() };
+}
+
+function releaseWorkerStreams(workerData) {
+	const { reader } = workerData;
+	if (reader) {
+		reader.releaseLock();
+	}
+	workerData.reader = null;
+	workerData.writer = null;
+}
+
+function terminateWorker(workerData) {
+	const { worker } = workerData;
+	if (worker) {
+		try {
+			worker.terminate();
+		} catch {
+			// ignored
+		}
+	}
+	workerData.interface = null;
+}
+
+function getWebWorker(url, baseURI, workerData, isModuleType, useBlobURI = true) {
+	const { createWorker } = workerData;
+	let worker, resolvedURI, resolvedOptions;
+	if (createWorker) {
+		worker = createWorker();
+	} else if (webWorkerURI === UNDEFINED_VALUE || webWorkerSource !== url) {
+		// deno-lint-ignore valid-typeof
+		const isFunctionURI = typeof url == FUNCTION_TYPE;
+		if (isFunctionURI) {
+			resolvedURI = url(useBlobURI);
+		} else {
+			resolvedURI = url;
+		}
+		const isDataURI = resolvedURI.startsWith("data:");
+		const isBlobURI = resolvedURI.startsWith("blob:");
+		if (isDataURI || isBlobURI) {
+			if (isModuleType === UNDEFINED_VALUE) {
+				isModuleType = false;
+			}
+			if (isModuleType) {
+				resolvedOptions = MODULE_WORKER_OPTIONS;
+			}
+			try {
+				worker = new Worker(resolvedURI, resolvedOptions);
+			} catch (error) {
+				if (isBlobURI) {
+					try {
+						URL.revokeObjectURL(resolvedURI);
+					} catch {
+						// ignored
+					}
+				}
+				if (isFunctionURI && isBlobURI) {
+					return getWebWorker(url, baseURI, workerData, isModuleType, false);
+				} else if (!isModuleType) {
+					return getWebWorker(url, baseURI, workerData, true, false);
+				} else {
+					throw error;
+				}
+			}
+		} else {
+			if (isModuleType === UNDEFINED_VALUE) {
+				isModuleType = true;
+			}
+			if (isModuleType) {
+				resolvedOptions = MODULE_WORKER_OPTIONS;
+			}
+			try {
+				resolvedURI = new URL(resolvedURI, baseURI);
+			} catch {
+				// ignored
+			}
+			try {
+				worker = new Worker(resolvedURI, resolvedOptions);
+			} catch (error) {
+				if (isModuleType) {
+					return getWebWorker(url, baseURI, workerData, false, useBlobURI);
+				} else {
+					throw error;
+				}
+			}
+		}
+		webWorkerSource = url;
+		webWorkerURI = resolvedURI;
+		webWorkerOptions = resolvedOptions;
+	} else {
+		worker = new Worker(webWorkerURI, webWorkerOptions);
+	}
+	worker.addEventListener(MESSAGE_EVENT_TYPE, event => {
+		workerData.workerAlive = true;
+		clearStartupTimeout(workerData);
+		onMessage(event, workerData);
+	});
+	worker.addEventListener(ERROR_EVENT_TYPE, event => onWorkerError(event, workerData));
+	worker.addEventListener(MESSAGE_ERROR_EVENT_TYPE, event => onWorkerError(event, workerData));
+	return worker;
+}
+
+function onStartupTimeout(workerData) {
+	workerData.startupTimeout = null;
+	if (workerData.workerAlive) {
+		return;
+	}
+	const { rejectResult, writer } = workerData;
+	terminateWorker(workerData);
+	workerData.worker = null;
+	if (rejectResult) {
+		const error = new Error(ERR_WORKER_STARTUP_TIMEOUT);
+		error.workerStartupFailed = true;
+		rejectResult(error);
+		if (writer) {
+			writer.releaseLock();
+		}
+	}
+}
+
+function clearStartupTimeout(workerData) {
+	const { startupTimeout } = workerData;
+	if (startupTimeout) {
+		clearTimeout(startupTimeout);
+		workerData.startupTimeout = null;
+	}
+}
+
+function onWorkerError(event, workerData) {
+	if (event.preventDefault) {
+		event.preventDefault();
+	}
+	clearStartupTimeout(workerData);
+	const { workerAlive, rejectResult, writer, onTaskFinished } = workerData;
+	terminateWorker(workerData);
+	if (!workerAlive) {
+		workerData.worker = null;
+	}
+	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();
+		}
+		if (workerAlive) {
+			onTaskFinished();
+		}
+	}
+}
+
+function sendMessage(message, { worker, writer, transferStreams, workerAlive }) {
+	try {
+		const { value, readable, writable } = message;
+		const transferables = [];
+		if (value) {
+			message.value = toExactUint8Array(value);
+			transferables.push(message.value.buffer);
+		}
+		if (transferStreams && transferStreamsSupported && workerAlive) {
+			if (readable) {
+				transferables.push(readable);
+			}
+			if (writable) {
+				transferables.push(writable);
+			}
+		} else {
+			message.readable = message.writable = null;
+		}
+		if (transferables.length) {
+			try {
+				worker.postMessage(message, transferables);
+				return true;
+			} catch {
+				transferStreamsSupported = false;
+				message.readable = message.writable = null;
+				worker.postMessage(message);
+			}
+		} else {
+			worker.postMessage(message);
+		}
+	} catch (error) {
+		if (writer) {
+			writer.releaseLock();
+		}
+		throw error;
+	}
+}
+
+async function onMessage({ data }, workerData) {
+	const { type, value, messageId, result, error } = data;
+	const { reader, writer, resolveResult, rejectResult, onTaskFinished, generation } = workerData;
+	const stale = () => workerData.generation != generation;
+	try {
+		if (error) {
+			const { message, stack, code, name, outputSize, cause, codecImportFailed } = error;
+			const responseError = new Error(message);
+			Object.assign(responseError, { stack, code, name, outputSize });
+			if (cause) {
+				responseError.cause = Object.assign(new Error(cause.message), { name: cause.name });
+			}
+			if (codecImportFailed) {
+				responseError.codecImportFailed = true;
+			}
+			close(responseError);
+		} else {
+			if (type == MESSAGE_PULL) {
+				const { value, done } = await reader.read();
+				if (!stale()) {
+					sendMessage({ type: MESSAGE_DATA, value, done, messageId }, workerData);
+				}
+			}
+			if (type == MESSAGE_DATA) {
+				await writer.ready;
+				await writer.write(new Uint8Array(value));
+				if (!stale()) {
+					sendMessage({ type: MESSAGE_ACK_DATA, messageId }, workerData);
+				}
+			}
+			if (type == MESSAGE_CLOSE) {
+				close(null, result);
+			}
+		}
+	} catch (error) {
+		if (!stale()) {
+			terminateWorker(workerData);
+			close(error);
+		}
+	}
+
+	function close(error, result) {
+		if (stale()) {
+			return;
+		}
+		if (error) {
+			rejectResult(error);
+		} else {
+			resolveResult(result);
+		}
+		if (writer) {
+			writer.releaseLock();
+		}
+		if (!(error && error.codecImportFailed)) {
+			onTaskFinished();
+		}
+	}
+}