@zip.js/zip.js 2.5.12 → 2.5.15

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

@@ -44,9 +44,9 @@ export {
 	getWorker
 };
 
-function getWorker(workerData, codecConstructor, stream, workerOptions, onTaskFinished) {
+function getWorker(workerData, stream, workerOptions, onTaskFinished) {
 	const { readable, writable } = stream;
-	const { options, config, streamOptions, webWorker, scripts } = workerOptions;
+	const { options, config, streamOptions, webWorker, scripts, codecConstructor } = workerOptions;
 	Object.assign(workerData, {
 		busy: true,
 		codecConstructor,
@@ -82,7 +82,7 @@ function getWorker(workerData, codecConstructor, stream, workerOptions, onTaskFi
 		if (onend) {
 			transformer.flush = () => callHandler(onend);
 		}
-		workerData.readable = readable.pipeThrough(new TransformStream(transformer), { signal });
+		workerData.readable = readable.pipeThrough(new TransformStream(transformer, { highWaterMark: 1, size: () => config.chunkSize }), { signal });
 	}
 	return webWorker ? createWebWorkerInterface(workerData, config) : createWorkerInterface(workerData, config);
 }
@@ -97,14 +97,15 @@ async function callHandler(handler, ...parameters) {
 
 function createWorkerInterface(workerData, config) {
 	const interfaceCodec = createCodec(workerData.codecConstructor, workerData.readable, workerData.writable, workerData.options, config);
+	const { onTaskFinished } = workerData;
 	const codec = {
 		abort() {
 			interfaceCodec.abort();
-			workerData.onTaskFinished();
+			onTaskFinished();
 		},
-		run() {
-			const result = interfaceCodec.run();
-			workerData.onTaskFinished();
+		async run() {
+			const result = await interfaceCodec.run();
+			onTaskFinished();
 			return result;
 		}
 	};
@@ -113,11 +114,14 @@ function createWorkerInterface(workerData, config) {
 
 function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 	const workerOptions = { type: "module" };
-	workerData.reader = workerData.readable.getReader();
-	workerData.writer = workerData.writable.getWriter();
-	workerData.result = new Promise((resolve, reject) => {
-		workerData.resolveResult = resolve;
-		workerData.rejectResult = reject;
+	const { readable, writable } = workerData;
+	Object.assign(workerData, {
+		reader: readable.getReader(),
+		writer: writable.getWriter(),
+		result: new Promise((resolve, reject) => {
+			workerData.resolveResult = resolve;
+			workerData.rejectResult = reject;
+		})
 	});
 	if (!workerData.interface) {
 		if (!classicWorkersSupported) {
@@ -133,12 +137,13 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 		workerData.worker.addEventListener(MESSAGE_EVENT_TYPE, onMessage, false);
 		workerData.interface = {
 			abort() {
+				workerData.interface.aborted = true;
 				sendMessage({ type: MESSAGE_ABORT });
 				workerData.writer.releaseLock();
 				workerData.onTaskFinished();
 			},
 			run() {
-				const options = workerData.options;
+				const { options } = workerData;
 				const scripts = workerData.scripts.slice(1);
 				sendMessage({ type: MESSAGE_START, scripts, options, config: { chunkSize } });
 				return workerData.result;
@@ -162,12 +167,13 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 	}
 
 	function sendMessage(message) {
-		const worker = workerData.worker;
+		const { worker, writer, onTaskFinished } = workerData;
 		try {
 			let { data } = message;
 			if (data) {
 				try {
-					if (data.length != data.buffer.byteLength) {
+					const { buffer, length } = data;
+					if (length != buffer.byteLength) {
 						data = new Uint8Array(data);
 					}
 					message.data = data.buffer;
@@ -179,43 +185,48 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 				worker.postMessage(message);
 			}
 		} catch (error) {
-			workerData.writer.releaseLock();
-			workerData.onTaskFinished();
+			writer.releaseLock();
+			onTaskFinished();
 			throw error;
 		}
 	}
 
 	async function onMessage(event) {
 		const message = event.data;
+		const { reader, writer, resolveResult, rejectResult, onTaskFinished } = workerData;
+		const { type, data, messageId, result } = message;
 		const reponseError = message.error;
 		try {
 			if (reponseError) {
-				const error = new Error(reponseError.message);
-				error.stack = reponseError.stack;
-				workerData.rejectResult(error);
-				workerData.writer.releaseLock();
-				workerData.onTaskFinished();
+				const { message, stack } = reponseError;
+				const error = new Error(message);
+				error.stack = stack;
+				close(error);
 			} else {
-				if (message.type == MESSAGE_PULL) {
-					const { value, done } = await workerData.reader.read();
-					sendMessage({ type: MESSAGE_DATA, data: value, done, messageId: message.messageId });
+				if (type == MESSAGE_PULL) {
+					const { value, done } = await reader.read();
+					sendMessage({ type: MESSAGE_DATA, data: value, done, messageId });
 				}
-				if (message.type == MESSAGE_DATA) {
-					let { data } = message;
-					data = new Uint8Array(data);
-					await workerData.writer.ready;
-					await workerData.writer.write(data);
+				if (type == MESSAGE_DATA) {
+					await writer.ready;
+					await writer.write(new Uint8Array(data));
 				}
-				if (message.type == MESSAGE_CLOSE) {
-					workerData.resolveResult(message.result);
-					workerData.writer.releaseLock();
-					workerData.onTaskFinished();
+				if (type == MESSAGE_CLOSE) {
+					close(null, result);
 				}
 			}
 		} catch (error) {
-			workerData.rejectResult(error);
-			workerData.writer.releaseLock();
-			workerData.onTaskFinished();
+			close(error);
+		}
+
+		function close(error, result) {
+			if (error && !workerData.interface.aborted) {
+				rejectResult(error);
+			} else {
+				resolveResult(result);
+			}
+			writer.releaseLock();
+			onTaskFinished();
 		}
 	}
 }

package/lib/core/codec-pool.js

@@ -41,7 +41,7 @@ let pool = [];
 const pendingRequests = [];
 
 export {
-	runCodec,
+	runWorker,
 	terminateWorkers,
 	CODEC_DEFLATE,
 	CODEC_INFLATE,
@@ -52,26 +52,27 @@ export {
 
 let indexWorker = 0;
 
-async function runCodec(codecConstructor, stream, codecOptions) {
-	const { options, config, streamOptions } = codecOptions;
+async function runWorker(stream, workerOptions) {
+	const { options, config, streamOptions } = workerOptions;
 	const streamCopy = !options.compressed && !options.signed && !options.encrypted;
-	codecOptions.webWorker = !streamCopy && (options.useWebWorkers || (options.useWebWorkers === undefined && config.useWebWorkers));
-	codecOptions.scripts = codecOptions.webWorker && config.workerScripts ? config.workerScripts[options.codecType] : [];
-	options.useCompressionStream = options.useCompressionStream === undefined ? config.useCompressionStream : options.useCompressionStream;
+	const { useWebWorkers, useCompressionStream, codecType } = options;
+	const { workerScripts } = config;
+	workerOptions.webWorker = !streamCopy && (useWebWorkers || (useWebWorkers === undefined && config.useWebWorkers));
+	workerOptions.scripts = workerOptions.webWorker && workerScripts ? workerScripts[codecType] : [];
+	options.useCompressionStream = useCompressionStream === undefined ? config.useCompressionStream : useCompressionStream;
 	let codec;
-
 	if (pool.length < config.maxWorkers) {
 		const workerData = { indexWorker };
 		indexWorker++;
 		pool.push(workerData);
-		codec = getWorker(workerData, codecConstructor, stream, codecOptions, onTaskFinished);
+		codec = getWorker(workerData, stream, workerOptions, onTaskFinished);
 	} else {
 		const workerData = pool.find(workerData => !workerData.busy);
 		if (workerData) {
 			clearTerminateTimeout(workerData);
-			codec = getWorker(workerData, codecConstructor, stream, codecOptions, onTaskFinished);
+			codec = getWorker(workerData, stream, workerOptions, onTaskFinished);
 		} else {
-			codec = await new Promise(resolve => pendingRequests.push({ resolve, codecConstructor, stream, codecOptions }));
+			codec = await new Promise(resolve => pendingRequests.push({ resolve, stream, workerOptions }));
 		}
 	}
 	const { signal } = streamOptions;
@@ -88,15 +89,16 @@ async function runCodec(codecConstructor, stream, codecOptions) {
 
 	function onTaskFinished(workerData) {
 		if (pendingRequests.length) {
-			const [{ resolve, codecConstructor, stream, codecOptions }] = pendingRequests.splice(0, 1);
-			resolve(getWorker(workerData, codecConstructor, stream, codecOptions, onTaskFinished));
+			const [{ resolve, stream, workerOptions }] = pendingRequests.splice(0, 1);
+			resolve(getWorker(workerData, stream, workerOptions, onTaskFinished));
 		} else if (workerData.worker) {
+			const { terminateWorkerTimeout } = config;
 			clearTerminateTimeout(workerData);
-			if (Number.isFinite(config.terminateWorkerTimeout) && config.terminateWorkerTimeout >= 0) {
+			if (Number.isFinite(terminateWorkerTimeout) && terminateWorkerTimeout >= 0) {
 				workerData.terminateTimeout = setTimeout(() => {
 					pool = pool.filter(data => data != workerData);
 					workerData.terminate();
-				}, config.terminateWorkerTimeout);
+				}, terminateWorkerTimeout);
 			}
 		} else {
 			pool = pool.filter(data => data != workerData);
@@ -105,8 +107,9 @@ async function runCodec(codecConstructor, stream, codecOptions) {
 }
 
 function clearTerminateTimeout(workerData) {
-	if (workerData.terminateTimeout) {
-		clearTimeout(workerData.terminateTimeout);
+	const { terminateTimeout } = workerData;
+	if (terminateTimeout) {
+		clearTimeout(terminateTimeout);
 		workerData.terminateTimeout = null;
 	}
 }

package/lib/core/configuration.js

@@ -29,6 +29,7 @@
 /* global navigator */
 
 const MINIMUM_CHUNK_SIZE = 64;
+const UNDEFINED_TYPE = undefined;
 const DEFAULT_CONFIGURATION = {
 	chunkSize: 512 * 1024,
 	maxWorkers: (typeof navigator != "undefined" && navigator.hardwareConcurrency) || 2,
@@ -54,48 +55,59 @@ function getChunkSize(config) {
 }
 
 function configure(configuration) {
-	if (configuration.baseURL !== undefined) {
-		config.baseURL = configuration.baseURL;
+	const {
+		baseURL,
+		chunkSize,
+		maxWorkers,
+		terminateWorkerTimeout,
+		useCompressionStream,
+		useWebWorkers,
+		Deflate,
+		Inflate,
+		workerScripts
+	} = configuration;
+	if (baseURL !== UNDEFINED_TYPE) {
+		config.baseURL = baseURL;
 	}
-	if (configuration.chunkSize !== undefined) {
-		config.chunkSize = configuration.chunkSize;
+	if (chunkSize !== UNDEFINED_TYPE) {
+		config.chunkSize = chunkSize;
 	}
-	if (configuration.maxWorkers !== undefined) {
-		config.maxWorkers = configuration.maxWorkers;
+	if (maxWorkers !== UNDEFINED_TYPE) {
+		config.maxWorkers = maxWorkers;
 	}
-	if (configuration.terminateWorkerTimeout !== undefined) {
-		config.terminateWorkerTimeout = configuration.terminateWorkerTimeout;
+	if (terminateWorkerTimeout !== UNDEFINED_TYPE) {
+		config.terminateWorkerTimeout = terminateWorkerTimeout;
 	}
-	if (configuration.useCompressionStream !== undefined) {
-		config.useCompressionStream = configuration.useCompressionStream;
+	if (useCompressionStream !== UNDEFINED_TYPE) {
+		config.useCompressionStream = useCompressionStream;
 	}
-	if (configuration.useWebWorkers !== undefined) {
-		config.useWebWorkers = configuration.useWebWorkers;
+	if (useWebWorkers !== UNDEFINED_TYPE) {
+		config.useWebWorkers = useWebWorkers;
 	}
-	if (configuration.Deflate !== undefined) {
-		config.Deflate = configuration.Deflate;
+	if (Deflate !== UNDEFINED_TYPE) {
+		config.Deflate = Deflate;
 	}
-	if (configuration.Inflate !== undefined) {
-		config.Inflate = configuration.Inflate;
+	if (Inflate !== UNDEFINED_TYPE) {
+		config.Inflate = Inflate;
 	}
-	if (configuration.workerScripts !== undefined) {
-		if (configuration.workerScripts.deflate) {
-			if (!Array.isArray(configuration.workerScripts.deflate)) {
-				throw new Error("workerScripts.deflate must be an array");
-			}
+	if (workerScripts !== UNDEFINED_TYPE) {
+		const { deflate, inflate } = workerScripts;
+		if (deflate || inflate) {
 			if (!config.workerScripts) {
 				config.workerScripts = {};
 			}
-			config.workerScripts.deflate = configuration.workerScripts.deflate;
 		}
-		if (configuration.workerScripts.inflate) {
-			if (!Array.isArray(configuration.workerScripts.inflate)) {
-				throw new Error("workerScripts.inflate must be an array");
+		if (deflate) {
+			if (!Array.isArray(deflate)) {
+				throw new Error("workerScripts.deflate must be an array");
 			}
-			if (!config.workerScripts) {
-				config.workerScripts = {};
+			config.workerScripts.deflate = deflate;
+		}
+		if (inflate) {
+			if (!Array.isArray(inflate)) {
+				throw new Error("workerScripts.inflate must be an array");
 			}
-			config.workerScripts.inflate = configuration.workerScripts.inflate;
+			config.workerScripts.inflate = inflate;
 		}
 	}
 }

package/lib/core/io.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global Blob, FileReader, atob, btoa, XMLHttpRequest, document, fetch, ReadableStream, WritableStream, TransformStream */
+/* global Blob, atob, btoa, XMLHttpRequest, document, fetch, ReadableStream, WritableStream, TransformStream */
 
 const ERR_HTTP_STATUS = "HTTP error ";
 const ERR_HTTP_RANGE = "HTTP Range not supported";
@@ -127,16 +127,7 @@ class TextWriter extends Writer {
 
 	getData() {
 		const writer = this;
-		if (writer.blob.text) {
-			return writer.blob.text();
-		} else {
-			const reader = new FileReader();
-			return new Promise((resolve, reject) => {
-				reader.onload = event => resolve(event.target.result);
-				reader.onerror = () => reject(reader.error);
-				reader.readAsText(writer.blob, writer.encoding);
-			});
-		}
+		return writer.blob.text();
 	}
 }
 
@@ -210,16 +201,7 @@ class BlobReader extends Reader {
 
 	async readUint8Array(offset, length) {
 		const reader = this;
-		if (reader.blob.arrayBuffer) {
-			return new Uint8Array(await reader.blob.slice(offset, offset + length).arrayBuffer());
-		} else {
-			const reader = new FileReader();
-			return new Promise((resolve, reject) => {
-				reader.onload = event => resolve(new Uint8Array(event.target.result));
-				reader.onerror = () => reject(reader.error);
-				reader.readAsArrayBuffer(reader.blob.slice(offset, offset + length));
-			});
-		}
+		return new Uint8Array(await reader.blob.slice(offset, offset + length).arrayBuffer());
 	}
 }
 
@@ -267,9 +249,12 @@ function flushArrayBuffers(blobWriter) {
 
 class ReadableStreamReader {
 
-	constructor(readableStream) {
+	constructor(readable) {
 		const reader = this;
-		reader.readableStream = readableStream.pipeThrough(new TransformStream({
+		if (!readable) {
+			readable = new ReadableStream({});
+		}
+		reader.readable = readable.pipeThrough(new TransformStream({
 			transform(chunk, controller) {
 				if (chunk) {
 					reader.size += chunk.length;
@@ -285,14 +270,18 @@ class ReadableStreamReader {
 	}
 
 	getReadable() {
-		return this.readableStream;
+		return this.readable;
 	}
 }
 
 class WritableStreamWriter extends Writer {
 
-	constructor(writable) {
+	constructor(writable, { preventClose } = {}) {
 		super();
+		this.preventClose = preventClose;
+		if (!writable) {
+			writable = new WritableStream({});
+		}
 		Object.defineProperty(this, "writable", {
 			get() {
 				return writable;
@@ -300,16 +289,13 @@ class WritableStreamWriter extends Writer {
 		});
 	}
 
-	async writeUint8Array(array) {
-		await this.writer.ready;
-		const writer = this.writable.getWriter();
-		await writer.write(array);
-		writer.releaseLock();
-	}
-
 	async getData() {
-		await this.writable.getWriter().close();
-		return this.writable;
+		const writer = this;
+		const { writable } = writer;
+		if (!writer.preventClose) {
+			await writable.getWriter().close();
+		}
+		return writable;
 	}
 }
 
@@ -543,7 +529,7 @@ class Uint8ArrayWriter extends Writer {
 
 	constructor() {
 		super();
-		this.array = new Uint8Array(0);
+		this.array = new Uint8Array();
 	}
 
 	writeUint8Array(array) {

package/lib/core/streams/aes-crypto-stream.js

@@ -74,7 +74,7 @@ class AESDecryptionStream extends TransformStream {
 					password,
 					signed,
 					strength: strength - 1,
-					pending: new Uint8Array(0)
+					pending: new Uint8Array()
 				});
 			},
 			async transform(chunk, controller) {
@@ -100,7 +100,7 @@ class AESDecryptionStream extends TransformStream {
 				const pending = aesCrypto.pending;
 				const chunkToDecrypt = subarray(pending, 0, pending.length - SIGNATURE_LENGTH);
 				const originalSignature = subarray(pending, pending.length - SIGNATURE_LENGTH);
-				let decryptedChunkArray = new Uint8Array(0);
+				let decryptedChunkArray = new Uint8Array();
 				if (chunkToDecrypt.length) {
 					const encryptedChunk = toBits(codecBytes, chunkToDecrypt);
 					aesCrypto.hmac.update(encryptedChunk);
@@ -133,12 +133,12 @@ class AESEncryptionStream extends TransformStream {
 					ready: new Promise(resolve => this.resolveReady = resolve),
 					password,
 					strength: strength - 1,
-					pending: new Uint8Array(0)
+					pending: new Uint8Array()
 				});
 			},
 			async transform(chunk, controller) {
 				const aesCrypto = this;
-				let preamble = new Uint8Array(0);
+				let preamble = new Uint8Array();
 				if (aesCrypto.password) {
 					const password = aesCrypto.password;
 					aesCrypto.password = null;
@@ -156,7 +156,7 @@ class AESEncryptionStream extends TransformStream {
 			async flush(controller) {
 				const aesCrypto = this;
 				await aesCrypto.ready;
-				let encryptedChunkArray = new Uint8Array(0);
+				let encryptedChunkArray = new Uint8Array();
 				if (aesCrypto.pending.length) {
 					const encryptedChunk = aesCrypto.ctr.update(toBits(codecBytes, aesCrypto.pending));
 					aesCrypto.hmac.update(encryptedChunk);

package/lib/core/streams/codecs/deflate.js

@@ -2029,7 +2029,7 @@ const ZipDeflate = (() => {
 					bufferIndex += chunk.length;
 				});
 			} else {
-				array = buffers[0] || new Uint8Array(0);
+				array = buffers[0] || new Uint8Array();
 			}
 			return array;
 		};

package/lib/core/streams/codecs/inflate.js

@@ -2155,7 +2155,7 @@ const ZipInflate = (() => {
 					bufferIndex += chunk.length;
 				});
 			} else {
-				array = buffers[0] || new Uint8Array(0);
+				array = buffers[0] || new Uint8Array();
 			}
 			return array;
 		};

package/lib/core/util/decode-text.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global TextDecoder, FileReader, Blob */
+/* global TextDecoder */
 
 import decodeCP437 from "./cp437-decode.js";
 
@@ -35,13 +35,6 @@ export default decodeText;
 function decodeText(value, encoding) {
 	if (encoding && encoding.trim().toLowerCase() == "cp437") {
 		return decodeCP437(value);
-	} else if (typeof TextDecoder == "undefined") {
-		const fileReader = new FileReader();
-		return new Promise((resolve, reject) => {
-			fileReader.onload = event => resolve(event.target.result);
-			fileReader.onerror = () => reject(fileReader.error);
-			fileReader.readAsText(new Blob([value]));
-		});
 	} else {
 		return new TextDecoder(encoding).decode(value);
 	}

package/lib/core/util/stream-codec-shim.js

@@ -41,7 +41,7 @@ function createCodecClass(constructor, constructorOptions, registerDataHandler)
 			const codecAdapter = this;
 			const onData = data => {
 				if (codecAdapter.pendingData) {
-					const pendingData = codecAdapter.pendingData;
+					const { pendingData } = codecAdapter;
 					codecAdapter.pendingData = new Uint8Array(pendingData.length + data.length);
 					codecAdapter.pendingData.set(pendingData, 0);
 					codecAdapter.pendingData.set(data, pendingData.length);
@@ -61,7 +61,7 @@ function createCodecClass(constructor, constructorOptions, registerDataHandler)
 			return getResponse(this);
 		}
 		flush() {
-			this.codec.push(new Uint8Array(0), true);
+			this.codec.push(new Uint8Array(), true);
 			return getResponse(this);
 		}
 	};
@@ -72,7 +72,7 @@ function createCodecClass(constructor, constructorOptions, registerDataHandler)
 			codec.pendingData = null;
 			return output;
 		} else {
-			return new Uint8Array(0);
+			return new Uint8Array();
 		}
 	}
 }

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

@@ -46,15 +46,15 @@ let messageId = 0;
 
 addEventListener(MESSAGE_EVENT_TYPE, async event => {
 	const message = event.data;
-	const type = message.type;
+	const { type, messageId, data, done } = message;
 	try {
 		if (type == MESSAGE_START) {
 			init(message);
 		}
 		if (type == MESSAGE_DATA) {
-			const { resolve } = pendingMessages.get(message.messageId);
-			pendingMessages.delete(message.messageId);
-			resolve({ value: new Uint8Array(message.data), done: message.done });
+			const { resolve } = pendingMessages.get(messageId);
+			pendingMessages.delete(messageId);
+			resolve({ value: new Uint8Array(data), done });
 		}
 		if (type == MESSAGE_ABORT) {
 			codec.abort();
@@ -66,45 +66,45 @@ addEventListener(MESSAGE_EVENT_TYPE, async event => {
 
 async function init(message) {
 	try {
-		if (message.scripts && message.scripts.length) {
-			importScripts.apply(undefined, message.scripts);
+		const { options, scripts, config } = message;
+		const { codecType } = options;
+		if (scripts && scripts.length) {
+			importScripts.apply(undefined, scripts);
 		}
-		const options = message.options;
 		if (self.initCodec) {
 			self.initCodec();
 		}
 		let codecConstructor;
-		if (options.codecType.startsWith(CODEC_DEFLATE)) {
+		if (codecType.startsWith(CODEC_DEFLATE)) {
 			codecConstructor = self.Deflate;
-		} else if (options.codecType.startsWith(CODEC_INFLATE)) {
+		} else if (codecType.startsWith(CODEC_INFLATE)) {
 			codecConstructor = self.Inflate;
 		}
+		const strategy = { highWaterMark: 1, size: () => config.chunkSize };
 		const readable = new ReadableStream({
 			async pull(controller) {
 				let result = new Promise((resolve, reject) => pendingMessages.set(messageId, { resolve, reject }));
 				sendMessage({ type: MESSAGE_PULL, messageId });
-				messageId++;
+				messageId = (messageId + 1) % Number.MAX_SAFE_INTEGER;
 				const { value, done } = await result;
-				// debugger;
 				controller.enqueue(value);
 				if (done) {
 					controller.close();
 				}
 			}
-		}, {
-			highWaterMark: 1
-		});
+		}, strategy);
 		const writable = new WritableStream({
 			write(data) {
 				sendMessage({ type: MESSAGE_DATA, data });
 			}
-		});
-		codec = createCodec(codecConstructor, readable, writable, options, message.config);
+		}, strategy);
+		codec = createCodec(codecConstructor, readable, writable, options, config);
 		const result = await codec.run();
 		sendMessage({ type: MESSAGE_CLOSE, result });
 
 	} catch (error) {
-		postMessage({ error: { message: error.message, stack: error.stack } });
+		const { message, stack } = error;
+		postMessage({ error: { message, stack } });
 	}
 }