@zip.js/zip.js 2.8.36 → 2.8.38

package/lib/core/codec-pool.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global setTimeout, clearTimeout */
+/* global setTimeout, clearTimeout, URL */
 
 import { UNDEFINED_VALUE } from "./constants.js";
 import {
@@ -38,7 +38,8 @@ import {
 	ERR_INVALID_COMPRESSED_DATA,
 	ERR_ABORT_CHECK_PASSWORD
 } from "./streams/codec-stream.js";
-import { CodecWorker } from "./codec-worker.js";
+import { ensureCodecStreams } from "./codec-registry.js";
+import { CodecWorker, resetWebWorkerSupport } from "./codec-worker.js";
 
 let pool = [];
 const pendingRequests = [];
@@ -61,11 +62,18 @@ let indexWorker = 0;
 
 async function runWorker(stream, workerOptions) {
 	const { options, config } = workerOptions;
-	const { transferStreams, useWebWorkers, useCompressionStream, compressed, signed, encrypted } = options;
+	const { transferStreams, useWebWorkers, useCompressionStream, compressed, signed, encrypted, format, codecURI } = options;
 	const { workerURI, maxWorkers } = config;
+	if (format) {
+		if (codecURI) {
+			options.codecURI = resolveCodecURI(codecURI, config.baseURI);
+		}
+		await ensureCodecStreams(format, options.codecURI);
+	}
 	workerOptions.transferStreams = transferStreams || (transferStreams === UNDEFINED_VALUE && config.transferStreams);
 	const streamCopy = !compressed && !signed && !encrypted;
-	workerOptions.useWebWorkers = !streamCopy && (useWebWorkers || (useWebWorkers === UNDEFINED_VALUE && config.useWebWorkers));
+	const workerSupported = format === UNDEFINED_VALUE || Boolean(options.codecURI);
+	workerOptions.useWebWorkers = !streamCopy && workerSupported && (useWebWorkers || (useWebWorkers === UNDEFINED_VALUE && config.useWebWorkers));
 	workerOptions.workerURI = workerOptions.useWebWorkers && workerURI ? workerURI : UNDEFINED_VALUE;
 	options.useCompressionStream = useCompressionStream || (useCompressionStream === UNDEFINED_VALUE && config.useCompressionStream);
 	return (await getWorker()).run();
@@ -105,6 +113,14 @@ async function runWorker(stream, workerOptions) {
 	}
 }
 
+function resolveCodecURI(codecURI, baseURI) {
+	try {
+		return new URL(codecURI, baseURI).toString();
+	} catch {
+		return codecURI;
+	}
+}
+
 function armStarvationTimeout() {
 	if (!starvationTimeout && pendingRequests.length && Number.isFinite(starvationDelay) && starvationDelay >= 0) {
 		starvationTimeout = setTimeout(onWorkerStarvation, starvationDelay);
@@ -165,4 +181,5 @@ async function terminateWorkers() {
 		clearTerminateTimeout(workerData);
 		return workerData.terminate();
 	}));
+	resetWebWorkerSupport();
 }

package/lib/core/codec-registry.js

