@zip.js/zip.js 2.12.0 → 2.13.1

package/dist/zip-core.js

@@ -489,6 +489,39 @@
 		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.
 
@@ -2756,7 +2789,9 @@
 
 	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;
@@ -2769,6 +2804,7 @@
 					.pipeThrough(new ProgressWatcherStream(streamOptions), { signal }),
 				writable,
 				options: Object.assign({}, options),
+				workerOptions,
 				workerURI,
 				createWorker,
 				transferStreams,
@@ -2850,7 +2886,7 @@
 		};
 	}
 
-	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) {
@@ -2891,7 +2927,15 @@
 			};
 		} 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 {
@@ -3001,8 +3045,14 @@
 		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);
 			};
@@ -3011,12 +3061,14 @@
 			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({
@@ -3059,7 +3111,18 @@
 			} 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() {
@@ -3073,12 +3136,27 @@
 		}
 	}
 
-	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) {
@@ -3271,21 +3349,12 @@
 	}
 
 	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();
@@ -3297,38 +3366,78 @@
 					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;
 	}
 
 	/*
@@ -5590,7 +5699,7 @@
 					readRanges
 				});
 			}
-			let writable, abortError;
+			let writable, abortError, aborted;
 			try {
 				if (!checkOverlappingEntryOnly) {
 					if (checkPasswordOnly) {
@@ -5606,18 +5715,22 @@
 					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 {
@@ -6677,7 +6790,7 @@
 				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);
@@ -6786,7 +6899,8 @@
 		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;
 	}
@@ -7702,7 +7816,10 @@
 					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;
@@ -8867,7 +8984,7 @@
 	 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.