@zip.js/zip.js 2.6.33 → 2.6.34

package/index.d.ts

@@ -7,6 +7,7 @@ declare global {
      * 
      * @see {@link https://wicg.github.io/entries-api/#api-entry|specification}
      */
+    // deno-lint-ignore no-empty-interface
     interface FileSystemEntry { }
 }
 
@@ -141,6 +142,7 @@ interface WorkerConfiguration {
  * @param registerDataHandler The function called to handle the `data` events triggered by a third-party codec implementation.
  * @returns An instance containing classes compatible with `ZipDeflate` and `ZipInflate`.
  */
+// deno-lint-ignore no-explicit-any
 export function initShimAsyncCodec(library: EventBasedZipLibrary, constructorOptions: any | null, registerDataHandler: registerDataHandler): ZipLibrary
 
 /**
@@ -367,11 +369,13 @@ export class Uint8ArrayReader extends Reader<Uint8Array> { }
 /**
  * Represents a `Reader` instance used to read data provided as an array of `Reader` instances (i.e. split zip files).
  */
+// deno-lint-ignore no-explicit-any
 export class SplitZipReader extends Reader<Reader<any>[] | ReadableReader[] | ReadableStream[]> { }
 
 /** 
  * Represents a URL stored into a `string`.
  */
+// deno-lint-ignore no-empty-interface
 interface URLString extends String { }
 
 /**
@@ -538,6 +542,27 @@ export class Data64URIWriter extends Writer<string> {
     constructor(mimeString?: string)
 }
 
+/**
+ * Represents a `Writer` instance used to retrieve the written data from a generator of `Writer` instances  (i.e. split zip files).
+ */
+export class SplitZipWriter implements DataProcessor, WritableWriter {
+    /**
+    * The `WritableStream` instance.
+    */
+    writable: WritableStream
+    /**
+     * Initializes the instance asynchronously
+     */
+    init(): Promise<void>
+    /**
+     * Creates the `SplitZipWriter` instance
+     * 
+     * @param writerGenerator The MIME type of the content.
+     * @param maxSize The maximum size of the data written into `Writer` instances.
+     */
+    constructor(writerGenerator: AsyncGenerator<Writer<any> | WritableWriter | WritableStream, boolean>, maxSize: number)
+}
+
 /**
  * Represents a `Writer` instance used to retrieve the written data as a `Uint8Array` instance.
  */
@@ -582,6 +607,7 @@ export class ZipReader<Type> {
      * @param reader The `Reader` instance used to read data.
      * @param options The options.
      */
+    // deno-lint-ignore no-explicit-any
     constructor(reader: Reader<Type> | ReadableReader | ReadableStream | Reader<any>[] | ReadableReader[] | ReadableStream[], options?: ZipReaderConstructorOptions)
     /**
      * The global comment of the zip file.
@@ -792,6 +818,10 @@ export interface Entry {
      * The external file attribute (raw).
      */
     externalFileAttribute: number
+    /**
+     * The number of the disk where the entry data starts.
+     */
+    diskNumberStart: number
     /**
      * Returns the content of the entry
      * 
@@ -834,7 +864,7 @@ export class ZipWriter<Type> {
      * @param writer The `Writer` instance where the zip content will be written.
      * @param options The options.
      */
-    constructor(writer: Writer<Type> | WritableWriter | WritableStream, options?: ZipWriterConstructorOptions)
+    constructor(writer: Writer<Type> | WritableWriter | WritableStream | SplitZipWriter | AsyncGenerator<Writer<any> | WritableWriter | WritableStream, boolean>, options?: ZipWriterConstructorOptions)
     /**
      * `true` if the zip contains at least one entry that has been partially written.
      */
@@ -1444,4 +1474,5 @@ export const ERR_INVALID_EXTRAFIELD_TYPE: string
 export const ERR_INVALID_EXTRAFIELD_DATA: string
 export const ERR_INVALID_ENCRYPTION_STRENGTH: string
 export const ERR_UNSUPPORTED_FORMAT: string
-export const ERR_SPLIT_ZIP_FILE: string
+export const ERR_SPLIT_ZIP_FILE: string
+export const ERR_ITERATOR_COMPLETED_TOO_SOON: string

package/index.js

@@ -55,6 +55,7 @@ export {
 	Uint8ArrayWriter,
 	Uint8ArrayReader,
 	SplitZipReader,
+	SplitZipWriter,
 	ERR_HTTP_RANGE,
 	ERR_BAD_FORMAT,
 	ERR_EOCDR_NOT_FOUND,
@@ -77,6 +78,7 @@ export {
 	ERR_INVALID_EXTRAFIELD_DATA,
 	ERR_INVALID_ENCRYPTION_STRENGTH,
 	ERR_UNSUPPORTED_FORMAT,
-	ERR_SPLIT_ZIP_FILE
+	ERR_SPLIT_ZIP_FILE,
+	ERR_ITERATOR_COMPLETED_TOO_SOON
 } from "./lib/zip-fs.js";
 export { getMimeType, terminateWorkers };

package/lib/core/codec-pool.js

@@ -34,8 +34,8 @@ import {
 	CODEC_DEFLATE,
 	ERR_INVALID_SIGNATURE,
 	ERR_INVALID_PASSWORD
-} from "./codec-interface.js";
-import { CodecWorker } from "./codec-pool-worker.js";
+} from "./streams/codec-stream.js";
+import { CodecWorker } from "./codec-worker.js";
 
 let pool = [];
 const pendingRequests = [];

package/lib/core/codec-worker.js

@@ -0,0 +1,321 @@
+/*
+ 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 Worker, URL, TransformStream, WritableStream */
+
+import {
+	UNDEFINED_TYPE,
+	FUNCTION_TYPE
+} from "./constants.js";
+import {
+	CodecStream,
+	MESSAGE_EVENT_TYPE,
+	MESSAGE_START,
+	MESSAGE_PULL,
+	MESSAGE_DATA,
+	MESSAGE_ACK_DATA,
+	MESSAGE_CLOSE
+} from "./streams/codec-stream.js";
+
+// deno-lint-ignore valid-typeof
+const WEB_WORKERS_SUPPORTED = typeof Worker != UNDEFINED_TYPE;
+
+export {
+	CodecWorker
+};
+
+class CodecWorker {
+
+	constructor(workerData, stream, workerOptions, onTaskFinished) {
+		const { readable, writable } = stream;
+		const { options, config, streamOptions, useWebWorkers, transferStreams, scripts } = workerOptions;
+		const { signal } = streamOptions;
+		Object.assign(workerData, {
+			busy: true,
+			readable: readable.pipeThrough(new ReadableStreamHooks(readable, streamOptions, config), { signal }),
+			writable,
+			options: Object.assign({}, options),
+			scripts,
+			transferStreams,
+			terminate() {
+				const { worker, busy } = workerData;
+				if (worker && !busy) {
+					worker.terminate();
+					workerData.interface = null;
+				}
+			},
+			onTaskFinished() {
+				workerData.busy = false;
+				onTaskFinished(workerData);
+			}
+		});
+		return (useWebWorkers && WEB_WORKERS_SUPPORTED ? createWebWorkerInterface : createWorkerInterface)(workerData, config);
+	}
+}
+
+class ReadableStreamHooks extends TransformStream {
+
+	constructor(readableSource, { onstart, onprogress, size, onend }, { chunkSize }) {
+		let chunkOffset = 0;
+		super({
+			start() {
+				if (onstart) {
+					callHandler(onstart, size);
+				}
+			},
+			async transform(chunk, controller) {
+				chunkOffset += chunk.length;
+				if (onprogress) {
+					await callHandler(onprogress, chunkOffset, size);
+				}
+				controller.enqueue(chunk);
+			},
+			flush() {
+				readableSource.size = chunkOffset;
+				if (onend) {
+					callHandler(onend, chunkOffset);
+				}
+			}
+		}, { highWaterMark: 1, size: () => chunkSize });
+	}
+}
+
+async function callHandler(handler, ...parameters) {
+	try {
+		await handler(...parameters);
+	} catch (_error) {
+		// ignored
+	}
+}
+
+function createWorkerInterface(workerData, config) {
+	return {
+		run: () => runWorker(workerData, config)
+	};
+}
+
+function createWebWorkerInterface(workerData, { baseURL, chunkSize }) {
+	if (!workerData.interface) {
+		Object.assign(workerData, {
+			worker: getWebWorker(workerData.scripts[0], baseURL, workerData),
+			interface: {
+				run: () => runWebWorker(workerData, { chunkSize })
+			}
+		});
+	}
+	return workerData.interface;
+}
+
+async function runWorker({ options, readable, writable, onTaskFinished }, config) {
+	const codecStream = new CodecStream(options, config);
+	try {
+		await readable.pipeThrough(codecStream).pipeTo(writable, { preventClose: true, preventAbort: true });
+		const {
+			signature,
+			size
+		} = codecStream;
+		return {
+			signature,
+			size
+		};
+	} finally {
+		onTaskFinished();
+	}
+}
+
+async function runWebWorker(workerData, config) {
+	let resolveResult, rejectResult;
+	const result = new Promise((resolve, reject) => {
+		resolveResult = resolve;
+		rejectResult = reject;
+	});
+	Object.assign(workerData, {
+		reader: null,
+		writer: null,
+		resolveResult,
+		rejectResult,
+		result
+	});
+	const { readable, options } = workerData;
+	const { writable, closed } = detectClosedStream(workerData.writable);
+	const streamsTransferred = sendMessage({
+		type: MESSAGE_START,
+		scripts: workerData.scripts.slice(1),
+		options,
+		config,
+		readable,
+		writable
+	}, workerData);
+	if (!streamsTransferred) {
+		Object.assign(workerData, {
+			reader: readable.getReader(),
+			writer: writable.getWriter()
+		});
+	}
+	const resultValue = await result;
+	try {
+		await writable.close();
+	} catch (_error) {
+		// ignored
+	}
+	await closed;
+	return resultValue;
+}
+
+function detectClosedStream(writableSource) {
+	const writer = writableSource.getWriter();
+	let resolveStreamClosed;
+	const closed = new Promise(resolve => resolveStreamClosed = resolve);
+	const writable = new WritableStream({
+		async write(chunk) {
+			await writer.ready;
+			await writer.write(chunk);
+		},
+		close() {
+			writer.releaseLock();
+			resolveStreamClosed();
+		},
+		abort(reason) {
+			writer.abort(reason);
+		}
+	});
+	return { writable, closed };
+}
+
+let classicWorkersSupported = true;
+let transferStreamsSupported = true;
+
+function getWebWorker(url, baseURL, workerData) {
+	const workerOptions = { type: "module" };
+	let scriptUrl, worker;
+	if (typeof url == FUNCTION_TYPE) {
+		url = url();
+	}
+	try {
+		scriptUrl = new URL(url, baseURL);
+	} catch (_error) {
+		scriptUrl = url;
+	}
+	if (classicWorkersSupported) {
+		try {
+			worker = new Worker(scriptUrl);
+		} catch (_error) {
+			classicWorkersSupported = false;
+			worker = new Worker(scriptUrl, workerOptions);
+		}
+	} else {
+		worker = new Worker(scriptUrl, workerOptions);
+	}
+	worker.addEventListener(MESSAGE_EVENT_TYPE, event => onMessage(event, workerData));
+	return worker;
+}
+
+function sendMessage(message, { worker, writer, onTaskFinished, transferStreams }) {
+	try {
+		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 (transferStreams && transferStreamsSupported) {
+			if (readable) {
+				transferrables.push(readable);
+			}
+			if (writable) {
+				transferrables.push(writable);
+			}
+		} else {
+			message.readable = message.writable = null;
+		}
+		if (transferrables.length) {
+			try {
+				worker.postMessage(message, transferrables);
+				return true;
+			} catch (_error) {
+				transferStreamsSupported = false;
+				message.readable = message.writable = null;
+				worker.postMessage(message);
+			}
+		} else {
+			worker.postMessage(message);
+		}
+	} catch (error) {
+		if (writer) {
+			writer.releaseLock();
+		}
+		onTaskFinished();
+		throw error;
+	}
+}
+
+async function onMessage(event, workerData) {
+	const message = event.data;
+	const { reader, writer, resolveResult, rejectResult, onTaskFinished } = workerData;
+	const { type, data, messageId, result } = message;
+	const reponseError = message.error;
+	try {
+		if (reponseError) {
+			const { message, stack, code, name } = reponseError;
+			const error = new Error(message);
+			Object.assign(error, { stack, code, name });
+			close(error);
+		} else {
+			if (type == MESSAGE_PULL) {
+				const { value, done } = await reader.read();
+				sendMessage({ type: MESSAGE_DATA, data: value, done, messageId }, workerData);
+			}
+			if (type == MESSAGE_DATA) {
+				await writer.ready;
+				await writer.write(new Uint8Array(data));
+				sendMessage({ type: MESSAGE_ACK_DATA, messageId }, workerData);
+			}
+			if (type == MESSAGE_CLOSE) {
+				close(null, result);
+			}
+		}
+	} catch (error) {
+		close(error);
+	}
+
+	function close(error, result) {
+		if (error) {
+			rejectResult(error);
+		} else {
+			resolveResult(result);
+		}
+		if (writer) {
+			writer.releaseLock();
+		}
+		onTaskFinished();
+	}
+}

package/lib/core/configuration.js

@@ -28,11 +28,11 @@
 
 /* global navigator, CompressionStream, DecompressionStream */
 
-import { getCodecStreamClass } from "./codec-interface.js";
 import {
 	UNDEFINED_VALUE,
 	UNDEFINED_TYPE
 } from "./constants.js";
+import { StreamAdapter } from "./streams/stream-adapter.js";
 
 const MINIMUM_CHUNK_SIZE = 64;
 let maxWorkers = 2;
@@ -91,10 +91,10 @@ function configure(configuration) {
 	setIfDefined("useCompressionStream", useCompressionStream);
 	setIfDefined("useWebWorkers", useWebWorkers);
 	if (Deflate) {
-		config.CompressionStream = getCodecStreamClass(Deflate);
+		config.CompressionStream = new StreamAdapter(Deflate);
 	}
 	if (Inflate) {
-		config.DecompressionStream = getCodecStreamClass(Inflate);
+		config.DecompressionStream = new StreamAdapter(Inflate);
 	}
 	setIfDefined("CompressionStream", CompressionStream);
 	setIfDefined("DecompressionStream", DecompressionStream);

package/lib/core/constants.js

@@ -33,7 +33,8 @@ const COMPRESSION_METHOD_STORE = 0x00;
 const COMPRESSION_METHOD_AES = 0x63;
 
 const LOCAL_FILE_HEADER_SIGNATURE = 0x04034b50;
-const DATA_DESCRIPTOR_RECORD_SIGNATURE = 0x08074b50;
+const SPLIT_ZIP_FILE_SIGNATURE = 0x08074b50;
+const DATA_DESCRIPTOR_RECORD_SIGNATURE = SPLIT_ZIP_FILE_SIGNATURE;
 const CENTRAL_FILE_HEADER_SIGNATURE = 0x02014b50;
 const END_OF_CENTRAL_DIR_SIGNATURE = 0x06054b50;
 const ZIP64_END_OF_CENTRAL_DIR_SIGNATURE = 0x06064b50;
@@ -43,8 +44,6 @@ const ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH = 20;
 const ZIP64_END_OF_CENTRAL_DIR_LENGTH = 56;
 const ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH = END_OF_CENTRAL_DIR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH + ZIP64_END_OF_CENTRAL_DIR_LENGTH;
 
-const ZIP64_TOTAL_NUMBER_OF_DISKS = 1;
-
 const EXTRAFIELD_TYPE_ZIP64 = 0x0001;
 const EXTRAFIELD_TYPE_AES = 0x9901;
 const EXTRAFIELD_TYPE_NTFS = 0x000a;
@@ -70,6 +69,7 @@ const MIN_DATE = new Date(1980, 0, 1);
 
 const UNDEFINED_VALUE = undefined;
 const UNDEFINED_TYPE = "undefined";
+const FUNCTION_TYPE = "function";
 
 export {
 	MAX_32_BITS,
@@ -77,6 +77,7 @@ export {
 	COMPRESSION_METHOD_DEFLATE,
 	COMPRESSION_METHOD_STORE,
 	COMPRESSION_METHOD_AES,
+	SPLIT_ZIP_FILE_SIGNATURE,
 	LOCAL_FILE_HEADER_SIGNATURE,
 	DATA_DESCRIPTOR_RECORD_SIGNATURE,
 	CENTRAL_FILE_HEADER_SIGNATURE,
@@ -94,7 +95,6 @@ export {
 	ZIP64_END_OF_CENTRAL_DIR_LOCATOR_LENGTH,
 	ZIP64_END_OF_CENTRAL_DIR_LENGTH,
 	ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH,
-	ZIP64_TOTAL_NUMBER_OF_DISKS,
 	BITFLAG_ENCRYPTED,
 	BITFLAG_LEVEL,
 	BITFLAG_DATA_DESCRIPTOR,
@@ -107,5 +107,6 @@ export {
 	MIN_DATE,
 	MAX_DATE,
 	UNDEFINED_VALUE,
-	UNDEFINED_TYPE
+	UNDEFINED_TYPE,
+	FUNCTION_TYPE
 };

package/lib/core/io.js

@@ -27,9 +27,11 @@
  */
 
 /* global Blob, atob, btoa, XMLHttpRequest, URL, fetch, ReadableStream, WritableStream, FileReader, TransformStream, Response */
+// deno-lint-ignore-file no-this-alias
 
 const ERR_HTTP_STATUS = "HTTP error ";
 const ERR_HTTP_RANGE = "HTTP Range not supported";
+const ERR_ITERATOR_COMPLETED_TOO_SOON = "Writer iterator completed too soon";
 
 const CONTENT_TYPE_TEXT_PLAIN = "text/plain";
 const HTTP_HEADER_CONTENT_LENGTH = "Content-Length";
@@ -565,6 +567,65 @@ class SplitZipReader extends Reader {
 	}
 }
 
+class SplitZipWriter extends Stream {
+
+	constructor(writerGenerator, maxSize = 4294967296) {
+		super();
+		const writer = this;
+		Object.assign(writer, {
+			diskNumber: 0,
+			diskOffset: 0,
+			size: 0,
+			availableSize: maxSize
+		});
+		let currentWriter, diskWritable, diskWriter;
+		const writable = new WritableStream({
+			async write(chunk) {
+				if (!diskWriter) {
+					const { value, done } = await writerGenerator.next();
+					if (done && !value) {
+						throw new Error(ERR_ITERATOR_COMPLETED_TOO_SOON);
+					} else {
+						currentWriter = value;
+						currentWriter.size = 0;
+						diskWritable = value.writable;
+						diskWriter = diskWritable.getWriter();
+					}
+					await this.write(chunk);
+				} else if (diskWriter && currentWriter.size + chunk.length > maxSize) {
+					await diskWriter.ready;
+					const chunkLength = maxSize - currentWriter.size;
+					await diskWriter.write(chunk.slice(0, chunkLength));
+					chunk = chunk.slice(chunkLength);
+					currentWriter.size += chunkLength;
+					writer.size += chunkLength;
+					writer.diskOffset += diskWritable.size = currentWriter.size;
+					writer.diskNumber++;
+					await diskWriter.close();
+					diskWriter = null;
+					await this.write(chunk);
+				} else {
+					await diskWriter.ready;
+					await diskWriter.write(chunk);
+					currentWriter.size += chunk.length;
+					writer.size += chunk.length;
+				}
+				writer.availableSize = maxSize - currentWriter.size;
+			},
+			async close() {
+				await diskWriter.ready;
+				diskWritable.size = currentWriter.size;
+				await diskWriter.close();
+			}
+		});
+		Object.defineProperty(writer, PROPERTY_NAME_WRITABLE, {
+			get() {
+				return writable;
+			}
+		});
+	}
+}
+
 function isHttpFamily(url) {
 	const { baseURL } = getConfiguration();
 	const { protocol } = new URL(url, baseURL);
@@ -597,5 +658,7 @@ export {
 	HttpReader,
 	HttpRangeReader,
 	SplitZipReader,
-	ERR_HTTP_RANGE
+	SplitZipWriter,
+	ERR_HTTP_RANGE,
+	ERR_ITERATOR_COMPLETED_TOO_SOON
 };

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

@@ -56,6 +56,7 @@ const SIGNATURE_LENGTH = 10;
 const COUNTER_DEFAULT_VALUE = [0, 0, 0, 0];
 const UNDEFINED_TYPE = "undefined";
 const FUNCTION_TYPE = "function";
+// deno-lint-ignore valid-typeof
 const CRYPTO_API_SUPPORTED = typeof crypto != UNDEFINED_TYPE;
 const subtle = CRYPTO_API_SUPPORTED && crypto.subtle;
 const SUBTLE_API_SUPPORTED = CRYPTO_API_SUPPORTED && typeof subtle != UNDEFINED_TYPE;
@@ -132,6 +133,7 @@ class AESDecryptionStream extends TransformStream {
 class AESEncryptionStream extends TransformStream {
 
 	constructor(password, strength) {
+		// deno-lint-ignore prefer-const
 		let stream;
 		super({
 			start() {

package/lib/core/streams/codec-stream.js

@@ -34,25 +34,72 @@
  */
 
 /* global TransformStream */
+// deno-lint-ignore-file no-this-alias
+
+import {
+	ERR_INVALID_PASSWORD,
+	ERR_INVALID_SIGNATURE,
+	InflateStream,
+	DeflateStream
+} from "./zip-entry-stream.js";
+
+const MESSAGE_EVENT_TYPE = "message";
+const MESSAGE_START = "start";
+const MESSAGE_PULL = "pull";
+const MESSAGE_DATA = "data";
+const MESSAGE_ACK_DATA = "ack";
+const MESSAGE_CLOSE = "close";
+const CODEC_DEFLATE = "deflate";
+const CODEC_INFLATE = "inflate";
+
+export {
+	CODEC_DEFLATE,
+	CODEC_INFLATE,
+	MESSAGE_EVENT_TYPE,
+	MESSAGE_START,
+	MESSAGE_PULL,
+	MESSAGE_DATA,
+	MESSAGE_ACK_DATA,
+	MESSAGE_CLOSE,
+	ERR_INVALID_PASSWORD,
+	ERR_INVALID_SIGNATURE,
+	CodecStream
+};
 
 class CodecStream extends TransformStream {
 
-	constructor(Codec, options) {
-		const codec = new Codec(options);
-		super({
+	constructor(options, config) {
+		super({});
+		const codec = this;
+		const { codecType } = options;
+		let Stream;
+		if (codecType.startsWith(CODEC_DEFLATE)) {
+			Stream = DeflateStream;
+		} else if (codecType.startsWith(CODEC_INFLATE)) {
+			Stream = InflateStream;
+		}
+		let size = 0;
+		const stream = new Stream(options, config);
+		const readable = super.readable;
+		const transformStream = new TransformStream({
 			transform(chunk, controller) {
-				controller.enqueue(codec.append(chunk));
-			},
-			flush(controller) {
-				const chunk = codec.flush();
-				if (chunk) {
+				if (chunk && chunk.length) {
+					size += chunk.length;
 					controller.enqueue(chunk);
 				}
+			},
+			flush() {
+				const { signature } = stream;
+				Object.assign(codec, {
+					signature,
+					size
+				});
+			}
+		});
+		Object.defineProperty(codec, "readable", {
+			get() {
+				return readable.pipeThrough(stream).pipeThrough(transformStream);
 			}
 		});
 	}
-}
-
-export {
-	CodecStream
-};
+}