@zip.js/zip.js 2.8.49 → 2.8.50

package/lib/core/codec-worker.js

@@ -7,8 +7,8 @@
  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 
+ 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
@@ -26,41 +26,24 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global Worker, URL, TransformStream, AbortController, structuredClone, DOMException, setTimeout, clearTimeout */
+/* global Worker, TransformStream */
 
 import {
 	UNDEFINED_VALUE,
-	UNDEFINED_TYPE,
-	FUNCTION_TYPE
+	UNDEFINED_TYPE
 } from "./constants.js";
 import { getChunkSize } from "./configuration.js";
-import { toExactUint8Array } from "./util/array.js";
 import {
 	CODEC_DEFLATE,
 	CodecStream,
 	ChunkStream,
 	supportsDeflateRaw,
-	supportsGzip,
-	MESSAGE_EVENT_TYPE,
-	MESSAGE_START,
-	MESSAGE_PULL,
-	MESSAGE_DATA,
-	MESSAGE_ACK_DATA,
-	MESSAGE_CLOSE
+	supportsGzip
 } from "./streams/codec-stream.js";
 
-const MODULE_WORKER_OPTIONS = { type: "module" };
-const ERROR_EVENT_TYPE = "error";
-const MESSAGE_ERROR_EVENT_TYPE = "messageerror";
 const ERR_WORKER_STARTUP_TIMEOUT = "Worker startup timeout";
 
