@zip.js/zip.js 2.11.4 → 2.13.0

package/lib/core/codec-worker-web.js

@@ -33,6 +33,7 @@ import {
 	FUNCTION_TYPE
 } from "./constants.js";
 import { toExactUint8Array } from "./util/array.js";
+import { isErrorObject } from "./util/error.js";
 import {
 	MESSAGE_EVENT_TYPE,
 	MESSAGE_START,
@@ -121,11 +122,23 @@ async function runWebWorker(workerData, config) {
 	let resolveResult, rejectResult;
 	const result = new Promise((resolve, reject) => {
 		resolveResult = resolve;
-		rejectResult = reject;
+		rejectResult = error => {
+			const { outputSize, workerOptions } = workerData;
+			workerOptions.outputSize = outputSize;
+			if (isErrorObject(error) && error.outputSize === UNDEFINED_VALUE) {
+				try {
+					error.outputSize = outputSize;
+				} catch {
+					// ignored
+				}
+			}
+			reject(error);
+		};
 	});
 	Object.assign(workerData, {
 		reader: null,
 		writer: null,
+		outputSize: 0,
 		resolveResult,
 		rejectResult,
 		result
@@ -386,21 +399,15 @@ 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;
+			if (error.outputSize !== UNDEFINED_VALUE) {
+				workerData.outputSize = error.outputSize;
 			}
-			close(responseError);
+			fail(getResponseError(error, errorValue));
 		} else {
 			if (type == MESSAGE_PULL) {
 				const { value, done } = await reader.read();
@@ -409,37 +416,80 @@ async function onMessage({ data }, workerData) {
 				}
 			}
 			if (type == MESSAGE_DATA) {
+				const chunk = new Uint8Array(value);
 				await writer.ready;
-				await writer.write(new Uint8Array(value));
+				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(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;
 }

package/lib/core/codec-worker.js

@@ -33,6 +33,7 @@ import {
 	UNDEFINED_TYPE
 } from "./constants.js";
 import { getChunkSize } from "./configuration.js";
+import { isErrorObject } from "./util/error.js";
 import {
 	CODEC_DEFLATE,
 	CodecStream,
@@ -102,7 +103,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;
@@ -115,6 +118,7 @@ class CodecWorker {
 				.pipeThrough(new ProgressWatcherStream(streamOptions), { signal }),
 			writable,
 			options: Object.assign({}, options),
+			workerOptions,
 			workerURI,
 			createWorker,
 			transferStreams,
@@ -196,8 +200,8 @@ function createWorkerInterface(workerData, config) {
 	};
 }
 
-async function runWorker({ options, readable, writable, onTaskFinished }, config) {
-	let codecStream;
+async function runWorker({ options, readable, writable, onTaskFinished, workerOptions }, config) {
+	let codecStream, chunkStream;
 	try {
 		if (options.compressed && !options.format) {
 			const deflate = options.codecType.startsWith(CODEC_DEFLATE);
@@ -220,9 +224,10 @@ async function runWorker({ options, readable, writable, onTaskFinished }, config
 			}
 		}
 		codecStream = new CodecStream(options, config);
+		chunkStream = new ChunkStream(getChunkSize(config));
 		await readable
 			.pipeThrough(codecStream)
-			.pipeThrough(new ChunkStream(getChunkSize(config)))
+			.pipeThrough(chunkStream)
 			.pipeTo(writable, { preventClose: true, preventAbort: true });
 		const {
 			crc32,
@@ -236,7 +241,15 @@ async function runWorker({ options, readable, writable, onTaskFinished }, config
 		};
 	} catch (error) {
 		if (codecStream) {
-			error.outputSize = codecStream.outputSize;
+			const outputSize = chunkStream ? chunkStream.outputSize : 0;
+			workerOptions.outputSize = outputSize;
+			if (isErrorObject(error)) {
+				try {
+					error.outputSize = outputSize;
+				} catch {
+					// ignored
+				}
+			}
 		}
 		throw error;
 	} finally {

package/lib/core/configuration.js

@@ -30,7 +30,9 @@
 
 import {
 	UNDEFINED_VALUE,
-	UNDEFINED_TYPE
+	UNDEFINED_TYPE,
+	FUNCTION_TYPE,
+	STRING_TYPE
 } from "./constants.js";
 import {
 	checkFunctionOption,
@@ -41,6 +43,8 @@ const DEFAULT_CHUNK_SIZE = 64 * 1024;
 const MINIMUM_CHUNK_SIZE = 64;
 const MINIMUM_PROPERTY_VALUE = 1;
 const ERR_INVALID_MAX_WORKERS = "Invalid maxWorkers (must be an integer greater than 0)";
+const ERR_INVALID_BASE_URI = "Invalid baseURI (must be a string)";
+const ERR_INVALID_URI = "Invalid URI (must be a string or a function returning a string)";
 let maxWorkers = 2;
 try {
 	if (typeof navigator != UNDEFINED_TYPE && navigator.hardwareConcurrency) {
@@ -65,9 +69,9 @@ const DEFAULT_CONFIGURATION = {
 };
 
 const PROPERTY_NAME_MAX_WORKERS = "maxWorkers";
+const PROPERTY_NAME_BASE_URI = "baseURI";
 
-const STRING_PROPERTY_NAMES = [
-	"baseURI",
+const URI_PROPERTY_NAMES = [
 	"wasmURI",
 	"workerURI"
 ];
@@ -91,7 +95,8 @@ const FUNCTION_PROPERTY_NAMES = [
 	"DecompressionStreamFallback"
 ];
 const CONFIGURABLE_PROPERTY_NAMES = [
-	...STRING_PROPERTY_NAMES,
+	PROPERTY_NAME_BASE_URI,
+	...URI_PROPERTY_NAMES,
 	...BOOLEAN_PROPERTY_NAMES,
 	...NUMBER_PROPERTY_NAMES,
 	...FUNCTION_PROPERTY_NAMES
@@ -106,7 +111,9 @@ export {
 	getConfiguration,
 	getChunkSize,
 	normalizeChunkSize,
-	ERR_INVALID_MAX_WORKERS
+	ERR_INVALID_MAX_WORKERS,
+	ERR_INVALID_BASE_URI,
+	ERR_INVALID_URI
 };
 
 function getConfiguration() {
@@ -145,6 +152,14 @@ function checkPropertyValue(propertyName, propertyValue) {
 		}
 	} else if (FUNCTION_PROPERTY_NAMES.includes(propertyName)) {
 		checkFunctionOption(propertyValue);
+	} else if (propertyName == PROPERTY_NAME_BASE_URI) {
+		if (propertyValue && typeof propertyValue != STRING_TYPE) {
+			throw new Error(ERR_INVALID_BASE_URI);
+		}
+	} else if (URI_PROPERTY_NAMES.includes(propertyName)) {
+		if (propertyValue && typeof propertyValue != STRING_TYPE && typeof propertyValue != FUNCTION_TYPE) {
+			throw new Error(ERR_INVALID_URI);
+		}
 	}
 	return propertyValue;
 }

package/lib/core/constants.js

@@ -125,9 +125,11 @@ const NUMBER_TYPE = "number";
 const BOOLEAN_TYPE = "boolean";
 
 const EMPTY_UINT8_ARRAY = new Uint8Array();
+const SYMBOL_ASYNC_DISPOSE = Symbol.asyncDispose || Symbol();
 
 export {
 	EMPTY_UINT8_ARRAY,
+	SYMBOL_ASYNC_DISPOSE,
 	MAX_32_BITS,
 	MAX_16_BITS,
 	MAX_8_BITS,

package/lib/core/io.js

@@ -42,10 +42,13 @@ import { toCompatibleReadable, toCompatibleWritable, streamToBlob } from "./util
 import { decodeTextRemovingBOM } from "./util/decode-text.js";
 
 const ERR_HTTP_STATUS = "HTTP error ";
+const MIN_SUCCESS_HTTP_STATUS = 200;
+const MAX_SUCCESS_HTTP_STATUS = 299;
 const ERR_HTTP_RANGE = "HTTP Range not supported";
 const ERR_HTTP_RESOURCE_CHANGED = "HTTP resource changed";
 const ERR_ITERATOR_COMPLETED_TOO_SOON = "Writer iterator completed too soon";
 const ERR_WRITER_NOT_INITIALIZED = "Writer not initialized";
+const ERR_WRITER_SIZE_NOT_WRITABLE = "Invalid writer (size must be writable)";
 
 const CONTENT_TYPE_TEXT_PLAIN = "text/plain";
 const HTTP_HEADER_CONTENT_LENGTH = "Content-Length";
@@ -237,6 +240,7 @@ class BlobReader extends Reader {
 		const reader = this;
 		const { sourceBlob, size } = reader;
 		const { offset = 0, size: readSize = size - offset } = options || {};
+		// deno-lint-ignore valid-typeof
 		if (typeof sourceBlob.stream == FUNCTION_TYPE) {
 			if (!offset && readSize >= size) {
 				return toCompatibleReadable(sourceBlob.stream());
@@ -643,7 +647,7 @@ async function getContentLength(httpReader, sendRequest, getRequestData) {
 
 async function sendFetchRequest(method, { fetch: fetchFunction = fetch, options, url }, headers) {
 	const response = await fetchFunction(url, Object.assign({}, options, { method, headers }));
-	if (response.status < 400) {
+	if (response.status >= MIN_SUCCESS_HTTP_STATUS && response.status <= MAX_SUCCESS_HTTP_STATUS) {
 		return response;
 	} else {
 		throw response.status == 416 ? new Error(ERR_HTTP_RANGE) : new Error(ERR_HTTP_STATUS + (response.statusText || response.status));
@@ -654,7 +658,7 @@ function sendXMLHttpRequest(method, { url }, headers) {
 	return new Promise((resolve, reject) => {
 		const request = new XMLHttpRequest();
 		request.addEventListener("load", () => {
-			if (request.status < 400) {
+			if (request.status >= MIN_SUCCESS_HTTP_STATUS && request.status <= MAX_SUCCESS_HTTP_STATUS) {
 				const headers = [];
 				request.getAllResponseHeaders().trim().split(/[\r\n]+/).forEach(header => {
 					const splitHeader = header.trim().split(/\s*:\s*/);
@@ -958,8 +962,10 @@ class GenericWriter {
 				writable: toCompatibleWritable(writer)
 			};
 		}
-		if (writer.size === UNDEFINED_VALUE) {
-			writer.size = 0;
+		try {
+			writer.size = writer.size === UNDEFINED_VALUE ? 0 : writer.size;
+		} catch {
+			throw new Error(ERR_WRITER_SIZE_NOT_WRITABLE);
 		}
 		return writer;
 	}
@@ -1030,7 +1036,9 @@ export {
 	SplitDataReader,
 	SplitDataWriter,
 	ERR_HTTP_RANGE,
+	ERR_HTTP_STATUS,
 	ERR_HTTP_RESOURCE_CHANGED,
 	ERR_ITERATOR_COMPLETED_TOO_SOON,
-	ERR_WRITER_NOT_INITIALIZED
+	ERR_WRITER_NOT_INITIALIZED,
+	ERR_WRITER_SIZE_NOT_WRITABLE
 };

package/lib/core/options.js

@@ -49,6 +49,7 @@ const OPTION_CHECK_OVERLAPPING_ENTRY_ONLY = "checkOverlappingEntryOnly";
 const OPTION_CHECK_OVERLAPPING_ENTRY = "checkOverlappingEntry";
 const OPTION_CHECK_AMBIGUITY = "checkAmbiguity";
 const OPTION_CHECK_LOCAL_DIRECTORY = "checkLocalDirectory";
+const OPTION_CHECK_LOCAL_FILENAME = "checkLocalFilename";
 const OPTION_CHECK_SIGNATURE = "checkSignature";
 const OPTION_CHECK_CRC32 = "checkCrc32";
 const OPTION_CHECK_AUTHENTICATION_CODE = "checkAuthenticationCode";
@@ -79,15 +80,18 @@ const OPTION_NORMALIZE_FILENAME = "normalizeFilename";
 const OPTION_MAX_APPENDED_DATA_SIZE = "maxAppendedDataSize";
 const OPTION_DECRYPT_CENTRAL_DIRECTORY = "decryptCentralDirectory";
 const OPTION_SIGN_CENTRAL_DIRECTORY = "signCentralDirectory";
+const OPTION_ENTRY = "entry";
 const TEXT_TYPE_FILENAME = "filename";
 const TEXT_TYPE_COMMENT = "comment";
 const STRICTNESS_STRICT = "strict";
 const STRICTNESS_BALANCED = "balanced";
 const STRICTNESS_TOLERANT = "tolerant";
+const PASS_THROUGH_COMPRESSED = "compressed";
 
 const ERR_INVALID_FUNCTION_OPTION = "Invalid option (must be a function)";
 const ERR_INVALID_SIGNAL = "Invalid signal (must be an AbortSignal instance)";
 const ERR_INVALID_PASSWORD_TYPE = "Invalid password (password must be a string, rawPassword must be a Uint8Array)";
+const ERR_INVALID_PASS_THROUGH_VALUE = "Invalid passThrough option (must be a boolean or 'compressed')";
 const ERR_ABORTED = "The operation was aborted";
 const ABORT_ERROR_NAME = "AbortError";
 
@@ -106,6 +110,7 @@ export {
 	OPTION_CHECK_OVERLAPPING_ENTRY,
 	OPTION_CHECK_AMBIGUITY,
 	OPTION_CHECK_LOCAL_DIRECTORY,
+	OPTION_CHECK_LOCAL_FILENAME,
 	OPTION_CHECK_SIGNATURE,
 	OPTION_CHECK_CRC32,
 	OPTION_CHECK_AUTHENTICATION_CODE,
@@ -136,20 +141,24 @@ export {
 	OPTION_MAX_APPENDED_DATA_SIZE,
 	OPTION_DECRYPT_CENTRAL_DIRECTORY,
 	OPTION_SIGN_CENTRAL_DIRECTORY,
+	OPTION_ENTRY,
 	TEXT_TYPE_FILENAME,
 	TEXT_TYPE_COMMENT,
 	STRICTNESS_STRICT,
 	STRICTNESS_BALANCED,
 	STRICTNESS_TOLERANT,
+	PASS_THROUGH_COMPRESSED,
 	ERR_INVALID_FUNCTION_OPTION,
 	ERR_INVALID_SIGNAL,
 	ERR_INVALID_PASSWORD_TYPE,
+	ERR_INVALID_PASS_THROUGH_VALUE,
 	ERR_ABORTED,
 	ABORT_ERROR_NAME,
 	checkFunctionOption,
 	checkSignalOption,
 	throwIfAborted,
 	checkPasswordOption,
+	checkPassThroughOption,
 	checkInteger,
 	checkIntegerOption,
 	toNumber
@@ -181,6 +190,13 @@ function checkPasswordOption(password, rawPassword) {
 	}
 }
 
+function checkPassThroughOption(passThrough) {
+	if (passThrough !== UNDEFINED_VALUE && typeof passThrough != BOOLEAN_TYPE && passThrough !== PASS_THROUGH_COMPRESSED) {
+		throw new Error(ERR_INVALID_PASS_THROUGH_VALUE);
+	}
+	return passThrough;
+}
+
 function checkInteger(value, maxValue, errorMessage) {
 	if (!Number.isInteger(value) || value < 0 || value > maxValue) {
 		throw new Error(errorMessage);

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

@@ -145,6 +145,7 @@ class ChunkStream extends TransformStream {
 	constructor(chunkSize) {
 		const pendingChunks = [];
 		let pendingLength = 0;
+		let outputSize = 0;
 		if (!Number.isFinite(chunkSize) || chunkSize < 1) {
 			chunkSize = DEFAULT_CHUNK_SIZE;
 		}
@@ -153,15 +154,20 @@ class ChunkStream extends TransformStream {
 				pendingChunks.push(chunk);
 				pendingLength += chunk.length;
 				while (pendingLength > chunkSize) {
+					outputSize += chunkSize;
 					controller.enqueue(shiftChunk());
 				}
 			},
 			flush(controller) {
 				if (pendingLength) {
+					outputSize += pendingLength;
 					controller.enqueue(concatChunks(pendingChunks, pendingLength));
 				}
 			}
 		});
+		Object.defineProperty(this, "outputSize", {
+			get: () => outputSize
+		});
 
 		function shiftChunk() {
 			const result = new Uint8Array(chunkSize);

package/lib/core/util/error.js

@@ -0,0 +1,35 @@
+/*
+ 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.
+ */
+
+export {
+	isErrorObject
+};
+
+function isErrorObject(error) {
+	return Boolean(error) && typeof error == "object";
+}

package/lib/core/util/warnings.js

@@ -0,0 +1,42 @@
+/*
+ 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.
+ */
+
+
+import { UNDEFINED_VALUE } from "../constants.js";
+
+export { addWarning };
+
+function addWarning(warnings, reason, filename) {
+	if (!warnings.some(warning => warning.reason == reason)) {
+		const warning = { reason };
+		if (filename !== UNDEFINED_VALUE) {
+			warning.filename = filename;
+		}
+		warnings.push(warning);
+	}
+}

package/lib/core/version.js

@@ -26,6 +26,6 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const VERSION = "2.11.4";
+const VERSION = "2.13.0";
 
 export { VERSION };

package/lib/core/web-worker-base.js

@@ -28,7 +28,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global self, addEventListener, postMessage, ReadableStream, WritableStream, AbortController */
+/* global self, addEventListener, postMessage, ReadableStream, WritableStream, AbortController, structuredClone */
 
 import {
 	CODEC_DEFLATE,
@@ -46,10 +46,13 @@ import {
 import { getChunkSize } from "./configuration.js";
 import { toCompatibleReadable, toCompatibleWritable } from "./util/compatible-streams.js";
 import { toExactUint8Array } from "./util/array.js";
+import { isErrorObject } from "./util/error.js";
+import { UNDEFINED_VALUE } from "./constants.js";
 import { ensureCodecStreams } from "./codec-registry.js";
 
 const pendingPullMessages = new Map();
 const pendingDataMessages = new Map();
+const errorValueSerializable = testErrorValueSerializable();
 
 let abortController, messageId = 0;
 
@@ -99,14 +102,20 @@ addEventListener(MESSAGE_EVENT_TYPE, ({ data }) => {
 postMessage({ type: MESSAGE_READY });
 
 async function init(message) {
-	let codecStream, writable;
+	let codecStream, chunkStream, writable;
 	try {
 		const { options, config } = message;
 		if (options.format) {
 			try {
 				await ensureCodecStreams(options.format, options.codecURI);
 			} catch (error) {
-				error.codecImportFailed = true;
+				if (isErrorObject(error)) {
+					try {
+						error.codecImportFailed = true;
+					} catch {
+						// ignored
+					}
+				}
 				throw error;
 			}
 		}
@@ -162,11 +171,12 @@ async function init(message) {
 			}
 		}, strategy);
 		codecStream = new CodecStream(options, config);
+		chunkStream = new ChunkStream(getChunkSize(config));
 		abortController = new AbortController();
 		const { signal } = abortController;
 		await readable
 			.pipeThrough(codecStream)
-			.pipeThrough(new ChunkStream(getChunkSize(config)))
+			.pipeThrough(chunkStream)
 			.pipeTo(writable, { signal, preventClose: true, preventAbort: true });
 		await writable.getWriter().close();
 		const {
@@ -183,7 +193,14 @@ async function init(message) {
 			}
 		});
 	} catch (error) {
-		error.outputSize = codecStream ? codecStream.outputSize : 0;
+		const outputSize = chunkStream ? chunkStream.outputSize : 0;
+		if (isErrorObject(error)) {
+			try {
+				error.outputSize = outputSize;
+			} catch {
+				// ignored
+			}
+		}
 		if (writable && !writable.locked) {
 			try {
 				await writable.getWriter().close();
@@ -191,7 +208,7 @@ async function init(message) {
 				// ignored
 			}
 		}
-		sendErrorMessage(error);
+		sendErrorMessage(error, outputSize);
 	}
 }
 
@@ -213,14 +230,34 @@ function sendMessage(message) {
 	}
 }
 
-function sendErrorMessage(error = new Error("Unknown error")) {
-	const { message, stack, code, name, outputSize, cause, codecImportFailed } = error;
-	const errorData = { message, stack, code, name, outputSize };
+function sendErrorMessage(errorValue, writtenSize) {
+	const { message, stack, code, name, outputSize, cause, codecImportFailed } = getErrorObject(errorValue);
+	const errorData = { message, stack, code, name, outputSize: outputSize === UNDEFINED_VALUE ? writtenSize : outputSize };
 	if (cause) {
 		errorData.cause = { name: cause.name, message: cause.message };
 	}
 	if (codecImportFailed) {
 		errorData.codecImportFailed = true;
 	}
+	if (errorValueSerializable) {
+		try {
+			postMessage({ error: errorData, errorValue: { value: errorValue } });
+			return;
+		} catch {
+			// ignored
+		}
+	}
 	postMessage({ error: errorData });
 }
+
+function getErrorObject(error = new Error("Unknown error")) {
+	return isErrorObject(error) ? error : new Error(String(error));
+}
+
+function testErrorValueSerializable() {
+	try {
+		return structuredClone(new Error()) instanceof Error;
+	} catch {
+		return false;
+	}
+}