@zip.js/zip.js 2.15.0 → 2.16.1

package/dist/zip-core-external.js

@@ -1310,12 +1310,12 @@ let createEngine$1 = createEngine$2;
 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,
@@ -1334,6 +1334,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));
 			},
@@ -1342,9 +1345,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);
@@ -1354,27 +1360,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,
@@ -1388,6 +1393,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));
@@ -1397,19 +1405,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);
 	}
 }
 
@@ -1422,7 +1431,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;
+		}
 	});
 }
 
@@ -1455,7 +1494,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();
 	}
@@ -1472,6 +1513,9 @@ async function createKeys$1(aesCrypto, strength, password, salt) {
 	const keyLength = KEY_LENGTH[strength];
 	const compositeKey = await deriveKey(password, salt, keyLength * 2 + PASSWORD_VERIFICATION_LENGTH);
 	aesCrypto.engine = createEngine$1(subarray(compositeKey, 0, keyLength), subarray(compositeKey, keyLength, keyLength * 2));
+	if (aesCrypto.discarded) {
+		disposeEngine(aesCrypto);
+	}
 	return subarray(compositeKey, keyLength * 2);
 }
 
@@ -1623,11 +1667,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++) {
@@ -1641,17 +1685,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);
 }
 
@@ -1699,11 +1743,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) {
@@ -1889,7 +1938,6 @@ const FORMAT_GZIP$1 = "gzip";
 const GZIP_HEADER_LENGTH = 10;
 const GZIP_TRAILER_LENGTH = 8;
 const GZIP_HEADER_BYTES = [0x1f, 0x8b, 0x08];
-const GZIP_OUTPUT_STALL_TIMEOUT = 5000;
 
 class DeflateStream extends TransformStream {
 
@@ -1900,7 +1948,7 @@ class DeflateStream extends TransformStream {
 		let crc32Stream, encryptionStream, gzipCrc32Stream;
 		let readable = super.readable;
 		const codecStreams = format && getCodecStreams(format);
-		const GzipCompressionStream = getGzipCompressionStream(useCompressionStream, CompressionStream, CompressionStreamFallback);
+		const GzipCompressionStream = getGzipCodecStream(useCompressionStream, CompressionStream, CompressionStreamFallback);
 		const useGzipCrc32 = computeCrc32 && compressed && !deflate64 && !codecStreams && (!encrypted || zipCrypto) && Boolean(GzipCompressionStream);
 		if ((!encrypted || zipCrypto) && computeCrc32 && !useGzipCrc32) {
 			crc32Stream = new Crc32Stream();
@@ -1917,6 +1965,9 @@ class DeflateStream extends TransformStream {
 				try {
 					readable = pipeThroughCompressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamFallback);
 				} catch (error) {
+					if (!useCompressionStream && CompressionStreamFallback) {
+						throw error;
+					}
 					let gzipStream;
 					try {
 						gzipStream = new CompressionStream(FORMAT_GZIP$1);
@@ -1986,74 +2037,134 @@ class GzipToRawDeflateStream extends TransformStream {
 }
 
 function pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, crc32) {
+	const writer = gzipStream.writable.getWriter();
+	const reader = gzipStream.readable.getReader();
+	const outputCrc32 = crc32 === UNDEFINED_VALUE ? new Crc32() : UNDEFINED_VALUE;
 	let outputLength = 0;
 	let inputDone = false;
-	let watchdogTimeout;
+	let trailerWritten = false;
+	let idleCheckArmed = false;
+	let readCount = 0;
+	let readPending = false;
 	let resolveTrailerReady, rejectTrailerReady;
 	const trailerReady = new Promise((resolve, reject) => {
 		resolveTrailerReady = resolve;
 		rejectTrailerReady = reject;
 	});
 	trailerReady.catch(() => { });
-	if (!outputSize) {
-		resolveTrailerReady();
-	}
-	const gzipWrapStream = new TransformStream({
-		start(controller) {
+	pump();
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				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;
+			}
+		},
+		cancel(reason) {
+			rejectTrailerReady(reason);
+			return reader.cancel(reason);
+		}
+	});
+
+	async function pump() {
+		const inputReader = readable.getReader();
+		try {
 			const header = new Uint8Array(GZIP_HEADER_LENGTH);
 			header.set(GZIP_HEADER_BYTES);
-			controller.enqueue(header);
-		},
-		transform(chunk, controller) {
-			controller.enqueue(chunk);
-		},
-		async flush(controller) {
+			await writer.write(header);
+			for (; ;) {
+				await writer.ready;
+				const { value, done } = await inputReader.read();
+				if (done) {
+					break;
+				}
+				await writer.write(value);
+			}
 			inputDone = true;
-			startWatchdog();
-			try {
+			if (outputCrc32) {
+				if (readPending) {
+					armIdleCheck();
+				}
 				await trailerReady;
-			} finally {
-				stopWatchdog();
 			}
 			const trailer = new Uint8Array(GZIP_TRAILER_LENGTH);
 			const dataView = getDataView(trailer);
-			dataView.setUint32(0, crc32.get(), true);
+			dataView.setUint32(0, outputCrc32 ? outputCrc32.get() : crc32, true);
 			dataView.setUint32(4, outputSize, true);
-			controller.enqueue(trailer);
-		},
-		cancel(reason) {
-			rejectTrailerReady(reason);
+			trailerWritten = true;
+			await writer.write(trailer);
+			await writer.close();
+		} catch (error) {
+			await abort(writer, error);
+			await cancel(inputReader, error);
 		}
-	});
-	const outputStream = new TransformStream({
-		transform(chunk, controller) {
-			crc32.append(chunk);
-			outputLength += chunk.length;
-			if (outputLength >= outputSize) {
-				resolveTrailerReady();
-			} else if (inputDone) {
-				startWatchdog();
-			}
-			controller.enqueue(chunk);
-		},
-		cancel(reason) {
-			rejectTrailerReady(reason);
+	}
+
+	function read() {
+		readCount++;
+		readPending = true;
+		const result = reader.read();
+		result.then(onReadSettled, onReadSettled);
+		if (inputDone && outputCrc32) {
+			armIdleCheck();
 		}
-	});
-	readable = pipeThrough(readable, gzipWrapStream);
-	readable = pipeThroughBackpressured(readable, gzipStream);
-	return pipeThrough(readable, outputStream);
+		return result;
+	}
 
-	function startWatchdog() {
-		stopWatchdog();
-		watchdogTimeout = setTimeout(() => rejectTrailerReady(new Error(ERR_INVALID_UNCOMPRESSED_SIZE)), GZIP_OUTPUT_STALL_TIMEOUT);
+	function onReadSettled() {
+		readPending = false;
+	}
+
+	async function armIdleCheck() {
+		if (!idleCheckArmed) {
+			idleCheckArmed = true;
+			const count = readCount;
+			await nextTask();
+			idleCheckArmed = false;
+			if (readPending) {
+				if (readCount == count) {
+					resolveTrailerReady();
+				} else {
+					armIdleCheck();
+				}
+			}
+		}
 	}
 
-	function stopWatchdog() {
-		clearTimeout(watchdogTimeout);
+	function getTrailerError(error) {
+		const trailerError = new Error(outputLength == outputSize ? ERR_INVALID_CRC32 : ERR_INVALID_UNCOMPRESSED_SIZE);
+		trailerError.cause = error;
+		return trailerError;
 	}
 }
 
+function nextTask() {
+	return new Promise(resolve => {
+		const { port1, port2 } = new MessageChannel();
+		port2.onmessage = () => {
+			port1.close();
+			port2.close();
+			resolve();
+		};
+		port1.postMessage(UNDEFINED_VALUE);
+	});
+}
+
 class InflateStream extends TransformStream {
 
 	constructor(options, { chunkSize, DecompressionStreamFallback, DecompressionStream }) {
@@ -2074,20 +2185,32 @@ class InflateStream extends TransformStream {
 			if (codecStreams) {
 				readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.DecompressionStream, format, { chunkSize, compressionMethod, rawBitFlag, uncompressedSize: outputSize }));
 			} else {
-				try {
-					readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamFallback);
-				} catch (error) {
-					if (deflate64 || outputSize === UNDEFINED_VALUE) {
-						throw error;
-					}
-					let gzipStream;
+				let gzipStream;
+				const GzipDecompressionStream = getGzipCodecStream(useCompressionStream, DecompressionStream, DecompressionStreamFallback);
+				if (checkCrc32 && !deflate64 && crc32 !== UNDEFINED_VALUE && outputSize !== UNDEFINED_VALUE && GzipDecompressionStream) {
 					try {
-						gzipStream = new DecompressionStream(FORMAT_GZIP$1);
+						gzipStream = new GzipDecompressionStream(FORMAT_GZIP$1, { chunkSize });
 					} catch {
-						throw error;
+						gzipStream = UNDEFINED_VALUE;
 					}
-					gzipCrc32 = new Crc32();
-					readable = pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, gzipCrc32);
+				}
+				if (!gzipStream) {
+					try {
+						readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamFallback);
+					} catch (error) {
+						if (deflate64 || outputSize === UNDEFINED_VALUE || (!useCompressionStream && DecompressionStreamFallback)) {
+							throw error;
+						}
+						try {
+							gzipStream = new DecompressionStream(FORMAT_GZIP$1);
+						} catch {
+							throw error;
+						}
+					}
+				}
+				if (gzipStream) {
+					gzipCrc32 = true;
+					readable = pipeThroughGzipDecompressionStream(readable, gzipStream, outputSize, crc32);
 				}
 			}
 			readable = mapInflateStreamError(readable);
@@ -2097,8 +2220,8 @@ class InflateStream extends TransformStream {
 			readable = pipeThrough(readable, crc32Stream);
 		}
 		setReadable(this, readable, () => {
-			if (checkCrc32) {
-				const computedCrc32 = gzipCrc32 ? gzipCrc32.get() >>> 0 : new DataView(crc32Stream.value.buffer).getUint32(0, false);
+			if (crc32Stream) {
+				const computedCrc32 = new DataView(crc32Stream.value.buffer).getUint32(0, false);
 				if (crc32 != computedCrc32) {
 					throw new Error(ERR_INVALID_CRC32);
 				}
@@ -2155,11 +2278,11 @@ function createCodecStream(CodecStreamClass, format, options) {
 	return new CodecStreamClass(format, options);
 }
 
-function getGzipCompressionStream(useCompressionStream, CompressionStreamNative, CompressionStreamFallback) {
-	if (useCompressionStream && CompressionStreamNative) {
-		return CompressionStreamNative;
-	} else if (CompressionStreamFallback && CompressionStreamFallback.requiresModule) {
-		return CompressionStreamFallback;
+function getGzipCodecStream(useCompressionStream, CodecStreamNative, CodecStreamFallback) {
+	if (useCompressionStream && CodecStreamNative) {
+		return CodecStreamNative;
+	} else if (CodecStreamFallback && CodecStreamFallback.requiresModule) {
+		return CodecStreamFallback;
 	}
 }
 
@@ -2229,10 +2352,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;
 				}
@@ -2240,12 +2368,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);
@@ -3741,10 +3863,11 @@ class FetchReader extends Reader {
 
 	createReadable(options) {
 		const reader = this;
-		const { useRangeHeader, forceRangeRequests, size } = reader;
+		const { useRangeHeader, forceRangeRequests, size, eocdCache } = reader;
 		if ((useRangeHeader || forceRangeRequests) && size !== UNDEFINED_VALUE) {
 			const { offset = 0, size: readSize = size - offset } = options || {};
-			if (readSize > 0 && offset < size) {
+			const cached = eocdCache && offset >= size - eocdCache.length;
+			if (readSize > 0 && offset < size && !cached) {
 				return createRangeReadable(reader, offset, Math.min(readSize, size - offset));
 			}
 		}
@@ -5303,8 +5426,8 @@ class ZipEntry {
 		const passThroughCompression = Boolean(passThrough);
 		const passThroughEncryption = passThrough === true;
 		checkPasswordOption(password, rawPassword);
-		password = password && password.length && password;
-		rawPassword = rawPassword && rawPassword.length && rawPassword;
+		password = password && password.length ? password : UNDEFINED_VALUE;
+		rawPassword = rawPassword && rawPassword.length ? rawPassword : UNDEFINED_VALUE;
 		if (extraFieldAES) {
 			if (extraFieldAES.originalCompressionMethod != COMPRESSION_METHOD_AES) {
 				throw new Error(ERR_UNSUPPORTED_COMPRESSION);
@@ -6065,7 +6188,7 @@ function getMaxAppendedDataSize(maxAppendedDataSize, strictness) {
 async function findEndOfCentralDirectory(reader, rejectAmbiguous, maxAppendedDataSize) {
 	const { size } = reader;
 	const anchoredLength = Math.min(size, END_OF_CENTRAL_DIR_LENGTH + MAX_16_BITS);
-	const remoteProbeBudget = { count: MAX_END_OF_CENTRAL_DIR_PROBES };
+	const remoteProbeBudget = { remaining: MAX_END_OF_CENTRAL_DIR_PROBES };
 	let endOfDirectoryInfo;
 	let plausibleEndOfDirectoryInfo;
 	let endOfDirectoryReachingEndCount = 0;
@@ -6158,8 +6281,8 @@ async function readSignature(reader, view, anchoredOffset, signatureOffset, size
 	if (signatureOffset >= anchoredOffset) {
 		return getUint32$1(view, signatureOffset - anchoredOffset);
 	}
-	if (remoteProbeBudget.count > 0) {
-		remoteProbeBudget.count--;
+	if (remoteProbeBudget.remaining > 0) {
+		remoteProbeBudget.remaining--;
 		const signatureArray = await readUint8Array(reader, signatureOffset, 4);
 		return getUint32$1(getDataView(signatureArray), 0);
 	}
@@ -7075,9 +7198,11 @@ function resolveMetadata(zipWriter, name, options) {
 	const passThrough = checkPassThroughOption(getOptionValue(zipWriter, options, OPTION_PASS_THROUGH));
 	const passThroughCompression = Boolean(passThrough);
 	const passThroughEncryption = passThrough === true;
-	const password = getOptionValue(zipWriter, options, OPTION_PASSWORD);
-	const rawPassword = getOptionValue(zipWriter, options, OPTION_RAW_PASSWORD);
+	let password = getOptionValue(zipWriter, options, OPTION_PASSWORD);
+	let rawPassword = getOptionValue(zipWriter, options, OPTION_RAW_PASSWORD);
 	checkPasswordOption(password, rawPassword);
+	password = password && password.length ? password : UNDEFINED_VALUE;
+	rawPassword = rawPassword && rawPassword.length ? rawPassword : UNDEFINED_VALUE;
 	const encryptionStrength = getNumberOptionValue(zipWriter, options, OPTION_ENCRYPTION_STRENGTH, 3);
 	const zipCrypto = getOptionValue(zipWriter, options, PROPERTY_NAME_ZIPCRYPTO);
 	const extendedTimestamp = getOptionValue(zipWriter, options, OPTION_EXTENDED_TIMESTAMP, true);
@@ -8775,7 +8900,7 @@ function formatSupported(StreamClass, format) {
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const VERSION = "2.15.0";
+const VERSION = "2.16.1";
 
 /*
  Copyright (c) 2025 Gildas Lormeau. All rights reserved.
@@ -9252,7 +9377,7 @@ try {
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global TransformStream */
+/* global ReadableStream, WritableStream */
 
 const FORMAT_DEFLATE = "deflate";
 const FORMAT_DEFLATE_RAW = "deflate-raw";
@@ -9287,137 +9412,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$1.deflate_process;
-					this._last_consumed = wasm$1.deflate_last_consumed;
-					this._end = wasm$1.deflate_end;
-					this.streamHandle = wasm$1.deflate_new();
-					if (type === FORMAT_GZIP) {
-						result = wasm$1.deflate_init_gzip(this.streamHandle, level);
-					} else if (type === FORMAT_DEFLATE_RAW) {
-						result = wasm$1.deflate_init_raw(this.streamHandle, level);
-					} else {
-						result = wasm$1.deflate_init(this.streamHandle, level);
-					}
-				} else {
-					if (type === FORMAT_DEFLATE64_RAW) {
-						this._process = wasm$1.inflate9_process;
-						this._last_consumed = wasm$1.inflate9_last_consumed;
-						this._end = wasm$1.inflate9_end;
-						this.streamHandle = wasm$1.inflate9_new();
-						result = wasm$1.inflate9_init_raw(this.streamHandle);
-					} else {
-						this._process = wasm$1.inflate_process;
-						this._last_consumed = wasm$1.inflate_last_consumed;
-						this._end = wasm$1.inflate_end;
-						this.streamHandle = wasm$1.inflate_new();
-						if (type === FORMAT_DEFLATE_RAW) {
-							result = wasm$1.inflate_init_raw(this.streamHandle);
-						} else if (type === FORMAT_GZIP) {
-							result = wasm$1.inflate_init_gzip(this.streamHandle);
-						} else {
-							result = wasm$1.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$1.deflate_process;
+				state._last_consumed = wasm$1.deflate_last_consumed;
+				state._end = wasm$1.deflate_end;
+				state.streamHandle = wasm$1.deflate_new();
+				if (type === FORMAT_GZIP) {
+					result = wasm$1.deflate_init_gzip(state.streamHandle, level);
+				} else if (type === FORMAT_DEFLATE_RAW) {
+					result = wasm$1.deflate_init_raw(state.streamHandle, level);
+				} else {
+					result = wasm$1.deflate_init(state.streamHandle, level);
+				}
+			} else {
+				if (type === FORMAT_DEFLATE64_RAW) {
+					state._process = wasm$1.inflate9_process;
+					state._last_consumed = wasm$1.inflate9_last_consumed;
+					state._end = wasm$1.inflate9_end;
+					state.streamHandle = wasm$1.inflate9_new();
+					result = wasm$1.inflate9_init_raw(state.streamHandle);
+				} else {
+					state._process = wasm$1.inflate_process;
+					state._last_consumed = wasm$1.inflate_last_consumed;
+					state._end = wasm$1.inflate_end;
+					state.streamHandle = wasm$1.inflate_new();
+					if (type === FORMAT_DEFLATE_RAW) {
+						result = wasm$1.inflate_init_raw(state.streamHandle);
+					} else if (type === FORMAT_GZIP) {
+						result = wasm$1.inflate_init_gzip(state.streamHandle);
+					} else {
+						result = wasm$1.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;