-let webWorkerSupported, webWorkerSource, webWorkerURI, webWorkerOptions, createWorkerFailed;
-let transferStreamsSupported = true;
-try {
-	transferStreamsSupported = typeof structuredClone == FUNCTION_TYPE && structuredClone(new DOMException("", "AbortError")).code !== UNDEFINED_VALUE;
-} catch {
-	// ignored
-}
+let webWorkerSupported, createWorkerFailed, webWorkerBackend;
 let initModule = () => { };
 
 export {
@@ -68,6 +51,10 @@ export {
 	configureWorker,
 	resetWebWorkerSupport,
 	supportsDeflate,
+	setWebWorkerBackend,
+	disableWebWorker,
+	createWorkerInterface,
+	runWorker,
 	ERR_WORKER_STARTUP_TIMEOUT
 };
 
@@ -75,6 +62,10 @@ function configureWorker({ initModule: initModuleFunction }) {
 	initModule = initModuleFunction;
 }
 
+function setWebWorkerBackend(backend) {
+	webWorkerBackend = backend;
+}
+
 async function supportsDeflate(config) {
 	const { CompressionStream: NativeStream, CompressionStreamFallback: FallbackStream } = config;
 	if (FallbackStream && !FallbackStream.requiresModule) {
@@ -99,6 +90,14 @@ function resetWebWorkerSupport() {
 	createWorkerFailed = false;
 }
 
+function disableWebWorker(workerData) {
+	if (workerData.createWorker) {
+		createWorkerFailed = true;
+	} else {
+		webWorkerSupported = false;
+	}
+}
+
 class CodecWorker {
 
 	constructor(workerData, { readable, writable }, { options, config, streamOptions, useWebWorkers, transferStreams, workerURI, createWorker }, onTaskFinished) {
@@ -151,7 +150,7 @@ class CodecWorker {
 			// deno-lint-ignore valid-typeof
 			webWorkerSupported = typeof Worker != UNDEFINED_TYPE;
 		}
-		return (useWebWorkers && ((webWorkerSupported && workerURI) || createWorker) ? createWebWorkerInterface : createWorkerInterface)(workerData, config);
+		return (useWebWorkers && webWorkerBackend && ((webWorkerSupported && workerURI) || createWorker) ? webWorkerBackend : createWorkerInterface)(workerData, config);
 	}
 }
 
@@ -195,60 +194,6 @@ function createWorkerInterface(workerData, config) {
 	};
 }
 
-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 {
-			if (workerData.createWorker) {
-				createWorkerFailed = true;
-			} else {
-				webWorkerSupported = false;
-			}
-			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) {
-							if (workerData.createWorker) {
-								createWorkerFailed = true;
-							} else {
-								webWorkerSupported = false;
-							}
-							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 runWorker({ options, readable, writable, onTaskFinished }, config) {
 	let codecStream;
 	try {
@@ -296,329 +241,3 @@ async function runWorker({ options, readable, writable, onTaskFinished }, config
 		onTaskFinished();
 	}
 }
-
-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();
-		}
-	}
-}

package/lib/core/constants.js

@@ -108,6 +108,8 @@ const INFINITY_VALUE = Infinity;
 const UNDEFINED_TYPE = "undefined";
 const FUNCTION_TYPE = "function";
 const OBJECT_TYPE = "object";
+const STRING_TYPE = "string";
+const NUMBER_TYPE = "number";
 
 const EMPTY_UINT8_ARRAY = new Uint8Array();
 
@@ -185,5 +187,7 @@ export {
 	INFINITY_VALUE,
 	UNDEFINED_TYPE,
 	FUNCTION_TYPE,
-	OBJECT_TYPE
+	OBJECT_TYPE,
+	STRING_TYPE,
+	NUMBER_TYPE
 };

package/lib/core/io.js

@@ -32,6 +32,7 @@
 import {
 	UNDEFINED_VALUE,
 	FUNCTION_TYPE,
+	UNDEFINED_TYPE,
 	END_OF_CENTRAL_DIR_LENGTH,
 	EMPTY_UINT8_ARRAY
 } from "./constants.js";
@@ -399,7 +400,7 @@ async function initHttpReader(httpReader, sendRequest, getRequestData) {
 		forceRangeRequests,
 		combineSizeEocd
 	} = httpReader;
-	if (isHttpFamily(url) && (useRangeHeader || forceRangeRequests) && (typeof preventHeadRequest == "undefined" || preventHeadRequest)) {
+	if (isHttpFamily(url) && (useRangeHeader || forceRangeRequests) && (typeof preventHeadRequest == UNDEFINED_TYPE || preventHeadRequest)) {
 		const response = await sendRequest(HTTP_METHOD_GET, httpReader, getRangeHeaders(httpReader, combineSizeEocd ? -END_OF_CENTRAL_DIR_LENGTH : undefined));
 		const acceptRanges = response.headers.get(HTTP_HEADER_ACCEPT_RANGES);
 		if (!forceRangeRequests && (!acceptRanges || acceptRanges.toLowerCase() != HTTP_RANGE_UNIT)) {

package/lib/core/options.js

@@ -63,9 +63,13 @@ const OPTION_USDZ = "usdz";
 const OPTION_UNIX_EXTRA_FIELD_TYPE = "unixExtraFieldType";
 const OPTION_LOCAL_EXTRA_FIELD = "localExtraField";
 const OPTION_STRICTNESS = "strictness";
+const OPTION_FILENAME_VALIDATION = "filenameValidation";
+const OPTION_NORMALIZE_FILENAME = "normalizeFilename";
 const OPTION_MAX_APPENDED_DATA_SIZE = "maxAppendedDataSize";
 const OPTION_DECRYPT_CENTRAL_DIRECTORY = "decryptCentralDirectory";
 const OPTION_SIGN_CENTRAL_DIRECTORY = "signCentralDirectory";
+const TEXT_TYPE_FILENAME = "filename";
+const TEXT_TYPE_COMMENT = "comment";
 const STRICTNESS_STRICT = "strict";
 const STRICTNESS_BALANCED = "balanced";
 const STRICTNESS_TOLERANT = "tolerant";
@@ -108,9 +112,13 @@ export {
 	OPTION_UNIX_EXTRA_FIELD_TYPE,
 	OPTION_LOCAL_EXTRA_FIELD,
 	OPTION_STRICTNESS,
+	OPTION_FILENAME_VALIDATION,
+	OPTION_NORMALIZE_FILENAME,
 	OPTION_MAX_APPENDED_DATA_SIZE,
 	OPTION_DECRYPT_CENTRAL_DIRECTORY,
 	OPTION_SIGN_CENTRAL_DIRECTORY,
+	TEXT_TYPE_FILENAME,
+	TEXT_TYPE_COMMENT,
 	STRICTNESS_STRICT,
 	STRICTNESS_BALANCED,
 	STRICTNESS_TOLERANT