@zip.js/zip.js 2.6.22 → 2.6.25

package/lib/core/codec-interface.js

@@ -61,29 +61,47 @@ export {
 
 class Codec {
 
-	constructor(codecConstructor, readable, writable, options, config) {
+	constructor(CodecConstructor, readable, writable, options, config) {
 		const { codecType } = options;
+		let StreamConstructor;
 		if (codecType.startsWith(CODEC_DEFLATE)) {
-			this.run = () => run(DeflateStream);
+			StreamConstructor = DeflateStream;
 		} else if (codecType.startsWith(CODEC_INFLATE)) {
-			this.run = () => run(InflateStream);
+			StreamConstructor = InflateStream;
 		}
+		Object.assign(this, {
+			StreamConstructor,
+			CodecConstructor,
+			readable,
+			writable,
+			options,
+			config
+		});
+	}
 
-		async function run(StreamConstructor) {
-			const stream = new StreamConstructor(codecConstructor, options, config);
-			await readable
-				.pipeThrough(stream)
-				.pipeThrough(new TransformStream({
-					transform(chunk, controller) {
-						if (chunk && chunk.length) {
-							writable.size += chunk.length;
-							controller.enqueue(chunk);
-						}
+	async run() {
+		const {
+			StreamConstructor,
+			CodecConstructor,
+			readable,
+			writable,
+			options,
+			config
+		} = this;
+		const stream = new StreamConstructor(CodecConstructor, options, config);
+		let size = 0;
+		await readable
+			.pipeThrough(stream)
+			.pipeThrough(new TransformStream({
+				transform(chunk, controller) {
+					if (chunk && chunk.length) {
+						size += chunk.length;
+						controller.enqueue(chunk);
 					}
-				}))
-				.pipeTo(writable, { preventClose: true, preventAbort: true });
-			const { size, signature } = stream;
-			return { size, signature };
-		}
+				}
+			}))
+			.pipeTo(writable, { preventClose: true, preventAbort: true });
+		const { signature } = stream;
+		return { size, signature };
 	}
 }

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

@@ -40,6 +40,7 @@ import {
 
 let workersSupported;
 let classicWorkersSupported = true;
+let transferStreamsSupported = true;
 
 export {
 	CodecWorker
@@ -49,7 +50,7 @@ class CodecWorker {
 
 	constructor(workerData, stream, workerOptions, onTaskFinished) {
 		const { readable, writable } = stream;
-		const { options, config, streamOptions, webWorker, scripts, codecConstructor } = workerOptions;
+		const { options, config, streamOptions, useWebWorkers, transferStreams, scripts, codecConstructor } = workerOptions;
 		Object.assign(workerData, {
 			busy: true,
 			codecConstructor,
@@ -57,6 +58,7 @@ class CodecWorker {
 			writable,
 			options: Object.assign({}, options),
 			scripts,
+			transferStreams,
 			terminate() {
 				if (workerData.worker && !workerData.busy) {
 					workerData.worker.terminate();
@@ -72,17 +74,17 @@ class CodecWorker {
 		let chunkOffset = 0;
 		const transformer = {};
 		if (onstart) {
-			transformer.start = () => callHandler(onstart, size());
+			transformer.start = () => callHandler(onstart, size);
 		}
 		transformer.transform = async (chunk, controller) => {
 			chunkOffset += chunk.length;
 			if (onprogress) {
-				await callHandler(onprogress, chunkOffset, size());
+				await callHandler(onprogress, chunkOffset, size);
 			}
 			controller.enqueue(chunk);
 		};
 		transformer.flush = () => {
-			readable.size = () => chunkOffset;
+			readable.size = chunkOffset;
 			if (onend) {
 				callHandler(onend, chunkOffset);
 			}
@@ -91,7 +93,7 @@ class CodecWorker {
 		if (workersSupported === undefined) {
 			workersSupported = typeof Worker != "undefined";
 		}
-		return webWorker && workersSupported ? createWebWorkerInterface(workerData, config) : createWorkerInterface(workerData, config);
+		return useWebWorkers && workersSupported ? createWebWorkerInterface(workerData, config) : createWorkerInterface(workerData, config);
 	}
 }
 
@@ -120,10 +122,8 @@ function createWorkerInterface(workerData, config) {
 
 function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 	const workerOptions = { type: "module" };
-	const { readable, writable } = workerData;
 	Object.assign(workerData, {
-		reader: readable.getReader(),
-		writer: writable.getWriter(),
+		streams: {},
 		result: new Promise((resolve, reject) => {
 			workerData.resolveResult = resolve;
 			workerData.rejectResult = reject;
@@ -143,15 +143,32 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 		workerData.worker.addEventListener(MESSAGE_EVENT_TYPE, onMessage, false);
 		workerData.interface = {
 			run() {
-				const { options } = workerData;
+				const { readable, writable, options } = workerData;
 				const scripts = workerData.scripts.slice(1);
-				sendMessage({ type: MESSAGE_START, scripts, options, config: { chunkSize } });
+				const message = { type: MESSAGE_START, scripts, options, config: { chunkSize } };
+				if (workerData.transferStreams && transferStreamsSupported) {
+					const streamsTransferred = sendMessage({ ...message, readable, writable });
+					if (!streamsTransferred) {
+						transferStreamsSupported = false;
+						initStreams(readable, writable);
+					}
+				} else {
+					sendMessage(message);
+					initStreams(readable, writable);
+				}
 				return workerData.result;
 			}
 		};
 	}
 	return workerData.interface;
 
+	function initStreams(readable, writable) {
+		Object.assign(workerData.streams, {
+			reader: readable.getReader(),
+			writer: writable.getWriter()
+		});
+	}
+
 	function getWorker(options) {
 		let url, scriptUrl;
 		url = workerData.scripts[0];
@@ -169,23 +186,37 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 	function sendMessage(message) {
 		const { worker, writer, onTaskFinished } = workerData;
 		try {
-			let { data } = message;
+			let { data, readable, writable } = message;
+			const transferrables = [];
 			if (data) {
+				const { buffer, length } = data;
+				if (length != buffer.byteLength) {
+					data = new Uint8Array(data);
+				}
+				message.data = data.buffer;
+				transferrables.push(message.data);
+			}
+			if (readable) {
+				transferrables.push(readable);
+			}
+			if (writable) {
+				transferrables.push(writable);
+			}
+			if (transferrables.length) {
 				try {
-					const { buffer, length } = data;
-					if (length != buffer.byteLength) {
-						data = new Uint8Array(data);
-					}
-					message.data = data.buffer;
-					worker.postMessage(message, [message.data]);
-				} catch (_error) {
+					worker.postMessage(message, transferrables);
+					return true;
+				} catch (error) {
+					message.readable = message.writable = null;
 					worker.postMessage(message);
 				}
 			} else {
 				worker.postMessage(message);
 			}
 		} catch (error) {
-			writer.releaseLock();
+			if (writer) {
+				writer.releaseLock();
+			}
 			onTaskFinished();
 			throw error;
 		}
@@ -193,14 +224,15 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 
 	async function onMessage(event) {
 		const message = event.data;
-		const { reader, writer, resolveResult, rejectResult, onTaskFinished } = workerData;
+		const { resolveResult, rejectResult, onTaskFinished } = workerData;
+		const { reader, writer } = workerData.streams;
 		const { type, data, messageId, result } = message;
 		const reponseError = message.error;
 		try {
 			if (reponseError) {
-				const { message, stack } = reponseError;
+				const { message, stack, code, name } = reponseError;
 				const error = new Error(message);
-				error.stack = stack;
+				Object.assign(error, { stack, code, name });
 				close(error);
 			} else {
 				if (type == MESSAGE_PULL) {
@@ -209,7 +241,6 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 				}
 				if (type == MESSAGE_DATA) {
 					await writer.ready;
-					workerData.writable.size += data.byteLength;
 					await writer.write(new Uint8Array(data));
 					sendMessage({ type: MESSAGE_ACK_DATA, messageId });
 				}
@@ -227,7 +258,9 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 			} else {
 				resolveResult(result);
 			}
-			writer.releaseLock();
+			if (writer) {
+				writer.releaseLock();
+			}
 			onTaskFinished();
 		}
 	}

package/lib/core/codec-pool.js

@@ -52,11 +52,12 @@ let indexWorker = 0;
 
 async function runWorker(stream, workerOptions) {
 	const { options, config } = workerOptions;
-	const streamCopy = !options.compressed && !options.signed && !options.encrypted;
-	const { useWebWorkers, useCompressionStream, codecType } = options;
+	const { transferStreams, useWebWorkers, useCompressionStream, codecType, compressed, signed, encrypted } = options;
 	const { workerScripts } = config;
-	workerOptions.webWorker = !streamCopy && (useWebWorkers || (useWebWorkers === undefined && config.useWebWorkers));
-	workerOptions.scripts = workerOptions.webWorker && workerScripts ? workerScripts[codecType] : [];
+	workerOptions.transferStreams = transferStreams || transferStreams === undefined;
+	const streamCopy = !compressed && !signed && !encrypted && !workerOptions.transferStreams;
+	workerOptions.useWebWorkers = !streamCopy && (useWebWorkers || (useWebWorkers === undefined && config.useWebWorkers));
+	workerOptions.scripts = workerOptions.useWebWorkers && workerScripts ? workerScripts[codecType] : [];
 	options.useCompressionStream = useCompressionStream === undefined ? config.useCompressionStream : useCompressionStream;
 	let worker;
 	if (pool.length < config.maxWorkers) {

package/lib/core/configuration.js

@@ -66,30 +66,14 @@ function configure(configuration) {
 		Inflate,
 		workerScripts
 	} = configuration;
-	if (baseURL !== UNDEFINED_TYPE) {
-		config.baseURL = baseURL;
-	}
-	if (chunkSize !== UNDEFINED_TYPE) {
-		config.chunkSize = chunkSize;
-	}
-	if (maxWorkers !== UNDEFINED_TYPE) {
-		config.maxWorkers = maxWorkers;
-	}
-	if (terminateWorkerTimeout !== UNDEFINED_TYPE) {
-		config.terminateWorkerTimeout = terminateWorkerTimeout;
-	}
-	if (useCompressionStream !== UNDEFINED_TYPE) {
-		config.useCompressionStream = useCompressionStream;
-	}
-	if (useWebWorkers !== UNDEFINED_TYPE) {
-		config.useWebWorkers = useWebWorkers;
-	}
-	if (Deflate !== UNDEFINED_TYPE) {
-		config.Deflate = Deflate;
-	}
-	if (Inflate !== UNDEFINED_TYPE) {
-		config.Inflate = Inflate;
-	}
+	setIfDefined("baseURL", baseURL);
+	setIfDefined("chunkSize", chunkSize);
+	setIfDefined("maxWorkers", maxWorkers);
+	setIfDefined("terminateWorkerTimeout", terminateWorkerTimeout);
+	setIfDefined("useCompressionStream", useCompressionStream);
+	setIfDefined("useWebWorkers", useWebWorkers);
+	setIfDefined("Deflate", Deflate);
+	setIfDefined("Inflate", Inflate);
 	if (workerScripts !== UNDEFINED_TYPE) {
 		const { deflate, inflate } = workerScripts;
 		if (deflate || inflate) {
@@ -111,3 +95,9 @@ function configure(configuration) {
 		}
 	}
 }
+
+function setIfDefined(propertyName, propertyValue) {
+	if (propertyValue !== UNDEFINED_TYPE) {
+		config[propertyName] = propertyValue;
+	}
+}

package/lib/core/io.js

@@ -66,8 +66,8 @@ class Reader extends Stream {
 			async pull(controller) {
 				const { offset = 0, size } = readable;
 				const { chunkOffset } = this;
-				controller.enqueue(await reader.readUint8Array(offset + chunkOffset, Math.min(chunkSize, size() - chunkOffset)));
-				if (chunkOffset + chunkSize > size()) {
+				controller.enqueue(await reader.readUint8Array(offset + chunkOffset, Math.min(chunkSize, size - chunkOffset)));
+				if (chunkOffset + chunkSize > size) {
 					controller.close();
 				} else {
 					this.chunkOffset += chunkSize;
@@ -224,23 +224,17 @@ class BlobWriter extends Stream {
 	constructor(contentType) {
 		super();
 		const writer = this;
-		writer.contentType = contentType;
-		writer.transformStream = new TransformStream();
+		const transformStream = new TransformStream();
+		const headers = [];
+		if (contentType) {
+			headers.push(["content-type", contentType]);
+		}
 		Object.defineProperty(writer, "writable", {
 			get() {
-				return writer.transformStream.writable;
+				return transformStream.writable;
 			}
 		});
-	}
-
-	init() {
-		super.init();
-		const writer = this;
-		const {
-			transformStream,
-			contentType
-		} = writer;
-		writer.blob = new Response(transformStream.readable, { headers: [["content-type", contentType]] }).blob();
+		writer.blob = new Response(transformStream.readable, { headers }).blob();
 	}
 
 	getData() {

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

@@ -63,7 +63,7 @@ addEventListener(MESSAGE_EVENT_TYPE, async event => {
 			resolve();
 		}
 	} catch (error) {
-		postMessage({ error: { message: error.message, stack: error.stack } });
+		sendErrorMessage(error);
 	}
 });
 
@@ -84,7 +84,7 @@ async function init(message) {
 			codecConstructor = self.Inflate;
 		}
 		const strategy = { highWaterMark: 1, size: () => config.chunkSize };
-		const readable = new ReadableStream({
+		const readable = message.readable || new ReadableStream({
 			async pull(controller) {
 				let result = new Promise(resolve => pendingPullMessages.set(messageId, resolve));
 				sendMessage({ type: MESSAGE_PULL, messageId });
@@ -96,7 +96,7 @@ async function init(message) {
 				}
 			}
 		}, strategy);
-		const writable = new WritableStream({
+		const writable = message.writable || new WritableStream({
 			async write(data) {
 				let resolveAckData;
 				const ackData = new Promise(resolve => resolveAckData = resolve);
@@ -108,10 +108,12 @@ async function init(message) {
 		}, strategy);
 		codec = new Codec(codecConstructor, readable, writable, options, config);
 		const result = await codec.run();
+		if (message.writable && !options.preventClose) {
+			await message.writable.close();
+		}
 		sendMessage({ type: MESSAGE_CLOSE, result });
 	} catch (error) {
-		const { message, stack } = error;
-		postMessage({ error: { message, stack } });
+		sendErrorMessage(error);
 	}
 }
 
@@ -132,4 +134,9 @@ function sendMessage(message) {
 	} else {
 		postMessage(message);
 	}
+}
+
+function sendErrorMessage(error) {
+	const { message, stack, code, name } = error;
+	postMessage({ error: { message, stack, code, name } });
 }

package/lib/core/zip-fs-core.js

@@ -122,9 +122,8 @@ class ZipFileEntry extends ZipEntry {
 		} else {
 			const reader = zipEntry.reader = new zipEntry.Reader(zipEntry.data, options);
 			await Promise.all([initStream(reader), initStream(writer, zipEntry.data.uncompressedSize)]);
-			zipEntry.uncompressedSize = reader.size;
 			const readable = reader.readable;
-			readable.size = () => reader.size;
+			readable.size = zipEntry.uncompressedSize = reader.size;
 			await readable.pipeTo(writer.writable);
 			return writer.getData ? writer.getData() : writer.writable;
 		}

package/lib/core/zip-reader.js

@@ -317,13 +317,15 @@ class ZipEntry {
 			}
 		}
 		const dataOffset = offset + 30 + localDirectory.filenameLength + localDirectory.extraFieldLength;
-		const size = () => compressedSize;
 		const readable = reader.readable;
 		readable.offset = dataOffset;
-		readable.size = size;
+		const size = readable.size = compressedSize;
 		const { writable } = writer;
-		writable.size = 0;
+		if (writable.size === undefined) {
+			writable.size = 0;
+		}
 		const signal = getOptionValue(zipEntry, options, "signal");
+		const preventClose = getOptionValue(zipEntry, options, "preventClose");
 		await initStream(writer, uncompressedSize);
 		const { onstart, onprogress, onend } = options;
 		const workerOptions = {
@@ -338,16 +340,21 @@ class ZipEntry {
 				compressed: compressionMethod != 0,
 				encrypted,
 				useWebWorkers: getOptionValue(zipEntry, options, "useWebWorkers"),
-				useCompressionStream: getOptionValue(zipEntry, options, "useCompressionStream")
+				useCompressionStream: getOptionValue(zipEntry, options, "useCompressionStream"),
+				transferStreams: getOptionValue(zipEntry, options, "transferStreams"),
+				preventClose
 			},
 			config,
 			streamOptions: { signal, size, onstart, onprogress, onend },
 			codecConstructor: config.Inflate
 		};
-		await runWorker({ readable, writable }, workerOptions);
-		const preventClose = getOptionValue(zipEntry, options, "preventClose");
+		writable.size += (await runWorker({ readable, writable }, workerOptions)).size;
 		if (!preventClose) {
-			await writable.getWriter().close();
+			try {
+				await writable.close();
+			} catch (_error) {
+				// ignored
+			}
 		}
 		return writer.getData ? writer.getData() : writable;
 	}

package/lib/core/zip-writer.js

@@ -151,7 +151,7 @@ class ZipWriter {
 		}
 		await closeFile(this, comment, options);
 		if (!writer.preventClose && !options.preventClose) {
-			await writable.getWriter().close();
+			await writable.close();
 		}
 		return writer.getData ? writer.getData() : writable;
 	}
@@ -354,7 +354,7 @@ async function getFileEntry(zipWriter, name, reader, entryInfo, options) {
 		files.set(name, fileEntry);
 		fileEntry.filename = name;
 		if (bufferedWrite) {
-			await fileWriter.writable.getWriter().close();
+			await fileWriter.writable.close();
 			let blob = await fileWriter.getData();
 			await lockPreviousFileEntry;
 			await requestLockWriter();
@@ -495,9 +495,8 @@ async function createFileEntry(reader, writer, pendingFileEntry, entryInfo, conf
 	if (reader) {
 		reader.chunkSize = getChunkSize(config);
 		await writeData(writable, localHeaderArray);
-		const size = () => reader.size;
 		const readable = reader.readable;
-		readable.size = size;
+		const size = readable.size = reader.size;
 		const workerOptions = {
 			options: {
 				codecType: CODEC_DEFLATE,
@@ -510,16 +509,18 @@ async function createFileEntry(reader, writer, pendingFileEntry, entryInfo, conf
 				compressed,
 				encrypted,
 				useWebWorkers,
-				useCompressionStream
+				useCompressionStream,
+				transferStreams: false
 			},
 			config,
 			streamOptions: { signal, size, onstart, onprogress, onend },
 			codecConstructor: config.Deflate
 		};
-		const previousSize = writable.size;
-		signature = (await runWorker({ readable, writable }, workerOptions)).signature;
-		uncompressedSize = reader.size = readable.size();
-		compressedSize = writable.size - previousSize;
+		const result = await runWorker({ readable, writable }, workerOptions);
+		writable.size += result.size;
+		signature = result.signature;
+		uncompressedSize = reader.size = readable.size;
+		compressedSize = result.size;
 	} else {
 		await writeData(writable, localHeaderArray);
 	}