@zip.js/zip.js 2.16.0 → 2.16.1

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

@@ -26,8 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global crypto, TransformStream */
-// deno-lint-ignore-file no-this-alias
+/* global crypto, TransformStream, ReadableStream */
 
 import { UNDEFINED_VALUE, UNDEFINED_TYPE, FUNCTION_TYPE, EMPTY_UINT8_ARRAY } from "../constants.js";
 import { encodeText } from "./../util/encode-text.js";
@@ -64,12 +63,12 @@ let createEngine = createDefaultEngine;
 class AESDecryptionStream extends TransformStream {
 
 	constructor({ password, rawPassword, encryptionStrength, checkPasswordOnly, checkAuthenticationCode = true }) {
+		const aesCrypto = {};
 		super({
 			start() {
-				initAesCrypto(this, password, rawPassword, encryptionStrength);
+				initAesCrypto(aesCrypto, password, rawPassword, encryptionStrength);
 			},
 			async transform(chunk, controller) {
-				const aesCrypto = this;
 				const {
 					password,
 					strength,
@@ -88,6 +87,9 @@ class AESDecryptionStream extends TransformStream {
 				} else {
 					await ready;
 				}
+				if (aesCrypto.discarded) {
+					return;
+				}
 				const output = new Uint8Array(chunk.length - AUTHENTICATION_CODE_LENGTH - ((chunk.length - AUTHENTICATION_CODE_LENGTH) % BLOCK_LENGTH));
 				controller.enqueue(append(aesCrypto, chunk, output, 0, AUTHENTICATION_CODE_LENGTH, true));
 			},
@@ -96,9 +98,12 @@ class AESDecryptionStream extends TransformStream {
 					engine,
 					pendingInput,
 					ready
-				} = this;
+				} = aesCrypto;
 				if (engine) {
 					await ready;
+					if (aesCrypto.discarded) {
+						return;
+					}
 					const originalAuthenticationCode = subarray(pendingInput, pendingInput.length - AUTHENTICATION_CODE_LENGTH);
 					const decryptedChunkArray = new Uint8Array(subarray(pendingInput, 0, pendingInput.length - AUTHENTICATION_CODE_LENGTH));
 					engine.process(decryptedChunkArray, true);
@@ -108,27 +113,26 @@ class AESDecryptionStream extends TransformStream {
 						invalidAuthenticationCode |= authenticationCode[indexByte] ^ originalAuthenticationCode[indexByte];
 					}
 					if (invalidAuthenticationCode && checkAuthenticationCode) {
-						throw new Error(ERR_INVALID_AUTHENTICATION_CODE);
+						controller.error(new Error(ERR_INVALID_AUTHENTICATION_CODE));
+						return;
 					}
 					controller.enqueue(decryptedChunkArray);
 				}
-			},
-			cancel() {
-				disposeEngine(this);
 			}
 		});
+		setDisposingReadable(this, aesCrypto);
 	}
 }
 
 class AESEncryptionStream extends TransformStream {
 
 	constructor({ password, rawPassword, encryptionStrength }) {
+		const aesCrypto = {};
 		super({
 			start() {
-				initAesCrypto(this, password, rawPassword, encryptionStrength);
+				initAesCrypto(aesCrypto, password, rawPassword, encryptionStrength);
 			},
 			async transform(chunk, controller) {
-				const aesCrypto = this;
 				const {
 					password,
 					strength,
@@ -142,6 +146,9 @@ class AESEncryptionStream extends TransformStream {
 				} else {
 					await ready;
 				}
+				if (aesCrypto.discarded) {
+					return;
+				}
 				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, false));
@@ -151,19 +158,20 @@ class AESEncryptionStream extends TransformStream {
 					engine,
 					pendingInput,
 					ready
-				} = this;
+				} = aesCrypto;
 				if (engine) {
 					await ready;
+					if (aesCrypto.discarded) {
+						return;
+					}
 					const encryptedChunkArray = new Uint8Array(pendingInput);
 					engine.process(encryptedChunkArray, false);
 					const authenticationCode = subarray(engine.digest(), 0, AUTHENTICATION_CODE_LENGTH);
 					controller.enqueue(concat(encryptedChunkArray, authenticationCode));
 				}
-			},
-			cancel() {
-				disposeEngine(this);
 			}
 		});
+		setDisposingReadable(this, aesCrypto);
 	}
 }
 
