@zip.js/zip.js 2.5.2 → 2.5.5

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;
@@ -45,14 +51,19 @@ const SALT_LENGTH = [8, 12, 16];
 const KEY_LENGTH = [16, 24, 32];
 const SIGNATURE_LENGTH = 10;
 const COUNTER_DEFAULT_VALUE = [0, 0, 0, 0];
-const CRYPTO_API_SUPPORTED = typeof crypto != "undefined";
-const SUBTLE_API_SUPPORTED = CRYPTO_API_SUPPORTED && typeof crypto.subtle != "undefined";
+const UNDEFINED_TYPE = "undefined";
+const FUNCTION_TYPE = "function";
+const CRYPTO_API_SUPPORTED = typeof crypto != UNDEFINED_TYPE;
+const SUBTLE_API_SUPPORTED = CRYPTO_API_SUPPORTED && typeof crypto.subtle != UNDEFINED_TYPE;
+const GET_RANDOM_VALUES_SUPPORTED = CRYPTO_API_SUPPORTED && typeof crypto.getRandomValues == FUNCTION_TYPE;
+const IMPORT_KEY_SUPPORTED = CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof crypto.subtle.importKey == FUNCTION_TYPE;
+const DERIVE_BITS_SUPPORTED = CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof crypto.subtle.deriveBits == FUNCTION_TYPE;
 const codecBytes = codec.bytes;
 const Aes = cipher.aes;
 const CtrGladman = mode.ctrGladman;
 const HmacSha1 = misc.hmacSha1;
 
