@zip.js/zip.js 2.5.4 → 2.5.8

package/lib/core/{codecs/codec-pool-worker.js → codec-pool-worker.js}

@@ -26,9 +26,17 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global Worker, URL */
-
-import { createCodec, MESSAGE_EVENT_TYPE, MESSAGE_START, MESSAGE_PULL, MESSAGE_DATA, MESSAGE_ABORT } from "./codec.js";
+/* global Worker, URL, TransformStream */
+
+import {
+	createCodec,
+	MESSAGE_EVENT_TYPE,
+	MESSAGE_START,
+	MESSAGE_PULL,
+	MESSAGE_DATA,
+	MESSAGE_ABORT,
+	MESSAGE_CLOSE
+} from "./codec-interface.js";
 
 let classicWorkersSupported = true;
 
@@ -36,10 +44,12 @@ export {
 	getWorker
 };
 
-function getWorker(workerData, codecConstructor, options, config, onTaskFinished, webWorker, scripts) {
+function getWorker(workerData, codecConstructor, readable, writable, options, config, streamOptions, onTaskFinished, webWorker, scripts) {
 	Object.assign(workerData, {
 		busy: true,
 		codecConstructor,
+		readable,
+		writable,
 		options: Object.assign({}, options),
 		scripts,
 		terminate() {
@@ -53,27 +63,50 @@ function getWorker(workerData, codecConstructor, options, config, onTaskFinished
 			onTaskFinished(workerData);
 		}
 	});
+	const { signal, onprogress, size } = streamOptions;
+	if (signal || onprogress) {
+		let chunkOffset = 0;
+		const transformer = {};
+		if (onprogress) {
+			transformer.transform = (chunk, controller) => {
+				chunkOffset += chunk.length;
+				try {
+					onprogress(chunkOffset, size());
+				} catch (_error) {
+					// ignored
+				}
+				controller.enqueue(chunk);
+			};
+		}
+		workerData.readable = readable.pipeThrough(new TransformStream(transformer), { signal });
+	}
 	return webWorker ? createWebWorkerInterface(workerData, config) : createWorkerInterface(workerData, config);
 }
 
 function createWorkerInterface(workerData, config) {
-	const interfaceCodec = createCodec(workerData.codecConstructor, workerData.options, config);
+	const interfaceCodec = createCodec(workerData.codecConstructor, workerData.readable, workerData.writable, workerData.options, config);
 	const codec = {
 		abort() {
 			interfaceCodec.abort();
 			workerData.onTaskFinished();
 		},
-		start() {
-			return interfaceCodec.start();
+		run() {
+			const result = interfaceCodec.run();
+			workerData.onTaskFinished();
+			return result;
 		}
 	};
-	interfaceCodec.pull = () => codec.pull();
-	interfaceCodec.ondata = data => ondata(workerData, codec, data);
 	return codec;
 }
 
 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;
+	});
 	if (!workerData.interface) {
 		if (!classicWorkersSupported) {
 			workerData.worker = getWorker(workerOptions);
@@ -89,12 +122,14 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 		workerData.interface = {
 			abort() {
 				sendMessage({ type: MESSAGE_ABORT });
+				workerData.writer.releaseLock();
 				workerData.onTaskFinished();
 			},
-			start() {
+			run() {
 				const options = workerData.options;
 				const scripts = workerData.scripts.slice(1);
 				sendMessage({ type: MESSAGE_START, scripts, options, config: { chunkSize } });
+				return workerData.result;
 			}
 		};
 	}
@@ -128,6 +163,7 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 				worker.postMessage(message);
 			}
 		} catch (error) {
+			workerData.writer.releaseLock();
 			workerData.onTaskFinished();
 			throw error;
 		}
@@ -136,39 +172,34 @@ function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
 	async function onMessage(event) {
 		const message = event.data;
 		const reponseError = message.error;
-		const codec = workerData.interface;
 		try {
 			if (reponseError) {
 				const error = new Error(reponseError.message);
 				error.stack = reponseError.stack;
-				codec.onerror(error);
+				workerData.rejectResult(error);
+				workerData.writer.releaseLock();
 				workerData.onTaskFinished();
 			} else {
 				if (message.type == MESSAGE_PULL) {
-					const { value, done } = await codec.pull();
+					const { value, done } = await workerData.reader.read();
 					sendMessage({ type: MESSAGE_DATA, data: value, done, messageId: message.messageId });
 				}
 				if (message.type == MESSAGE_DATA) {
-					const { value } = message.data;
-					if (value && value.data) {
-						value.data = new Uint8Array(value.data);
-					}
-					await ondata(workerData, codec, message.data);
+					let { data } = message;
+					data = new Uint8Array(data);
+					await workerData.writer.ready;
+					await workerData.writer.write(data);
+				}
+				if (message.type == MESSAGE_CLOSE) {
+					workerData.resolveResult(message.result);
+					workerData.writer.releaseLock();
+					workerData.onTaskFinished();
 				}
 			}
 		} catch (error) {
-			codec.onerror(error);
+			workerData.rejectResult(error);
+			workerData.writer.releaseLock();
 			workerData.onTaskFinished();
 		}
 	}
-}
-
-async function ondata(workerData, codec, data) {
-	let { value, done } = data;
-	if (done) {
-		await codec.ondata({ value: { data: value.data, signature: value.signature }, done });
-		workerData.onTaskFinished();
-	} else if (value.data) {
-		await codec.ondata({ value: { data: value.data } });
-	}
 }

