@zip.js/zip.js 2.8.45 → 2.8.46

package/dist/zip-core.js

@@ -176,6 +176,7 @@
 		"baseURI",
 		"wasmURI",
 		"workerURI",
+		"createWorker",
 		"chunkSize",
 		"maxWorkers",
 		"terminateWorkerTimeout",
@@ -186,8 +187,8 @@
 		"transferStreams",
 		"CompressionStream",
 		"DecompressionStream",
-		"CompressionStreamZlib",
-		"DecompressionStreamZlib"
+		"CompressionStreamFallback",
+		"DecompressionStreamFallback"
 	];
 
 	const config = { ...DEFAULT_CONFIGURATION };
@@ -201,6 +202,7 @@
 	}
 
 	function configure(configuration) {
+		configuration = normalizeConfiguration(configuration);
 		for (const propertyName of CONFIGURABLE_PROPERTY_NAMES) {
 			const propertyValue = configuration[propertyName];
 			if (propertyValue !== UNDEFINED_VALUE) {
@@ -209,7 +211,23 @@
 		}
 	}
 
+	function normalizeConfiguration(configuration) {
+		const { CompressionStreamZlib, DecompressionStreamZlib } = configuration;
+		if (CompressionStreamZlib === UNDEFINED_VALUE && DecompressionStreamZlib === UNDEFINED_VALUE) {
+			return configuration;
+		}
+		const normalizedConfiguration = Object.assign({}, configuration);
+		if (normalizedConfiguration.CompressionStreamFallback === UNDEFINED_VALUE) {
+			normalizedConfiguration.CompressionStreamFallback = CompressionStreamZlib;
+		}
+		if (normalizedConfiguration.DecompressionStreamFallback === UNDEFINED_VALUE) {
+			normalizedConfiguration.DecompressionStreamFallback = DecompressionStreamZlib;
+		}
+		return normalizedConfiguration;
+	}
+
 	function setDefaultConfiguration(configuration) {
+		configuration = normalizeConfiguration(configuration);
 		for (const propertyName of CONFIGURABLE_PROPERTY_NAMES) {
 			const propertyValue = configuration[propertyName];
 			if (propertyValue !== UNDEFINED_VALUE) {
@@ -1936,7 +1954,7 @@
 
 	class DeflateStream extends TransformStream {
 
-		constructor(options, { chunkSize, CompressionStreamZlib, CompressionStream }) {
+		constructor(options, { chunkSize, CompressionStreamFallback, CompressionStream }) {
 			super({});
 			const { compressed, encrypted, useCompressionStream, zipCrypto, computeCrc32, level, deflate64, format, compressionMethod } = options;
 			const stream = this;
@@ -1958,7 +1976,7 @@
 					readable = pipeThrough(readable, gzipCrc32Stream);
 				} else {
 					try {
-						readable = pipeThroughCompressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamZlib);
+						readable = pipeThroughCompressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamFallback);
 					} catch (error) {
 						let gzipStream;
 						try {
@@ -2100,7 +2118,7 @@
 
 	class InflateStream extends TransformStream {
 
-		constructor(options, { chunkSize, DecompressionStreamZlib, DecompressionStream }) {
+		constructor(options, { chunkSize, DecompressionStreamFallback, DecompressionStream }) {
 			super({});
 			const { zipCrypto, encrypted, checkCrc32, crc32, compressed, useCompressionStream, deflate64, format, compressionMethod, rawBitFlag, outputSize } = options;
 			let crc32Stream, decryptionStream;
@@ -2119,7 +2137,7 @@
 					readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.DecompressionStream, format, { chunkSize, compressionMethod, rawBitFlag, uncompressedSize: outputSize }));
 				} else {
 					try {
-						readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamZlib);
+						readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamFallback);
 					} catch (error) {
 						if (deflate64 || outputSize === UNDEFINED_VALUE) {
 							throw error;
@@ -2198,17 +2216,17 @@
 		return new CodecStreamClass(format, options);
 	}
 
-	function pipeThroughCompressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamZlib) {
+	function pipeThroughCompressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamFallback) {
 		const Stream = useCompressionStream && CompressionStreamNative ?
 			CompressionStreamNative :
-			CompressionStreamZlib || CompressionStreamNative;
+			CompressionStreamFallback || CompressionStreamNative;
 		const format = options.deflate64 ? FORMAT_DEFLATE64_RAW : FORMAT_DEFLATE_RAW;
 		let codecStream;
 		try {
 			codecStream = new Stream(format, options);
 		} catch (error) {
-			if (useCompressionStream && CompressionStreamZlib && Stream != CompressionStreamZlib) {
-				codecStream = new CompressionStreamZlib(format, options);
+			if (useCompressionStream && CompressionStreamFallback && Stream != CompressionStreamFallback) {
+				codecStream = new CompressionStreamFallback(format, options);
 			} else {
 				throw error;
 			}
@@ -2471,7 +2489,7 @@
 	const MESSAGE_ERROR_EVENT_TYPE = "messageerror";
 	const ERR_WORKER_STARTUP_TIMEOUT = "Worker startup timeout";
 
-	let webWorkerSupported, webWorkerSource, webWorkerURI, webWorkerOptions;
+	let webWorkerSupported, webWorkerSource, webWorkerURI, webWorkerOptions, createWorkerFailed;
 	let transferStreamsSupported = true;
 	try {
 		transferStreamsSupported = typeof structuredClone == FUNCTION_TYPE && structuredClone(new DOMException("", "AbortError")).code !== UNDEFINED_VALUE;
@@ -2481,14 +2499,14 @@
 	let initModule = () => { };
 
 	async function supportsDeflate(config) {
-		const { CompressionStream: NativeStream, CompressionStreamZlib: ZlibStream } = config;
-		if (ZlibStream && !ZlibStream.requiresModule) {
+		const { CompressionStream: NativeStream, CompressionStreamFallback: FallbackStream } = config;
+		if (FallbackStream && !FallbackStream.requiresModule) {
 			return true;
 		}
 		if (supportsDeflateRaw(NativeStream) || supportsGzip(NativeStream)) {
 			return true;
 		}
-		if (ZlibStream) {
+		if (FallbackStream) {
 			try {
 				await initModule(config);
 				return true;
@@ -2501,12 +2519,16 @@
 
 	function resetWebWorkerSupport() {
 		webWorkerSupported = UNDEFINED_VALUE;
+		createWorkerFailed = false;
 	}
 
 	class CodecWorker {
 
-		constructor(workerData, { readable, writable }, { options, config, streamOptions, useWebWorkers, transferStreams, workerURI }, onTaskFinished) {
+		constructor(workerData, { readable, writable }, { options, config, streamOptions, useWebWorkers, transferStreams, workerURI, createWorker }, onTaskFinished) {
 			const { signal } = streamOptions;
+			if (createWorkerFailed) {
+				createWorker = UNDEFINED_VALUE;
+			}
 			Object.assign(workerData, {
 				busy: true,
 				generation: (workerData.generation || 0) + 1,
@@ -2516,6 +2538,7 @@
 				writable,
 				options: Object.assign({}, options),
 				workerURI,
+				createWorker,
 				transferStreams,
 				terminate() {
 					return new Promise(resolve => {
@@ -2551,7 +2574,7 @@
 				// deno-lint-ignore valid-typeof
 				webWorkerSupported = typeof Worker != UNDEFINED_TYPE;
 			}
-			return (useWebWorkers && webWorkerSupported ? createWebWorkerInterface : createWorkerInterface)(workerData, config);
+			return (useWebWorkers && ((webWorkerSupported && workerURI) || createWorker) ? createWebWorkerInterface : createWorkerInterface)(workerData, config);
 		}
 	}
 
@@ -2608,7 +2631,11 @@
 			try {
 				worker = getWebWorker(workerData.workerURI, baseURI, workerData);
 			} catch {
-				webWorkerSupported = false;
+				if (workerData.createWorker) {
+					createWorkerFailed = true;
+				} else {
+					webWorkerSupported = false;
+				}
 				return createWorkerInterface(workerData, config);
 			}
 			Object.assign(workerData, {
@@ -2621,7 +2648,11 @@
 							return await runWebWorker(workerData, { chunkSize, wasmURI, baseURI, workerStartupTimeout });
 						} catch (error) {
 							if (error && error.workerStartupFailed) {
-								webWorkerSupported = false;
+								if (workerData.createWorker) {
+									createWorkerFailed = true;
+								} else {
+									webWorkerSupported = false;
+								}
 								const { reader } = workerData;
 								if (reader) {
 									reader.releaseLock();
@@ -2644,17 +2675,17 @@
 		try {
 			if (options.compressed && !options.format) {
 				const deflate = options.codecType.startsWith(CODEC_DEFLATE);
-				const ZlibStream = deflate ? config.CompressionStreamZlib : config.DecompressionStreamZlib;
+				const FallbackStream = deflate ? config.CompressionStreamFallback : config.DecompressionStreamFallback;
 				const NativeStream = deflate ? config.CompressionStream : config.DecompressionStream;
 				if (!options.useCompressionStream) {
 					try {
 						await initModule(config);
 					} catch {
-						if (!ZlibStream || ZlibStream.requiresModule) {
+						if (!FallbackStream || FallbackStream.requiresModule) {
 							options.useCompressionStream = true;
 						}
 					}
-				} else if (ZlibStream && ZlibStream.requiresModule && !supportsDeflateRaw(NativeStream)) {
+				} else if (FallbackStream && FallbackStream.requiresModule && !supportsDeflateRaw(NativeStream)) {
 					try {
 						await initModule(config);
 					} catch {
@@ -2779,8 +2810,11 @@
 	}
 
 	function getWebWorker(url, baseURI, workerData, isModuleType, useBlobURI = true) {
+		const { createWorker } = workerData;
 		let worker, resolvedURI, resolvedOptions;
-		if (webWorkerURI === UNDEFINED_VALUE || webWorkerSource !== url) {
+		if (createWorker) {
+			worker = createWorker();
+		} else if (webWorkerURI === UNDEFINED_VALUE || webWorkerSource !== url) {
 			// deno-lint-ignore valid-typeof
 			const isFunctionURI = typeof url == FUNCTION_TYPE;
 			if (isFunctionURI) {
@@ -3035,7 +3069,7 @@
 	async function runWorker(stream, workerOptions) {
 		const { options, config } = workerOptions;
 		const { transferStreams, useWebWorkers, useCompressionStream, compressed, checkCrc32, computeCrc32, encrypted, format, codecURI } = options;
-		const { workerURI, maxWorkers } = config;
+		const { workerURI, createWorker, maxWorkers } = config;
 		if (format) {
 			if (codecURI) {
 				options.codecURI = resolveCodecURI(codecURI, config.baseURI);
@@ -3047,6 +3081,7 @@
 		const workerSupported = format === UNDEFINED_VALUE || Boolean(options.codecURI);
 		workerOptions.useWebWorkers = !streamCopy && workerSupported && (useWebWorkers || (useWebWorkers === UNDEFINED_VALUE && config.useWebWorkers));
 		workerOptions.workerURI = workerOptions.useWebWorkers && workerURI ? workerURI : UNDEFINED_VALUE;
+		workerOptions.createWorker = workerOptions.useWebWorkers && createWorker ? createWorker : UNDEFINED_VALUE;
 		options.useCompressionStream = useCompressionStream || (useCompressionStream === UNDEFINED_VALUE && config.useCompressionStream);
 		return (await getWorker()).run();
 
@@ -3110,7 +3145,7 @@
 		starvationTimeout = null;
 		if (pendingRequests.length) {
 			const [{ resolve, stream, workerOptions }] = pendingRequests.splice(0, 1);
-			const inlineWorkerOptions = Object.assign({}, workerOptions, { useWebWorkers: false, workerURI: UNDEFINED_VALUE });
+			const inlineWorkerOptions = Object.assign({}, workerOptions, { useWebWorkers: false, workerURI: UNDEFINED_VALUE, createWorker: UNDEFINED_VALUE });
 			resolve(new CodecWorker({}, stream, inlineWorkerOptions, onInlineTaskFinished));
 			armStarvationTimeout();
 		}