@@ -182,7 +190,37 @@ function initAesCrypto(aesCrypto, password, rawPassword, encryptionStrength) {
 		ready: new Promise(resolve => aesCrypto.resolveReady = resolve),
 		password: encodePassword(password, rawPassword),
 		strength: encryptionStrength - 1,
-		pendingInput: EMPTY_UINT8_ARRAY
+		pendingInput: EMPTY_UINT8_ARRAY,
+		discarded: false
+	});
+}
+
+function setDisposingReadable(stream, aesCrypto) {
+	const reader = stream.readable.getReader();
+	const readable = new ReadableStream({
+		async pull(controller) {
+			try {
+				const { value, done } = await reader.read();
+				if (done) {
+					controller.close();
+				} else {
+					controller.enqueue(value);
+				}
+			} catch (error) {
+				disposeEngine(aesCrypto);
+				reader.cancel(error).catch(() => { });
+				throw error;
+			}
+		},
+		cancel(reason) {
+			disposeEngine(aesCrypto);
+			return reader.cancel(reason);
+		}
+	});
+	Object.defineProperty(stream, "readable", {
+		get() {
+			return readable;
+		}
 	});
 }
 
@@ -215,7 +253,9 @@ async function createDecryptionKeys(decrypt, strength, password, preamble) {
 	}
 }
 