package/lib/core/{codecs/codec-pool.js → codec-pool.js}

@@ -28,47 +28,66 @@
 
 /* global setTimeout, clearTimeout */
 
-import { CODEC_INFLATE, CODEC_DEFLATE, ERR_INVALID_SIGNATURE, ERR_INVALID_PASSWORD } from "./codec.js";
+import {
+	CODEC_INFLATE,
+	CODEC_DEFLATE,
+	ERR_INVALID_SIGNATURE,
+	ERR_INVALID_PASSWORD,
+	ERR_ABORT
+} from "./codec-interface.js";
 import { getWorker } from "./codec-pool-worker.js";
 
 let pool = [];
 const pendingRequests = [];
 
 export {
-	createCodec,
+	runCodec,
 	terminateWorkers,
 	CODEC_DEFLATE,
 	CODEC_INFLATE,
 	ERR_INVALID_SIGNATURE,
-	ERR_INVALID_PASSWORD
+	ERR_INVALID_PASSWORD,
+	ERR_ABORT
 };
 
 let indexWorker = 0;
 
-function createCodec(codecConstructor, options, config) {
+async function runCodec(codecConstructor, readable, writable, options, config, streamOptions) {
 	const streamCopy = !options.compressed && !options.signed && !options.encrypted;
 	const webWorker = !streamCopy && (options.useWebWorkers || (options.useWebWorkers === undefined && config.useWebWorkers));
 	const scripts = webWorker && config.workerScripts ? config.workerScripts[options.codecType] : [];
 	options.useCompressionStream = options.useCompressionStream === undefined ? config.useCompressionStream : options.useCompressionStream;
+	let codec;
 	if (pool.length < config.maxWorkers) {
 		const workerData = { indexWorker };
 		indexWorker++;
 		pool.push(workerData);
-		return getWorker(workerData, codecConstructor, options, config, onTaskFinished, webWorker, scripts);
+		codec = getWorker(workerData, codecConstructor, readable, writable, options, config, streamOptions, onTaskFinished, webWorker, scripts);
 	} else {
 		const workerData = pool.find(workerData => !workerData.busy);
 		if (workerData) {
 			clearTerminateTimeout(workerData);
-			return getWorker(workerData, codecConstructor, options, config, onTaskFinished, webWorker, scripts);
+			codec = getWorker(workerData, codecConstructor, readable, writable, options, config, streamOptions, onTaskFinished, webWorker, scripts);
+		} else {
+			codec = await new Promise(resolve => pendingRequests.push({ resolve, codecConstructor, readable, writable, options, webWorker, scripts }));
+		}
+	}
+	const { signal } = streamOptions;
+	try {
+		return await codec.run(signal);
+	} catch (error) {
+		if (signal && signal.aborted && (signal.reason == error || error.name == ERR_ABORT)) {
+			codec.abort();
+			throw new Error(ERR_ABORT);
 		} else {
-			return new Promise(resolve => pendingRequests.push({ resolve, codecConstructor, options, webWorker, scripts }));
+			throw error;
 		}
 	}
 
 	function onTaskFinished(workerData) {
 		if (pendingRequests.length) {
-			const [{ resolve, codecConstructor, options, webWorker, scripts }] = pendingRequests.splice(0, 1);
-			resolve(getWorker(workerData, codecConstructor, options, config, onTaskFinished, webWorker, scripts));
+			const [{ resolve, codecConstructor, readable, writable, options, webWorker, scripts }] = pendingRequests.splice(0, 1);
+			resolve(getWorker(workerData, codecConstructor, readable, writable, options, config, streamOptions, onTaskFinished, webWorker, scripts));
 		} else if (workerData.worker) {
 			clearTerminateTimeout(workerData);
 			if (Number.isFinite(config.terminateWorkerTimeout) && config.terminateWorkerTimeout >= 0) {

package/lib/core/configuration.js

@@ -66,6 +66,9 @@ function configure(configuration) {
 	if (configuration.terminateWorkerTimeout !== undefined) {
 		config.terminateWorkerTimeout = configuration.terminateWorkerTimeout;
 	}
+	if (configuration.useCompressionStream !== undefined) {
+		config.useCompressionStream = configuration.useCompressionStream;
+	}
 	if (configuration.useWebWorkers !== undefined) {
 		config.useWebWorkers = configuration.useWebWorkers;
 	}

package/lib/core/io.js

@@ -75,24 +75,15 @@ class Reader extends Stream {
 }
 
 class WriterStream extends Stream {
+
 	getStream() {
 		const writer = this;
 		return new WritableStream({
 			write(chunk) {
-				if (chunk && chunk.length) {
-					return writer.writeUint8Array(chunk);
-				}
+				return writer.writeUint8Array(chunk);
 			}
 		});
 	}
-
-	getStreamWriter() {
-		const writer = this;
-		if (!writer.streamWriter) {
-			writer.streamWriter = writer.getStream().getWriter();
-		}
-		return writer.streamWriter;
-	}
 }
 
 class Writer extends WriterStream {
@@ -275,13 +266,12 @@ function flushArrayBuffers(blobWriter) {
 
 class ReadableStreamReader {
 
-	constructor(readableStream) {
+	constructor(readableStream, size = Infinity) {
 		this.readableStream = readableStream;
-		this.size = Infinity;
+		this.size = size;
 	}
 
-	init(size) {
-		this.size = size;
+	init() {
 		this.initialized = true;
 	}
 
@@ -292,27 +282,26 @@ class ReadableStreamReader {
 
 class WritableStreamWriter extends Writer {
 
-	constructor(writableStream) {
+	constructor(writable) {
 		super();
 		const writer = this;
-		writer.writableStream = writableStream;
-		writer.writer = writer.getStreamWriter();
+		writer.writable = writable;
 	}
 
 	async writeUint8Array(array) {
 		await this.writer.ready;
-		return this.writer.write(array);
+		const writer = this.writable.getWriter();
+		await writer.write(array);
+		writer.releaseLock();
 	}
 
 	getStream() {
-		return this.writableStream;
+		return this.writable;
 	}
 
 	async getData() {
-		const writer = this;
-		await writer.writer.ready;
-		await writer.writer.close();
-		return writer.writableStream;
+		await this.writable.getWriter().close();
+		return this.writable;
 	}
 }
 

package/lib/core/{codecs → streams}/aes-crypto-stream.js

@@ -30,7 +30,13 @@
 // deno-lint-ignore-file no-this-alias
 
 import encodeText from "./../util/encode-text.js";
-import { cipher, codec, misc, mode, random } from "./sjcl.js";
+import {
+	cipher,
+	codec,
+	misc,
+	mode,
+	random
+} from "./codecs/sjcl.js";
 
 const ERR_INVALID_PASSWORD = "Invalid pasword";
 const BLOCK_LENGTH = 16;
@@ -72,23 +78,21 @@ class AESDecryptionStream extends TransformStream {
 				});
 			},
 			async transform(chunk, controller) {
-				if (chunk && chunk.length) {
-					const aesCrypto = this;
-					if (aesCrypto.password) {
-						const password = aesCrypto.password;
-						aesCrypto.password = null;
-						const preamble = subarray(chunk, 0, SALT_LENGTH[aesCrypto.strength] + 2);
-						await createDecryptionKeys(aesCrypto, preamble, password);
-						aesCrypto.ctr = new CtrGladman(new Aes(aesCrypto.keys.key), Array.from(COUNTER_DEFAULT_VALUE));
-						aesCrypto.hmac = new HmacSha1(aesCrypto.keys.authentication);
-						chunk = subarray(chunk, SALT_LENGTH[aesCrypto.strength] + 2);
-						aesCrypto.resolveReady();
-					} else {
-						await aesCrypto.ready;
-					}
-					const output = new Uint8Array(chunk.length - SIGNATURE_LENGTH - ((chunk.length - SIGNATURE_LENGTH) % BLOCK_LENGTH));
-					controller.enqueue(append(aesCrypto, chunk, output, 0, SIGNATURE_LENGTH, true));
+				const aesCrypto = this;
+				if (aesCrypto.password) {
+					const password = aesCrypto.password;
+					aesCrypto.password = null;
+					const preamble = subarray(chunk, 0, SALT_LENGTH[aesCrypto.strength] + 2);
+					await createDecryptionKeys(aesCrypto, preamble, password);
+					aesCrypto.ctr = new CtrGladman(new Aes(aesCrypto.keys.key), Array.from(COUNTER_DEFAULT_VALUE));
+					aesCrypto.hmac = new HmacSha1(aesCrypto.keys.authentication);
+					chunk = subarray(chunk, SALT_LENGTH[aesCrypto.strength] + 2);
+					aesCrypto.resolveReady();
+				} else {
+					await aesCrypto.ready;
 				}
+				const output = new Uint8Array(chunk.length - SIGNATURE_LENGTH - ((chunk.length - SIGNATURE_LENGTH) % BLOCK_LENGTH));
+				controller.enqueue(append(aesCrypto, chunk, output, 0, SIGNATURE_LENGTH, true));
 			},
 			async flush(controller) {
 				const aesCrypto = this;
@@ -133,23 +137,21 @@ class AESEncryptionStream extends TransformStream {
 				});
 			},
 			async transform(chunk, controller) {
-				if (chunk && chunk.length) {
-					const aesCrypto = this;
-					let preamble = new Uint8Array(0);
-					if (aesCrypto.password) {
-						const password = aesCrypto.password;
-						aesCrypto.password = null;
-						preamble = await createEncryptionKeys(aesCrypto, password);
-						aesCrypto.ctr = new CtrGladman(new Aes(aesCrypto.keys.key), Array.from(COUNTER_DEFAULT_VALUE));
-						aesCrypto.hmac = new HmacSha1(aesCrypto.keys.authentication);
-						aesCrypto.resolveReady();
-					} else {
-						await aesCrypto.ready;
-					}
-					const output = new Uint8Array(preamble.length + chunk.length - (chunk.length % BLOCK_LENGTH));
-					output.set(preamble, 0);
-					controller.enqueue(append(aesCrypto, chunk, output, preamble.length, 0));
+				const aesCrypto = this;
+				let preamble = new Uint8Array(0);
+				if (aesCrypto.password) {
+					const password = aesCrypto.password;
+					aesCrypto.password = null;
+					preamble = await createEncryptionKeys(aesCrypto, password);
+					aesCrypto.ctr = new CtrGladman(new Aes(aesCrypto.keys.key), Array.from(COUNTER_DEFAULT_VALUE));
+					aesCrypto.hmac = new HmacSha1(aesCrypto.keys.authentication);
+					aesCrypto.resolveReady();
+				} else {
+					await aesCrypto.ready;
 				}
+				const output = new Uint8Array(preamble.length + chunk.length - (chunk.length % BLOCK_LENGTH));
+				output.set(preamble, 0);
+				controller.enqueue(append(aesCrypto, chunk, output, preamble.length, 0));
 			},
 			async flush(controller) {
 				const aesCrypto = this;

package/lib/core/{codecs → streams}/codec-stream.js

@@ -36,20 +36,20 @@
 /* global TransformStream */
 
 class CodecStream extends TransformStream {
+
 	constructor(Codec, options) {
+		let codec;
 		super({
 			start() {
-				this.codec = new Codec(options);
+				codec = new Codec(options);
 			},
 			transform(chunk, controller) {
-				chunk = this.codec.append(chunk);
-				if (chunk && chunk.length) {
-					controller.enqueue(chunk);
-				}
+				chunk = codec.append(chunk);
+				controller.enqueue(chunk);
 			},
 			flush(controller) {
-				const chunk = this.codec.flush();
-				if (chunk && chunk.length) {
+				const chunk = codec.flush();
+				if (chunk) {
 					controller.enqueue(chunk);
 				}
 			}

package/lib/core/{codecs → streams}/crc32-stream.js

@@ -28,18 +28,17 @@
 
 /* global TransformStream */
 
-import Crc32 from "./crc32.js";
+import Crc32 from "./codecs/crc32.js";
 
 class Crc32Stream extends TransformStream {
+
 	constructor() {
 		super({
 			start() {
 				this.crc32 = new Crc32();
 			},
 			transform(chunk) {
-				if (chunk && chunk.length) {
-					this.crc32.append(chunk);
-				}
+				this.crc32.append(chunk);
 			},
 			flush(controller) {
 				const value = new Uint8Array(4);

package/lib/core/{codecs → streams}/zip-crypto-stream.js

@@ -29,7 +29,7 @@
 /* global crypto, TransformStream */
 // deno-lint-ignore-file no-this-alias
 
-import Crc32 from "./crc32.js";
+import Crc32 from "./codecs/crc32.js";
 import { ERR_INVALID_PASSWORD } from "./aes-crypto-stream.js";
 
 const HEADER_LENGTH = 12;
@@ -47,18 +47,16 @@ class ZipCryptoDecryptionStream extends TransformStream {
 				createKeys(this, password);
 			},
 			transform(chunk, controller) {
-				if (chunk && chunk.length) {
-					const zipCrypto = this;
-					if (zipCrypto.password) {
-						const decryptedHeader = decrypt(zipCrypto, chunk.subarray(0, HEADER_LENGTH));
-						zipCrypto.password = null;
-						if (decryptedHeader[HEADER_LENGTH - 1] != zipCrypto.passwordVerification) {
-							throw new Error(ERR_INVALID_PASSWORD);
-						}
-						chunk = chunk.subarray(HEADER_LENGTH);
+				const zipCrypto = this;
+				if (zipCrypto.password) {
+					const decryptedHeader = decrypt(zipCrypto, chunk.subarray(0, HEADER_LENGTH));
+					zipCrypto.password = null;
+					if (decryptedHeader[HEADER_LENGTH - 1] != zipCrypto.passwordVerification) {
+						throw new Error(ERR_INVALID_PASSWORD);
 					}
-					controller.enqueue(decrypt(zipCrypto, chunk));
+					chunk = chunk.subarray(HEADER_LENGTH);
 				}
+				controller.enqueue(decrypt(zipCrypto, chunk));
 			},
 			flush() {
 				stream.valid = true;
@@ -80,24 +78,22 @@ class ZipCryptoEncryptionStream extends TransformStream {
 				createKeys(this, password);
 			},
 			transform(chunk, controller) {
-				if (chunk && chunk.length) {
-					const zipCrypto = this;
-					let output;
-					let offset;
-					if (zipCrypto.password) {
-						zipCrypto.password = null;
-						const header = crypto.getRandomValues(new Uint8Array(HEADER_LENGTH));
-						header[HEADER_LENGTH - 1] = zipCrypto.passwordVerification;
-						output = new Uint8Array(chunk.length + header.length);
-						output.set(encrypt(zipCrypto, header), 0);
-						offset = HEADER_LENGTH;
-					} else {
-						output = new Uint8Array(chunk.length);
-						offset = 0;
-					}
-					output.set(encrypt(zipCrypto, chunk), offset);
-					controller.enqueue(output);
+				const zipCrypto = this;
+				let output;
+				let offset;
+				if (zipCrypto.password) {
+					zipCrypto.password = null;
+					const header = crypto.getRandomValues(new Uint8Array(HEADER_LENGTH));
+					header[HEADER_LENGTH - 1] = zipCrypto.passwordVerification;
+					output = new Uint8Array(chunk.length + header.length);
+					output.set(encrypt(zipCrypto, header), 0);
+					offset = HEADER_LENGTH;
+				} else {
+					output = new Uint8Array(chunk.length);
+					offset = 0;
 				}
+				output.set(encrypt(zipCrypto, chunk), offset);
+				controller.enqueue(output);
 			},
 			flush() {
 			}