@zip.js/zip.js 2.6.25 → 2.6.28

package/lib/core/streams/common-crypto.js

@@ -35,10 +35,12 @@ import {
 } from "./codecs/sjcl.js";
 
 const ERR_INVALID_PASSWORD = "Invalid password";
+const ERR_INVALID_SIGNATURE = "Invalid signature";
 
 export {
 	getRandomValues,
-	ERR_INVALID_PASSWORD
+	ERR_INVALID_PASSWORD,
+	ERR_INVALID_SIGNATURE
 };
 
 function getRandomValues(array) {

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

@@ -28,26 +28,26 @@
 
 /* global TransformStream */
 
-import Crc32 from "./codecs/crc32.js";
+import { Crc32 } from "./codecs/crc32.js";
 
 class Crc32Stream extends TransformStream {
 
 	constructor() {
+		const crc32 = new Crc32();
 		super({
-			start() {
-				this.crc32 = new Crc32();
-			},
 			transform(chunk) {
-				this.crc32.append(chunk);
+				crc32.append(chunk);
 			},
 			flush(controller) {
 				const value = new Uint8Array(4);
 				const dataView = new DataView(value.buffer);
-				dataView.setUint32(0, this.crc32.get());
+				dataView.setUint32(0, crc32.get());
 				controller.enqueue(value);
 			}
 		});
 	}
 }
 
-export default Crc32Stream;
+export {
+	Crc32Stream
+};

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

@@ -28,7 +28,7 @@
 
 /* global TransformStream */
 
-import Crc32 from "./codecs/crc32.js";
+import { Crc32 } from "./codecs/crc32.js";
 import {
 	ERR_INVALID_PASSWORD,
 	getRandomValues
@@ -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;
 	}
 }
 
@@ -128,21 +123,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,60 +26,45 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global CompressionStream, DecompressionStream, TransformStream */
+/* global TransformStream */
 
-import Crc32Stream from "./crc32-stream.js";
+import { Crc32Stream } from "./crc32-stream.js";
 import {
 	AESEncryptionStream,
 	AESDecryptionStream
 } 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/util/cp437-decode.js

@@ -31,7 +31,11 @@
 const CP437 = "\0☺☻♥♦♣♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ ".split("");
 const VALID_CP437 = CP437.length == 256;
 
-export default (stringValue) => {
+export {
+	decodeCP437
+};
+
+function decodeCP437(stringValue) {
 	if (VALID_CP437) {
 		let result = "";
 		for (let indexCharacter = 0; indexCharacter < stringValue.length; indexCharacter++) {
@@ -41,4 +45,4 @@ export default (stringValue) => {
 	} else {
 		return new TextDecoder().decode(stringValue);
 	}
-};
+}

package/lib/core/util/decode-text.js

@@ -28,9 +28,11 @@
 
 /* global TextDecoder */
 
-import decodeCP437 from "./cp437-decode.js";
+import { decodeCP437 } from "./cp437-decode.js";
 
-export default decodeText;
+export {
+	decodeText
+};
 
 function decodeText(value, encoding) {
 	if (encoding && encoding.trim().toLowerCase() == "cp437") {

package/lib/core/util/encode-text.js

@@ -28,7 +28,9 @@
 
 /* global TextEncoder */
 
-export default encodeText;
+export {
+	encodeText
+};
 
 function encodeText(value) {
 	if (typeof TextEncoder == "undefined") {

package/lib/core/util/stream-codec-shim.js

@@ -27,12 +27,16 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-export default (library, options = {}, registerDataHandler) => {
+export {
+	initShimAsyncCodec
+};
+
+function initShimAsyncCodec(library, options = {}, registerDataHandler) {
 	return {
 		Deflate: createCodecClass(library.Deflate, options.deflate, registerDataHandler),
 		Inflate: createCodecClass(library.Inflate, options.inflate, registerDataHandler)
 	};
-};
+}
 
 function createCodecClass(constructor, constructorOptions, registerDataHandler) {
 	return class {

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-entry.js

@@ -34,10 +34,14 @@ const PROPERTY_NAMES = [
 	"extraFieldNTFS", "lastAccessDate", "creationDate", "extraFieldExtendedTimestamp",
 	"version", "versionMadeBy", "msDosCompatible", "internalFileAttribute", "externalFileAttribute"];
 
-export default class Entry {
+class Entry {
 
 	constructor(data) {
 		PROPERTY_NAMES.forEach(name => this[name] = data[name]);
 	}
 
-}
+}
+
+export {
+	Entry
+};

package/lib/core/zip-reader.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global BigInt, Response */
+/* global BigInt, Response, ReadableStream, WritableStream */
 
 import {
 	MAX_32_BITS,
@@ -70,9 +70,9 @@ import {
 	initStream,
 	BlobReader
 } from "./io.js";
-import decodeText from "./util/decode-text.js";
-import Crc32 from "./streams/codecs/crc32.js";
-import Entry from "./zip-entry.js";
+import { decodeText } from "./util/decode-text.js";
+import { Crc32 } from "./streams/codecs/crc32.js";
+import { Entry } from "./zip-entry.js";
 
 const ERR_BAD_FORMAT = "File format is not recognized";
 const ERR_EOCDR_NOT_FOUND = "End of central directory not found";
@@ -91,6 +91,11 @@ const ZIP64_PROPERTIES = ["uncompressedSize", "compressedSize", "offset"];
 class ZipReader {
 
 	constructor(reader, options = {}) {
+		if (reader instanceof ReadableStream) {
+			reader = {
+				readable: reader
+			};
+		}
 		Object.assign(this, {
 			reader,
 			options,
@@ -320,6 +325,11 @@ class ZipEntry {
 		const readable = reader.readable;
 		readable.offset = dataOffset;
 		const size = readable.size = compressedSize;
+		if (writer instanceof WritableStream) {
+			writer = {
+				writable: writer
+			};
+		}
 		const { writable } = writer;
 		if (writable.size === undefined) {
 			writable.size = 0;
@@ -345,8 +355,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) {