@@ -0,0 +1,116 @@
+/*
+ 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.
+ */
+
+import {
+	MAX_16_BITS,
+	COMPRESSION_METHOD_STORE,
+	COMPRESSION_METHOD_DEFLATE,
+	COMPRESSION_METHOD_DEFLATE_64,
+	COMPRESSION_METHOD_AES,
+	FUNCTION_TYPE
+} from "./constants.js";
+
+const ERR_INVALID_CODEC_DEFINITION = "Invalid codec definition";
+const ERR_RESERVED_COMPRESSION_METHOD = "Reserved compression method";
+const ERR_INVALID_CODEC_MODULE = "Invalid codec module";
+
+const STRING_TYPE = "string";
+const RESERVED_COMPRESSION_METHODS = [
+	COMPRESSION_METHOD_STORE,
+	COMPRESSION_METHOD_DEFLATE,
+	COMPRESSION_METHOD_DEFLATE_64,
+	COMPRESSION_METHOD_AES
+];
+
+const registeredCodecs = new Map();
+const codecStreams = new Map();
+
+export {
+	ERR_INVALID_CODEC_DEFINITION,
+	ERR_RESERVED_COMPRESSION_METHOD,
+	ERR_INVALID_CODEC_MODULE,
+	registerCodec,
+	unregisterCodec,
+	getRegisteredCodec,
+	getCodecStreams,
+	setCodecStreams,
+	ensureCodecStreams
+};
+
+function registerCodec(codec = {}) {
+	const { compressionMethod, format, codecURI, CompressionStream, DecompressionStream, versionNeeded } = codec;
+	if (!Number.isInteger(compressionMethod) || compressionMethod < 0 || compressionMethod > MAX_16_BITS ||
+		typeof format != STRING_TYPE || !format.length) {
+		throw new Error(ERR_INVALID_CODEC_DEFINITION);
+	}
+	if (RESERVED_COMPRESSION_METHODS.includes(compressionMethod)) {
+		throw new Error(ERR_RESERVED_COMPRESSION_METHOD);
+	}
+	const hasStreams = typeof CompressionStream == FUNCTION_TYPE || typeof DecompressionStream == FUNCTION_TYPE;
+	if (!hasStreams && (typeof codecURI != STRING_TYPE || !codecURI.length)) {
+		throw new Error(ERR_INVALID_CODEC_DEFINITION);
+	}
+	registeredCodecs.set(compressionMethod, { compressionMethod, format, codecURI, versionNeeded });
+	if (hasStreams) {
+		setCodecStreams(format, { CompressionStream, DecompressionStream });
+	}
+}
+
+function unregisterCodec(compressionMethod) {
+	const codec = registeredCodecs.get(compressionMethod);
+	if (codec) {
+		registeredCodecs.delete(compressionMethod);
+		let formatUsed;
+		registeredCodecs.forEach(otherCodec => formatUsed = formatUsed || otherCodec.format == codec.format);
+		if (!formatUsed) {
+			codecStreams.delete(codec.format);
+		}
+	}
+}
+
+function getRegisteredCodec(compressionMethod) {
+	return registeredCodecs.get(compressionMethod);
+}
+
+function getCodecStreams(format) {
+	return codecStreams.get(format);
+}
+
+function setCodecStreams(format, streams) {
+	const { CompressionStream, DecompressionStream } = streams;
+	if (typeof CompressionStream != FUNCTION_TYPE && typeof DecompressionStream != FUNCTION_TYPE) {
+		throw new Error(ERR_INVALID_CODEC_MODULE);
+	}
+	codecStreams.set(format, { CompressionStream, DecompressionStream });
+}
+
+async function ensureCodecStreams(format, codecURI) {
+	if (!codecStreams.has(format) && codecURI) {
+		setCodecStreams(format, await import(codecURI));
+	}
+}

package/lib/core/codec-worker.js

