@zip.js/zip.js 2.12.0 → 2.13.1

package/deno.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zip-js/zip-js",
-	"version": "2.12.0",
+	"version": "2.13.1",
 	"exports": {
 		".": "./index.js",
 		"./external": "./lib/zip-fs-external.js",

package/dist/zip-core-external.js

@@ -516,6 +516,39 @@ function getDataView(array) {
 	return new DataView(array.buffer, array.byteOffset, array.byteLength);
 }
 
+/*
+ Copyright (c) 2026 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.
+ */
+
+
+function isErrorObject(error) {
+	return Boolean(error) && typeof error == "object";
+}
+
 /*
  Copyright (c) 2022 Gildas Lormeau. All rights reserved.
 
@@ -2787,7 +2820,9 @@ function disableWebWorker(workerData) {
 
 class CodecWorker {
 
-	constructor(workerData, { readable, writable }, { options, config, streamOptions, useWebWorkers, transferStreams, workerURI, createWorker }, onTaskFinished) {
+	constructor(workerData, { readable, writable }, workerOptions, onTaskFinished) {
+		const { options, config, streamOptions, useWebWorkers, transferStreams, workerURI } = workerOptions;
+		let { createWorker } = workerOptions;
 		const { signal } = streamOptions;
 		if (createWorkerFailed) {
 			createWorker = UNDEFINED_VALUE;
@@ -2800,6 +2835,7 @@ class CodecWorker {
 				.pipeThrough(new ProgressWatcherStream(streamOptions), { signal }),
 			writable,
 			options: Object.assign({}, options),
+			workerOptions,
 			workerURI,
 			createWorker,
 			transferStreams,
@@ -2881,7 +2917,7 @@ function createWorkerInterface(workerData, config) {
 	};
 }
 
-async function runWorker$1({ options, readable, writable, onTaskFinished }, config) {
+async function runWorker$1({ options, readable, writable, onTaskFinished, workerOptions }, config) {
 	let codecStream, chunkStream;
 	try {
 		if (options.compressed && !options.format) {
@@ -2922,7 +2958,15 @@ async function runWorker$1({ options, readable, writable, onTaskFinished }, conf
 		};
 	} catch (error) {
 		if (codecStream) {
-			error.outputSize = chunkStream ? chunkStream.outputSize : 0;
+			const outputSize = chunkStream ? chunkStream.outputSize : 0;
+			workerOptions.outputSize = outputSize;
+			if (isErrorObject(error)) {
+				try {
+					error.outputSize = outputSize;
+				} catch {
+					// ignored
+				}
+			}
 		}
 		throw error;
 	} finally {
@@ -3032,8 +3076,14 @@ async function runWebWorker(workerData, config) {
 	const result = new Promise((resolve, reject) => {
 		resolveResult = resolve;
 		rejectResult = error => {
-			if (error && error.outputSize === UNDEFINED_VALUE) {
-				error.outputSize = workerData.outputSize;
+			const { outputSize, workerOptions } = workerData;
+			workerOptions.outputSize = outputSize;
+			if (isErrorObject(error)) {
+				try {
+					error.outputSize = outputSize;
+				} catch {
+					// ignored
+				}
 			}
 			reject(error);
 		};
@@ -3042,12 +3092,14 @@ async function runWebWorker(workerData, config) {
 		reader: null,
 		writer: null,
 		outputSize: 0,
+		destinationFailed: false,
+		destinationError: null,
 		resolveResult,
 		rejectResult,
 		result
 	});
 	const { readable, options } = workerData;
-	const { writable, closed, abortPipe } = watchClosedStream(workerData.writable);
+	const { writable, closed, abortPipe } = watchClosedStream(workerData.writable, workerData);
 	let streamsTransferred;
 	try {
 		streamsTransferred = sendMessage({
@@ -3090,7 +3142,18 @@ async function runWebWorker(workerData, config) {
 		} catch {
 			// ignored
 		}
-		throw error;
+		const { outputSize, workerOptions, destinationFailed, destinationError } = workerData;
+		workerOptions.outputSize = outputSize;
+		const workerFailed = isErrorObject(error) && (error.codecImportFailed || error.workerStartupFailed);
+		const reportedError = destinationFailed && !workerFailed ? destinationError : error;
+		if (isErrorObject(reportedError)) {
+			try {
+				reportedError.outputSize = outputSize;
+			} catch {
+				// ignored
+			}
+		}
+		throw reportedError;
 	}
 
 	async function closeWritable() {
@@ -3104,12 +3167,27 @@ async function runWebWorker(workerData, config) {
 	}
 }
 
-function watchClosedStream(writableSource) {
+function watchClosedStream(writableSource, workerData) {
 	const abortController = new AbortController();
-	const { writable, readable } = new TransformStream();
+	let aborting;
+	const { writable, readable } = new TransformStream({
+		transform(chunk, controller) {
+			workerData.outputSize += chunk.length;
+			controller.enqueue(chunk);
+		}
+	});
 	const closed = readable.pipeTo(writableSource, { preventClose: true, preventAbort: true, signal: abortController.signal });
-	closed.catch(() => { });
-	return { writable, closed, abortPipe: () => abortController.abort() };
+	closed.catch(error => {
+		if (!aborting) {
+			Object.assign(workerData, { destinationFailed: true, destinationError: error });
+		}
+	});
+	return {
+		writable, closed, abortPipe: () => {
+			aborting = true;
+			abortController.abort();
+		}
+	};
 }
 
 function releaseWorkerStreams(workerData) {
@@ -3302,21 +3380,12 @@ function sendMessage(message, { worker, writer, transferStreams, workerAlive })
 }
 
 async function onMessage({ data }, workerData) {
-	const { type, value, messageId, result, error } = data;
+	const { type, value, messageId, result, error, errorValue } = 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);
+			fail(getResponseError(error, errorValue));
 		} else {
 			if (type == MESSAGE_PULL) {
 				const { value, done } = await reader.read();
@@ -3328,38 +3397,78 @@ async function onMessage({ data }, workerData) {
 				const chunk = new Uint8Array(value);
 				await writer.ready;
 				await writer.write(chunk);
-				workerData.outputSize += chunk.length;
 				if (!stale()) {
 					sendMessage({ type: MESSAGE_ACK_DATA, messageId }, workerData);
 				}
 			}
 			if (type == MESSAGE_CLOSE) {
-				close(null, result);
+				succeed(result);
 			}
 		}
 	} catch (error) {
 		if (!stale()) {
 			terminateWorker$1(workerData);
-			close(error);
+			fail(error);
 		}
 	}
 
-	function close(error, result) {
-		if (stale()) {
-			return;
-		}
-		if (error) {
+	function fail(error) {
+		if (!stale()) {
 			rejectResult(error);
-		} else {
+			releaseWriter();
+			if (!(isErrorObject(error) && error.codecImportFailed)) {
+				onTaskFinished();
+			}
+		}
+	}
+
+	function succeed(result) {
+		if (!stale()) {
 			resolveResult(result);
+			releaseWriter();
+			onTaskFinished();
 		}
+	}
+
+	function releaseWriter() {
 		if (writer) {
 			writer.releaseLock();
 		}
-		if (!(error && error.codecImportFailed)) {
-			onTaskFinished();
+	}
+}
+
+function getResponseError(errorData, errorValue) {
+	const { message, stack, code, name, outputSize, cause, codecImportFailed } = errorData;
+	let responseError;
+	if (errorValue) {
+		responseError = errorValue.value;
+	} else {
+		responseError = Object.assign(new Error(message), { stack, code, name });
+		if (cause) {
+			responseError.cause = Object.assign(new Error(cause.message), { name: cause.name });
+		}
+	}
+	if (isErrorObject(responseError)) {
+		try {
+			if (outputSize !== UNDEFINED_VALUE) {
+				responseError.outputSize = outputSize;
+			}
+			if (codecImportFailed) {
+				responseError.codecImportFailed = true;
+			}
+			if (errorValue) {
+				if (responseError.name !== name) {
+					responseError.name = name;
+				}
+				if (responseError.code !== code) {
+					responseError.code = code;
+				}
+			}
+		} catch {
+			// ignored
 		}
 	}
+	return responseError;
 }
 
 /*
@@ -5621,7 +5730,7 @@ class ZipEntry {
 				readRanges
 			});
 		}
-		let writable, abortError;
+		let writable, abortError, aborted;
 		try {
 			if (!checkOverlappingEntryOnly) {
 				if (checkPasswordOnly) {
@@ -5637,18 +5746,22 @@ class ZipEntry {
 				writer.size += writtenSize;
 			}
 		} catch (error) {
-			if (error.outputSize !== UNDEFINED_VALUE) {
+			const { outputSize: failedOutputSize } = workerOptions;
+			if (failedOutputSize !== UNDEFINED_VALUE) {
+				writer.size += failedOutputSize;
+			} else if (isErrorObject(error) && error.outputSize !== UNDEFINED_VALUE) {
 				writer.size += error.outputSize;
 			}
-			if (!checkPasswordOnly || error.message != ERR_ABORT_CHECK_PASSWORD) {
+			if (!checkPasswordOnly || !isErrorObject(error) || error.message != ERR_ABORT_CHECK_PASSWORD) {
 				abortError = error;
+				aborted = true;
 				throw error;
 			}
 		} finally {
 			const preventClose = !ownsWritable(writer) && getOptionValue$1(zipEntry, options, OPTION_PREVENT_CLOSE);
 			if (!preventClose && writable && !writable.locked) {
 				const writableWriter = writable.getWriter();
-				if (abortError) {
+				if (aborted) {
 					try {
 						await writableWriter.abort(abortError);
 					} catch {
@@ -6708,7 +6821,7 @@ class ZipWriter {
 			await Promise.allSettled(Array.from(pendingAddFileCalls));
 		}
 		await Promise.allSettled(zipWriter.pendingErrors.map(watcher => watcher.recorded));
-		const unobservedWatchers = zipWriter.pendingErrors.filter(watcher => watcher.error && !watcher.observed);
+		const unobservedWatchers = zipWriter.pendingErrors.filter(watcher => watcher.failed && !watcher.observed);
 		if (unobservedWatchers.length) {
 			const unobservedErrors = unobservedWatchers.map(watcher => watcher.error);
 			unobservedWatchers.forEach(watcher => watcher.observed = true);
@@ -6817,7 +6930,8 @@ function watchPromiseError(zipWriter, promise) {
 	const watchedPromise = new WatchedPromise((resolve, reject) => Promise.prototype.then.call(promise, resolve, reject));
 	const watcher = {};
 	watchedPromise.watcher = watcher;
-	watcher.recorded = Promise.prototype.then.call(watchedPromise, UNDEFINED_VALUE, error => watcher.error = error);
+	watcher.recorded = Promise.prototype.then.call(watchedPromise, UNDEFINED_VALUE,
+		error => Object.assign(watcher, { failed: true, error }));
 	zipWriter.pendingErrors.push(watcher);
 	return watchedPromise;
 }
@@ -7733,7 +7847,10 @@ async function createFileEntry(reader, writer, { diskNumberStart, lockFileEntry
 				throw new Error(ERR_UNSUPPORTED_FORMAT);
 			}
 		} catch (error) {
-			if (error.outputSize !== UNDEFINED_VALUE) {
+			const { outputSize: failedOutputSize } = workerOptions;
+			if (failedOutputSize !== UNDEFINED_VALUE) {
+				writer.size += failedOutputSize;
+			} else if (isErrorObject(error) && error.outputSize !== UNDEFINED_VALUE) {
 				writer.size += error.outputSize;
 			}
 			throw error;
@@ -8898,7 +9015,7 @@ function formatSupported(StreamClass, format) {
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const VERSION = "2.12.0";
+const VERSION = "2.13.1";
 
 /*
  Copyright (c) 2025 Gildas Lormeau. All rights reserved.