-function disposeEngine({ engine }) {
+function disposeEngine(aesCrypto) {
+	const { engine } = aesCrypto;
+	aesCrypto.discarded = true;
 	if (engine && engine.dispose) {
 		engine.dispose();
 	}
@@ -232,6 +272,9 @@ async function createKeys(aesCrypto, strength, password, salt) {
 	const keyLength = KEY_LENGTH[strength];
 	const compositeKey = await deriveKey(password, salt, keyLength * 2 + PASSWORD_VERIFICATION_LENGTH);
 	aesCrypto.engine = createEngine(subarray(compositeKey, 0, keyLength), subarray(compositeKey, keyLength, keyLength * 2));
+	if (aesCrypto.discarded) {
+		disposeEngine(aesCrypto);
+	}
 	return subarray(compositeKey, keyLength * 2);
 }
 

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

@@ -127,11 +127,11 @@ function encrypt(target, input) {
 }
 
 function createKeys(target, password, rawPassword) {
-	const keys = [0x12345678, 0x23456789, 0x34567890];
+	const cryptoKeys = [0x12345678, 0x23456789, 0x34567890];
 	Object.assign(target, {
-		keys,
-		crcKey0: new Crc32(keys[0]),
-		crcKey2: new Crc32(keys[2])
+		cryptoKeys,
+		crcKey0: new Crc32(cryptoKeys[0]),
+		crcKey2: new Crc32(cryptoKeys[2])
 	});
 	if (rawPassword) {
 		for (let index = 0; index < rawPassword.length; index++) {
@@ -145,17 +145,17 @@ function createKeys(target, password, rawPassword) {
 }
 
 function updateKeys(target, byte) {
-	let [, key1] = target.keys;
+	let [, key1] = target.cryptoKeys;
 	target.crcKey0.append([byte]);
 	const key0 = ~target.crcKey0.get();
 	key1 = getInt32(Math.imul(getInt32(key1 + getInt8(key0)), 134775813) + 1);
 	target.crcKey2.append([key1 >>> 24]);
 	const key2 = ~target.crcKey2.get();
-	target.keys = [key0, key1, key2];
+	target.cryptoKeys = [key0, key1, key2];
 }
 
 function getByte(target) {
-	const temp = target.keys[2] | 2;
+	const temp = target.cryptoKeys[2] | 2;
 	return getInt8(Math.imul(temp, (temp ^ 1)) >>> 8);
 }
 

package/lib/core/streams/zip-entry-stream.js

@@ -176,28 +176,25 @@ function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, cr
 	pump();
 	return new ReadableStream({
 		async pull(controller) {
-			let result;
 			try {
-				result = await read();
+				const { value, done } = await read();
+				if (done) {
+					controller.close();
+				} else {
+					outputLength += value.length;
+					if (outputLength > outputSize) {
+						throw new Error(ERR_INVALID_UNCOMPRESSED_SIZE);
+					}
+					if (outputCrc32) {
+						outputCrc32.append(value);
+					}
+					controller.enqueue(value);
+				}
 			} catch (error) {
+				rejectTrailerReady(error);
+				await cancel(reader, error);
 				throw trailerWritten ? getTrailerError(error) : error;
 			}
-			const { value, done } = result;
-			if (done) {
-				controller.close();
-			} else {
-				outputLength += value.length;
-				if (outputLength > outputSize) {
-					const error = new Error(ERR_INVALID_UNCOMPRESSED_SIZE);
-					rejectTrailerReady(error);
-					await cancel(reader, error);
-					throw error;
-				}
-				if (outputCrc32) {
-					outputCrc32.append(value);
-				}
-				controller.enqueue(value);
-			}
 		},
 		cancel(reason) {
 			rejectTrailerReady(reason);
@@ -494,10 +491,15 @@ function mapInflateStreamError(readable) {
 	const reader = readable.getReader();
 	return new ReadableStream({
 		async pull(controller) {
-			let result;
 			try {
-				result = await reader.read();
+				const { value, done } = await reader.read();
+				if (done) {
+					controller.close();
+				} else {
+					controller.enqueue(value);
+				}
 			} catch (error) {
+				await cancel(reader, error);
 				if (error && error.message) {
 					throw error;
 				}
@@ -505,12 +507,6 @@ function mapInflateStreamError(readable) {
 				mappedError.cause = error;
 				throw mappedError;
 			}
-			const { value, done } = result;
-			if (done) {
-				controller.close();
-			} else {
-				controller.enqueue(value);
-			}
 		},
 		cancel(reason) {
 			return reader.cancel(reason);

package/lib/core/streams/zlib-wasm/zlib-streams.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global TransformStream */
+/* global ReadableStream, WritableStream */
 
 const FORMAT_DEFLATE = "deflate";
 const FORMAT_DEFLATE_RAW = "deflate-raw";
@@ -61,137 +61,195 @@ function _make(isCompress, type, options = {}) {
 	const level = (typeof options.level === "number") ? options.level : -1;
 	const outBufferSize = (typeof options.outBuffer === "number") ? options.outBuffer : 64 * 1024;
 	const inBufferSize = (typeof options.inBufferSize === "number") ? options.inBufferSize : 64 * 1024;
-
-	return new TransformStream({
-		start() {
+	const state = { out: 0, in: 0, inBufferSize: 0, streamHandle: 0 };
+	let readableController, writableController, resolveWrite, cancelReason;
+	let backpressure = true;
+	let cancelled = false;
+	initStream();
+	const readable = new ReadableStream({
+		start(controller) {
+			readableController = controller;
+		},
+		pull() {
+			backpressure = false;
+			resumeWrite();
+		},
+		cancel(reason) {
+			cancelled = true;
+			cancelReason = reason;
+			disposeStream(state);
+			writableController.error(reason);
+			resumeWrite();
+		}
+	}, { highWaterMark: 0 });
+	const writable = new WritableStream({
+		start(controller) {
+			writableController = controller;
+		},
+		async write(chunk) {
+			if (backpressure) {
+				await new Promise(resolve => resolveWrite = resolve);
+			}
+			if (cancelled) {
+				throw cancelReason;
+			}
 			try {
-				let result;
-				this.out = malloc(outBufferSize);
-				this.in = malloc(inBufferSize);
-				this.inBufferSize = inBufferSize;
-				if (!this.out || !this.in) {
-					throw new Error("allocation failed");
-				}
-				if (isCompress) {
-					this._process = wasm.deflate_process;
-					this._last_consumed = wasm.deflate_last_consumed;
-					this._end = wasm.deflate_end;
-					this.streamHandle = wasm.deflate_new();
-					if (type === FORMAT_GZIP) {
-						result = wasm.deflate_init_gzip(this.streamHandle, level);
-					} else if (type === FORMAT_DEFLATE_RAW) {
-						result = wasm.deflate_init_raw(this.streamHandle, level);
-					} else {
-						result = wasm.deflate_init(this.streamHandle, level);
-					}
-				} else {
-					if (type === FORMAT_DEFLATE64_RAW) {
-						this._process = wasm.inflate9_process;
-						this._last_consumed = wasm.inflate9_last_consumed;
-						this._end = wasm.inflate9_end;
-						this.streamHandle = wasm.inflate9_new();
-						result = wasm.inflate9_init_raw(this.streamHandle);
-					} else {
-						this._process = wasm.inflate_process;
-						this._last_consumed = wasm.inflate_last_consumed;
-						this._end = wasm.inflate_end;
-						this.streamHandle = wasm.inflate_new();
-						if (type === FORMAT_DEFLATE_RAW) {
-							result = wasm.inflate_init_raw(this.streamHandle);
-						} else if (type === FORMAT_GZIP) {
-							result = wasm.inflate_init_gzip(this.streamHandle);
-						} else {
-							result = wasm.inflate_init(this.streamHandle);
-						}
-					}
-				}
-				if (result !== 0) {
-					throw new Error("init failed:" + result);
-				}
+				processChunk(chunk);
 			} catch (error) {
-				disposeStream(this);
+				disposeStream(state);
+				readableController.error(error);
 				throw error;
 			}
 		},
-		transform(chunk, controller) {
+		close() {
+			if (cancelled) {
+				return;
+			}
 			try {
-				const buffer = chunk;
-				const heap = new Uint8Array(memory.buffer);
-				const process = this._process;
-				const last_consumed = this._last_consumed;
-				const out = this.out;
-				let offset = 0;
-				while (offset < buffer.length) {
-					const toRead = Math.min(buffer.length - offset, 32 * 1024);
-					if (!this.in || this.inBufferSize < toRead) {
-						if (this.in && free) {
-							free(this.in);
-							this.in = 0;
-						}
-						this.in = malloc(toRead);
-						this.inBufferSize = toRead;
-						if (!this.in) {
-							throw new Error("allocation failed");
-						}
-					}
-					heap.set(buffer.subarray(offset, offset + toRead), this.in);
-					const result = process(this.streamHandle, this.in, toRead, out, outBufferSize, 0);
-					// checked before the byte count is used, so a status code can never be read as one
-					const code = (result >> 24) & 0xff;
-					const signedCode = (code & 0x80) ? code - 256 : code;
-					if (signedCode < 0) {
-						throw new Error("process error:" + signedCode);
-					}
-					const prod = result & 0x00ffffff;
-					if (prod) {
-						controller.enqueue(heap.slice(out, out + prod));
-					}
-					const consumed = last_consumed(this.streamHandle);
-					if (consumed === 0 && prod === 0) {
-						break;
-					}
-					offset += consumed;
-				}
+				flushStream();
 			} catch (error) {
-				disposeStream(this);
-				controller.error(error);
+				disposeStream(state);
+				readableController.error(error);
+				throw error;
 			}
+			const result = disposeStream(state);
+			if (result !== 0) {
+				const error = new Error("end error:" + result);
+				readableController.error(error);
+				throw error;
+			}
+			readableController.close();
 		},
-		flush(controller) {
-			try {
-				const heap = new Uint8Array(memory.buffer);
-				const process = this._process;
-				const out = this.out;
-				while (true) {
-					const result = process(this.streamHandle, 0, 0, out, outBufferSize, 4);
-					const code = (result >> 24) & 0xff;
-					const signedCode = (code & 0x80) ? code - 256 : code;
-					if (signedCode < 0) {
-						throw new Error("process error:" + signedCode);
-					}
-					const produced = result & 0x00ffffff;
-					if (produced) {
-						controller.enqueue(heap.slice(out, out + produced));
-					}
-					if (code === 1 || produced === 0) {
-						break;
+		abort(reason) {
+			disposeStream(state);
+			readableController.error(reason);
+		}
+	}, { highWaterMark: 1 });
+	return { readable, writable };
+
+	function initStream() {
+		try {
+			let result;
+			state.out = malloc(outBufferSize);
+			state.in = malloc(inBufferSize);
+			state.inBufferSize = inBufferSize;
+			if (!state.out || !state.in) {
+				throw new Error("allocation failed");
+			}
+			if (isCompress) {
+				state._process = wasm.deflate_process;
+				state._last_consumed = wasm.deflate_last_consumed;
+				state._end = wasm.deflate_end;
+				state.streamHandle = wasm.deflate_new();
+				if (type === FORMAT_GZIP) {
+					result = wasm.deflate_init_gzip(state.streamHandle, level);
+				} else if (type === FORMAT_DEFLATE_RAW) {
+					result = wasm.deflate_init_raw(state.streamHandle, level);
+				} else {
+					result = wasm.deflate_init(state.streamHandle, level);
+				}
+			} else {
+				if (type === FORMAT_DEFLATE64_RAW) {
+					state._process = wasm.inflate9_process;
+					state._last_consumed = wasm.inflate9_last_consumed;
+					state._end = wasm.inflate9_end;
+					state.streamHandle = wasm.inflate9_new();
+					result = wasm.inflate9_init_raw(state.streamHandle);
+				} else {
+					state._process = wasm.inflate_process;
+					state._last_consumed = wasm.inflate_last_consumed;
+					state._end = wasm.inflate_end;
+					state.streamHandle = wasm.inflate_new();
+					if (type === FORMAT_DEFLATE_RAW) {
+						result = wasm.inflate_init_raw(state.streamHandle);
+					} else if (type === FORMAT_GZIP) {
+						result = wasm.inflate_init_gzip(state.streamHandle);
+					} else {
+						result = wasm.inflate_init(state.streamHandle);
 					}
 				}
-			} catch (error) {
-				controller.error(error);
-			} finally {
-				const result = disposeStream(this);
-				if (result !== 0) {
-					controller.error(new Error("end error:" + result));
+			}
+			if (result !== 0) {
+				throw new Error("init failed:" + result);
+			}
+		} catch (error) {
+			disposeStream(state);
+			throw error;
+		}
+	}
+
+	function processChunk(chunk) {
+		const heap = new Uint8Array(memory.buffer);
+		const process = state._process;
+		const last_consumed = state._last_consumed;
+		const out = state.out;
+		let offset = 0;
+		while (offset < chunk.length) {
+			const toRead = Math.min(chunk.length - offset, 32 * 1024);
+			if (!state.in || state.inBufferSize < toRead) {
+				if (state.in && free) {
+					free(state.in);
+					state.in = 0;
+				}
+				state.in = malloc(toRead);
+				state.inBufferSize = toRead;
+				if (!state.in) {
+					throw new Error("allocation failed");
 				}
 			}
-		},
-		cancel() {
-			// release the stream handle and buffers when the pipeline is aborted,
-			// they would be leaked in the process-lifetime wasm heap otherwise
-			disposeStream(this);
+			heap.set(chunk.subarray(offset, offset + toRead), state.in);
+			const result = process(state.streamHandle, state.in, toRead, out, outBufferSize, 0);
+			// checked before the byte count is used, so a status code can never be read as one
+			const code = (result >> 24) & 0xff;
+			const signedCode = (code & 0x80) ? code - 256 : code;
+			if (signedCode < 0) {
+				throw new Error("process error:" + signedCode);
+			}
+			const prod = result & 0x00ffffff;
+			if (prod) {
+				enqueue(heap.slice(out, out + prod));
+			}
+			const consumed = last_consumed(state.streamHandle);
+			if (consumed === 0 && prod === 0) {
+				break;
+			}
+			offset += consumed;
+		}
+	}
+
+	function flushStream() {
+		const heap = new Uint8Array(memory.buffer);
+		const process = state._process;
+		const out = state.out;
+		while (true) {
+			const result = process(state.streamHandle, 0, 0, out, outBufferSize, 4);
+			const code = (result >> 24) & 0xff;
+			const signedCode = (code & 0x80) ? code - 256 : code;
+			if (signedCode < 0) {
+				throw new Error("process error:" + signedCode);
+			}
+			const produced = result & 0x00ffffff;
+			if (produced) {
+				enqueue(heap.slice(out, out + produced));
+			}
+			if (code === 1 || produced === 0) {
+				break;
+			}
 		}
-	});
+	}
+
+	function enqueue(chunk) {
+		backpressure = true;
+		readableController.enqueue(chunk);
+	}
+
+	function resumeWrite() {
+		if (resolveWrite) {
+			const resolve = resolveWrite;
+			resolveWrite = null;
+			resolve();
+		}
+	}
 
 	function disposeStream(state) {
 		let endResult = 0;

package/lib/core/util/compatible-streams.js

@@ -43,11 +43,16 @@ function toCompatibleReadable(readable) {
 	const reader = readable.getReader();
 	return new ReadableStream({
 		async pull(controller) {
-			const { value, done } = await reader.read();
-			if (done) {
-				controller.close();
-			} else {
-				controller.enqueue(value);
+			try {
+				const { value, done } = await reader.read();
+				if (done) {
+					controller.close();
+				} else {
+					controller.enqueue(value);
+				}
+			} catch (error) {
+				reader.cancel(error).catch(() => { });
+				throw error;
 			}
 		},
 		cancel(reason) {

package/lib/core/version.js

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