@zip.js/zip.js 2.5.4 → 2.5.8

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, getChunkSize } 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,19 +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;
-		const size = () => compressedSize;
-		await processData(
-			codec,
-			reader.getStream({ offset: dataOffset, size, chunkSize: getChunkSize(config) }).getReader(),
-			writer.getStreamWriter(),
-			size,
-			{ 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, getChunkSize } 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";
@@ -74,7 +79,7 @@ const ERR_INVALID_VERSION = "Version exceeds 65535";
 const ERR_INVALID_ENCRYPTION_STRENGTH = "The strength must equal 1, 2, or 3";
 const ERR_INVALID_EXTRAFIELD_TYPE = "Extra field type exceeds 65535";
 const ERR_INVALID_EXTRAFIELD_DATA = "Extra field data exceeds 64KB";
-const ERR_UNSUPPORTED_FORMAT = "Zip64 is not supported";
+const ERR_UNSUPPORTED_FORMAT = "Zip64 is not supported (make sure 'keepOrder' is set to 'true')";
 
 const EXTRAFIELD_DATA_AES = new Uint8Array([0x07, 0x00, 0x02, 0x00, 0x41, 0x45, 0x03, 0x00, 0x00]);
 const EXTRAFIELD_LENGTH_ZIP64 = 24;
@@ -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) {
@@ -281,7 +283,6 @@ async function addFile(zipWriter, name, reader, options) {
 
 async function getFileEntry(zipWriter, name, reader, options) {
 	const { files, writer } = zipWriter;
-	const streamWriter = writer.getStreamWriter();
 	const previousFileEntry = Array.from(files.values()).pop();
 	let fileEntry = {};
 	let bufferedWrite;
@@ -307,7 +308,7 @@ async function getFileEntry(zipWriter, name, reader, options) {
 			}
 			fileWriter = writer;
 		}
-		fileEntry = await createFileEntry(reader, fileWriter.getStreamWriter(), zipWriter.config, options);
+		fileEntry = await createFileEntry(reader, fileWriter.getStream(), zipWriter.config, options);
 		fileEntry.lock = lockCurrentFileEntry;
 		files.set(name, fileEntry);
 		fileEntry.filename = name;
@@ -323,6 +324,7 @@ async function getFileEntry(zipWriter, name, reader, options) {
 				}
 			} while (pendingFileEntry && pendingFileEntry.lock);
 			fileEntry.writingBufferedData = true;
+			const writable = writer.getStream();
 			if (!options.dataDescriptor) {
 				const headerLength = 26;
 				const arrayBuffer = await sliceAsArrayBuffer(blob, 0, headerLength);
@@ -337,10 +339,10 @@ async function getFileEntry(zipWriter, name, reader, options) {
 					setUint32(arrayBufferView, 18, fileEntry.compressedSize);
 					setUint32(arrayBufferView, 22, fileEntry.uncompressedSize);
 				}
-				await writeUint8Array(streamWriter, new Uint8Array(arrayBuffer));
+				await writeUint8Array(writable, new Uint8Array(arrayBuffer));
 				indexWrittenData = headerLength;
 			}
-			await writeBlob(streamWriter, blob, indexWrittenData);
+			await writeBlob(writable, blob, indexWrittenData);
 			delete fileEntry.writingBufferedData;
 		}
 		fileEntry.offset = zipWriter.offset;
@@ -369,7 +371,7 @@ async function getFileEntry(zipWriter, name, reader, options) {
 	}
 }
 
-async function createFileEntry(reader, streamWriter, config, options) {
+async function createFileEntry(reader, writable, config, options) {
 	const {
 		rawFilename,
 		lastAccessDate,
@@ -516,7 +518,11 @@ async function createFileEntry(reader, streamWriter, config, options) {
 	let result;
 	let compressedSize = 0;
 	if (reader) {
-		const codec = await createCodec(config.Deflate, {
+		await writeUint8Array(writable, 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,20 +534,11 @@ async function createFileEntry(reader, streamWriter, config, options) {
 			encrypted,
 			useWebWorkers,
 			useCompressionStream
-		}, config);
-		await writeUint8Array(streamWriter, localHeaderArray);
-		fileEntry.dataWritten = true;
-		const size = () => reader.size;
-		result = await processData(
-			codec,
-			reader.getStream({ offset: 0, size, chunkSize: getChunkSize(config) }).getReader(),
-			streamWriter,
-			() => reader.size,
-			{ onprogress, signal });
+		}, config, { signal, onprogress, size });
 		uncompressedSize = fileEntry.uncompressedSize = reader.size;
 		compressedSize = result.length;
 	} else {
-		await writeUint8Array(streamWriter, localHeaderArray);
+		await writeUint8Array(writable, localHeaderArray);
 		fileEntry.dataWritten = true;
 	}
 	let dataDescriptorArray = new Uint8Array(0);
@@ -585,7 +582,7 @@ async function createFileEntry(reader, streamWriter, config, options) {
 		}
 	}
 	if (dataDescriptor) {
-		await writeUint8Array(streamWriter, dataDescriptorArray);
+		await writeUint8Array(writable, dataDescriptorArray);
 	}
 	const length = localHeaderArray.length + compressedSize + dataDescriptorArray.length;
 	Object.assign(fileEntry, { compressedSize, lastModDate, rawLastModDate, creationDate, lastAccessDate, encrypted, length });
@@ -594,7 +591,6 @@ async function createFileEntry(reader, streamWriter, config, options) {
 
 async function closeFile(zipWriter, comment, options) {
 	const { files } = zipWriter;
-	const streamWriter = zipWriter.writer.getStreamWriter();
 	let offset = 0;
 	let directoryDataLength = 0;
 	let directoryOffset = zipWriter.offset;
@@ -709,9 +705,10 @@ async function closeFile(zipWriter, comment, options) {
 	setUint16(directoryView, offset + 10, filesLength);
 	setUint32(directoryView, offset + 12, directoryDataLength);
 	setUint32(directoryView, offset + 16, directoryOffset);
-	await writeUint8Array(streamWriter, directoryArray);
+	const writable = zipWriter.writer.getStream();
+	await writeUint8Array(writable, directoryArray);
 	if (comment && comment.length) {
-		await writeUint8Array(streamWriter, comment);
+		await writeUint8Array(writable, comment);
 	}
 }
 
@@ -732,23 +729,25 @@ function sliceAsArrayBuffer(blob, start, end) {
 	}
 }
 
-async function writeBlob(streamWriter, blob, start = 0) {
+async function writeBlob(writable, 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 writeUint8Array(streamWriter, new Uint8Array(arrayBuffer));
+			await writeUint8Array(writable, new Uint8Array(arrayBuffer));
 			start += blockSize;
 			await writeSlice();
 		}
 	}
 }
 
-async function writeUint8Array(streamWriter, array) {
+async function writeUint8Array(writable, array) {
+	const streamWriter = writable.getWriter();
 	await streamWriter.ready;
 	await streamWriter.write(array);
+	streamWriter.releaseLock();
 }
 
 function getTimeNTFS(date) {

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;