@zip.js/zip.js 2.7.32 → 2.7.33

package/lib/core/codec-pool.js

@@ -84,10 +84,18 @@ async function runWorker(stream, workerOptions) {
 		} else if (workerData.worker) {
 			clearTerminateTimeout(workerData);
 			if (Number.isFinite(terminateWorkerTimeout) && terminateWorkerTimeout >= 0) {
-				workerData.terminateTimeout = setTimeout(() => {
-					pool = pool.filter(data => data != workerData);
-					workerData.terminate();
-				}, terminateWorkerTimeout);
+				if (workerData.terminated) {
+					workerData.terminated = false;
+				} else {
+					workerData.terminateTimeout = setTimeout(async () => {
+						pool = pool.filter(data => data != workerData);
+						try {
+							await workerData.terminate();
+						} catch (_error) {
+							// ignored
+						}
+					}, terminateWorkerTimeout);
+				}
 			}
 		} else {
 			pool = pool.filter(data => data != workerData);
@@ -103,9 +111,9 @@ function clearTerminateTimeout(workerData) {
 	}
 }
 
-function terminateWorkers() {
-	pool.forEach(workerData => {
+async function terminateWorkers() {
+	await Promise.allSettled(pool.map(workerData => {
 		clearTerminateTimeout(workerData);
-		workerData.terminate();
-	});
+		return workerData.terminate();
+	}));
 }

package/lib/core/codec-worker.js

@@ -34,6 +34,7 @@ import {
 } from "./constants.js";
 import {
 	CodecStream,
+	ChunkStream,
 	MESSAGE_EVENT_TYPE,
 	MESSAGE_START,
 	MESSAGE_PULL,
@@ -43,7 +44,7 @@ import {
 } from "./streams/codec-stream.js";
 
 // deno-lint-ignore valid-typeof
-const WEB_WORKERS_SUPPORTED = typeof Worker != UNDEFINED_TYPE;
+let WEB_WORKERS_SUPPORTED = typeof Worker != UNDEFINED_TYPE;
 
 export {
 	CodecWorker
@@ -55,19 +56,37 @@ class CodecWorker {
 		const { signal } = streamOptions;
 		Object.assign(workerData, {
 			busy: true,
-			readable: readable.pipeThrough(new ProgressWatcherStream(readable, streamOptions, config), { signal }),
+			readable: readable
+				.pipeThrough(new ChunkStream(config.chunkSize))
+				.pipeThrough(new ProgressWatcherStream(readable, streamOptions), { signal }),
 			writable,
 			options: Object.assign({}, options),
 			scripts,
 			transferStreams,
 			terminate() {
-				const { worker, busy } = workerData;
-				if (worker && !busy) {
-					worker.terminate();
-					workerData.interface = null;
-				}
+				return new Promise(resolve => {
+					const { worker, busy } = workerData;
+					if (worker) {
+						if (busy) {
+							workerData.resolveTerminated = resolve;
+						} else {
+							worker.terminate();
+							resolve();
+						}
+						workerData.interface = null;
+					} else {
+						resolve();
+					}
+				});
 			},
 			onTaskFinished() {
+				const { resolveTerminated } = workerData;
+				if (resolveTerminated) {
+					workerData.resolveTerminated = null;
+					workerData.terminated = true;
+					workerData.worker.terminate();
+					resolveTerminated();
+				}
 				workerData.busy = false;
 				onTaskFinished(workerData);
 			}
@@ -78,7 +97,7 @@ class CodecWorker {
 
 class ProgressWatcherStream extends TransformStream {
 
-	constructor(readableSource, { onstart, onprogress, size, onend }, { chunkSize }) {
+	constructor(readableSource, { onstart, onprogress, size, onend }) {
 		let chunkOffset = 0;
 		super({
 			start() {
@@ -99,7 +118,7 @@ class ProgressWatcherStream extends TransformStream {
 					callHandler(onend, chunkOffset);
 				}
 			}
-		}, { highWaterMark: 1, size: () => chunkSize });
+		});
 	}
 }
 
@@ -117,10 +136,18 @@ function createWorkerInterface(workerData, config) {
 	};
 }
 
-function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
+function createWebWorkerInterface(workerData, config) {
+	const { baseURL, chunkSize } = config;
 	if (!workerData.interface) {
+		let worker;
+		try {
+			worker = getWebWorker(workerData.scripts[0], baseURL, workerData);
+		} catch (error) {
+			WEB_WORKERS_SUPPORTED = false;
+			return createWorkerInterface(workerData, config);
+		}
 		Object.assign(workerData, {
-			worker: getWebWorker(workerData.scripts[0], baseURL, workerData),
+			worker,
 			interface: {
 				run: () => runWebWorker(workerData, { chunkSize })
 			}
@@ -130,16 +157,18 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 }
 
 async function runWorker({ options, readable, writable, onTaskFinished }, config) {
-	const codecStream = new CodecStream(options, config);
 	try {
+		const codecStream = new CodecStream(options, config);
 		await readable.pipeThrough(codecStream).pipeTo(writable, { preventClose: true, preventAbort: true });
 		const {
 			signature,
-			size
+			inputSize,
+			outputSize
 		} = codecStream;
 		return {
 			signature,
-			size
+			inputSize,
+			outputSize
 		};
 	} finally {
 		onTaskFinished();
@@ -186,19 +215,20 @@ async function runWebWorker(workerData, config) {
 }
 
 function watchClosedStream(writableSource) {
-	const writer = writableSource.getWriter();
 	let resolveStreamClosed;
 	const closed = new Promise(resolve => resolveStreamClosed = resolve);
 	const writable = new WritableStream({
 		async write(chunk) {
+			const writer = writableSource.getWriter();
 			await writer.ready;
 			await writer.write(chunk);
+			writer.releaseLock();
 		},
 		close() {
-			writer.releaseLock();
 			resolveStreamClosed();
 		},
 		abort(reason) {
+			const writer = writableSource.getWriter();
 			return writer.abort(reason);
 		}
 	});
@@ -302,6 +332,7 @@ async function onMessage({ data }, workerData) {
 			}
 		}
 	} catch (error) {
+		sendMessage({ type: MESSAGE_CLOSE, messageId }, workerData);
 		close(error);
 	}
 

package/lib/core/streams/codec-stream.js

@@ -65,7 +65,8 @@ export {
 	ERR_INVALID_PASSWORD,
 	ERR_INVALID_SIGNATURE,
 	ERR_ABORT_CHECK_PASSWORD,
-	CodecStream
+	CodecStream,
+	ChunkStream
 };
 
 class CodecStream extends TransformStream {
@@ -80,13 +81,27 @@ class CodecStream extends TransformStream {
 		} else if (codecType.startsWith(CODEC_INFLATE)) {
 			Stream = InflateStream;
 		}
-		let size = 0;
+		let outputSize = 0;
+		let inputSize = 0;
 		const stream = new Stream(options, config);
 		const readable = super.readable;
-		const transformStream = new TransformStream({
+		const inputSizeStream = new TransformStream({
 			transform(chunk, controller) {
 				if (chunk && chunk.length) {
-					size += chunk.length;
+					inputSize += chunk.length;
+					controller.enqueue(chunk);
+				}
+			},
+			flush() {
+				Object.assign(codec, {
+					inputSize
+				});
+			}
+		});
+		const outputSizeStream = new TransformStream({
+			transform(chunk, controller) {
+				if (chunk && chunk.length) {
+					outputSize += chunk.length;
 					controller.enqueue(chunk);
 				}
 			},
@@ -94,14 +109,46 @@ class CodecStream extends TransformStream {
 				const { signature } = stream;
 				Object.assign(codec, {
 					signature,
-					size
+					outputSize,
+					inputSize
 				});
 			}
 		});
 		Object.defineProperty(codec, "readable", {
 			get() {
-				return readable.pipeThrough(stream).pipeThrough(transformStream);
+				return readable.pipeThrough(inputSizeStream).pipeThrough(stream).pipeThrough(outputSizeStream);
 			}
 		});
 	}
+}
+
+class ChunkStream extends TransformStream {
+
+	constructor(chunkSize) {
+		let pendingChunk;
+		super({
+			transform,
+			flush(controller) {
+				if (pendingChunk && pendingChunk.length) {
+					controller.enqueue(pendingChunk);
+				}
+			}
+		});
+
+		function transform(chunk, controller) {
+			if (pendingChunk) {
+				const newChunk = new Uint8Array(pendingChunk.length + chunk.length);
+				newChunk.set(pendingChunk);
+				newChunk.set(chunk, pendingChunk.length);
+				chunk = newChunk;
+				pendingChunk = null;
+			}
+			if (chunk.length > chunkSize) {
+				controller.enqueue(chunk.slice(0, chunkSize));
+				transform(chunk.slice(chunkSize), controller);
+			} else {
+				pendingChunk = chunk;
+			}
+		}
+	}
 }

package/lib/core/streams/zip-entry-stream.js

@@ -148,9 +148,13 @@ function pipeThroughCommpressionStream(readable, useCompressionStream, options,
 		readable = pipeThrough(readable, new CompressionStream(COMPRESSION_FORMAT, options));
 	} catch (error) {
 		if (useCompressionStream) {
-			readable = pipeThrough(readable, new CodecStream(COMPRESSION_FORMAT, options));
+			try {
+				readable = pipeThrough(readable, new CodecStream(COMPRESSION_FORMAT, options));
+			} catch (error) {
+				return readable;
+			}
 		} else {
-			throw error;
+			return readable;
 		}
 	}
 	return readable;

package/lib/core/z-worker-core.js

@@ -26,12 +26,13 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global self, importScripts, addEventListener, postMessage, ReadableStream, WritableStream */
+/* global self, importScripts, addEventListener, postMessage, ReadableStream, WritableStream, AbortController */
 
 import { UNDEFINED_VALUE } from "./constants.js";
 import { StreamAdapter } from "./streams/stream-adapter.js";
 import {
 	CodecStream,
+	ChunkStream,
 	MESSAGE_EVENT_TYPE,
 	MESSAGE_START,
 	MESSAGE_PULL,
@@ -43,7 +44,7 @@ import {
 const pendingPullMessages = new Map();
 const pendingDataMessages = new Map();
 
-let messageId = 0;
+let abortController, messageId = 0, importScriptSupported = true;
 
 addEventListener(MESSAGE_EVENT_TYPE, ({ data }) => {
 	const { type, messageId, value, done } = data;
@@ -61,6 +62,9 @@ addEventListener(MESSAGE_EVENT_TYPE, ({ data }) => {
 			pendingDataMessages.delete(messageId);
 			resolve();
 		}
+		if (type == MESSAGE_CLOSE) {
+			abortController.abort();
+		}
 	} catch (error) {
 		sendErrorMessage(error);
 	}
@@ -70,7 +74,16 @@ async function init(message) {
 	try {
 		const { options, scripts, config } = message;
 		if (scripts && scripts.length) {
-			importScripts.apply(UNDEFINED_VALUE, scripts);
+			try {
+				if (importScriptSupported) {
+					importScripts.apply(UNDEFINED_VALUE, scripts);
+				} else {
+					await imporModuleScripts(scripts);
+				}
+			} catch (error) {
+				importScriptSupported = false;
+				await imporModuleScripts(scripts);
+			}
 		}
 		if (self.initCodec) {
 			self.initCodec();
@@ -83,7 +96,7 @@ async function init(message) {
 		if (self.Inflate) {
 			config.DecompressionStream = new StreamAdapter(self.Inflate);
 		}
-		const strategy = { highWaterMark: 1, size: () => config.chunkSize };
+		const strategy = { highWaterMark: 1 };
 		const readable = message.readable || new ReadableStream({
 			async pull(controller) {
 				const result = new Promise(resolve => pendingPullMessages.set(messageId, resolve));
@@ -107,7 +120,12 @@ async function init(message) {
 			}
 		}, strategy);
 		const codecStream = new CodecStream(options, config);
-		await readable.pipeThrough(codecStream).pipeTo(writable, { preventClose: true, preventAbort: true });
+		abortController = new AbortController();
+		const { signal } = abortController;
+		await readable
+			.pipeThrough(codecStream)
+			.pipeThrough(new ChunkStream(config.chunkSize))
+			.pipeTo(writable, { signal, preventClose: true, preventAbort: true });
 		try {
 			await writable.getWriter().close();
 		} catch (_error) {
@@ -115,13 +133,15 @@ async function init(message) {
 		}
 		const {
 			signature,
-			size
+			inputSize,
+			outputSize
 		} = codecStream;
 		sendMessage({
 			type: MESSAGE_CLOSE,
 			result: {
 				signature,
-				size
+				inputSize,
+				outputSize
 			}
 		});
 	} catch (error) {
@@ -129,6 +149,12 @@ async function init(message) {
 	}
 }
 
+async function imporModuleScripts(scripts) {
+	for (const script of scripts) {
+		await import(script);
+	}
+}
+
 function sendMessage(message) {
 	let { value } = message;
 	if (value) {

package/lib/core/zip-writer.js

@@ -164,7 +164,7 @@ class ZipWriter {
 		const { pendingAddFileCalls, writer } = this;
 		const { writable } = writer;
 		while (pendingAddFileCalls.size) {
-			await Promise.all(Array.from(pendingAddFileCalls));
+			await Promise.allSettled(Array.from(pendingAddFileCalls));
 		}
 		await closeFile(this, comment, options);
 		const preventClose = getOptionValue(zipWriter, options, "preventClose");
@@ -420,7 +420,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		} else if (fileEntry.offset >= MAX_32_BITS) {
 			throw new Error(ERR_UNSUPPORTED_FORMAT);
 		}
-		zipWriter.offset += fileEntry.length;
+		zipWriter.offset += fileEntry.size;
 		return fileEntry;
 	} catch (error) {
 		if ((bufferedWrite && writingBufferedEntryData) || (!bufferedWrite && writingEntryData)) {
@@ -571,10 +571,10 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 			streamOptions: { signal, size, onstart, onprogress, onend }
 		};
 		const result = await runWorker({ readable, writable }, workerOptions);
-		writable.size += result.size;
+		uncompressedSize = result.inputSize;
+		compressedSize = result.outputSize;
 		signature = result.signature;
-		uncompressedSize = reader.size = readable.size;
-		compressedSize = result.size;
+		writable.size += uncompressedSize;
 	} else {
 		await writeData(writable, localHeaderArray);
 	}
@@ -616,7 +616,7 @@ async function createFileEntry(reader, writer, { diskNumberStart, lock }, entryI
 		creationDate,
 		lastAccessDate,
 		encrypted,
-		length: metadataSize + compressedSize,
+		size: metadataSize + compressedSize,
 		compressionMethod,
 		version,
 		headerArray,
@@ -1088,10 +1088,13 @@ async function closeFile(zipWriter, comment, options) {
 
 async function writeData(writable, array) {
 	const streamWriter = writable.getWriter();
-	await streamWriter.ready;
-	writable.size += getLength(array);
-	await streamWriter.write(array);
-	streamWriter.releaseLock();
+	try {
+		await streamWriter.ready;
+		writable.size += getLength(array);
+		await streamWriter.write(array);
+	} finally {
+		streamWriter.releaseLock();
+	}
 }
 
 function getTimeNTFS(date) {