@helloao/cli 0.0.1

package/node_modules/@zip.js/zip.js/lib/core/streams/aes-crypto-stream.js

@@ -0,0 +1,326 @@
+/*
+ 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 crypto, TransformStream */
+// deno-lint-ignore-file no-this-alias
+
+import { UNDEFINED_VALUE, UNDEFINED_TYPE, FUNCTION_TYPE } from "../constants.js";
+import { encodeText } from "./../util/encode-text.js";
+import {
+	cipher,
+	codec,
+	misc,
+	mode
+} from "./codecs/sjcl.js";
+import {
+	ERR_INVALID_PASSWORD,
+	ERR_INVALID_SIGNATURE,
+	ERR_ABORT_CHECK_PASSWORD,
+	getRandomValues
+} from "./common-crypto.js";
+
+const BLOCK_LENGTH = 16;
+const RAW_FORMAT = "raw";
+const PBKDF2_ALGORITHM = { name: "PBKDF2" };
+const HASH_ALGORITHM = { name: "HMAC" };
+const HASH_FUNCTION = "SHA-1";
+const BASE_KEY_ALGORITHM = Object.assign({ hash: HASH_ALGORITHM }, PBKDF2_ALGORITHM);
+const DERIVED_BITS_ALGORITHM = Object.assign({ iterations: 1000, hash: { name: HASH_FUNCTION } }, PBKDF2_ALGORITHM);
+const DERIVED_BITS_USAGE = ["deriveBits"];
+const SALT_LENGTH = [8, 12, 16];
+const KEY_LENGTH = [16, 24, 32];
+const SIGNATURE_LENGTH = 10;
+const COUNTER_DEFAULT_VALUE = [0, 0, 0, 0];
+// deno-lint-ignore valid-typeof
+const CRYPTO_API_SUPPORTED = typeof crypto != UNDEFINED_TYPE;
+const subtle = CRYPTO_API_SUPPORTED && crypto.subtle;
+const SUBTLE_API_SUPPORTED = CRYPTO_API_SUPPORTED && typeof subtle != UNDEFINED_TYPE;
+const codecBytes = codec.bytes;
+const Aes = cipher.aes;
+const CtrGladman = mode.ctrGladman;
+const HmacSha1 = misc.hmacSha1;
+
+let IMPORT_KEY_SUPPORTED = CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof subtle.importKey == FUNCTION_TYPE;
+let DERIVE_BITS_SUPPORTED = CRYPTO_API_SUPPORTED && SUBTLE_API_SUPPORTED && typeof subtle.deriveBits == FUNCTION_TYPE;
+
+class AESDecryptionStream extends TransformStream {
+
+	constructor({ password, rawPassword, signed, encryptionStrength, checkPasswordOnly }) {
+		super({
+			start() {
+				Object.assign(this, {
+					ready: new Promise(resolve => this.resolveReady = resolve),
+					password: encodePassword(password, rawPassword),
+					signed,
+					strength: encryptionStrength - 1,
+					pending: new Uint8Array()
+				});
+			},
+			async transform(chunk, controller) {
+				const aesCrypto = this;
+				const {
+					password,
+					strength,
+					resolveReady,
+					ready
+				} = aesCrypto;
+				if (password) {
+					await createDecryptionKeys(aesCrypto, strength, password, subarray(chunk, 0, SALT_LENGTH[strength] + 2));
+					chunk = subarray(chunk, SALT_LENGTH[strength] + 2);
+					if (checkPasswordOnly) {
+						controller.error(new Error(ERR_ABORT_CHECK_PASSWORD));
+					} else {
+						resolveReady();
+					}
+				} else {
+					await ready;
+				}
+				const output = new Uint8Array(chunk.length - SIGNATURE_LENGTH - ((chunk.length - SIGNATURE_LENGTH) % BLOCK_LENGTH));
+				controller.enqueue(append(aesCrypto, chunk, output, 0, SIGNATURE_LENGTH, true));
+			},
+			async flush(controller) {
+				const {
+					signed,
+					ctr,
+					hmac,
+					pending,
+					ready
+				} = this;
+				if (hmac && ctr) {
+					await ready;
+					const chunkToDecrypt = subarray(pending, 0, pending.length - SIGNATURE_LENGTH);
+					const originalSignature = subarray(pending, pending.length - SIGNATURE_LENGTH);
+					let decryptedChunkArray = new Uint8Array();
+					if (chunkToDecrypt.length) {
+						const encryptedChunk = toBits(codecBytes, chunkToDecrypt);
+						hmac.update(encryptedChunk);
+						const decryptedChunk = ctr.update(encryptedChunk);
+						decryptedChunkArray = fromBits(codecBytes, decryptedChunk);
+					}
+					if (signed) {
+						const signature = subarray(fromBits(codecBytes, hmac.digest()), 0, SIGNATURE_LENGTH);
+						for (let indexSignature = 0; indexSignature < SIGNATURE_LENGTH; indexSignature++) {
+							if (signature[indexSignature] != originalSignature[indexSignature]) {
+								throw new Error(ERR_INVALID_SIGNATURE);
+							}
+						}
+					}
+					controller.enqueue(decryptedChunkArray);
+				}
+			}
+		});
+	}
+}
+
+class AESEncryptionStream extends TransformStream {
+
+	constructor({ password, rawPassword, encryptionStrength }) {
+		// deno-lint-ignore prefer-const
+		let stream;
+		super({
+			start() {
+				Object.assign(this, {
+					ready: new Promise(resolve => this.resolveReady = resolve),
+					password: encodePassword(password, rawPassword),
+					strength: encryptionStrength - 1,
+					pending: new Uint8Array()
+				});
+			},
+			async transform(chunk, controller) {
+				const aesCrypto = this;
+				const {
+					password,
+					strength,
+					resolveReady,
+					ready
+				} = aesCrypto;
+				let preamble = new Uint8Array();
+				if (password) {
+					preamble = await createEncryptionKeys(aesCrypto, strength, password);
+					resolveReady();
+				} else {
+					await ready;
+				}
+				const output = new Uint8Array(preamble.length + chunk.length - (chunk.length % BLOCK_LENGTH));
+				output.set(preamble, 0);
+				controller.enqueue(append(aesCrypto, chunk, output, preamble.length, 0));
+			},
+			async flush(controller) {
+				const {
+					ctr,
+					hmac,
+					pending,
+					ready
+				} = this;
+				if (hmac && ctr) {
+					await ready;
+					let encryptedChunkArray = new Uint8Array();
+					if (pending.length) {
+						const encryptedChunk = ctr.update(toBits(codecBytes, pending));
+						hmac.update(encryptedChunk);
+						encryptedChunkArray = fromBits(codecBytes, encryptedChunk);
+					}
+					stream.signature = fromBits(codecBytes, hmac.digest()).slice(0, SIGNATURE_LENGTH);
+					controller.enqueue(concat(encryptedChunkArray, stream.signature));
+				}
+			}
+		});
+		stream = this;
+	}
+}
+
+export {
+	AESDecryptionStream,
+	AESEncryptionStream,
+	ERR_INVALID_PASSWORD
+};
+
+function append(aesCrypto, input, output, paddingStart, paddingEnd, verifySignature) {
+	const {
+		ctr,
+		hmac,
+		pending
+	} = aesCrypto;
+	const inputLength = input.length - paddingEnd;
+	if (pending.length) {
+		input = concat(pending, input);
+		output = expand(output, inputLength - (inputLength % BLOCK_LENGTH));
+	}
+	let offset;
+	for (offset = 0; offset <= inputLength - BLOCK_LENGTH; offset += BLOCK_LENGTH) {
+		const inputChunk = toBits(codecBytes, subarray(input, offset, offset + BLOCK_LENGTH));
+		if (verifySignature) {
+			hmac.update(inputChunk);
+		}
+		const outputChunk = ctr.update(inputChunk);
+		if (!verifySignature) {
+			hmac.update(outputChunk);
+		}
+		output.set(fromBits(codecBytes, outputChunk), offset + paddingStart);
+	}
+	aesCrypto.pending = subarray(input, offset);
+	return output;
+}
+
+async function createDecryptionKeys(decrypt, strength, password, preamble) {
+	const passwordVerificationKey = await createKeys(decrypt, strength, password, subarray(preamble, 0, SALT_LENGTH[strength]));
+	const passwordVerification = subarray(preamble, SALT_LENGTH[strength]);
+	if (passwordVerificationKey[0] != passwordVerification[0] || passwordVerificationKey[1] != passwordVerification[1]) {
+		throw new Error(ERR_INVALID_PASSWORD);
+	}
+}
+
+async function createEncryptionKeys(encrypt, strength, password) {
+	const salt = getRandomValues(new Uint8Array(SALT_LENGTH[strength]));
+	const passwordVerification = await createKeys(encrypt, strength, password, salt);
+	return concat(salt, passwordVerification);
+}
+
+async function createKeys(aesCrypto, strength, password, salt) {
+	aesCrypto.password = null;
+	const baseKey = await importKey(RAW_FORMAT, password, BASE_KEY_ALGORITHM, false, DERIVED_BITS_USAGE);
+	const derivedBits = await deriveBits(Object.assign({ salt }, DERIVED_BITS_ALGORITHM), baseKey, 8 * ((KEY_LENGTH[strength] * 2) + 2));
+	const compositeKey = new Uint8Array(derivedBits);
+	const key = toBits(codecBytes, subarray(compositeKey, 0, KEY_LENGTH[strength]));
+	const authentication = toBits(codecBytes, subarray(compositeKey, KEY_LENGTH[strength], KEY_LENGTH[strength] * 2));
+	const passwordVerification = subarray(compositeKey, KEY_LENGTH[strength] * 2);
+	Object.assign(aesCrypto, {
+		keys: {
+			key,
+			authentication,
+			passwordVerification
+		},
+		ctr: new CtrGladman(new Aes(key), Array.from(COUNTER_DEFAULT_VALUE)),
+		hmac: new HmacSha1(authentication)
+	});
+	return passwordVerification;
+}
+
+async function importKey(format, password, algorithm, extractable, keyUsages) {
+	if (IMPORT_KEY_SUPPORTED) {
+		try {
+			return await subtle.importKey(format, password, algorithm, extractable, keyUsages);
+		} catch (_error) {
+			IMPORT_KEY_SUPPORTED = false;
+			return misc.importKey(password);
+		}
+	} else {
+		return misc.importKey(password);
+	}
+}
+
+async function deriveBits(algorithm, baseKey, length) {
+	if (DERIVE_BITS_SUPPORTED) {
+		try {
+			return await subtle.deriveBits(algorithm, baseKey, length);
+		} catch (_error) {
+			DERIVE_BITS_SUPPORTED = false;
+			return misc.pbkdf2(baseKey, algorithm.salt, DERIVED_BITS_ALGORITHM.iterations, length);
+		}
+	} else {
+		return misc.pbkdf2(baseKey, algorithm.salt, DERIVED_BITS_ALGORITHM.iterations, length);
+	}
+}
+
+function encodePassword(password, rawPassword) {
+	if (rawPassword === UNDEFINED_VALUE) {
+		return encodeText(password);
+	} else {
+		return rawPassword;
+	}
+}
+
+function concat(leftArray, rightArray) {
+	let array = leftArray;
+	if (leftArray.length + rightArray.length) {
+		array = new Uint8Array(leftArray.length + rightArray.length);
+		array.set(leftArray, 0);
+		array.set(rightArray, leftArray.length);
+	}
+	return array;
+}
+
+function expand(inputArray, length) {
+	if (length && length > inputArray.length) {
+		const array = inputArray;
+		inputArray = new Uint8Array(length);
+		inputArray.set(array, 0);
+	}
+	return inputArray;
+}
+
+function subarray(array, begin, end) {
+	return array.subarray(begin, end);
+}
+
+function fromBits(codecBytes, chunk) {
+	return codecBytes.fromBits(chunk);
+}
+function toBits(codecBytes, chunk) {
+	return codecBytes.toBits(chunk);
+}

