@zip.js/zip.js 2.7.73 → 2.8.0

package/lib/core/codec-pool.js

@@ -1,5 +1,5 @@
 /*
- Copyright (c) 2022 Gildas Lormeau. All rights reserved.
+ Copyright (c) 2025 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:
@@ -38,6 +38,7 @@ import {
 	ERR_ABORT_CHECK_PASSWORD
 } from "./streams/codec-stream.js";
 import { CodecWorker } from "./codec-worker.js";
+import { resetWasmModule } from "./streams/zlib/zlib-streams-loader.js";
 
 let pool = [];
 const pendingRequests = [];
@@ -57,12 +58,12 @@ let indexWorker = 0;
 
 async function runWorker(stream, workerOptions) {
 	const { options, config } = workerOptions;
-	const { transferStreams, useWebWorkers, useCompressionStream, codecType, compressed, signed, encrypted } = options;
-	const { workerScripts, maxWorkers } = config;
+	const { transferStreams, useWebWorkers, useCompressionStream, compressed, signed, encrypted } = options;
+	const { workerURI, maxWorkers } = config;
 	workerOptions.transferStreams = transferStreams || transferStreams === UNDEFINED_VALUE;
 	const streamCopy = !compressed && !signed && !encrypted && !workerOptions.transferStreams;
 	workerOptions.useWebWorkers = !streamCopy && (useWebWorkers || (useWebWorkers === UNDEFINED_VALUE && config.useWebWorkers));
-	workerOptions.scripts = workerOptions.useWebWorkers && workerScripts ? workerScripts[codecType] : [];
+	workerOptions.workerURI = workerOptions.useWebWorkers && workerURI ? workerURI : UNDEFINED_VALUE;
 	options.useCompressionStream = useCompressionStream || (useCompressionStream === UNDEFINED_VALUE && config.useCompressionStream);
 	return (await getWorker()).run();
 
@@ -128,4 +129,5 @@ async function terminateWorkers() {
 		clearTerminateTimeout(workerData);
 		return workerData.terminate();
 	}));
+	resetWasmModule();
 }

package/lib/core/codec-worker.js

@@ -1,5 +1,5 @@
 /*
- Copyright (c) 2022 Gildas Lormeau. All rights reserved.
+ Copyright (c) 2025 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:
@@ -42,7 +42,12 @@ import {
 	MESSAGE_ACK_DATA,
 	MESSAGE_CLOSE
 } from "./streams/codec-stream.js";
+import {
+	initModule,
+	initializedModule
+} from "./streams/zlib/zlib-streams-loader.js";
 
+// deno-lint-ignore valid-typeof
 let WEB_WORKERS_SUPPORTED = typeof Worker != UNDEFINED_TYPE;
 
 export {
@@ -51,7 +56,7 @@ export {
 
 class CodecWorker {
 
-	constructor(workerData, { readable, writable }, { options, config, streamOptions, useWebWorkers, transferStreams, scripts }, onTaskFinished) {
+	constructor(workerData, { readable, writable }, { options, config, streamOptions, useWebWorkers, transferStreams, workerURI }, onTaskFinished) {
 		const { signal } = streamOptions;
 		Object.assign(workerData, {
 			busy: true,
@@ -60,7 +65,7 @@ class CodecWorker {
 				.pipeThrough(new ProgressWatcherStream(streamOptions), { signal }),
 			writable,
 			options: Object.assign({}, options),
-			scripts,
+			workerURI,
 			transferStreams,
 			terminate() {
 				return new Promise(resolve => {
@@ -136,11 +141,17 @@ function createWorkerInterface(workerData, config) {
 }
 
 function createWebWorkerInterface(workerData, config) {
-	const { baseURL, chunkSize } = config;
+	const { baseURI, chunkSize } = config;
+	let { wasmURI } = config;
+
 	if (!workerData.interface) {
+		// deno-lint-ignore valid-typeof
+		if (typeof wasmURI == FUNCTION_TYPE) {
+			wasmURI = wasmURI();
+		}
 		let worker;
 		try {
-			worker = getWebWorker(workerData.scripts[0], baseURL, workerData);
+			worker = getWebWorker(workerData.workerURI, baseURI, workerData);
 			// eslint-disable-next-line no-unused-vars
 		} catch (_) {
 			WEB_WORKERS_SUPPORTED = false;
@@ -149,7 +160,7 @@ function createWebWorkerInterface(workerData, config) {
 		Object.assign(workerData, {
 			worker,
 			interface: {
-				run: () => runWebWorker(workerData, { chunkSize })
+				run: () => runWebWorker(workerData, { chunkSize, wasmURI, baseURI })
 			}
 		});
 	}
@@ -159,6 +170,14 @@ function createWebWorkerInterface(workerData, config) {
 async function runWorker({ options, readable, writable, onTaskFinished }, config) {
 	let codecStream;
 	try {
+		if (!options.useCompressionStream && !initializedModule) {
+			let { wasmURI } = config;
+			// deno-lint-ignore valid-typeof
+			if (typeof wasmURI == FUNCTION_TYPE) {
+				wasmURI = wasmURI();
+			}
+			await initModule(wasmURI, config);
+		}
 		codecStream = new CodecStream(options, config);
 		await readable.pipeThrough(codecStream).pipeTo(writable, { preventClose: true, preventAbort: true });
 		const {
@@ -194,11 +213,10 @@ async function runWebWorker(workerData, config) {
 		rejectResult,
 		result
 	});
-	const { readable, options, scripts } = workerData;
+	const { readable, options } = workerData;
 	const { writable, closed } = watchClosedStream(workerData.writable);
 	const streamsTransferred = sendMessage({
 		type: MESSAGE_START,
-		scripts: scripts.slice(1),
 		options,
 		config,
 		readable,
@@ -239,30 +257,29 @@ function watchClosedStream(writableSource) {
 	return { writable, closed };
 }
 
-let classicWorkersSupported = true;
 let transferStreamsSupported = true;
 
-function getWebWorker(url, baseURL, workerData) {
+function getWebWorker(url, baseURI, workerData) {
 	const workerOptions = { type: "module" };
 	let scriptUrl, worker;
+	// deno-lint-ignore valid-typeof
 	if (typeof url == FUNCTION_TYPE) {
 		url = url();
 	}
-	try {
-		scriptUrl = new URL(url, baseURL);
-		// eslint-disable-next-line no-unused-vars
-	} catch (_) {
-		scriptUrl = url;
-	}
-	if (classicWorkersSupported) {
+	if (url.startsWith("data:") || url.startsWith("blob:")) {
 		try {
-			worker = new Worker(scriptUrl);
+			worker = new Worker(url);
 			// eslint-disable-next-line no-unused-vars
 		} catch (_) {
-			classicWorkersSupported = false;
-			worker = new Worker(scriptUrl, workerOptions);
+			worker = new Worker(url, workerOptions);
 		}
 	} else {
+		try {
+			scriptUrl = new URL(url, baseURI);
+			// eslint-disable-next-line no-unused-vars
+		} catch (_) {
+			scriptUrl = url;
+		}
 		worker = new Worker(scriptUrl, workerOptions);
 	}
 	worker.addEventListener(MESSAGE_EVENT_TYPE, event => onMessage(event, workerData));

package/lib/core/configuration.js

@@ -1,5 +1,5 @@
 /*
- Copyright (c) 2022 Gildas Lormeau. All rights reserved.
+ Copyright (c) 2025 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:
@@ -32,7 +32,6 @@ import {
 	UNDEFINED_VALUE,
 	UNDEFINED_TYPE
 } from "./constants.js";
-import { StreamAdapter } from "./streams/stream-adapter.js";
 
 const MINIMUM_CHUNK_SIZE = 64;
 let maxWorkers = 2;
@@ -45,14 +44,15 @@ try {
 	// ignored
 }
 const DEFAULT_CONFIGURATION = {
-	chunkSize: 512 * 1024,
+	workerURI: "./core/web-worker.js",
+	wasmURI: "./core/streams/zlib/zlib-streams.wasm",
+	chunkSize: 64 * 1024,
 	maxWorkers,
 	terminateWorkerTimeout: 5000,
 	useWebWorkers: true,
 	useCompressionStream: true,
-	workerScripts: UNDEFINED_VALUE,
-	CompressionStreamNative: typeof CompressionStream != UNDEFINED_TYPE && CompressionStream,
-	DecompressionStreamNative: typeof DecompressionStream != UNDEFINED_TYPE && DecompressionStream
+	CompressionStream: typeof CompressionStream != UNDEFINED_TYPE && CompressionStream,
+	DecompressionStream: typeof DecompressionStream != UNDEFINED_TYPE && DecompressionStream
 };
 
 const config = Object.assign({}, DEFAULT_CONFIGURATION);
@@ -73,52 +73,31 @@ function getChunkSize(config) {
 
 function configure(configuration) {
 	const {
-		baseURL,
+		baseURI,
 		chunkSize,
 		maxWorkers,
 		terminateWorkerTimeout,
 		useCompressionStream,
 		useWebWorkers,
-		Deflate,
-		Inflate,
 		CompressionStream,
 		DecompressionStream,
-		workerScripts
+		CompressionStreamZlib,
+		DecompressionStreamZlib,
+		workerURI,
+		wasmURI
 	} = configuration;
-	setIfDefined("baseURL", baseURL);
+	setIfDefined("baseURI", baseURI);
+	setIfDefined("wasmURI", wasmURI);
+	setIfDefined("workerURI", workerURI);
 	setIfDefined("chunkSize", chunkSize);
 	setIfDefined("maxWorkers", maxWorkers);
 	setIfDefined("terminateWorkerTimeout", terminateWorkerTimeout);
 	setIfDefined("useCompressionStream", useCompressionStream);
 	setIfDefined("useWebWorkers", useWebWorkers);
-	if (Deflate) {
-		config.CompressionStream = new StreamAdapter(Deflate);
-	}
-	if (Inflate) {
-		config.DecompressionStream = new StreamAdapter(Inflate);
-	}
 	setIfDefined("CompressionStream", CompressionStream);
 	setIfDefined("DecompressionStream", DecompressionStream);
-	if (workerScripts !== UNDEFINED_VALUE) {
-		const { deflate, inflate } = workerScripts;
-		if (deflate || inflate) {
-			if (!config.workerScripts) {
-				config.workerScripts = {};
-			}
-		}
-		if (deflate) {
-			if (!Array.isArray(deflate)) {
-				throw new Error("workerScripts.deflate must be an array");
-			}
-			config.workerScripts.deflate = deflate;
-		}
-		if (inflate) {
-			if (!Array.isArray(inflate)) {
-				throw new Error("workerScripts.inflate must be an array");
-			}
-			config.workerScripts.inflate = inflate;
-		}
-	}
+	setIfDefined("CompressionStreamZlib", CompressionStreamZlib);
+	setIfDefined("DecompressionStreamZlib", DecompressionStreamZlib);
 }
 
 function setIfDefined(propertyName, propertyValue) {

package/lib/core/io.js

@@ -1,5 +1,5 @@
 /*
- Copyright (c) 2022 Gildas Lormeau. All rights reserved.
+ Copyright (c) 2025 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:
@@ -738,8 +738,8 @@ class GenericWriter {
 }
 
 function isHttpFamily(url) {
-	const { baseURL } = getConfiguration();
-	const { protocol } = new URL(url, baseURL);
+	const { baseURI } = getConfiguration();
+	const { protocol } = new URL(url, baseURI);
 	return protocol == "http:" || protocol == "https:";
 }
 
@@ -755,9 +755,6 @@ function readUint8Array(reader, offset, size, diskNumber) {
 	return reader.readUint8Array(offset, size, diskNumber);
 }
 
-const SplitZipReader = SplitDataReader;
-const SplitZipWriter = SplitDataWriter;
-
 export {
 	initStream,
 	GenericReader,
@@ -775,8 +772,6 @@ export {
 	Uint8ArrayWriter,
 	HttpReader,
 	HttpRangeReader,
-	SplitZipReader,
-	SplitZipWriter,
 	SplitDataReader,
 	SplitDataWriter,
 	ERR_HTTP_RANGE,

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

@@ -56,6 +56,7 @@ const SALT_LENGTH = [8, 12, 16];
 const KEY_LENGTH = [16, 24, 32];
 const SIGNATURE_LENGTH = 10;
 const COUNTER_DEFAULT_VALUE = [0, 0, 0, 0];
+// 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;

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

@@ -1,5 +1,5 @@
 /*
- Copyright (c) 2022 Gildas Lormeau. All rights reserved.
+ Copyright (c) 2025 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:
@@ -45,11 +45,12 @@ import {
 } from "./common-crypto.js";
 
 const ERR_INVALID_UNCOMPRESSED_SIZE = "Invalid uncompressed size";
-const COMPRESSION_FORMAT = "deflate-raw";
+const FORMAT_DEFLATE_RAW = "deflate-raw";
+const FORMAT_DEFLATE64_RAW = "deflate64-raw";
 
 class DeflateStream extends TransformStream {
 
-	constructor(options, { chunkSize, CompressionStream, CompressionStreamNative }) {
+	constructor(options, { chunkSize, CompressionStreamZlib, CompressionStream }) {
 		super({});
 		const { compressed, encrypted, useCompressionStream, zipCrypto, signed, level } = options;
 		const stream = this;
@@ -60,7 +61,7 @@ class DeflateStream extends TransformStream {
 			readable = pipeThrough(readable, crc32Stream);
 		}
 		if (compressed) {
-			readable = pipeThroughCommpressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStreamNative, CompressionStream);
+			readable = pipeThroughCommpressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamZlib, CompressionStream);
 		}
 		if (encrypted) {
 			if (zipCrypto) {
@@ -85,9 +86,9 @@ class DeflateStream extends TransformStream {
 
 class InflateStream extends TransformStream {
 
-	constructor(options, { chunkSize, DecompressionStream, DecompressionStreamNative }) {
+	constructor(options, { chunkSize, DecompressionStreamZlib, DecompressionStream }) {
 		super({});
-		const { zipCrypto, encrypted, signed, signature, compressed, useCompressionStream } = options;
+		const { zipCrypto, encrypted, signed, signature, compressed, useCompressionStream, deflate64 } = options;
 		let crc32Stream, decryptionStream;
 		let readable = super.readable;
 		if (encrypted) {
@@ -99,7 +100,7 @@ class InflateStream extends TransformStream {
 			}
 		}
 		if (compressed) {
-			readable = pipeThroughCommpressionStream(readable, useCompressionStream, { chunkSize }, DecompressionStreamNative, DecompressionStream);
+			readable = pipeThroughCommpressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamZlib, DecompressionStream);
 		}
 		if ((!encrypted || zipCrypto) && signed) {
 			crc32Stream = new Crc32Stream();
@@ -134,13 +135,20 @@ function setReadable(stream, readable, flush) {
 	});
 }
 
-function pipeThroughCommpressionStream(readable, useCompressionStream, options, CodecStreamNative, CodecStream) {
+function pipeThroughCommpressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamZlib, CompressionStream) {
+	const Stream = useCompressionStream && CompressionStreamNative ? CompressionStreamNative : CompressionStreamZlib || CompressionStream;
+	const format = options.deflate64 ? FORMAT_DEFLATE64_RAW : FORMAT_DEFLATE_RAW;
 	try {
-		const CompressionStream = useCompressionStream && CodecStreamNative ? CodecStreamNative : CodecStream;
-		readable = pipeThrough(readable, new CompressionStream(COMPRESSION_FORMAT, options));
+		readable = pipeThrough(readable, new Stream(format, options));
 	} catch (error) {
 		if (useCompressionStream) {
-			readable = pipeThrough(readable, new CodecStream(COMPRESSION_FORMAT, options));
+			if (CompressionStreamZlib) {
+				readable = pipeThrough(readable, new CompressionStreamZlib(format, options));
+			} else if (CompressionStream) {
+				readable = pipeThrough(readable, new CompressionStream(format, options));
+			} else {
+				throw error;
+			}
 		} else {
 			throw error;
 		}

package/lib/core/streams/zlib/README.md

@@ -0,0 +1 @@
+See https://github.com/gildas-lormeau/zlib-streams/tree/main/dist

package/lib/core/streams/{stream-adapter.js → zlib/zlib-streams-loader.js}

@@ -1,5 +1,5 @@
 /*
- Copyright (c) 2022 Gildas Lormeau. All rights reserved.
+ Copyright (c) 2025 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:
@@ -26,30 +26,59 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global TransformStream */
+/* global WebAssembly, URL, fetch, atob */
 
