@stryke/crypto 0.5.43 → 0.6.0

package/dist/neutral-BISXAuIW.cjs

@@ -0,0 +1,868 @@
+
+//#region ../convert/src/array-buffer-to-string.ts
+/**
+* Convert an ArrayBuffer or Uint8Array to a string
+*
+* @param buffer - The ArrayBuffer or Uint8Array to convert
+* @returns The converted string
+*/
+function arrayBufferToString(buffer) {
+	const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+	const len = bytes.byteLength;
+	if (len < 65535) return String.fromCharCode.apply(null, bytes);
+	let binary = "";
+	for (let i = 0; i < len; i++) binary += String.fromCharCode(bytes[i]);
+	return binary;
+}
+
+//#endregion
+//#region ../type-checks/src/is-undefined.ts
+const isUndefined = (value) => {
+	return value === void 0;
+};
+
+//#endregion
+//#region ../type-checks/src/is-buffer.ts
+const isBufferExists = typeof Buffer !== "undefined";
+/**
+* Check if the provided value's type is `Buffer`
+*/
+const isBuffer = isBufferExists ? Buffer.isBuffer.bind(Buffer) : function isBuffer$1(value) {
+	return false;
+};
+
+//#endregion
+//#region ../type-checks/src/type-detect.ts
+const globalObject = ((Obj) => {
+	if (typeof globalThis === "object") return globalThis;
+	Object.defineProperty(Obj, "typeDetectGlobalObject", {
+		get() {
+			return this;
+		},
+		configurable: true
+	});
+	return globalThis;
+})(Object.prototype);
+
+//#endregion
+//#region ../type-checks/src/is-string.ts
+const isString = (value) => {
+	try {
+		return typeof value === "string";
+	} catch {
+		return false;
+	}
+};
+
+//#endregion
+//#region ../convert/src/string-to-uint8-array.ts
+/**
+* Convert a string to Uint8Array
+*
+* @param text - The text to convert
+* @returns The converted Uint8Array
+*/
+function stringToUint8Array(text) {
+	return Uint8Array.from([...encodeURIComponent(text)].map((letter) => letter.codePointAt(0)));
+}
+/**
+* Convert a base64 string to a Uint8Array
+*
+* @param data - The base64 string to convert
+* @returns The converted Uint8Array
+*/
+function base64StringToUint8Array(data) {
+	return stringToUint8Array(atob(data));
+}
+
+//#endregion
+//#region ../convert/src/string-to-utf8-array.ts
+const encoder = new TextEncoder();
+/**
+* Convert a string to a utf-8 array
+*
+* @param input - The string to convert
+* @returns The converted utf-8 array
+*/
+function stringToUtf8Array(input) {
+	return encoder.encode(input);
+}
+
+//#endregion
+//#region ../convert/src/uint8-array-to-stream.ts
+/**
+* Concatenate an array of Uint8Array chunks into a single Uint8Array
+*
+* @param chunks - Array of Uint8Array chunks to concatenate
+* @returns The concatenated Uint8Array
+*/
+function concatUint8Array(chunks) {
+	let total = 0;
+	for (const chunk of chunks) total += chunk.length;
+	const result = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		result.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return result;
+}
+
+//#endregion
+//#region ../convert/src/uint8-array-to-string.ts
+/**
+* Convert a Uint8Array to a base64 string
+*
+* @param buffer - The Uint8Array to convert
+* @returns The converted base64 string
+*/
+function uint8ArrayToString(buffer) {
+	return btoa(arrayBufferToString(buffer));
+}
+
+//#endregion
+//#region ../convert/src/utf8-array-to-string.ts
+const decoder = new TextDecoder();
+/**
+* Convert a utf-8 array to string
+*
+* @param input - Utf-8 Array
+* @returns The converted string
+*/
+function utf8ArrayToString(input) {
+	return decoder.decode(input);
+}
+
+//#endregion
+//#region src/base-64.ts
+const ENCODE_MAP = new Uint8Array([
+	65,
+	66,
+	67,
+	68,
+	69,
+	70,
+	71,
+	72,
+	73,
+	74,
+	75,
+	76,
+	77,
+	78,
+	79,
+	80,
+	81,
+	82,
+	83,
+	84,
+	85,
+	86,
+	87,
+	88,
+	89,
+	90,
+	97,
+	98,
+	99,
+	100,
+	101,
+	102,
+	103,
+	104,
+	105,
+	106,
+	107,
+	108,
+	109,
+	110,
+	111,
+	112,
+	113,
+	114,
+	115,
+	116,
+	117,
+	118,
+	119,
+	120,
+	121,
+	122,
+	48,
+	49,
+	50,
+	51,
+	52,
+	53,
+	54,
+	55,
+	56,
+	57,
+	43,
+	47
+]);
+const ENCODE_PAD = 61;
+const DECODE_MAP$1 = new Uint8Array([
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	62,
+	100,
+	100,
+	100,
+	63,
+	52,
+	53,
+	54,
+	55,
+	56,
+	57,
+	58,
+	59,
+	60,
+	61,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	8,
+	9,
+	10,
+	11,
+	12,
+	13,
+	14,
+	15,
+	16,
+	17,
+	18,
+	19,
+	20,
+	21,
+	22,
+	23,
+	24,
+	25,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	26,
+	27,
+	28,
+	29,
+	30,
+	31,
+	32,
+	33,
+	34,
+	35,
+	36,
+	37,
+	38,
+	39,
+	40,
+	41,
+	42,
+	43,
+	44,
+	45,
+	46,
+	47,
+	48,
+	49,
+	50,
+	51,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100,
+	100
+]);
+/**
+* Encodes a Uint8Array into a Base64 encoded Uint8Array.
+*
+* @credit https://github.com/hi-ogawa/js-utils
+*
+* @param input - The input Uint8Array or string to encode.
+* @returns The Base64 encoded Uint8Array.
+*/
+function encodeBase64(input) {
+	if (isString(input)) input = stringToUint8Array(input);
+	const xLen = input.length;
+	const result = new Uint8Array(Math.ceil(xLen / 3) * 4);
+	const chunkLen = Math.floor(xLen / 3);
+	for (let i$1 = 0; i$1 < chunkLen; i$1++) {
+		const chunk = input[3 * i$1 + 0] << 16 | input[3 * i$1 + 1] << 8 | input[3 * i$1 + 2];
+		result[4 * i$1 + 0] = ENCODE_MAP[chunk >> 18 & 63];
+		result[4 * i$1 + 1] = ENCODE_MAP[chunk >> 12 & 63];
+		result[4 * i$1 + 2] = ENCODE_MAP[chunk >> 6 & 63];
+		result[4 * i$1 + 3] = ENCODE_MAP[chunk >> 0 & 63];
+	}
+	const i = chunkLen;
+	switch (xLen % 3) {
+		case 1: {
+			const chunk = input[3 * i + 0] << 16;
+			result[4 * i + 0] = ENCODE_MAP[chunk >> 18 & 63];
+			result[4 * i + 1] = ENCODE_MAP[chunk >> 12 & 63];
+			result[4 * i + 2] = ENCODE_PAD;
+			result[4 * i + 3] = ENCODE_PAD;
+			break;
+		}
+		case 2: {
+			const chunk = input[3 * i + 0] << 16 | input[3 * i + 1] << 8;
+			result[4 * i + 0] = ENCODE_MAP[chunk >> 18 & 63];
+			result[4 * i + 1] = ENCODE_MAP[chunk >> 12 & 63];
+			result[4 * i + 2] = ENCODE_MAP[chunk >> 6 & 63];
+			result[4 * i + 3] = ENCODE_PAD;
+			break;
+		}
+	}
+	return utf8ArrayToString(result);
+}
+/**
+* Decodes a Base64 encoded Uint8Array into a Uint8Array.
+*
+* @credit https://github.com/hi-ogawa/js-utils
+*
+* @param input - The Base64 encoded Uint8Array or string to decode.
+* @returns The decoded Uint8Array.
+*/
+function decodeBase64(input) {
+	if (isString(input)) input = stringToUint8Array(input);
+	const yLen = input.length;
+	if (yLen % 4 !== 0) throw new Error("invalid length");
+	let padLen = 0;
+	while (padLen < 2 && padLen < input.length && input[input.length - 1 - padLen] === ENCODE_PAD) padLen++;
+	for (let i$1 = 0; i$1 < input.length - padLen; i$1++) if (isUndefined(input[i$1]) || isUndefined(DECODE_MAP$1[input[i$1]]) || DECODE_MAP$1[input[i$1]] >= 64) throw new Error("invalid data");
+	const chunkLen = Math.floor((yLen - padLen) / 4);
+	const xLen = 3 * chunkLen + (3 - padLen) % 3;
+	const result = new Uint8Array(xLen);
+	for (let i$1 = 0; i$1 < chunkLen; i$1++) {
+		const chunk = DECODE_MAP$1[input[4 * i$1 + 0]] << 18 | DECODE_MAP$1[input[4 * i$1 + 1]] << 12 | DECODE_MAP$1[input[4 * i$1 + 2]] << 6 | DECODE_MAP$1[input[4 * i$1 + 3]] << 0;
+		result[3 * i$1] = chunk >> 16 & 255;
+		result[3 * i$1 + 1] = chunk >> 8 & 255;
+		result[3 * i$1 + 2] = chunk >> 0 & 255;
+	}
+	const i = chunkLen;
+	switch (xLen % 3) {
+		case 1: {
+			const chunk = DECODE_MAP$1[input[4 * i + 0]] << 18 | DECODE_MAP$1[input[4 * i + 1]] << 12;
+			result[3 * i] = chunk >> 16 & 255;
+			break;
+		}
+		case 2: {
+			const chunk = DECODE_MAP$1[input[4 * i + 0]] << 18 | DECODE_MAP$1[input[4 * i + 1]] << 12 | DECODE_MAP$1[input[4 * i + 2]] << 6;
+			result[3 * i] = chunk >> 16 & 255;
+			result[3 * i + 1] = chunk >> 8 & 255;
+			break;
+		}
+	}
+	return result;
+}
+/**
+* Converts a Base64 encoded string to a [Base64url](https://datatracker.ietf.org/doc/html/rfc7515#appendix-C) encoded string.
+*
+* @see https://datatracker.ietf.org/doc/html/rfc7515#appendix-C
+*
+* @param base64 - The Base64 encoded string to convert.
+* @returns The Base64url encoded string.
+*/
+function base64UrlEncode(base64) {
+	return btoa(String.fromCharCode(...base64)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+/**
+* Converts a [Base64url](https://datatracker.ietf.org/doc/html/rfc7515#appendix-C) encoded string to a Base64 encoded string.
+*
+* @see https://datatracker.ietf.org/doc/html/rfc7515#appendix-C
+*
+* @param base64url - The Base64url encoded string to convert.
+* @returns The Base64 encoded string.
+*/
+function base64UrlDecode(base64url) {
+	const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
+	return new Uint8Array([...atob(base64 + "=".repeat((4 - base64.length % 4) % 4))].map((c) => c.charCodeAt(0)));
+}
+
+//#endregion
+//#region src/hex.ts
+const ALPHABET = "0123456789ABCDEF";
+const DECODE_MAP = {
+	"0": 0,
+	"1": 1,
+	"2": 2,
+	"3": 3,
+	"4": 4,
+	"5": 5,
+	"6": 6,
+	"7": 7,
+	"8": 8,
+	"9": 9,
+	a: 10,
+	A: 10,
+	b: 11,
+	B: 11,
+	c: 12,
+	C: 12,
+	d: 13,
+	D: 13,
+	e: 14,
+	E: 14,
+	f: 15,
+	F: 15
+};
+/**
+* Encodes a Uint8Array into a hexadecimal string.
+*
+* @param input - The input Uint8Array.
+* @returns The hexadecimal string.
+*/
+function encodeHex(input) {
+	let result = "";
+	for (let i = 0; i < input.length; i++) {
+		result += ALPHABET[input[i] >> 4];
+		result += ALPHABET[input[i] & 15];
+	}
+	return result;
+}
+/**
+* Encodes a Uint8Array into an uppercase hexadecimal string.
+*
+* @param input - The input Uint8Array.
+* @returns The uppercase hexadecimal string.
+*/
+function decodeHex(input) {
+	if (input.length % 2 !== 0) throw new Error("Invalid hex string");
+	const result = new Uint8Array(input.length / 2);
+	for (let i = 0; i < input.length; i += 2) {
+		if (!(input[i] in DECODE_MAP)) throw new Error("Invalid character");
+		if (!(input[i + 1] in DECODE_MAP)) throw new Error("Invalid character");
+		result[i / 2] |= DECODE_MAP[input[i]] << 4;
+		result[i / 2] |= DECODE_MAP[input[i + 1]];
+	}
+	return result;
+}
+
+//#endregion
+//#region src/encryption.ts
+/**
+* Creates a CryptoKey object that can be used to encrypt any string.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/generateKey
+*
+* @returns A promise that resolves to a CryptoKey object that can be used to encrypt and decrypt strings.
+*/
+async function createKey() {
+	return crypto.subtle.generateKey({
+		name: "AES-GCM",
+		length: 256
+	}, true, ["encrypt", "decrypt"]);
+}
+/**
+* Encodes a CryptoKey to base64 string, so that it can be embedded in JSON / JavaScript
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/exportKey
+*
+* @param key - The CryptoKey to encode
+* @returns A promise that resolves to a base64 string representing the key
+*/
+async function encodeKey(key) {
+	const exported = await crypto.subtle.exportKey("raw", key);
+	return encodeBase64(new Uint8Array(exported)).toString();
+}
+/**
+* Decodes a base64 string into bytes and then imports the key.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/importKey
+*
+* @param encoded - The base64 encoded key
+* @returns A promise that resolves to a CryptoKey object that can be used to encrypt and decrypt strings
+*/
+async function decodeKey(encoded) {
+	const bytes = decodeBase64(encoded);
+	return crypto.subtle.importKey("raw", bytes.buffer, "AES-GCM", true, ["encrypt", "decrypt"]);
+}
+const IV_LENGTH = 24;
+/**
+* Using a CryptoKey, use AES-GCM to encrypt a string into a base64 string.
+*
+* @remarks
+* The initialization vector is randomly generated and prepended to the encrypted string. The IV is required for decryption, so it must be stored alongside the encrypted data.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/encrypt
+*
+* @param key - The CryptoKey to use for encryption
+* @param plaintext - The plaintext string to encrypt
+* @returns A promise that resolves to a base64 string representing the encrypted data
+*/
+async function encrypt(key, plaintext) {
+	const iv = crypto.getRandomValues(new Uint8Array(IV_LENGTH / 2));
+	const encrypted = await crypto.subtle.encrypt({
+		name: "AES-GCM",
+		iv
+	}, key, stringToUtf8Array(plaintext));
+	return encodeHex(iv) + encodeBase64(new Uint8Array(encrypted));
+}
+/**
+* Takes a base64 encoded string, decodes it and returns the AES-GCM decrypted text.
+*
+* @remarks
+* The initialization vector is expected to be prepended to the encrypted string. The IV is required for decryption, so it must be extracted from the start of the string.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/decrypt
+*
+* @param key - The CryptoKey to use for decryption
+* @param encrypted - The encrypted base64 encoded string to decrypt
+* @returns A promise that resolves to the decrypted string
+*/
+async function decrypt(key, encrypted) {
+	return utf8ArrayToString(await crypto.subtle.decrypt({
+		name: "AES-GCM",
+		iv: decodeHex(encrypted.slice(0, IV_LENGTH))
+	}, key, decodeBase64(encrypted.slice(IV_LENGTH))));
+}
+/**
+* Encrypts a buffer using AES-GCM with a given CryptoKey.
+*
+* @remarks
+* The initialization vector (IV) is randomly generated and prepended to the encrypted data. The resulting data is then encoded as a base64 string for easy storage/transmission.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/encrypt
+*
+* @param key - The CryptoKey to use for encryption
+* @param buffer - The buffer to encrypt
+* @returns A promise that resolves to a base64 string representing the encrypted data
+*/
+async function encryptBuffer(key, buffer) {
+	const iv = crypto.getRandomValues(new Uint8Array(16));
+	const encrypted = await crypto.subtle.encrypt({
+		name: "AES-GCM",
+		iv
+	}, key, buffer);
+	return uint8ArrayToString(concatUint8Array([iv, new Uint8Array(encrypted)]));
+}
+/**
+* Decrypts a buffer using AES-GCM with a given CryptoKey.
+*
+* @remarks
+* The initialization vector (IV) is expected to be prepended to the encrypted data. The IV is required for decryption, so it must be extracted from the start of the buffer.
+*
+* @see https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/decrypt
+*
+* @param key - The CryptoKey to use for decryption
+* @param encrypted - The encrypted base64 encoded string to decrypt
+* @returns A promise that resolves to the decrypted string
+*/
+async function decryptBuffer(key, encrypted) {
+	const concatenated = base64StringToUint8Array(encrypted);
+	return crypto.subtle.decrypt({
+		name: "AES-GCM",
+		iv: concatenated.slice(0, 16)
+	}, key, concatenated.slice(16));
+}
+
+//#endregion
+//#region src/random.ts
+/**
+* Generate a random byte array of the specified length using the Web Crypto API.
+*
+* @param length - The length of the random byte array to generate (default is 32 bytes)
+* @returns A Uint8Array containing random bytes of the specified length
+*/
+function generateRandomBytes(length = 32) {
+	return crypto.getRandomValues(new Uint8Array(length));
+}
+/**
+* Generate a random string of the specified length using characters A-Z, a-z, and 0-9 for CSRF tokens, etc.
+*
+* @remarks
+* This function uses the Web Crypto API's `crypto.getRandomValues` to generate secure random bytes,
+* and then maps those bytes to characters in the specified character set. It uses rejection sampling
+* to ensure a uniform distribution of characters without modulo bias.
+*
+* @param length - The length of the random string to generate (default is 32 characters)
+* @returns A random string of the specified length
+*/
+function generateRandomString(length = 32) {
+	const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+	const charsLen = 62;
+	const maxValid = 256 - 256 % charsLen;
+	const result = [];
+	while (result.length < length) {
+		const bytes = generateRandomBytes(length - result.length);
+		for (const b of bytes) if (b < maxValid && result.length < length && chars[b % charsLen]) result.push(chars[b % charsLen]);
+	}
+	return result.join("");
+}
+
+//#endregion
+Object.defineProperty(exports, 'base64UrlDecode', {
+  enumerable: true,
+  get: function () {
+    return base64UrlDecode;
+  }
+});
+Object.defineProperty(exports, 'base64UrlEncode', {
+  enumerable: true,
+  get: function () {
+    return base64UrlEncode;
+  }
+});
+Object.defineProperty(exports, 'createKey', {
+  enumerable: true,
+  get: function () {
+    return createKey;
+  }
+});
+Object.defineProperty(exports, 'decodeBase64', {
+  enumerable: true,
+  get: function () {
+    return decodeBase64;
+  }
+});
+Object.defineProperty(exports, 'decodeHex', {
+  enumerable: true,
+  get: function () {
+    return decodeHex;
+  }
+});
+Object.defineProperty(exports, 'decodeKey', {
+  enumerable: true,
+  get: function () {
+    return decodeKey;
+  }
+});
+Object.defineProperty(exports, 'decrypt', {
+  enumerable: true,
+  get: function () {
+    return decrypt;
+  }
+});
+Object.defineProperty(exports, 'decryptBuffer', {
+  enumerable: true,
+  get: function () {
+    return decryptBuffer;
+  }
+});
+Object.defineProperty(exports, 'encodeBase64', {
+  enumerable: true,
+  get: function () {
+    return encodeBase64;
+  }
+});
+Object.defineProperty(exports, 'encodeHex', {
+  enumerable: true,
+  get: function () {
+    return encodeHex;
+  }
+});
+Object.defineProperty(exports, 'encodeKey', {
+  enumerable: true,
+  get: function () {
+    return encodeKey;
+  }
+});
+Object.defineProperty(exports, 'encrypt', {
+  enumerable: true,
+  get: function () {
+    return encrypt;
+  }
+});
+Object.defineProperty(exports, 'encryptBuffer', {
+  enumerable: true,
+  get: function () {
+    return encryptBuffer;
+  }
+});
+Object.defineProperty(exports, 'generateRandomBytes', {
+  enumerable: true,
+  get: function () {
+    return generateRandomBytes;
+  }
+});
+Object.defineProperty(exports, 'generateRandomString', {
+  enumerable: true,
+  get: function () {
+    return generateRandomString;
+  }
+});