@@ -39,6 +39,7 @@ import {
 	CODEC_DEFLATE,
 	CodecStream,
 	ChunkStream,
+	supportsDeflateRaw,
 	MESSAGE_EVENT_TYPE,
 	MESSAGE_START,
 	MESSAGE_PULL,
@@ -50,6 +51,7 @@ import {
 const MODULE_WORKER_OPTIONS = { type: "module" };
 const ERROR_EVENT_TYPE = "error";
 const MESSAGE_ERROR_EVENT_TYPE = "messageerror";
+const ERR_WORKER_STARTUP_TIMEOUT = "Worker startup timeout";
 
 let webWorkerSupported, webWorkerSource, webWorkerURI, webWorkerOptions;
 let transferStreamsSupported = true;
@@ -62,13 +64,18 @@ let initModule = () => { };
 
 export {
 	CodecWorker,
-	configureWorker
+	configureWorker,
+	resetWebWorkerSupport
 };
 
 function configureWorker({ initModule: initModuleFunction }) {
 	initModule = initModuleFunction;
 }
 
+function resetWebWorkerSupport() {
+	webWorkerSupported = UNDEFINED_VALUE;
+}
+
 class CodecWorker {
 
 	constructor(workerData, { readable, writable }, { options, config, streamOptions, useWebWorkers, transferStreams, workerURI }, onTaskFinished) {
@@ -162,7 +169,7 @@ function createWorkerInterface(workerData, config) {
 }
 
 function createWebWorkerInterface(workerData, config) {
-	const { baseURI, chunkSize } = config;
+	const { baseURI, chunkSize, workerStartupTimeout } = config;
 	let { wasmURI } = config;
 
 	if (!workerData.interface) {
@@ -179,9 +186,26 @@ function createWebWorkerInterface(workerData, config) {
 		}
 		Object.assign(workerData, {
 			worker,
+			workerAlive: false,
 			terminated: false,
 			interface: {
-				run: () => runWebWorker(workerData, { chunkSize, wasmURI, baseURI })
+				run: async () => {
+					try {
+						return await runWebWorker(workerData, { chunkSize, wasmURI, baseURI, workerStartupTimeout });
+					} catch (error) {
+						if (error && error.workerStartupFailed) {
+							webWorkerSupported = false;
+							const { reader } = workerData;
+							if (reader) {
+								reader.releaseLock();
+							}
+							workerData.reader = null;
+							workerData.writer = null;
+							return runWorker(workerData, config);
+						}
+						throw error;
+					}
+				}
 			}
 		});
 	}
@@ -191,15 +215,23 @@ function createWebWorkerInterface(workerData, config) {
 async function runWorker({ options, readable, writable, onTaskFinished }, config) {
 	let codecStream;
 	try {
-		if (!options.useCompressionStream) {
-			try {
-				await initModule(config);
-			} catch {
-				const ZlibStream = options.codecType.startsWith(CODEC_DEFLATE) ?
-					config.CompressionStreamZlib :
-					config.DecompressionStreamZlib;
-				if (!ZlibStream || ZlibStream.requiresModule) {
-					options.useCompressionStream = true;
+		if (options.compressed && !options.format) {
+			const deflate = options.codecType.startsWith(CODEC_DEFLATE);
+			const ZlibStream = deflate ? config.CompressionStreamZlib : config.DecompressionStreamZlib;
+			const NativeStream = deflate ? config.CompressionStream : config.DecompressionStream;
+			if (!options.useCompressionStream) {
+				try {
+					await initModule(config);
+				} catch {
+					if (!ZlibStream || ZlibStream.requiresModule) {
+						options.useCompressionStream = true;
+					}
+				}
+			} else if (ZlibStream && ZlibStream.requiresModule && !supportsDeflateRaw(NativeStream)) {
+				try {
+					await initModule(config);
+				} catch {
+					// ignored
 				}
 			}
 		}
@@ -268,6 +300,10 @@ async function runWebWorker(workerData, config) {
 			writer: writable.getWriter()
 		});
 	}
+	const { workerStartupTimeout } = config;
+	if (!workerData.workerAlive && Number.isFinite(workerStartupTimeout) && workerStartupTimeout >= 0) {
+		workerData.startupTimeout = setTimeout(() => onStartupTimeout(workerData), workerStartupTimeout);
+	}
 	try {
 		const resultValue = await result;
 		await closeWritable();
@@ -380,28 +416,68 @@ function getWebWorker(url, baseURI, workerData, isModuleType, useBlobURI = true)
 	} else {
 		worker = new Worker(webWorkerURI, webWorkerOptions);
 	}
-	worker.addEventListener(MESSAGE_EVENT_TYPE, event => onMessage(event, workerData));
+	worker.addEventListener(MESSAGE_EVENT_TYPE, event => {
+		workerData.workerAlive = true;
+		clearStartupTimeout(workerData);
+		onMessage(event, workerData);
+	});
 	worker.addEventListener(ERROR_EVENT_TYPE, event => onWorkerError(event, workerData));
 	worker.addEventListener(MESSAGE_ERROR_EVENT_TYPE, event => onWorkerError(event, workerData));
 	return worker;
 }
 
+function onStartupTimeout(workerData) {
+	workerData.startupTimeout = null;
+	if (workerData.workerAlive) {
+		return;
+	}
+	const { rejectResult, writer } = workerData;
+	terminateWorker(workerData);
+	workerData.worker = null;
+	if (rejectResult) {
+		const error = new Error(ERR_WORKER_STARTUP_TIMEOUT);
+		error.workerStartupFailed = true;
+		rejectResult(error);
+		if (writer) {
+			writer.releaseLock();
+		}
+	}
+}
+
+function clearStartupTimeout(workerData) {
+	const { startupTimeout } = workerData;
+	if (startupTimeout) {
+		clearTimeout(startupTimeout);
+		workerData.startupTimeout = null;
+	}
+}
+
 function onWorkerError(event, workerData) {
 	if (event.preventDefault) {
 		event.preventDefault();
 	}
-	const { rejectResult, writer, onTaskFinished } = workerData;
+	clearStartupTimeout(workerData);
+	const { workerAlive, rejectResult, writer, onTaskFinished } = workerData;
 	terminateWorker(workerData);
+	if (!workerAlive) {
+		workerData.worker = null;
+	}
 	if (rejectResult) {
-		rejectResult(event.error || new Error(event.message || ERROR_EVENT_TYPE));
+		let error = event.error || new Error(event.message || ERROR_EVENT_TYPE);
+		if (!workerAlive) {
+			error = Object.assign(new Error(error.message || ERROR_EVENT_TYPE), { workerStartupFailed: true });
+		}
+		rejectResult(error);
 		if (writer) {
 			writer.releaseLock();
 		}
-		onTaskFinished();
+		if (workerAlive) {
+			onTaskFinished();
+		}
 	}
 }
 
-function sendMessage(message, { worker, writer, transferStreams }) {
+function sendMessage(message, { worker, writer, transferStreams, workerAlive }) {
 	try {
 		const { value, readable, writable } = message;
 		const transferables = [];
@@ -409,7 +485,7 @@ function sendMessage(message, { worker, writer, transferStreams }) {
 			message.value = toExactUint8Array(value);
 			transferables.push(message.value.buffer);
 		}
-		if (transferStreams && transferStreamsSupported) {
+		if (transferStreams && transferStreamsSupported && workerAlive) {
 			if (readable) {
 				transferables.push(readable);
 			}

package/lib/core/configuration.js

@@ -49,6 +49,7 @@ const DEFAULT_CONFIGURATION = {
 	maxWorkers,
 	terminateWorkerTimeout: 5000,
 	workerStarvationTimeout: 5000,
+	workerStartupTimeout: 5000,
 	useWebWorkers: true,
 	useCompressionStream: true,
 	transferStreams: true,
@@ -64,6 +65,7 @@ const CONFIGURABLE_PROPERTY_NAMES = [
 	"maxWorkers",
 	"terminateWorkerTimeout",
 	"workerStarvationTimeout",
+	"workerStartupTimeout",
 	"useCompressionStream",
 	"useWebWorkers",
 	"transferStreams",

package/lib/core/constants.js

@@ -37,6 +37,7 @@ const COMPRESSION_METHOD_AES = 0x63;
 const LOCAL_FILE_HEADER_SIGNATURE = 0x04034b50;
 const SPLIT_ZIP_FILE_SIGNATURE = 0x08074b50;
 const DATA_DESCRIPTOR_RECORD_SIGNATURE = SPLIT_ZIP_FILE_SIGNATURE;
+const ARCHIVE_EXTRA_DATA_SIGNATURE = 0x08064b50;
 const CENTRAL_FILE_HEADER_SIGNATURE = 0x02014b50;
 const END_OF_CENTRAL_DIR_SIGNATURE = 0x06054b50;
 const ZIP64_END_OF_CENTRAL_DIR_SIGNATURE = 0x06064b50;
@@ -68,6 +69,7 @@ const BITFLAG_LEVEL_MAX_MASK = 0b010;
 const BITFLAG_LEVEL_FAST_MASK = 0b100;
 const BITFLAG_LEVEL_SUPER_FAST_MASK = 0b110;
 const BITFLAG_DATA_DESCRIPTOR = 0b1000;
+const BITFLAG_STRONG_ENCRYPTION = 0b1000000;
 const BITFLAG_LANG_ENCODING_FLAG = 0b100000000000;
 const FILE_ATTR_MSDOS_DIR_MASK = 0b10000;
 const FILE_ATTR_MSDOS_READONLY_MASK = 0x01;
@@ -95,7 +97,7 @@ const HEADER_OFFSET_COMPRESSED_SIZE = 14;
 const HEADER_OFFSET_UNCOMPRESSED_SIZE = 18;
 const LOCAL_HEADER_COMMON_OFFSET = 4;
 
-const MAX_DATE = new Date(2107, 11, 31);
+const MAX_DATE = new Date(2107, 11, 31, 23, 59, 58);
 const MIN_DATE = new Date(1980, 0, 1);
 
 const UNDEFINED_VALUE = undefined;
@@ -116,6 +118,7 @@ export {
 	COMPRESSION_METHOD_STORE,
 	COMPRESSION_METHOD_AES,
 	SPLIT_ZIP_FILE_SIGNATURE,
+	ARCHIVE_EXTRA_DATA_SIGNATURE,
 	LOCAL_FILE_HEADER_SIGNATURE,
 	DATA_DESCRIPTOR_RECORD_SIGNATURE,
 	CENTRAL_FILE_HEADER_SIGNATURE,
@@ -146,6 +149,7 @@ export {
 	BITFLAG_LEVEL_FAST_MASK,
 	BITFLAG_LEVEL_SUPER_FAST_MASK,
 	BITFLAG_DATA_DESCRIPTOR,
+	BITFLAG_STRONG_ENCRYPTION,
 	BITFLAG_LANG_ENCODING_FLAG,
 	FILE_ATTR_MSDOS_DIR_MASK,
 	FILE_ATTR_MSDOS_READONLY_MASK,

package/lib/core/options.js

@@ -46,6 +46,7 @@ const OPTION_TRANSFER_STREAMS = "transferStreams";
 const OPTION_PREVENT_CLOSE = "preventClose";
 const OPTION_ENCRYPTION_STRENGTH = "encryptionStrength";
 const OPTION_EXTENDED_TIMESTAMP = "extendedTimestamp";
+const OPTION_NTFS_TIMESTAMP = "ntfsTimestamp";
 const OPTION_KEEP_ORDER = "keepOrder";
 const OPTION_LEVEL = "level";
 const OPTION_BUFFERED_WRITE = "bufferedWrite";
@@ -85,6 +86,7 @@ export {
 	OPTION_PREVENT_CLOSE,
 	OPTION_ENCRYPTION_STRENGTH,
 	OPTION_EXTENDED_TIMESTAMP,
+	OPTION_NTFS_TIMESTAMP,
 	OPTION_KEEP_ORDER,
 	OPTION_LEVEL,
 	OPTION_BUFFERED_WRITE,

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

@@ -44,7 +44,8 @@ import {
 	ERR_INVALID_COMPRESSED_DATA,
 	ERR_ABORT_CHECK_PASSWORD,
 	InflateStream,
-	DeflateStream
+	DeflateStream,
+	supportsDeflateRaw
 } from "./zip-entry-stream.js";
 
 const DEFAULT_CHUNK_SIZE = 64 * 1024;
@@ -54,6 +55,7 @@ const MESSAGE_PULL = "pull";
 const MESSAGE_DATA = "data";
 const MESSAGE_ACK_DATA = "ack";
 const MESSAGE_CLOSE = "close";
+const MESSAGE_READY = "ready";
 const CODEC_DEFLATE = "deflate";
 const CODEC_INFLATE = "inflate";
 
@@ -66,13 +68,15 @@ export {
 	MESSAGE_DATA,
 	MESSAGE_ACK_DATA,
 	MESSAGE_CLOSE,
+	MESSAGE_READY,
 	ERR_INVALID_PASSWORD,
 	ERR_INVALID_SIGNATURE,
 	ERR_INVALID_UNCOMPRESSED_SIZE,
 	ERR_INVALID_COMPRESSED_DATA,
 	ERR_ABORT_CHECK_PASSWORD,
 	CodecStream,
-	ChunkStream
+	ChunkStream,
+	supportsDeflateRaw
 };
 
 class CodecStream extends TransformStream {

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

@@ -43,10 +43,13 @@ import {
 	ERR_INVALID_SIGNATURE,
 	ERR_ABORT_CHECK_PASSWORD
 } from "./common-crypto.js";
+import { UNDEFINED_VALUE } from "../constants.js";
 import { concat, getDataView } from "../util/array.js";
+import { getCodecStreams } from "../codec-registry.js";
 
 const ERR_INVALID_UNCOMPRESSED_SIZE = "Invalid uncompressed size";
 const ERR_INVALID_COMPRESSED_DATA = "Invalid compressed data";
+const ERR_UNSUPPORTED_COMPRESSION = "Compression method not supported";
 const FORMAT_DEFLATE_RAW = "deflate-raw";
 const FORMAT_DEFLATE64_RAW = "deflate64-raw";
 const FORMAT_GZIP = "gzip";
@@ -57,23 +60,26 @@ class DeflateStream extends TransformStream {
 
 	constructor(options, { chunkSize, CompressionStreamZlib, CompressionStream }) {
 		super({});
-		const { compressed, encrypted, useCompressionStream, zipCrypto, signed, level, deflate64 } = options;
+		const { compressed, encrypted, useCompressionStream, zipCrypto, signed, level, deflate64, format } = options;
 		const stream = this;
 		let crc32Stream, encryptionStream, gzipCrc32Stream;
 		let readable = super.readable;
-		const useGzipCrc32 = signed && compressed && !deflate64 && (!encrypted || zipCrypto) &&
+		const codecStreams = format && getCodecStreams(format);
+		const useGzipCrc32 = signed && compressed && !deflate64 && !codecStreams && (!encrypted || zipCrypto) &&
 			Boolean(useCompressionStream && CompressionStream);
 		if ((!encrypted || zipCrypto) && signed && !useGzipCrc32) {
 			crc32Stream = new Crc32Stream();
 			readable = pipeThrough(readable, crc32Stream);
 		}
 		if (compressed) {
-			if (useGzipCrc32) {
+			if (codecStreams) {
+				readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.CompressionStream, format, { level, chunkSize }));
+			} else if (useGzipCrc32) {
 				gzipCrc32Stream = new GzipToRawDeflateStream();
 				readable = pipeThroughBackpressured(readable, new CompressionStream(FORMAT_GZIP));
 				readable = pipeThrough(readable, gzipCrc32Stream);
 			} else {
-				readable = pipeThroughCommpressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamZlib, CompressionStream);
+				readable = pipeThroughCompressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStream, CompressionStreamZlib);
 			}
 		}
 		if (encrypted) {
@@ -142,7 +148,7 @@ class InflateStream extends TransformStream {
 
 	constructor(options, { chunkSize, DecompressionStreamZlib, DecompressionStream }) {
 		super({});
-		const { zipCrypto, encrypted, signed, signature, compressed, useCompressionStream, deflate64 } = options;
+		const { zipCrypto, encrypted, signed, signature, compressed, useCompressionStream, deflate64, format } = options;
 		let crc32Stream, decryptionStream;
 		let readable = super.readable;
 		if (encrypted) {
@@ -154,7 +160,12 @@ class InflateStream extends TransformStream {
 			}
 		}
 		if (compressed) {
-			readable = pipeThroughCommpressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamZlib, DecompressionStream);
+			const codecStreams = format && getCodecStreams(format);
+			if (codecStreams) {
+				readable = pipeThroughBackpressured(readable, createCodecStream(codecStreams.DecompressionStream, format, { chunkSize }));
+			} else {
+				readable = pipeThroughCompressionStream(readable, useCompressionStream, { chunkSize, deflate64 }, DecompressionStream, DecompressionStreamZlib);
+			}
 			readable = mapInflateStreamError(readable);
 		}
 		if ((!encrypted || zipCrypto) && signed) {
@@ -172,9 +183,29 @@ class InflateStream extends TransformStream {
 	}
 }
 
+const deflateRawSupportByStream = new Map();
+
+function supportsDeflateRaw(StreamClass) {
+	if (!StreamClass) {
+		return false;
+	}
+	let supported = deflateRawSupportByStream.get(StreamClass);
+	if (supported === UNDEFINED_VALUE) {
+		try {
+			new StreamClass(FORMAT_DEFLATE_RAW);
+			supported = true;
+		} catch {
+			supported = false;
+		}
+		deflateRawSupportByStream.set(StreamClass, supported);
+	}
+	return supported;
+}
+
 export {
 	DeflateStream,
 	InflateStream,
+	supportsDeflateRaw,
 	ERR_INVALID_PASSWORD,
 	ERR_INVALID_SIGNATURE,
 	ERR_INVALID_UNCOMPRESSED_SIZE,
@@ -191,21 +222,24 @@ function setReadable(stream, readable, flush) {
 	});
 }
 
-function pipeThroughCommpressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamZlib, CompressionStream) {
-	const Stream = useCompressionStream && CompressionStreamNative ? CompressionStreamNative : CompressionStreamZlib || CompressionStream;
+function createCodecStream(CodecStreamClass, format, options) {
+	if (!CodecStreamClass) {
+		throw new Error(ERR_UNSUPPORTED_COMPRESSION);
+	}
+	return new CodecStreamClass(format, options);
+}
+
+function pipeThroughCompressionStream(readable, useCompressionStream, options, CompressionStreamNative, CompressionStreamZlib) {
+	const Stream = useCompressionStream && CompressionStreamNative ?
+		CompressionStreamNative :
+		CompressionStreamZlib || CompressionStreamNative;
 	const format = options.deflate64 ? FORMAT_DEFLATE64_RAW : FORMAT_DEFLATE_RAW;
 	let codecStream;
 	try {
 		codecStream = new Stream(format, options);
 	} catch (error) {
-		if (useCompressionStream) {
-			if (CompressionStreamZlib) {
-				codecStream = new CompressionStreamZlib(format, options);
-			} else if (CompressionStream) {
-				codecStream = new CompressionStream(format, options);
-			} else {
-				throw error;
-			}
+		if (useCompressionStream && CompressionStreamZlib && Stream != CompressionStreamZlib) {
+			codecStream = new CompressionStreamZlib(format, options);
 		} else {
 			throw error;
 		}