-class AESDecryptStream extends TransformStream {
+class AESDecryptionStream extends TransformStream {
 
 	constructor(password, signed, strength) {
 		let stream;
@@ -67,23 +78,21 @@ class AESDecryptStream 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.aesCtrGladman = 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;
@@ -93,14 +102,14 @@ class AESDecryptStream extends TransformStream {
 				const originalSignature = subarray(pending, pending.length - SIGNATURE_LENGTH);
 				let decryptedChunkArray = new Uint8Array(0);
 				if (chunkToDecrypt.length) {
-					const encryptedChunk = codecBytes.toBits(chunkToDecrypt);
+					const encryptedChunk = toBits(codecBytes, chunkToDecrypt);
 					aesCrypto.hmac.update(encryptedChunk);
-					const decryptedChunk = aesCrypto.aesCtrGladman.update(encryptedChunk);
-					decryptedChunkArray = codecBytes.fromBits(decryptedChunk);
+					const decryptedChunk = aesCrypto.ctr.update(encryptedChunk);
+					decryptedChunkArray = fromBits(codecBytes, decryptedChunk);
 				}
 				stream.valid = true;
 				if (aesCrypto.signed) {
-					const signature = subarray(codecBytes.fromBits(aesCrypto.hmac.digest()), 0, SIGNATURE_LENGTH);
+					const signature = subarray(fromBits(codecBytes, aesCrypto.hmac.digest()), 0, SIGNATURE_LENGTH);
 					for (let indexSignature = 0; indexSignature < SIGNATURE_LENGTH; indexSignature++) {
 						if (signature[indexSignature] != originalSignature[indexSignature]) {
 							stream.valid = false;
@@ -114,7 +123,7 @@ class AESDecryptStream extends TransformStream {
 	}
 }
 
-class AESEncryptStream extends TransformStream {
+class AESEncryptionStream extends TransformStream {
 
 	constructor(password, strength) {
 		let stream;
@@ -128,34 +137,32 @@ class AESEncryptStream 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.aesCtrGladman = 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;
 				await aesCrypto.ready;
 				let encryptedChunkArray = new Uint8Array(0);
 				if (aesCrypto.pending.length) {
-					const encryptedChunk = aesCrypto.aesCtrGladman.update(codecBytes.toBits(aesCrypto.pending));
+					const encryptedChunk = aesCrypto.ctr.update(toBits(codecBytes, aesCrypto.pending));
 					aesCrypto.hmac.update(encryptedChunk);
-					encryptedChunkArray = codecBytes.fromBits(encryptedChunk);
+					encryptedChunkArray = fromBits(codecBytes, encryptedChunk);
 				}
-				stream.signature = codecBytes.fromBits(aesCrypto.hmac.digest()).slice(0, SIGNATURE_LENGTH);
+				stream.signature = fromBits(codecBytes, aesCrypto.hmac.digest()).slice(0, SIGNATURE_LENGTH);
 				controller.enqueue(concat(encryptedChunkArray, stream.signature));
 			}
 		});
@@ -164,8 +171,8 @@ class AESEncryptStream extends TransformStream {
 }
 
 export {
-	AESDecryptStream,
-	AESEncryptStream,
+	AESDecryptionStream,
+	AESEncryptionStream,
 	ERR_INVALID_PASSWORD
 };
 
@@ -177,15 +184,15 @@ function append(aesCrypto, input, output, paddingStart, paddingEnd, verifySignat
 	}
 	let offset;
 	for (offset = 0; offset <= inputLength - BLOCK_LENGTH; offset += BLOCK_LENGTH) {
-		const inputChunk = codecBytes.toBits(subarray(input, offset, offset + BLOCK_LENGTH));
+		const inputChunk = toBits(codecBytes, subarray(input, offset, offset + BLOCK_LENGTH));
 		if (verifySignature) {
 			aesCrypto.hmac.update(inputChunk);
 		}
-		const outputChunk = aesCrypto.aesCtrGladman.update(inputChunk);
+		const outputChunk = aesCrypto.ctr.update(inputChunk);
 		if (!verifySignature) {
 			aesCrypto.hmac.update(outputChunk);
 		}
-		output.set(codecBytes.fromBits(outputChunk), offset + paddingStart);
+		output.set(fromBits(codecBytes, outputChunk), offset + paddingStart);
 	}
 	aesCrypto.pending = subarray(input, offset);
 	return output;
@@ -212,14 +219,14 @@ async function createKeys(target, password, salt) {
 	const derivedBits = await deriveBits(Object.assign({ salt }, DERIVED_BITS_ALGORITHM), basekey, 8 * ((KEY_LENGTH[target.strength] * 2) + 2));
 	const compositeKey = new Uint8Array(derivedBits);
 	target.keys = {
-		key: codecBytes.toBits(subarray(compositeKey, 0, KEY_LENGTH[target.strength])),
-		authentication: codecBytes.toBits(subarray(compositeKey, KEY_LENGTH[target.strength], KEY_LENGTH[target.strength] * 2)),
+		key: toBits(codecBytes, subarray(compositeKey, 0, KEY_LENGTH[target.strength])),
+		authentication: toBits(codecBytes, subarray(compositeKey, KEY_LENGTH[target.strength], KEY_LENGTH[target.strength] * 2)),
 		passwordVerification: subarray(compositeKey, KEY_LENGTH[target.strength] * 2)
 	};
 }
 
 function getRandomValues(array) {
-	if (CRYPTO_API_SUPPORTED && typeof crypto.getRandomValues == "function") {
+	if (GET_RANDOM_VALUES_SUPPORTED) {
 		return crypto.getRandomValues(array);
 	} else {
 		return random.getRandomValues(array);
@@ -227,7 +234,7 @@ function getRandomValues(array) {
 }
 
 function importKey(format, password, algorithm, extractable, keyUsages) {
-	if (CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof crypto.subtle.importKey == "function") {
+	if (IMPORT_KEY_SUPPORTED) {
 		return crypto.subtle.importKey(format, password, algorithm, extractable, keyUsages);
 	} else {
 		return misc.importKey(password);
@@ -235,7 +242,7 @@ function importKey(format, password, algorithm, extractable, keyUsages) {
 }
 
 async function deriveBits(algorithm, baseKey, length) {
-	if (CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof crypto.subtle.deriveBits == "function") {
+	if (DERIVE_BITS_SUPPORTED) {
 		return await crypto.subtle.deriveBits(algorithm, baseKey, length);
 	} else {
 		return misc.pbkdf2(baseKey, algorithm.salt, DERIVED_BITS_ALGORITHM.iterations, length);
@@ -263,4 +270,11 @@ function expand(inputArray, length) {
 
 function subarray(array, begin, end) {
 	return array.subarray(begin, end);
+}
+
+function fromBits(codecBytes, chunk) {
+	return codecBytes.fromBits(chunk);
+}
+function toBits(codecBytes, chunk) {
+	return codecBytes.toBits(chunk);
 }

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

@@ -36,6 +36,7 @@
 /* global TransformStream */
 
 class CodecStream extends TransformStream {
+
 	constructor(Codec, options) {
 		super({
 			start() {
@@ -43,15 +44,11 @@ class CodecStream extends TransformStream {
 			},
 			transform(chunk, controller) {
 				chunk = this.codec.append(chunk);
-				if (chunk) {
-					controller.enqueue(chunk);
-				}
+				controller.enqueue(chunk);
 			},
 			flush(controller) {
 				const chunk = this.codec.flush();
-				if (chunk) {
-					controller.enqueue(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) {
-					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,12 +29,12 @@
 /* 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;
 
-class ZipCryptoDecryptStream extends TransformStream {
+class ZipCryptoDecryptionStream extends TransformStream {
 
 	constructor(password, passwordVerification) {
 		let stream;
@@ -47,18 +47,16 @@ class ZipCryptoDecryptStream 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;
@@ -68,7 +66,7 @@ class ZipCryptoDecryptStream extends TransformStream {
 	}
 }
 
-class ZipCryptoEncryptStream extends TransformStream {
+class ZipCryptoEncryptionStream extends TransformStream {
 
 	constructor(password, passwordVerification) {
 		super({
@@ -80,24 +78,22 @@ class ZipCryptoEncryptStream 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() {
 			}
@@ -106,8 +102,8 @@ class ZipCryptoEncryptStream extends TransformStream {
 }
 
 export {
-	ZipCryptoDecryptStream,
-	ZipCryptoEncryptStream,
+	ZipCryptoDecryptionStream,
+	ZipCryptoEncryptionStream,
 	ERR_INVALID_PASSWORD
 };
 

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

@@ -0,0 +1,178 @@
+/*
+ Copyright (c) 2022 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.
+ */
+
+/* global CompressionStream, DecompressionStream, TransformStream */
+
+import Crc32Stream from "./crc32-stream.js";
+import {
+	AESEncryptionStream,
+	AESDecryptionStream
+} from "./aes-crypto-stream.js";
+import {
+	ZipCryptoEncryptionStream,
+	ZipCryptoDecryptionStream,
+	ERR_INVALID_PASSWORD
+} from "./zip-crypto-stream.js";
+import CodecStream from "./codec-stream.js";
+
+const ERR_INVALID_SIGNATURE = "Invalid signature";
+const COMPRESSION_FORMAT = "deflate-raw";
+const UNDEFINED_TYPE = "undefined";
+
+class DeflateStream extends TransformStream {
+
+	constructor(codecConstructor, { compressed, useCompressionStream, password, passwordVerification, encryptionStrength, zipCrypto, signed }, { chunkSize }, ...strategies) {
+		super({}, ...strategies);
+		const stream = this;
+		let crc32Stream, encryptionStream;
+		let readable = filterEmptyChunks(super.readable);
+		const encrypted = Boolean(password);
+		if ((!encrypted || zipCrypto) && signed) {
+			[readable, crc32Stream] = readable.tee();
+			crc32Stream = crc32Stream.pipeThrough(new Crc32Stream());
+		}
+		if (compressed) {
+			if ((useCompressionStream !== undefined && !useCompressionStream) || typeof CompressionStream == UNDEFINED_TYPE) {
+				readable = pipeCodecStream(codecConstructor, readable, chunkSize);
+			} else {
+				try {
+					const compressionStream = new CompressionStream(COMPRESSION_FORMAT);
+					readable = readable.pipeThrough(compressionStream);
+				} catch (_error) {
+					readable = pipeCodecStream(codecConstructor, readable, chunkSize);
+				}
+			}
+		}
+		if (encrypted) {
+			if (zipCrypto) {
+				readable = readable.pipeThrough(new ZipCryptoEncryptionStream(password, passwordVerification));
+			} else {
+				encryptionStream = new AESEncryptionStream(password, encryptionStrength);
+				readable = readable.pipeThrough(encryptionStream);
+			}
+		}
+		setReadable(stream, readable, async () => {
+			let signature;
+			if (encrypted && !zipCrypto) {
+				signature = encryptionStream.signature;
+			}
+			if ((!encrypted || zipCrypto) && signed) {
+				signature = await crc32Stream.getReader().read();
+				signature = new DataView(signature.value.buffer).getUint32(0);
+			}
+			stream.signature = signature;
+		});
+	}
+}
+
+class InflateStream extends TransformStream {
+
+	constructor(codecConstructor, { zipCrypto, password, passwordVerification, signed, encryptionStrength, compressed, useCompressionStream }, { chunkSize }, ...strategies) {
+		super({}, ...strategies);
+		const stream = this;
+		let crc32Stream, decryptionStream;
+		let readable = filterEmptyChunks(super.readable);
+		const encrypted = Boolean(password);
+		if (encrypted) {
+			if (zipCrypto) {
+				readable = readable.pipeThrough(new ZipCryptoDecryptionStream(password, passwordVerification));
+			} else {
+				decryptionStream = new AESDecryptionStream(password, signed, encryptionStrength);
+				readable = readable.pipeThrough(decryptionStream);
+			}
+		}
+		if (compressed) {
+			if ((useCompressionStream !== undefined && !useCompressionStream) || typeof DecompressionStream == UNDEFINED_TYPE) {
+				readable = pipeCodecStream(codecConstructor, readable, chunkSize);
+			} else {
+				try {
+					readable = readable.pipeThrough(new DecompressionStream(COMPRESSION_FORMAT));
+				} catch (_error) {
+					readable = pipeCodecStream(codecConstructor, readable, chunkSize);
+				}
+			}
+		}
+		if ((!encrypted || zipCrypto) && signed) {
+			[readable, crc32Stream] = readable.tee();
+			crc32Stream = crc32Stream.pipeThrough(new Crc32Stream());
+		}
+		setReadable(stream, readable, async () => {
+			let signature;
+			if (encrypted && !zipCrypto) {
+				if (!decryptionStream.valid) {
+					throw new Error(ERR_INVALID_SIGNATURE);
+				}
+			}
+			if ((!encrypted || zipCrypto) && signed) {
+				signature = await crc32Stream.getReader().read();
+				const dataViewSignature = new DataView(signature.value.buffer);
+				if (signature != dataViewSignature.getUint32(0, false)) {
+					throw new Error(ERR_INVALID_SIGNATURE);
+				}
+			}
+		});
+	}
+}
+
+export {
+	DeflateStream,
+	InflateStream,
+	ERR_INVALID_PASSWORD,
+	ERR_INVALID_SIGNATURE
+};
+
+function pipeCodecStream(codecConstructor, stream, chunkSize) {
+	return stream.pipeThrough(new CodecStream(codecConstructor, { chunkSize }));
+}
+
+function filterEmptyChunks(readable) {
+	return readable.pipeThrough(new TransformStream({
+		transform(chunk, controller) {
+			if (chunk && chunk.length) {
+				controller.enqueue(chunk);
+			}
+		}
+	}));
+}
+
+function setReadable(stream, readable, flush) {
+	stream.length = 0;
+	readable = readable.pipeThrough(new TransformStream({
+		transform(chunk, controller) {
+			if (chunk && chunk.length) {
+				stream.length += chunk.length;
+				controller.enqueue(chunk);
+			}
+		}, flush
+	}));
+	Object.defineProperty(stream, "readable", {
+		get() {
+			return readable;
+		}
+	});
+}

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

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global self, importScripts, addEventListener, postMessage */
+/* global self, importScripts, addEventListener, postMessage, ReadableStream, WritableStream */
 
 import {
 	createCodec,
@@ -37,7 +37,8 @@ import {
 	MESSAGE_PULL,
 	MESSAGE_DATA,
 	MESSAGE_ABORT,
-} from "./codecs/codec.js";
+	MESSAGE_CLOSE
+} from "./codec-interface.js";
 
 const pendingMessages = new Map();
 let codec;
@@ -78,16 +79,30 @@ async function init(message) {
 		} else if (options.codecType.startsWith(CODEC_INFLATE)) {
 			codecConstructor = self.Inflate;
 		}
-		codec = createCodec(codecConstructor, options, message.config);
-		codec.ondata = data => sendMessage({ type: MESSAGE_DATA, data });
-		codec.onerror = error => postMessage({ error: { message: error.message, stack: error.stack } });
-		codec.pull = () => {
-			const result = new Promise((resolve, reject) => pendingMessages.set(messageId, { resolve, reject }));
-			sendMessage({ type: MESSAGE_PULL, messageId });
-			messageId++;
-			return result;
-		};
-		await codec.start();
+		const readable = new ReadableStream({
+			async pull(controller) {
+				let result = new Promise((resolve, reject) => pendingMessages.set(messageId, { resolve, reject }));
+				sendMessage({ type: MESSAGE_PULL, messageId });
+				messageId++;
+				const { value, done } = await result;
+				// debugger;
+				controller.enqueue(value);
+				if (done) {
+					controller.close();
+				}
+			}
+		}, {
+			highWaterMark: 1
+		});
+		const writable = new WritableStream({
+			write(data) {
+				sendMessage({ type: MESSAGE_DATA, data });
+			}
+		});
+		codec = createCodec(codecConstructor, readable, writable, options, message.config);
+		const result = await codec.run();
+		sendMessage({ type: MESSAGE_CLOSE, result });
+
 	} catch (error) {
 		postMessage({ error: { message: error.message, stack: error.stack } });
 	}
@@ -95,11 +110,11 @@ async function init(message) {
 
 function sendMessage(message) {
 	if (message.data) {
-		const data = message.data.value.data;
+		const data = message.data;
 		if (data && data.length) {
 			try {
-				message.data.value.data = data.buffer;
-				postMessage(message, [message.data.value.data]);
+				message.data = data.buffer;
+				postMessage(message, [message.data]);
 			} catch (_error) {
 				postMessage(message);
 			}

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

@@ -26,7 +26,6 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-export { ERR_ABORT } from "./engine.js";
 import {
 	Reader,
 	TextReader,
@@ -419,6 +418,7 @@ class FS {
 }
 
 const fs = { FS, ZipDirectoryEntry, ZipFileEntry };
+export { ERR_ABORT } from "./codec-pool.js";
 export { fs };
 
 function getTotalSize(entries, propertyName) {