package/node_modules/@zip.js/zip.js/lib/core/streams/codec-stream.js

@@ -0,0 +1,154 @@
+/*
+ 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.
+ */
+
+/*
+ * This program is based on JZlib 1.0.2 ymnk, JCraft,Inc.
+ * JZlib is based on zlib-1.1.3, so all credit should go authors
+ * Jean-loup Gailly(jloup@gzip.org) and Mark Adler(madler@alumni.caltech.edu)
+ * and contributors of zlib.
+ */
+
+/* global TransformStream */
+// deno-lint-ignore-file no-this-alias
+
+import {
+	ERR_INVALID_PASSWORD,
+	ERR_INVALID_SIGNATURE,
+	ERR_ABORT_CHECK_PASSWORD,
+	InflateStream,
+	DeflateStream
+} from "./zip-entry-stream.js";
+
+const MESSAGE_EVENT_TYPE = "message";
+const MESSAGE_START = "start";
+const MESSAGE_PULL = "pull";
+const MESSAGE_DATA = "data";
+const MESSAGE_ACK_DATA = "ack";
+const MESSAGE_CLOSE = "close";
+const CODEC_DEFLATE = "deflate";
+const CODEC_INFLATE = "inflate";
+
+export {
+	CODEC_DEFLATE,
+	CODEC_INFLATE,
+	MESSAGE_EVENT_TYPE,
+	MESSAGE_START,
+	MESSAGE_PULL,
+	MESSAGE_DATA,
+	MESSAGE_ACK_DATA,
+	MESSAGE_CLOSE,
+	ERR_INVALID_PASSWORD,
+	ERR_INVALID_SIGNATURE,
+	ERR_ABORT_CHECK_PASSWORD,
+	CodecStream,
+	ChunkStream
+};
+
+class CodecStream extends TransformStream {
+
+	constructor(options, config) {
+		super({});
+		const codec = this;
+		const { codecType } = options;
+		let Stream;
+		if (codecType.startsWith(CODEC_DEFLATE)) {
+			Stream = DeflateStream;
+		} else if (codecType.startsWith(CODEC_INFLATE)) {
+			Stream = InflateStream;
+		}
+		let outputSize = 0;
+		let inputSize = 0;
+		const stream = new Stream(options, config);
+		const readable = super.readable;
+		const inputSizeStream = new TransformStream({
+			transform(chunk, controller) {
+				if (chunk && chunk.length) {
+					inputSize += chunk.length;
+					controller.enqueue(chunk);
+				}
+			},
+			flush() {
+				Object.assign(codec, {
+					inputSize
+				});
+			}
+		});
+		const outputSizeStream = new TransformStream({
+			transform(chunk, controller) {
+				if (chunk && chunk.length) {
+					outputSize += chunk.length;
+					controller.enqueue(chunk);
+				}
+			},
+			flush() {
+				const { signature } = stream;
+				Object.assign(codec, {
+					signature,
+					outputSize,
+					inputSize
+				});
+			}
+		});
+		Object.defineProperty(codec, "readable", {
+			get() {
+				return readable.pipeThrough(inputSizeStream).pipeThrough(stream).pipeThrough(outputSizeStream);
+			}
+		});
+	}
+}
+
+class ChunkStream extends TransformStream {
+
+	constructor(chunkSize) {
+		let pendingChunk;
+		super({
+			transform,
+			flush(controller) {
+				if (pendingChunk && pendingChunk.length) {
+					controller.enqueue(pendingChunk);
+				}
+			}
+		});
+
+		function transform(chunk, controller) {
+			if (pendingChunk) {
+				const newChunk = new Uint8Array(pendingChunk.length + chunk.length);
+				newChunk.set(pendingChunk);
+				newChunk.set(chunk, pendingChunk.length);
+				chunk = newChunk;
+				pendingChunk = null;
+			}
+			if (chunk.length > chunkSize) {
+				controller.enqueue(chunk.slice(0, chunkSize));
+				transform(chunk.slice(chunkSize), controller);
+			} else {
+				pendingChunk = chunk;
+			}
+		}
+	}
+}

package/node_modules/@zip.js/zip.js/lib/core/streams/codecs/crc32.js

@@ -0,0 +1,63 @@
+/*
+ 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.
+ */
+
+const table = [];
+for (let i = 0; i < 256; i++) {
+	let t = i;
+	for (let j = 0; j < 8; j++) {
+		if (t & 1) {
+			t = (t >>> 1) ^ 0xEDB88320;
+		} else {
+			t = t >>> 1;
+		}
+	}
+	table[i] = t;
+}
+
+class Crc32 {
+
+	constructor(crc) {
+		this.crc = crc || -1;
+	}
+
+	append(data) {
+		let crc = this.crc | 0;
+		for (let offset = 0, length = data.length | 0; offset < length; offset++) {
+			crc = (crc >>> 8) ^ table[(crc ^ data[offset]) & 0xFF];
+		}
+		this.crc = crc;
+	}
+
+	get() {
+		return ~this.crc;
+	}
+}
+
+export {
+	Crc32
+};