@zip.js/zip.js 2.5.3 → 2.5.7

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 */
+/* global Blob, FileReader, atob, btoa, XMLHttpRequest, document, fetch, ReadableStream, WritableStream */
 
 const ERR_HTTP_STATUS = "HTTP error ";
 const ERR_HTTP_RANGE = "HTTP Range not supported";
@@ -40,6 +40,7 @@ const HTTP_HEADER_RANGE = "Range";
 const HTTP_METHOD_HEAD = "HEAD";
 const HTTP_METHOD_GET = "GET";
 const HTTP_RANGE_UNIT = "bytes";
+const DEFAULT_CHUNK_SIZE = 64 * 1024;
 
 class Stream {
 
@@ -53,9 +54,39 @@ class Stream {
 }
 
 class Reader extends Stream {
+
+	getStream({ offset, size, chunkSize } = { offset: 0, chunkSize: DEFAULT_CHUNK_SIZE }) {
+		const reader = this;
+		return new ReadableStream({
+			start() {
+				this.chunkOffset = 0;
+			},
+			async pull(controller) {
+				const { chunkOffset } = this;
+				controller.enqueue(await reader.readUint8Array(offset + chunkOffset, Math.min(chunkSize, size() - chunkOffset)));
+				if (chunkOffset + chunkSize > size()) {
+					controller.close();
+				} else {
+					this.chunkOffset += chunkSize;
+				}
+			}
+		});
+	}
+}
+
+class WriterStream extends Stream {
+
+	getStream() {
+		const writer = this;
+		return new WritableStream({
+			write(chunk) {
+				return writer.writeUint8Array(chunk);
+			}
+		});
+	}
 }
 
-class Writer extends Stream {
+class Writer extends WriterStream {
 
 	writeUint8Array(array) {
 		this.size += array.length;
@@ -70,9 +101,10 @@ class TextReader extends Reader {
 	}
 
 	init() {
+		const reader = this;
 		super.init();
-		this.blobReader.init();
-		this.size = this.blobReader.size;
+		reader.blobReader.init();
+		reader.size = reader.blobReader.size;
 	}
 
 	readUint8Array(offset, length) {
@@ -94,14 +126,15 @@ class TextWriter extends Writer {
 	}
 
 	getData() {
-		if (this.blob.text) {
-			return this.blob.text();
+		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(this.blob, this.encoding);
+				reader.readAsText(writer.blob, writer.encoding);
 			});
 		}
 	}
@@ -111,19 +144,21 @@ class Data64URIReader extends Reader {
 
 	constructor(dataURI) {
 		super();
-		this.dataURI = dataURI;
+		const reader = this;
+		reader.dataURI = dataURI;
 		let dataEnd = dataURI.length;
 		while (dataURI.charAt(dataEnd - 1) == "=") {
 			dataEnd--;
 		}
-		this.dataStart = dataURI.indexOf(",") + 1;
-		this.size = Math.floor((dataEnd - this.dataStart) * 0.75);
+		reader.dataStart = dataURI.indexOf(",") + 1;
+		reader.size = Math.floor((dataEnd - reader.dataStart) * 0.75);
 	}
 
 	readUint8Array(offset, length) {
 		const dataArray = new Uint8Array(length);
 		const start = Math.floor(offset / 3) * 4;
-		const bytes = atob(this.dataURI.substring(start + this.dataStart, Math.ceil((offset + length) / 3) * 4 + this.dataStart));
+		const dataStart = this.dataStart;
+		const bytes = atob(this.dataURI.substring(start + dataStart, Math.ceil((offset + length) / 3) * 4 + dataStart));
 		const delta = offset - Math.floor(start / 4) * 3;
 		for (let indexByte = delta; indexByte < delta + length; indexByte++) {
 			dataArray[indexByte - delta] = bytes.charCodeAt(indexByte);
@@ -142,20 +177,21 @@ class Data64URIWriter extends Writer {
 
 	writeUint8Array(array) {
 		super.writeUint8Array(array);
+		const writer = this;
 		let indexArray = 0;
-		let dataString = this.pending;
-		const delta = this.pending.length;
-		this.pending = "";
+		let dataString = writer.pending;
+		const delta = writer.pending.length;
+		writer.pending = "";
 		for (indexArray = 0; indexArray < (Math.floor((delta + array.length) / 3) * 3) - delta; indexArray++) {
 			dataString += String.fromCharCode(array[indexArray]);
 		}
 		for (; indexArray < array.length; indexArray++) {
-			this.pending += String.fromCharCode(array[indexArray]);
+			writer.pending += String.fromCharCode(array[indexArray]);
 		}
 		if (dataString.length > 2) {
-			this.data += btoa(dataString);
+			writer.data += btoa(dataString);
 		} else {
-			this.pending = dataString;
+			writer.pending = dataString;
 		}
 	}
 
@@ -173,14 +209,15 @@ class BlobReader extends Reader {
 	}
 
 	async readUint8Array(offset, length) {
-		if (this.blob.arrayBuffer) {
-			return new Uint8Array(await this.blob.slice(offset, offset + length).arrayBuffer());
+		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(this.blob.slice(offset, offset + length));
+				reader.readAsArrayBuffer(reader.blob.slice(offset, offset + length));
 			});
 		}
 	}
@@ -197,21 +234,23 @@ class BlobWriter extends Writer {
 
 	writeUint8Array(array) {
 		super.writeUint8Array(array);
-		if (this.arrayBuffers.length == this.arrayBuffersMaxlength) {
-			flushArrayBuffers(this);
+		const writer = this;
+		if (writer.arrayBuffers.length == writer.arrayBuffersMaxlength) {
+			flushArrayBuffers(writer);
 		}
-		this.arrayBuffers.push(array.buffer);
+		writer.arrayBuffers.push(array.buffer);
 	}
 
 	getData() {
-		if (!this.blob) {
-			if (this.arrayBuffers.length) {
-				flushArrayBuffers(this);
+		const writer = this;
+		if (!writer.blob) {
+			if (writer.arrayBuffers.length) {
+				flushArrayBuffers(writer);
 			}
-			this.blob = this.pendingBlob;
-			initArrayBuffers(this);
+			writer.blob = writer.pendingBlob;
+			initArrayBuffers(writer);
 		}
-		return this.blob;
+		return writer.blob;
 	}
 }
 
@@ -229,78 +268,38 @@ class ReadableStreamReader {
 
 	constructor(readableStream) {
 		this.readableStream = readableStream;
-		this.reader = readableStream.getReader();
 		this.size = Infinity;
-		this.index = 0;
-		this.currentSize = 0;
-		this.pendingValue = new Uint8Array();
 	}
 
-	init() {
+	init(size) {
+		this.size = size;
 		this.initialized = true;
 	}
 
-	async readUint8Array(index, length) {
-		if (this.index != index) {
-			throw new Error(ERR_NOT_SEEKABLE_READER);
-		}
-		let data = new Uint8Array(length);
-		let size = 0, done;
-		do {
-			const result = await this.reader.read();
-			let { value } = result;
-			done = result.done;
-			if (value) {
-				this.currentSize += value.length;
-			} else {
-				value = this.pendingValue;
-				this.pendingValue = new Uint8Array();
-			}
-			if (this.pendingValue.length) {
-				const newValue = new Uint8Array(this.pendingValue.length + value.length);
-				newValue.set(this.pendingValue);
-				newValue.set(value, this.pendingValue.length);
-				this.pendingValue = new Uint8Array();
-				value = newValue;
-			}
-			if (size + value.length > length) {
-				data.set(value.subarray(0, length), size);
-				this.pendingValue = value.subarray(length);
-				size += length;
-			} else {
-				data.set(value, size);
-				size += value.length;
-			}
-		} while (size < length && !done);
-		if (done && this.size == Infinity) {
-			this.size = this.currentSize;
-		}
-		if (this.size < length) {
-			data = data.slice(0, this.size);
-			length = this.size;
-		}
-		this.index += length;
-		return data;
+	getStream() {
+		return this.readableStream;
 	}
 }
 
 class WritableStreamWriter extends Writer {
 
-	constructor(writableStream) {
+	constructor(writable) {
 		super();
-		this.writableStream = writableStream;
-		this.writer = writableStream.getWriter();
+		const writer = this;
+		writer.writable = writable;
 	}
 
 	async writeUint8Array(array) {
 		await this.writer.ready;
-		return this.writer.write(array);
+		return this.writable.getWriter().write(array);
+	}
+
+	getStream() {
+		return this.writable;
 	}
 
 	async getData() {
-		await this.writer.ready;
-		await this.writer.close();
-		return this.writableStream;
+		return this.writable;
 	}
 }
 
@@ -308,15 +307,16 @@ class FetchReader extends Reader {
 
 	constructor(url, options) {
 		super();
-		this.url = url;
-		this.preventHeadRequest = options.preventHeadRequest;
-		this.useRangeHeader = options.useRangeHeader;
-		this.forceRangeRequests = options.forceRangeRequests;
-		this.options = Object.assign({}, options);
-		delete this.options.preventHeadRequest;
-		delete this.options.useRangeHeader;
-		delete this.options.forceRangeRequests;
-		delete this.options.useXHR;
+		const reader = this;
+		reader.url = url;
+		reader.preventHeadRequest = options.preventHeadRequest;
+		reader.useRangeHeader = options.useRangeHeader;
+		reader.forceRangeRequests = options.forceRangeRequests;
+		reader.options = Object.assign({}, options);
+		delete reader.options.preventHeadRequest;
+		delete reader.options.useRangeHeader;
+		delete reader.options.forceRangeRequests;
+		delete reader.options.useXHR;
 	}
 
 	async init() {
@@ -333,11 +333,12 @@ class XHRReader extends Reader {
 
 	constructor(url, options) {
 		super();
-		this.url = url;
-		this.preventHeadRequest = options.preventHeadRequest;
-		this.useRangeHeader = options.useRangeHeader;
-		this.forceRangeRequests = options.forceRangeRequests;
-		this.options = options;
+		const reader = this;
+		reader.url = url;
+		reader.preventHeadRequest = options.preventHeadRequest;
+		reader.useRangeHeader = options.useRangeHeader;
+		reader.forceRangeRequests = options.forceRangeRequests;
+		reader.options = options;
 	}
 
 	async init() {
@@ -540,10 +541,11 @@ class Uint8ArrayWriter extends Writer {
 
 	writeUint8Array(array) {
 		super.writeUint8Array(array);
-		const previousArray = this.array;
-		this.array = new Uint8Array(previousArray.length + array.length);
-		this.array.set(previousArray);
-		this.array.set(array, previousArray.length);
+		const writer = this;
+		const previousArray = writer.array;
+		writer.array = new Uint8Array(previousArray.length + array.length);
+		writer.array.set(previousArray);
+		writer.array.set(array, previousArray.length);
 	}
 
 	getData() {

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,19 +36,19 @@
 /* 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) {
-					controller.enqueue(chunk);
-				}
+				chunk = codec.append(chunk);
+				controller.enqueue(chunk);
 			},
 			flush(controller) {
-				const chunk = this.codec.flush();
+				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) {
-					this.crc32.append(chunk);
-				}
+				this.crc32.append(chunk);
 			},
 			flush(controller) {
 				const value = new Uint8Array(4);