@zip.js/zip.js 2.5.3 → 2.5.7

package/lib/core/{codecs → streams}/zip-crypto-stream.js

@@ -29,12 +29,12 @@
 /* global crypto, TransformStream */
 // deno-lint-ignore-file no-this-alias
 
-import Crc32 from "./crc32.js";
+import Crc32 from "./codecs/crc32.js";
 import { ERR_INVALID_PASSWORD } from "./aes-crypto-stream.js";
 
 const HEADER_LENGTH = 12;
 
-class ZipCryptoDecryptStream extends TransformStream {
+class ZipCryptoDecryptionStream extends TransformStream {
 
 	constructor(password, passwordVerification) {
 		let stream;
@@ -47,18 +47,16 @@ class ZipCryptoDecryptStream extends TransformStream {
 				createKeys(this, password);
 			},
 			transform(chunk, controller) {
-				if (chunk && chunk.length) {
-					const zipCrypto = this;
-					if (zipCrypto.password) {
-						const decryptedHeader = decrypt(zipCrypto, chunk.subarray(0, HEADER_LENGTH));
-						zipCrypto.password = null;
-						if (decryptedHeader[HEADER_LENGTH - 1] != zipCrypto.passwordVerification) {
-							throw new Error(ERR_INVALID_PASSWORD);
-						}
-						chunk = chunk.subarray(HEADER_LENGTH);
+				const zipCrypto = this;
+				if (zipCrypto.password) {
+					const decryptedHeader = decrypt(zipCrypto, chunk.subarray(0, HEADER_LENGTH));
+					zipCrypto.password = null;
+					if (decryptedHeader[HEADER_LENGTH - 1] != zipCrypto.passwordVerification) {
+						throw new Error(ERR_INVALID_PASSWORD);
 					}
-					controller.enqueue(decrypt(zipCrypto, chunk));
+					chunk = chunk.subarray(HEADER_LENGTH);
 				}
+				controller.enqueue(decrypt(zipCrypto, chunk));
 			},
 			flush() {
 				stream.valid = true;
@@ -68,7 +66,7 @@ class ZipCryptoDecryptStream extends TransformStream {
 	}
 }
 
-class ZipCryptoEncryptStream extends TransformStream {
+class ZipCryptoEncryptionStream extends TransformStream {
 
 	constructor(password, passwordVerification) {
 		super({
@@ -80,24 +78,22 @@ class ZipCryptoEncryptStream extends TransformStream {
 				createKeys(this, password);
 			},
 			transform(chunk, controller) {
-				if (chunk && chunk.length) {
-					const zipCrypto = this;
-					let output;
-					let offset;
-					if (zipCrypto.password) {
-						zipCrypto.password = null;
-						const header = crypto.getRandomValues(new Uint8Array(HEADER_LENGTH));
-						header[HEADER_LENGTH - 1] = zipCrypto.passwordVerification;
-						output = new Uint8Array(chunk.length + header.length);
-						output.set(encrypt(zipCrypto, header), 0);
-						offset = HEADER_LENGTH;
-					} else {
-						output = new Uint8Array(chunk.length);
-						offset = 0;
-					}
-					output.set(encrypt(zipCrypto, chunk), offset);
-					controller.enqueue(output);
+				const zipCrypto = this;
+				let output;
+				let offset;
+				if (zipCrypto.password) {
+					zipCrypto.password = null;
+					const header = crypto.getRandomValues(new Uint8Array(HEADER_LENGTH));
+					header[HEADER_LENGTH - 1] = zipCrypto.passwordVerification;
+					output = new Uint8Array(chunk.length + header.length);
+					output.set(encrypt(zipCrypto, header), 0);
+					offset = HEADER_LENGTH;
+				} else {
+					output = new Uint8Array(chunk.length);
+					offset = 0;
 				}
+				output.set(encrypt(zipCrypto, chunk), offset);
+				controller.enqueue(output);
 			},
 			flush() {
 			}
@@ -106,8 +102,8 @@ class ZipCryptoEncryptStream extends TransformStream {
 }
 
 export {
-	ZipCryptoDecryptStream,
-	ZipCryptoEncryptStream,
+	ZipCryptoDecryptionStream,
+	ZipCryptoEncryptionStream,
 	ERR_INVALID_PASSWORD
 };
 

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

@@ -0,0 +1,185 @@
+/*
+ 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 CompressionStream, DecompressionStream, TransformStream */
+
+import Crc32Stream from "./crc32-stream.js";
+import {
+	AESEncryptionStream,
+	AESDecryptionStream
+} from "./aes-crypto-stream.js";
+import {
+	ZipCryptoEncryptionStream,
+	ZipCryptoDecryptionStream,
+	ERR_INVALID_PASSWORD
+} from "./zip-crypto-stream.js";
+import CodecStream from "./codec-stream.js";
+
+const ERR_INVALID_SIGNATURE = "Invalid signature";
+const COMPRESSION_FORMAT = "deflate-raw";
+const UNDEFINED_TYPE = "undefined";
+const COMPRESSION_STREAM_API_SUPPORTED = typeof CompressionStream == UNDEFINED_TYPE;
+const DECOMPRESSION_STREAM_API_SUPPORTED = typeof DecompressionStream == UNDEFINED_TYPE;
+let INFLATE_RAW_SUPPORTED = true;
+let DEFLATE_RAW_SUPPORTED = true;
+
+class DeflateStream extends TransformStream {
+
+	constructor(codecConstructor, options, { chunkSize }, ...strategies) {
+		super({}, ...strategies);
+		const { compressed, useCompressionStream, password, passwordVerification, encryptionStrength, zipCrypto, signed } = options;
+		const stream = this;
+		let crc32Stream, encryptionStream;
+		let readable = filterEmptyChunks(super.readable);
+		const encrypted = Boolean(password);
+		if ((!encrypted || zipCrypto) && signed) {
+			[readable, crc32Stream] = readable.tee();
+			crc32Stream = crc32Stream.pipeThrough(new Crc32Stream());
+		}
+		if (compressed) {
+			if ((useCompressionStream !== undefined && !useCompressionStream) || (COMPRESSION_STREAM_API_SUPPORTED && !DEFLATE_RAW_SUPPORTED)) {
+				readable = pipeCodecStream(codecConstructor, readable, chunkSize);
+			} else {
+				try {
+					const compressionStream = new CompressionStream(COMPRESSION_FORMAT);
+					readable = readable.pipeThrough(compressionStream);
+				} catch (_error) {
+					DEFLATE_RAW_SUPPORTED = false;
+					readable = pipeCodecStream(codecConstructor, readable, chunkSize);
+				}
+			}
+		}
+		if (encrypted) {
+			if (zipCrypto) {
+				readable = readable.pipeThrough(new ZipCryptoEncryptionStream(password, passwordVerification));
+			} else {
+				encryptionStream = new AESEncryptionStream(password, encryptionStrength);
+				readable = readable.pipeThrough(encryptionStream);
+			}
+		}
+		setReadable(stream, readable, async () => {
+			let signature;
+			if (encrypted && !zipCrypto) {
+				signature = encryptionStream.signature;
+			}
+			if ((!encrypted || zipCrypto) && signed) {
+				signature = await crc32Stream.getReader().read();
+				signature = new DataView(signature.value.buffer).getUint32(0);
+			}
+			stream.signature = signature;
+		});
+	}
+}
+
+class InflateStream extends TransformStream {
+
+	constructor(codecConstructor, options, { chunkSize }, ...strategies) {
+		super({}, ...strategies);
+		const { zipCrypto, password, passwordVerification, signed, encryptionStrength, compressed, useCompressionStream } = options;
+		const stream = this;
+		let crc32Stream, decryptionStream;
+		let readable = filterEmptyChunks(super.readable);
+		const encrypted = Boolean(password);
+		if (encrypted) {
+			if (zipCrypto) {
+				readable = readable.pipeThrough(new ZipCryptoDecryptionStream(password, passwordVerification));
+			} else {
+				decryptionStream = new AESDecryptionStream(password, signed, encryptionStrength);
+				readable = readable.pipeThrough(decryptionStream);
+			}
+		}
+		if (compressed) {
+			if ((useCompressionStream !== undefined && !useCompressionStream) || (DECOMPRESSION_STREAM_API_SUPPORTED && !INFLATE_RAW_SUPPORTED)) {
+				readable = pipeCodecStream(codecConstructor, readable, chunkSize);
+			} else {
+				try {
+					readable = readable.pipeThrough(new DecompressionStream(COMPRESSION_FORMAT));
+				} catch (_error) {
+					INFLATE_RAW_SUPPORTED = false;
+					readable = pipeCodecStream(codecConstructor, readable, chunkSize);
+				}
+			}
+		}
+		if ((!encrypted || zipCrypto) && signed) {
+			[readable, crc32Stream] = readable.tee();
+			crc32Stream = crc32Stream.pipeThrough(new Crc32Stream());
+		}
+		setReadable(stream, readable, async () => {
+			if (encrypted && !zipCrypto) {
+				if (!decryptionStream.valid) {
+					throw new Error(ERR_INVALID_SIGNATURE);
+				}
+			}
+			if ((!encrypted || zipCrypto) && signed) {
+				const signature = await crc32Stream.getReader().read();
+				const dataViewSignature = new DataView(signature.value.buffer);
+				if (signature != dataViewSignature.getUint32(0, false)) {
+					throw new Error(ERR_INVALID_SIGNATURE);
+				}
+			}
+		});
+	}
+}
+
+export {
+	DeflateStream,
+	InflateStream,
+	ERR_INVALID_PASSWORD,
+	ERR_INVALID_SIGNATURE
+};
+
+function pipeCodecStream(codecConstructor, stream, chunkSize) {
+	return stream.pipeThrough(new CodecStream(codecConstructor, { chunkSize }));
+}
+
+function filterEmptyChunks(readable) {
+	return readable.pipeThrough(new TransformStream({
+		transform(chunk, controller) {
+			if (chunk && chunk.length) {
+				controller.enqueue(chunk);
+			}
+		}
+	}));
+}
+
+function setReadable(stream, readable, flush) {
+	stream.length = 0;
+	readable = readable.pipeThrough(new TransformStream({
+		transform(chunk, controller) {
+			if (chunk && chunk.length) {
+				stream.length += chunk.length;
+				controller.enqueue(chunk);
+			}
+		}, flush
+	}));
+	Object.defineProperty(stream, "readable", {
+		get() {
+			return readable;
+		}
+	});
+}

package/lib/core/z-worker-core.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global self, importScripts, addEventListener, postMessage */
+/* global self, importScripts, addEventListener, postMessage, ReadableStream, WritableStream */
 
 import {
 	createCodec,
@@ -37,7 +37,8 @@ import {
 	MESSAGE_PULL,
 	MESSAGE_DATA,
 	MESSAGE_ABORT,
-} from "./codecs/codec.js";
+	MESSAGE_CLOSE
+} from "./codec-interface.js";
 
 const pendingMessages = new Map();
 let codec;
@@ -78,16 +79,30 @@ async function init(message) {
 		} else if (options.codecType.startsWith(CODEC_INFLATE)) {
 			codecConstructor = self.Inflate;
 		}
-		codec = createCodec(codecConstructor, options, message.config);
-		codec.ondata = data => sendMessage({ type: MESSAGE_DATA, data });
-		codec.onerror = error => postMessage({ error: { message: error.message, stack: error.stack } });
-		codec.pull = () => {
-			const result = new Promise((resolve, reject) => pendingMessages.set(messageId, { resolve, reject }));
-			sendMessage({ type: MESSAGE_PULL, messageId });
-			messageId++;
-			return result;
-		};
-		await codec.start();
+		const readable = new ReadableStream({
+			async pull(controller) {
+				let result = new Promise((resolve, reject) => pendingMessages.set(messageId, { resolve, reject }));
+				sendMessage({ type: MESSAGE_PULL, messageId });
+				messageId++;
+				const { value, done } = await result;
+				// debugger;
+				controller.enqueue(value);
+				if (done) {
+					controller.close();
+				}
+			}
+		}, {
+			highWaterMark: 1
+		});
+		const writable = new WritableStream({
+			write(data) {
+				sendMessage({ type: MESSAGE_DATA, data });
+			}
+		});
+		codec = createCodec(codecConstructor, readable, writable, options, message.config);
+		const result = await codec.run();
+		sendMessage({ type: MESSAGE_CLOSE, result });
+
 	} catch (error) {
 		postMessage({ error: { message: error.message, stack: error.stack } });
 	}
@@ -95,11 +110,11 @@ async function init(message) {
 
 function sendMessage(message) {
 	if (message.data) {
-		const data = message.data.value.data;
+		const data = message.data;
 		if (data && data.length) {
 			try {
-				message.data.value.data = data.buffer;
-				postMessage(message, [message.data.value.data]);
+				message.data = data.buffer;
+				postMessage(message, [message.data]);
 			} catch (_error) {
 				postMessage(message);
 			}

package/lib/core/zip-fs-core.js

@@ -26,7 +26,6 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-export { ERR_ABORT } from "./engine.js";
 import {
 	Reader,
 	TextReader,
@@ -419,6 +418,7 @@ class FS {
 }
 
 const fs = { FS, ZipDirectoryEntry, ZipFileEntry };
+export { ERR_ABORT } from "./codec-pool.js";
 export { fs };
 
 function getTotalSize(entries, propertyName) {

package/lib/core/zip-reader.js

@@ -56,11 +56,18 @@ import {
 	FILE_ATTR_MSDOS_DIR_MASK,
 	DIRECTORY_SIGNATURE
 } from "./constants.js";
-import { getConfiguration } from "./configuration.js";
-import { createCodec, CODEC_INFLATE, ERR_INVALID_SIGNATURE, ERR_INVALID_PASSWORD } from "./codecs/codec-pool.js";
+import {
+	getConfiguration,
+	getChunkSize
+} from "./configuration.js";
+import {
+	runCodec,
+	CODEC_INFLATE,
+	ERR_INVALID_SIGNATURE,
+	ERR_INVALID_PASSWORD
+} from "./codec-pool.js";
 import decodeText from "./util/decode-text.js";
-import Crc32 from "./codecs/crc32.js";
-import { processData } from "./engine.js";
+import Crc32 from "./streams/codecs/crc32.js";
 import Entry from "./zip-entry.js";
 
 const ERR_BAD_FORMAT = "File format is not recognized";
@@ -292,7 +299,15 @@ class ZipEntry {
 				throw new Error(ERR_ENCRYPTED);
 			}
 		}
-		const codec = await createCodec(config.Inflate, {
+		const dataOffset = offset + 30 + localDirectory.filenameLength + localDirectory.extraFieldLength;
+		const size = () => compressedSize;
+		const readable = reader.getStream({ offset: dataOffset, size, chunkSize: getChunkSize(config) });
+		const writable = writer.getStream();
+		const signal = getOptionValue(zipEntry, options, "signal");
+		if (!writer.initialized) {
+			await writer.init();
+		}
+		await runCodec(config.Inflate, readable, writable, {
 			codecType: CODEC_INFLATE,
 			password,
 			zipCrypto,
@@ -304,13 +319,7 @@ class ZipEntry {
 			encrypted,
 			useWebWorkers: getOptionValue(zipEntry, options, "useWebWorkers"),
 			useCompressionStream: getOptionValue(zipEntry, options, "useCompressionStream")
-		}, config);
-		if (!writer.initialized) {
-			await writer.init();
-		}
-		const signal = getOptionValue(zipEntry, options, "signal");
-		const dataOffset = offset + 30 + localDirectory.filenameLength + localDirectory.extraFieldLength;
-		await processData(codec, reader, writer, dataOffset, () => compressedSize, config, { onprogress: options.onprogress, signal });
+		}, config, { signal, onprogress: options.onprogress, size });
 		return writer.getData();
 	}
 }

package/lib/core/zip-writer.js

@@ -59,11 +59,16 @@ import {
 	MIN_DATE,
 	MAX_DATE
 } from "./constants.js";
-import { getConfiguration } from "./configuration.js";
-import { CODEC_DEFLATE, createCodec } from "./codecs/codec-pool.js";
+import {
+	getConfiguration,
+	getChunkSize
+} from "./configuration.js";
+import {
+	CODEC_DEFLATE,
+	runCodec
+} from "./codec-pool.js";
 import encodeText from "./util/encode-text.js";
 import { BlobWriter } from "./io.js";
-import { processData } from "./engine.js";
 import Entry from "./zip-entry.js";
 
 const ERR_DUPLICATED_NAME = "File already exists";
@@ -204,9 +209,6 @@ async function addFile(zipWriter, name, reader, options) {
 	}
 	let maximumCompressedSize = 0;
 	let keepOrder = getOptionValue(zipWriter, options, "keepOrder");
-	if (keepOrder === undefined) {
-		keepOrder = true;
-	}
 	let uncompressedSize = 0;
 	let msDosCompatible = getOptionValue(zipWriter, options, "msDosCompatible");
 	if (msDosCompatible === undefined) {
@@ -280,8 +282,8 @@ async function addFile(zipWriter, name, reader, options) {
 }
 
 async function getFileEntry(zipWriter, name, reader, options) {
-	const files = zipWriter.files;
-	const writer = zipWriter.writer;
+	const { files, writer } = zipWriter;
+	const streamWriter = writer.getStream().getWriter();
 	const previousFileEntry = Array.from(files.values()).pop();
 	let fileEntry = {};
 	let bufferedWrite;
@@ -307,7 +309,7 @@ async function getFileEntry(zipWriter, name, reader, options) {
 			}
 			fileWriter = writer;
 		}
-		fileEntry = await createFileEntry(reader, fileWriter, zipWriter.config, options);
+		fileEntry = await createFileEntry(reader, fileWriter.getStream(), fileWriter.getStream().getWriter(), zipWriter.config, options);
 		fileEntry.lock = lockCurrentFileEntry;
 		files.set(name, fileEntry);
 		fileEntry.filename = name;
@@ -337,10 +339,10 @@ async function getFileEntry(zipWriter, name, reader, options) {
 					setUint32(arrayBufferView, 18, fileEntry.compressedSize);
 					setUint32(arrayBufferView, 22, fileEntry.uncompressedSize);
 				}
-				await writer.writeUint8Array(new Uint8Array(arrayBuffer));
+				await writeUint8Array(streamWriter, new Uint8Array(arrayBuffer));
 				indexWrittenData = headerLength;
 			}
-			await writeBlob(writer, blob, indexWrittenData);
+			await writeBlob(streamWriter, blob, indexWrittenData);
 			delete fileEntry.writingBufferedData;
 		}
 		fileEntry.offset = zipWriter.offset;
@@ -369,7 +371,7 @@ async function getFileEntry(zipWriter, name, reader, options) {
 	}
 }
 
-async function createFileEntry(reader, writer, config, options) {
+async function createFileEntry(reader, writable, streamWriter, config, options) {
 	const {
 		rawFilename,
 		lastAccessDate,
@@ -516,7 +518,11 @@ async function createFileEntry(reader, writer, config, options) {
 	let result;
 	let compressedSize = 0;
 	if (reader) {
-		const codec = await createCodec(config.Deflate, {
+		await writeUint8Array(streamWriter, localHeaderArray);
+		fileEntry.dataWritten = true;
+		const size = () => reader.size;
+		const readable = reader.getStream({ offset: 0, size, chunkSize: getChunkSize(config) });
+		result = await runCodec(config.Deflate, readable, writable, {
 			codecType: CODEC_DEFLATE,
 			level,
 			password,
@@ -528,14 +534,11 @@ async function createFileEntry(reader, writer, config, options) {
 			encrypted,
 			useWebWorkers,
 			useCompressionStream
-		}, config);
-		await writer.writeUint8Array(localHeaderArray);
-		fileEntry.dataWritten = true;
-		result = await processData(codec, reader, writer, 0, () => reader.size, config, { onprogress, signal });
+		}, config, { signal, onprogress, size });
 		uncompressedSize = fileEntry.uncompressedSize = reader.size;
 		compressedSize = result.length;
 	} else {
-		await writer.writeUint8Array(localHeaderArray);
+		await writeUint8Array(streamWriter, localHeaderArray);
 		fileEntry.dataWritten = true;
 	}
 	let dataDescriptorArray = new Uint8Array(0);
@@ -579,7 +582,7 @@ async function createFileEntry(reader, writer, config, options) {
 		}
 	}
 	if (dataDescriptor) {
-		await writer.writeUint8Array(dataDescriptorArray);
+		await writeUint8Array(streamWriter, dataDescriptorArray);
 	}
 	const length = localHeaderArray.length + compressedSize + dataDescriptorArray.length;
 	Object.assign(fileEntry, { compressedSize, lastModDate, rawLastModDate, creationDate, lastAccessDate, encrypted, length });
@@ -587,8 +590,8 @@ async function createFileEntry(reader, writer, config, options) {
 }
 
 async function closeFile(zipWriter, comment, options) {
-	const writer = zipWriter.writer;
-	const files = zipWriter.files;
+	const { files } = zipWriter;
+	const streamWriter = zipWriter.writer.getStream().getWriter();
 	let offset = 0;
 	let directoryDataLength = 0;
 	let directoryOffset = zipWriter.offset;
@@ -703,9 +706,9 @@ async function closeFile(zipWriter, comment, options) {
 	setUint16(directoryView, offset + 10, filesLength);
 	setUint32(directoryView, offset + 12, directoryDataLength);
 	setUint32(directoryView, offset + 16, directoryOffset);
-	await writer.writeUint8Array(directoryArray);
+	await writeUint8Array(streamWriter, directoryArray);
 	if (comment && comment.length) {
-		await writer.writeUint8Array(comment);
+		await writeUint8Array(streamWriter, comment);
 	}
 }
 
@@ -726,20 +729,25 @@ function sliceAsArrayBuffer(blob, start, end) {
 	}
 }
 
-async function writeBlob(writer, blob, start = 0) {
+async function writeBlob(streamWriter, blob, start = 0) {
 	const blockSize = 512 * 1024 * 1024;
 	await writeSlice();
 
 	async function writeSlice() {
 		if (start < blob.size) {
 			const arrayBuffer = await sliceAsArrayBuffer(blob, start, start + blockSize);
-			await writer.writeUint8Array(new Uint8Array(arrayBuffer));
+			await writeUint8Array(streamWriter, new Uint8Array(arrayBuffer));
 			start += blockSize;
 			await writeSlice();
 		}
 	}
 }
 
+async function writeUint8Array(streamWriter, array) {
+	await streamWriter.ready;
+	await streamWriter.write(array);
+}
+
 function getTimeNTFS(date) {
 	if (date) {
 		return ((BigInt(date.getTime()) + BigInt(11644473600000)) * BigInt(10000));

package/lib/z-worker-fflate.js

@@ -29,7 +29,10 @@
 /* global self */
 
 import "./core/z-worker-core.js";
-import { Deflate, Inflate } from "./zip-fflate-shim.js";
+import {
+	Deflate,
+	Inflate
+} from "./zip-fflate-shim.js";
 
 self.initCodec = () => {
 	self.Deflate = Deflate;