@zip.js/zip.js 2.6.26 → 2.6.29

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

@@ -39,7 +39,6 @@ const HEADER_LENGTH = 12;
 class ZipCryptoDecryptionStream extends TransformStream {
 
 	constructor(password, passwordVerification) {
-		let stream;
 		super({
 			start() {
 				Object.assign(this, {
@@ -59,12 +58,8 @@ class ZipCryptoDecryptionStream extends TransformStream {
 					chunk = chunk.subarray(HEADER_LENGTH);
 				}
 				controller.enqueue(decrypt(zipCrypto, chunk));
-			},
-			flush() {
-				stream.valid = true;
 			}
 		});
-		stream = this;
 	}
 }
 
@@ -96,8 +91,6 @@ class ZipCryptoEncryptionStream extends TransformStream {
 				}
 				output.set(encrypt(zipCrypto, chunk), offset);
 				controller.enqueue(output);
-			},
-			flush() {
 			}
 		});
 	}
@@ -128,21 +121,25 @@ function encrypt(target, input) {
 }
 
 function createKeys(target, password) {
-	target.keys = [0x12345678, 0x23456789, 0x34567890];
-	target.crcKey0 = new Crc32(target.keys[0]);
-	target.crcKey2 = new Crc32(target.keys[2]);
+	const keys = [0x12345678, 0x23456789, 0x34567890];
+	Object.assign(target, {
+		keys,
+		crcKey0: new Crc32(keys[0]),
+		crcKey2: new Crc32(keys[2]),
+	});
 	for (let index = 0; index < password.length; index++) {
 		updateKeys(target, password.charCodeAt(index));
 	}
 }
 
 function updateKeys(target, byte) {
+	let [key0, key1, key2] = target.keys;
 	target.crcKey0.append([byte]);
-	target.keys[0] = ~target.crcKey0.get();
-	target.keys[1] = getInt32(target.keys[1] + getInt8(target.keys[0]));
-	target.keys[1] = getInt32(Math.imul(target.keys[1], 134775813) + 1);
-	target.crcKey2.append([target.keys[1] >>> 24]);
-	target.keys[2] = ~target.crcKey2.get();
+	key0 = ~target.crcKey0.get();
+	key1 = getInt32(Math.imul(getInt32(key1 + getInt8(key0)), 134775813) + 1);
+	target.crcKey2.append([key1 >>> 24]);
+	key2 = ~target.crcKey2.get();
+	target.keys = [key0, key1, key2];
 }
 
 function getByte(target) {

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

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global CompressionStream, DecompressionStream, TransformStream */
+/* global TransformStream */
 
 import { Crc32Stream } from "./crc32-stream.js";
 import {
@@ -35,51 +35,36 @@ import {
 } from "./aes-crypto-stream.js";
 import {
 	ZipCryptoEncryptionStream,
-	ZipCryptoDecryptionStream,
+	ZipCryptoDecryptionStream
 } from "./zip-crypto-stream.js";
 import {
-	ERR_INVALID_PASSWORD
+	ERR_INVALID_PASSWORD,
+	ERR_INVALID_SIGNATURE
 } from "./common-crypto.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);
+	constructor(options, { chunkSize, CompressionStream, CompressionStreamNative }) {
+		super({});
 		const { compressed, encrypted, useCompressionStream, password, passwordVerification, encryptionStrength, zipCrypto, signed, level } = options;
 		const stream = this;
 		let crc32Stream, encryptionStream;
 		let readable = filterEmptyChunks(super.readable);
 		if ((!encrypted || zipCrypto) && signed) {
 			[readable, crc32Stream] = readable.tee();
-			crc32Stream = crc32Stream.pipeThrough(new Crc32Stream());
+			crc32Stream = pipeThrough(crc32Stream, new Crc32Stream());
 		}
 		if (compressed) {
-			if ((useCompressionStream !== undefined && !useCompressionStream) || (COMPRESSION_STREAM_API_SUPPORTED && !DEFLATE_RAW_SUPPORTED)) {
-				readable = pipeCodecStream(codecConstructor, readable, { chunkSize, level });
-			} else {
-				try {
-					readable = readable.pipeThrough(new CompressionStream(COMPRESSION_FORMAT));
-				} catch (_error) {
-					DEFLATE_RAW_SUPPORTED = false;
-					readable = pipeCodecStream(codecConstructor, readable, { chunkSize, level });
-				}
-			}
+			readable = pipeThroughCommpressionStream(readable, useCompressionStream, { level, chunkSize }, CompressionStreamNative, CompressionStream);
 		}
 		if (encrypted) {
 			if (zipCrypto) {
-				readable = readable.pipeThrough(new ZipCryptoEncryptionStream(password, passwordVerification));
+				readable = pipeThrough(readable, new ZipCryptoEncryptionStream(password, passwordVerification));
 			} else {
 				encryptionStream = new AESEncryptionStream(password, encryptionStrength);
-				readable = readable.pipeThrough(encryptionStream);
+				readable = pipeThrough(readable, encryptionStream);
 			}
 		}
 		setReadable(stream, readable, async () => {
@@ -98,46 +83,31 @@ class DeflateStream extends TransformStream {
 
 class InflateStream extends TransformStream {
 
-	constructor(codecConstructor, options, { chunkSize }, ...strategies) {
-		super({}, ...strategies);
-		const { zipCrypto, encrypted, password, passwordVerification, signed, encryptionStrength, compressed, useCompressionStream } = options;
-		const stream = this;
+	constructor(options, { chunkSize, DecompressionStream, DecompressionStreamNative }) {
+		super({});
+		const { zipCrypto, encrypted, password, passwordVerification, signed, signature, encryptionStrength, compressed, useCompressionStream } = options;
 		let crc32Stream, decryptionStream;
 		let readable = filterEmptyChunks(super.readable);
 		if (encrypted) {
 			if (zipCrypto) {
-				readable = readable.pipeThrough(new ZipCryptoDecryptionStream(password, passwordVerification));
+				readable = pipeThrough(readable, new ZipCryptoDecryptionStream(password, passwordVerification));
 			} else {
 				decryptionStream = new AESDecryptionStream(password, signed, encryptionStrength);
-				readable = readable.pipeThrough(decryptionStream);
+				readable = pipeThrough(readable, 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 });
-				}
-			}
+			readable = pipeThroughCommpressionStream(readable, useCompressionStream, { chunkSize }, DecompressionStreamNative, DecompressionStream);
 		}
 		if ((!encrypted || zipCrypto) && signed) {
 			[readable, crc32Stream] = readable.tee();
-			crc32Stream = crc32Stream.pipeThrough(new Crc32Stream());
+			crc32Stream = pipeThrough(crc32Stream, new Crc32Stream());
 		}
-		setReadable(stream, readable, async () => {
-			if (encrypted && !zipCrypto) {
-				if (!decryptionStream.valid) {
-					throw new Error(ERR_INVALID_SIGNATURE);
-				}
-			}
+		setReadable(this, readable, async () => {
 			if ((!encrypted || zipCrypto) && signed) {
-				const signature = await crc32Stream.getReader().read();
-				const dataViewSignature = new DataView(signature.value.buffer);
-				if (options.signature != dataViewSignature.getUint32(0, false)) {
+				const streamSignature = await crc32Stream.getReader().read();
+				const dataViewSignature = new DataView(streamSignature.value.buffer);
+				if (signature != dataViewSignature.getUint32(0, false)) {
 					throw new Error(ERR_INVALID_SIGNATURE);
 				}
 			}
@@ -152,12 +122,8 @@ export {
 	ERR_INVALID_SIGNATURE
 };
 
-function pipeCodecStream(codecConstructor, readable, options) {
-	return readable.pipeThrough(new CodecStream(codecConstructor, options));
-}
-
 function filterEmptyChunks(readable) {
-	return readable.pipeThrough(new TransformStream({
+	return pipeThrough(readable, new TransformStream({
 		transform(chunk, controller) {
 			if (chunk && chunk.length) {
 				controller.enqueue(chunk);
@@ -167,10 +133,28 @@ function filterEmptyChunks(readable) {
 }
 
 function setReadable(stream, readable, flush) {
-	readable = readable.pipeThrough(new TransformStream({ flush }));
+	readable = pipeThrough(readable, new TransformStream({ flush }));
 	Object.defineProperty(stream, "readable", {
 		get() {
 			return readable;
 		}
 	});
+}
+
+function pipeThroughCommpressionStream(readable, useCompressionStream, options, CodecStreamNative, CodecStream) {
+	try {
+		const CompressionStream = useCompressionStream && CodecStreamNative ? CodecStreamNative : CodecStream;
+		readable = pipeThrough(readable, new CompressionStream(COMPRESSION_FORMAT, options));
+	} catch (error) {
+		if (useCompressionStream) {
+			readable = pipeThrough(readable, new CodecStream(COMPRESSION_FORMAT, options));
+		} else {
+			throw error;
+		}
+	}
+	return readable;
+}
+
+function pipeThrough(readable, transformStream) {
+	return readable.pipeThrough(transformStream);
 }

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

@@ -30,8 +30,7 @@
 
 import {
 	Codec,
-	CODEC_DEFLATE,
-	CODEC_INFLATE,
+	getCodecStreamClass,
 	MESSAGE_EVENT_TYPE,
 	MESSAGE_START,
 	MESSAGE_PULL,
@@ -70,18 +69,19 @@ addEventListener(MESSAGE_EVENT_TYPE, async event => {
 async function init(message) {
 	try {
 		const { options, scripts, config } = message;
-		const { codecType } = options;
 		if (scripts && scripts.length) {
 			importScripts.apply(undefined, scripts);
 		}
 		if (self.initCodec) {
 			self.initCodec();
 		}
-		let codecConstructor;
-		if (codecType.startsWith(CODEC_DEFLATE)) {
-			codecConstructor = self.Deflate;
-		} else if (codecType.startsWith(CODEC_INFLATE)) {
-			codecConstructor = self.Inflate;
+		config.CompressionStreamNative = self.CompressionStream;
+		config.DecompressionStreamNative = self.DecompressionStream;
+		if (self.Deflate) {
+			config.CompressionStream = getCodecStreamClass(self.Deflate);
+		}
+		if (self.Inflate) {
+			config.DecompressionStream = getCodecStreamClass(self.Inflate);
 		}
 		const strategy = { highWaterMark: 1, size: () => config.chunkSize };
 		const readable = message.readable || new ReadableStream({
@@ -106,7 +106,7 @@ async function init(message) {
 				await ackData;
 			}
 		}, strategy);
-		codec = new Codec(codecConstructor, readable, writable, options, config);
+		codec = new Codec(readable, writable, options, config);
 		const result = await codec.run();
 		if (message.writable && !options.preventClose) {
 			await message.writable.close();

package/lib/core/zip-reader.js

@@ -186,40 +186,48 @@ class ZipReader {
 			const commentOffset = extraFieldOffset + fileEntry.extraFieldLength;
 			const versionMadeBy = getUint16(directoryView, offset + 4);
 			const msDosCompatible = (versionMadeBy & 0) == 0;
+			const rawFilename = directoryArray.subarray(filenameOffset, extraFieldOffset);
+			const commentLength = getUint16(directoryView, offset + 32);
+			const endOffset = commentOffset + commentLength;
+			const rawComment = directoryArray.subarray(commentOffset, endOffset);
+			const filenameUTF8 = languageEncodingFlag;
+			const commentUTF8 = languageEncodingFlag;
+			const directory = msDosCompatible && ((getUint8(directoryView, offset + 38) & FILE_ATTR_MSDOS_DIR_MASK) == FILE_ATTR_MSDOS_DIR_MASK);
+			const offsetFileEntry = getUint32(directoryView, offset + 42) + prependedDataLength;
 			Object.assign(fileEntry, {
 				versionMadeBy,
 				msDosCompatible,
 				compressedSize: 0,
 				uncompressedSize: 0,
-				commentLength: getUint16(directoryView, offset + 32),
-				directory: msDosCompatible && ((getUint8(directoryView, offset + 38) & FILE_ATTR_MSDOS_DIR_MASK) == FILE_ATTR_MSDOS_DIR_MASK),
-				offset: getUint32(directoryView, offset + 42) + prependedDataLength,
+				commentLength,
+				directory,
+				offset: offsetFileEntry,
 				internalFileAttribute: getUint16(directoryView, offset + 36),
 				externalFileAttribute: getUint32(directoryView, offset + 38),
-				rawFilename: directoryArray.subarray(filenameOffset, extraFieldOffset),
-				filenameUTF8: languageEncodingFlag,
-				commentUTF8: languageEncodingFlag,
+				rawFilename,
+				filenameUTF8,
+				commentUTF8,
 				rawExtraField: directoryArray.subarray(extraFieldOffset, commentOffset)
 			});
-			startOffset = Math.max(fileEntry.offset, startOffset);
-			const endOffset = commentOffset + fileEntry.commentLength;
-			fileEntry.rawComment = directoryArray.subarray(commentOffset, endOffset);
 			const [filename, comment] = await Promise.all([
-				decodeText(fileEntry.rawFilename, fileEntry.filenameUTF8 ? CHARSET_UTF8 : filenameEncoding || CHARSET_CP437),
-				decodeText(fileEntry.rawComment, fileEntry.commentUTF8 ? CHARSET_UTF8 : commentEncoding || CHARSET_CP437)
+				decodeText(rawFilename, filenameUTF8 ? CHARSET_UTF8 : filenameEncoding || CHARSET_CP437),
+				decodeText(rawComment, commentUTF8 ? CHARSET_UTF8 : commentEncoding || CHARSET_CP437)
 			]);
-			fileEntry.filename = filename;
-			fileEntry.comment = comment;
-			if (!fileEntry.directory && fileEntry.filename.endsWith(DIRECTORY_SIGNATURE)) {
-				fileEntry.directory = true;
-			}
+			Object.assign(fileEntry, {
+				rawComment,
+				filename,
+				comment,
+				directory: directory || filename.endsWith(DIRECTORY_SIGNATURE)
+			});
+			startOffset = Math.max(offsetFileEntry, startOffset);
 			await readCommonFooter(fileEntry, fileEntry, directoryView, offset + 6);
 			const entry = new Entry(fileEntry);
 			entry.getData = (writer, options) => fileEntry.getData(writer, entry, options);
 			offset = endOffset;
-			if (options.onprogress) {
+			const { onprogress } = options;
+			if (onprogress) {
 				try {
-					await options.onprogress(indexFile + 1, filesLength, new Entry(fileEntry));
+					await onprogress(indexFile + 1, filesLength, new Entry(fileEntry));
 				} catch (_error) {
 					// ignored
 				}
@@ -310,8 +318,10 @@ class ZipEntry {
 		dataArray = await readUint8Array(reader, offset, 30 + localDirectory.filenameLength + localDirectory.extraFieldLength);
 		localDirectory.rawExtraField = dataArray.subarray(30 + localDirectory.filenameLength);
 		await readCommonFooter(zipEntry, localDirectory, dataView, 4);
-		fileEntry.lastAccessDate = localDirectory.lastAccessDate;
-		fileEntry.creationDate = localDirectory.creationDate;
+		Object.assign(fileEntry, {
+			lastAccessDate: localDirectory.lastAccessDate,
+			creationDate: localDirectory.creationDate
+		});
 		const encrypted = zipEntry.encrypted && localDirectory.encrypted;
 		const zipCrypto = encrypted && !extraFieldAES;
 		if (encrypted) {
@@ -355,8 +365,7 @@ class ZipEntry {
 				preventClose
 			},
 			config,
-			streamOptions: { signal, size, onstart, onprogress, onend },
-			codecConstructor: config.Inflate
+			streamOptions: { signal, size, onstart, onprogress, onend }
 		};
 		writable.size += (await runWorker({ readable, writable }, workerOptions)).size;
 		if (!preventClose) {
@@ -408,9 +417,11 @@ async function readCommonFooter(fileEntry, directory, dataView, offset) {
 		// ignored
 	}
 	const compressionMethod = getUint16(dataView, offset + 4);
-	directory.signature = getUint32(dataView, offset + 10);
-	directory.uncompressedSize = getUint32(dataView, offset + 18);
-	directory.compressedSize = getUint32(dataView, offset + 14);
+	Object.assign(directory, {
+		signature: getUint32(dataView, offset + 10),
+		uncompressedSize: getUint32(dataView, offset + 18),
+		compressedSize: getUint32(dataView, offset + 14)
+	});
 	const extraFieldZip64 = extraField.get(EXTRAFIELD_TYPE_ZIP64);
 	if (extraFieldZip64) {
 		readExtraFieldZip64(extraFieldZip64, directory);
@@ -469,14 +480,16 @@ function readExtraFieldZip64(extraFieldZip64, directory) {
 
 async function readExtraFieldUnicode(extraFieldUnicode, propertyName, rawPropertyName, directory, fileEntry) {
 	const extraFieldView = getDataView(extraFieldUnicode.data);
-	extraFieldUnicode.version = getUint8(extraFieldView, 0);
-	extraFieldUnicode.signature = getUint32(extraFieldView, 1);
 	const crc32 = new Crc32();
 	crc32.append(fileEntry[rawPropertyName]);
 	const dataViewSignature = getDataView(new Uint8Array(4));
 	dataViewSignature.setUint32(0, crc32.get(), true);
-	extraFieldUnicode[propertyName] = await decodeText(extraFieldUnicode.data.subarray(5));
-	extraFieldUnicode.valid = !fileEntry.bitFlag.languageEncodingFlag && extraFieldUnicode.signature == getUint32(dataViewSignature, 0);
+	Object.assign(extraFieldUnicode, {
+		version: getUint8(extraFieldView, 0),
+		signature: getUint32(extraFieldView, 1),
+		[propertyName]: await decodeText(extraFieldUnicode.data.subarray(5)),
+		valid: !fileEntry.bitFlag.languageEncodingFlag && extraFieldUnicode.signature == getUint32(dataViewSignature, 0)
+	});
 	if (extraFieldUnicode.valid) {
 		directory[propertyName] = extraFieldUnicode[propertyName];
 		directory[propertyName + "UTF8"] = true;
@@ -485,12 +498,15 @@ async function readExtraFieldUnicode(extraFieldUnicode, propertyName, rawPropert
 
 function readExtraFieldAES(extraFieldAES, directory, compressionMethod) {
 	const extraFieldView = getDataView(extraFieldAES.data);
-	extraFieldAES.vendorVersion = getUint8(extraFieldView, 0);
-	extraFieldAES.vendorId = getUint8(extraFieldView, 2);
 	const strength = getUint8(extraFieldView, 4);
-	extraFieldAES.strength = strength;
-	extraFieldAES.originalCompressionMethod = compressionMethod;
-	directory.compressionMethod = extraFieldAES.compressionMethod = getUint16(extraFieldView, 5);
+	Object.assign(extraFieldAES, {
+		vendorVersion: getUint8(extraFieldView, 0),
+		vendorId: getUint8(extraFieldView, 2),
+		strength,
+		originalCompressionMethod: compressionMethod,
+		compressionMethod: getUint16(extraFieldView, 5)
+	});
+	directory.compressionMethod = extraFieldAES.compressionMethod;
 }
 
 function readExtraFieldNTFS(extraFieldNTFS, directory) {