@zip.js/zip.js 2.8.45 → 2.8.46

package/dist/zip-fs-core-external.js

@@ -167,6 +167,7 @@ const CONFIGURABLE_PROPERTY_NAMES = [
 	"baseURI",
 	"wasmURI",
 	"workerURI",
+	"createWorker",
 	"chunkSize",
 	"maxWorkers",
 	"terminateWorkerTimeout",
@@ -177,8 +178,8 @@ const CONFIGURABLE_PROPERTY_NAMES = [
 	"transferStreams",
 	"CompressionStream",
 	"DecompressionStream",
-	"CompressionStreamZlib",
-	"DecompressionStreamZlib"
+	"CompressionStreamFallback",
+	"DecompressionStreamFallback"
 ];
 
 const config = { ...DEFAULT_CONFIGURATION };
@@ -192,6 +193,7 @@ function getChunkSize(config) {
 }
 
 function configure(configuration) {
+	configuration = normalizeConfiguration(configuration);
 	for (const propertyName of CONFIGURABLE_PROPERTY_NAMES) {
 		const propertyValue = configuration[propertyName];
 		if (propertyValue !== UNDEFINED_VALUE) {
@@ -200,7 +202,23 @@ function configure(configuration) {
 	}
 }
 
+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) {
@@ -1963,7 +1981,7 @@ const GZIP_OUTPUT_STALL_TIMEOUT = 5000;
 
 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;
@@ -1985,7 +2003,7 @@ class DeflateStream extends TransformStream {
 				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 {
@@ -2127,7 +2145,7 @@ function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize) {
 
 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;
@@ -2146,7 +2164,7 @@ class InflateStream extends TransformStream {
 				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;
@@ -2225,17 +2243,17 @@ function createCodecStream(CodecStreamClass, format, options) {
 	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;
 		}
@@ -2498,7 +2516,7 @@ const ERROR_EVENT_TYPE = "error";
 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;
@@ -2512,14 +2530,14 @@ function configureWorker({ initModule: initModuleFunction }) {
 }
 
 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$1(config);
 			return true;
@@ -2532,12 +2550,16 @@ async function supportsDeflate(config) {
 
 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,
@@ -2547,6 +2569,7 @@ class CodecWorker {
 			writable,
 			options: Object.assign({}, options),
 			workerURI,
+			createWorker,
 			transferStreams,
 			terminate() {
 				return new Promise(resolve => {
@@ -2582,7 +2605,7 @@ class CodecWorker {
 			// 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);
 	}
 }
 
@@ -2639,7 +2662,11 @@ function createWebWorkerInterface(workerData, config) {
 		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, {
@@ -2652,7 +2679,11 @@ function createWebWorkerInterface(workerData, config) {
 						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();
@@ -2675,17 +2706,17 @@ async function runWorker$1({ options, readable, writable, onTaskFinished }, conf
 	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$1(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$1(config);
 				} catch {
@@ -2810,8 +2841,11 @@ function terminateWorker$1(workerData) {
 }
 
 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) {
@@ -3066,7 +3100,7 @@ let indexWorker = 0;
 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);
@@ -3078,6 +3112,7 @@ async function runWorker(stream, workerOptions) {
 	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();
 
@@ -3141,7 +3176,7 @@ function onWorkerStarvation() {
 	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();
 	}
@@ -8278,8 +8313,8 @@ configureWorker({
 	}
 });
 setDefaultConfiguration({
-	CompressionStreamZlib,
-	DecompressionStreamZlib
+	CompressionStreamFallback: CompressionStreamZlib,
+	DecompressionStreamFallback: DecompressionStreamZlib
 });
 
 function terminateWorkersAndModule() {