-export {
-	StreamAdapter
-};
-
-class StreamAdapter {
-
-	constructor(Codec) {
-		return class extends TransformStream {
-			constructor(_format, options) {
-				const codec = new Codec(options);
-				super({
-					transform(chunk, controller) {
-						controller.enqueue(codec.append(chunk));
-					},
-					flush(controller) {
-						const chunk = codec.flush();
-						if (chunk) {
-							controller.enqueue(chunk);
-						}
-					}
-				});
+import { setWasmExports } from "./zlib-streams.js";
+
+let initializedModule = false;
+
+async function initModule(wasmURI, { baseURI }) {
+	if (!initializedModule) {
+		let arrayBuffer, uri;
+		try {
+			try {
+				uri = new URL(wasmURI, baseURI);
+				// eslint-disable-next-line no-unused-vars
+			} catch (_) {
+				// ignored
 			}
-		};
+			const response = await fetch(uri);
+			arrayBuffer = await response.arrayBuffer();
+		} catch (error) {
+			if (wasmURI.startsWith("data:application/wasm;base64,")) {
+				arrayBuffer = arrayBufferFromDataURI(wasmURI);
+			} else {
+				throw error;
+			}
+		}
+		const wasmInstance = await WebAssembly.instantiate(arrayBuffer);
+		setWasmExports(wasmInstance.instance.exports);
+		initializedModule = true;
+	}
+}
+
+function resetWasmModule() {
+	initializedModule = false;
+}
+
+function arrayBufferFromDataURI(dataURI) {
+	const base64 = dataURI.split(",")[1];
+	const binary = atob(base64);
+	const len = binary.length;
+	const bytes = new Uint8Array(len);
+	for (let i = 0; i < len; ++i) {
+		bytes[i] = binary.charCodeAt(i);
 	}
-}
+	return bytes.buffer;
+}
+
+export {
+	setWasmExports,
+	CompressionStreamZlib,
+	DecompressionStreamZlib
+} from "./zlib-streams.js";
+export {
+	initModule,
+	resetWasmModule,
+	initializedModule
+};

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

@@ -0,0 +1,184 @@
+/*
+ Copyright (c) 2025 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 TransformStream */
+
+let wasm, malloc, free, memory;
+
+export function setWasmExports(wasmAPI) {
+	wasm = wasmAPI;
+	({ malloc, free, memory } = wasm);
+}
+
+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() {
+			let result;
+			this.out = malloc(outBufferSize);
+			this.in = malloc(inBufferSize);
+			this.inBufferSize = inBufferSize;
+			this._scratch = new Uint8Array(outBufferSize);
+			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 === "gzip") {
+					result = wasm.deflate_init_gzip(this.streamHandle, level);
+				} else if (type === "deflate-raw") {
+					result = wasm.deflate_init_raw(this.streamHandle, level);
+				} else {
+					result = wasm.deflate_init(this.streamHandle, level);
+				}
+			} else {
+				if (type === "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 === "deflate-raw") {
+						result = wasm.inflate_init_raw(this.streamHandle);
+					} else if (type === "gzip") {
+						result = wasm.inflate_init_gzip(this.streamHandle);
+					} else {
+						result = wasm.inflate_init(this.streamHandle);
+					}
+				}
+			}
+			if (result !== 0) {
+				throw new Error("init failed:" + result);
+			}
+		},
+		transform(chunk, controller) {
+			try {
+				const buffer = chunk;
+				const heap = new Uint8Array(memory.buffer);
+				const process = this._process;
+				const last_consumed = this._last_consumed;
+				const out = this.out;
+				const scratch = this._scratch;
+				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 = malloc(toRead);
+						this.inBufferSize = toRead;
+					}
+					heap.set(buffer.subarray(offset, offset + toRead), this.in);
+					const result = process(this.streamHandle, this.in, toRead, out, outBufferSize, 0);
+					if (!isCompress && result < 0) {
+						throw new Error("process error:" + result);
+					}
+					const prod = result & 0x00ffffff;
+					if (prod) {
+						scratch.set(heap.subarray(out, out + prod), 0);
+						controller.enqueue(scratch.slice(0, prod));
+					}
+					const consumed = last_consumed(this.streamHandle);
+					if (consumed === 0) {
+						break;
+					}
+					offset += consumed;
+				}
+			} catch (error) {
+				if (this._end && this.streamHandle) {
+					this._end(this.streamHandle);
+				}
+				if (this.in && free) {
+					free(this.in);
+				}
+				if (this.out && free) {
+					free(this.out);
+				}
+				controller.error(error);
+			}
+		},
+		flush(controller) {
+			try {
+				const heap = new Uint8Array(memory.buffer);
+				const process = this._process;
+				const out = this.out;
+				const scratch = this._scratch;
+				while (true) {
+					const result = process(this.streamHandle, 0, 0, out, outBufferSize, 4);
+					if (!isCompress && result < 0) {
+						throw new Error("process error:" + result);
+					}
+					const produced = result & 0x00ffffff;
+					const code = (result >> 24) & 0xff;
+					if (produced) {
+						scratch.set(heap.subarray(out, out + produced), 0);
+						controller.enqueue(scratch.slice(0, produced));
+					}
+					if (code === 1 || produced === 0) {
+						break;
+					}
+				}
+			} catch (error) {
+				controller.error(error);
+			} finally {
+				if (this._end && this.streamHandle) {
+					const result = this._end(this.streamHandle);
+					if (result !== 0) {
+						controller.error(new Error("end error:" + result));
+					}
+				}
+				if (this.in && free) {
+					free(this.in);
+				}
+				if (this.out && free) {
+					free(this.out);
+				}
+			}
+		}
+	});
+}
+
+export class CompressionStreamZlib {
+	constructor(type = "deflate", options) {
+		return _make(true, type, options);
+	}
+}
+export class DecompressionStreamZlib {
+	constructor(type = "deflate", options) {
+		return _make(false, type, options);
+	}
+}

package/lib/core/util/decode-text.js

@@ -28,7 +28,7 @@
 
 /* global TextDecoder */
 
-import { decodeCP437 } from "./cp437-decode.js";
+import { decodeCP437 } from "./decode-cp437.js";
 
 export {
 	decodeText

package/lib/core/util/encode-text.js

@@ -35,6 +35,7 @@ export {
 };
 
 function encodeText(value) {
+	// deno-lint-ignore valid-typeof
 	if (typeof TextEncoder == UNDEFINED_TYPE) {
 		value = unescape(encodeURIComponent(value));
 		const result = new Uint8Array(value.length);