@hexclave/shared 1.0.0

package/dist/esm/utils/booleans.js

@@ -0,0 +1,35 @@
+//#region src/utils/booleans.tsx
+function isTruthy(value) {
+	return !!value;
+}
+(void 0)?.test("isTruthy", ({ expect }) => {
+	expect(isTruthy(true)).toBe(true);
+	expect(isTruthy(1)).toBe(true);
+	expect(isTruthy("hello")).toBe(true);
+	expect(isTruthy({})).toBe(true);
+	expect(isTruthy([])).toBe(true);
+	expect(isTruthy(false)).toBe(false);
+	expect(isTruthy(0)).toBe(false);
+	expect(isTruthy("")).toBe(false);
+	expect(isTruthy(null)).toBe(false);
+	expect(isTruthy(void 0)).toBe(false);
+});
+function isFalsy(value) {
+	return !value;
+}
+(void 0)?.test("isFalsy", ({ expect }) => {
+	expect(isFalsy(false)).toBe(true);
+	expect(isFalsy(0)).toBe(true);
+	expect(isFalsy("")).toBe(true);
+	expect(isFalsy(null)).toBe(true);
+	expect(isFalsy(void 0)).toBe(true);
+	expect(isFalsy(true)).toBe(false);
+	expect(isFalsy(1)).toBe(false);
+	expect(isFalsy("hello")).toBe(false);
+	expect(isFalsy({})).toBe(false);
+	expect(isFalsy([])).toBe(false);
+});
+
+//#endregion
+export { isFalsy, isTruthy };
+//# sourceMappingURL=booleans.js.map

package/dist/esm/utils/booleans.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"booleans.js","names":[],"sources":["../../../src/utils/booleans.tsx"],"sourcesContent":["export type Truthy<T> = T extends null | undefined | 0 | \"\" | false ? false : true;\nexport type Falsy<T> = T extends null | undefined | 0 | \"\" | false ? true : false;\n\nexport function isTruthy<T>(value: T): value is T & Truthy<T> {\n  return !!value;\n}\nimport.meta.vitest?.test(\"isTruthy\", ({ expect }) => {\n  expect(isTruthy(true)).toBe(true);\n  expect(isTruthy(1)).toBe(true);\n  expect(isTruthy(\"hello\")).toBe(true);\n  expect(isTruthy({})).toBe(true);\n  expect(isTruthy([])).toBe(true);\n  expect(isTruthy(false)).toBe(false);\n  expect(isTruthy(0)).toBe(false);\n  expect(isTruthy(\"\")).toBe(false);\n  expect(isTruthy(null)).toBe(false);\n  expect(isTruthy(undefined)).toBe(false);\n});\n\nexport function isFalsy<T>(value: T): value is T & Falsy<T> {\n  return !value;\n}\nimport.meta.vitest?.test(\"isFalsy\", ({ expect }) => {\n  expect(isFalsy(false)).toBe(true);\n  expect(isFalsy(0)).toBe(true);\n  expect(isFalsy(\"\")).toBe(true);\n  expect(isFalsy(null)).toBe(true);\n  expect(isFalsy(undefined)).toBe(true);\n  expect(isFalsy(true)).toBe(false);\n  expect(isFalsy(1)).toBe(false);\n  expect(isFalsy(\"hello\")).toBe(false);\n  expect(isFalsy({})).toBe(false);\n  expect(isFalsy([])).toBe(false);\n});\n"],"mappings":";AAGA,SAAgB,SAAY,OAAkC;AAC5D,QAAO,CAAC,CAAC;;CAEX,SAAW,KAAC,aAAc,EAAA,aAAc;AACtC,QAAO,SAAS,KAAK,CAAC,CAAC,KAAK,KAAK;AACjC,QAAO,SAAS,EAAE,CAAC,CAAC,KAAK,KAAK;AAC9B,QAAO,SAAS,QAAQ,CAAC,CAAC,KAAK,KAAK;AACpC,QAAO,SAAS,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK;AAC/B,QAAO,SAAS,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK;AAC/B,QAAO,SAAS,MAAM,CAAC,CAAC,KAAK,MAAM;AACnC,QAAO,SAAS,EAAE,CAAC,CAAC,KAAK,MAAM;AAC/B,QAAO,SAAS,GAAG,CAAC,CAAC,KAAK,MAAM;AAChC,QAAO,SAAS,KAAK,CAAC,CAAC,KAAK,MAAM;AAClC,QAAO,SAAS,OAAU,CAAC,CAAC,KAAK,MAAM;EACvC;AAEF,SAAgB,QAAW,OAAiC;AAC1D,QAAO,CAAC;;CAEV,SAAW,KAAC,YAAc,EAAA,aAAa;AACrC,QAAO,QAAQ,MAAM,CAAC,CAAC,KAAK,KAAK;AACjC,QAAO,QAAQ,EAAE,CAAC,CAAC,KAAK,KAAK;AAC7B,QAAO,QAAQ,GAAG,CAAC,CAAC,KAAK,KAAK;AAC9B,QAAO,QAAQ,KAAK,CAAC,CAAC,KAAK,KAAK;AAChC,QAAO,QAAQ,OAAU,CAAC,CAAC,KAAK,KAAK;AACrC,QAAO,QAAQ,KAAK,CAAC,CAAC,KAAK,MAAM;AACjC,QAAO,QAAQ,EAAE,CAAC,CAAC,KAAK,MAAM;AAC9B,QAAO,QAAQ,QAAQ,CAAC,CAAC,KAAK,MAAM;AACpC,QAAO,QAAQ,EAAE,CAAC,CAAC,CAAC,KAAK,MAAM;AAC/B,QAAO,QAAQ,EAAE,CAAC,CAAC,CAAC,KAAK,MAAM;EAC/B"}

package/dist/esm/utils/browser-compat.d.ts

@@ -0,0 +1,10 @@
+//#region src/utils/browser-compat.d.ts
+declare function getBrowserCompatibilityReport(): {
+  optionalChaining: string | boolean;
+  nullishCoalescing: string | boolean;
+  weakRef: string | boolean;
+  cryptoUuid: string | boolean;
+};
+//#endregion
+export { getBrowserCompatibilityReport };
+//# sourceMappingURL=browser-compat.d.ts.map

package/dist/esm/utils/browser-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-compat.d.ts","names":[],"sources":["../../../src/utils/browser-compat.tsx"],"mappings":";iBAAgB,6BAAA,CAAA"}

package/dist/esm/utils/browser-compat.js

@@ -0,0 +1,21 @@
+//#region src/utils/browser-compat.tsx
+function getBrowserCompatibilityReport() {
+	const test = (snippet) => {
+		try {
+			(0, eval)(snippet);
+			return true;
+		} catch (e) {
+			return `FAILED: ${e}`;
+		}
+	};
+	return {
+		optionalChaining: test("({})?.b?.c"),
+		nullishCoalescing: test("0 ?? 1"),
+		weakRef: test("new WeakRef({})"),
+		cryptoUuid: test("crypto.randomUUID()")
+	};
+}
+
+//#endregion
+export { getBrowserCompatibilityReport };
+//# sourceMappingURL=browser-compat.js.map

package/dist/esm/utils/browser-compat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-compat.js","names":[],"sources":["../../../src/utils/browser-compat.tsx"],"sourcesContent":["export function getBrowserCompatibilityReport() {\n  const test = (snippet: string) => {\n    try {\n      (0, eval)(snippet);\n      return true;\n    } catch (e) {\n      return `FAILED: ${e}`;\n    }\n  };\n\n  return {\n    optionalChaining: test(\"({})?.b?.c\"),\n    nullishCoalescing: test(\"0 ?? 1\"),\n    weakRef: test(\"new WeakRef({})\"),\n    cryptoUuid: test(\"crypto.randomUUID()\"),\n  };\n}\n"],"mappings":";AAAA,SAAgB,gCAAgC;CAC9C,MAAM,QAAQ,YAAoB;AAChC,MAAI;AACF,IAAC,GAAG,MAAM,QAAQ;AAClB,UAAO;WACA,GAAG;AACV,UAAO,WAAW;;;AAItB,QAAO;EACL,kBAAkB,KAAK,aAAa;EACpC,mBAAmB,KAAK,SAAS;EACjC,SAAS,KAAK,kBAAkB;EAChC,YAAY,KAAK,sBAAsB;EACxC"}

package/dist/esm/utils/bytes.d.ts

@@ -0,0 +1,17 @@
+//#region src/utils/bytes.d.ts
+declare function toHexString(input: Uint8Array): string;
+declare function getBase32CharacterFromIndex(index: number): string;
+declare function getBase32IndexFromCharacter(character: string): number;
+declare function encodeBase32(input: Uint8Array): string;
+declare function decodeBase32(input: string): Uint8Array<ArrayBuffer>;
+declare function encodeBase64(input: Uint8Array): string;
+declare function decodeBase64(input: string): Uint8Array<ArrayBuffer>;
+declare function encodeBase64Url(input: Uint8Array): string;
+declare function decodeBase64Url(input: string): Uint8Array<ArrayBuffer>;
+declare function decodeBase64OrBase64Url(input: string): Uint8Array<ArrayBuffer>;
+declare function isBase32(input: string): boolean;
+declare function isBase64(input: string): boolean;
+declare function isBase64Url(input: string): boolean;
+//#endregion
+export { decodeBase32, decodeBase64, decodeBase64OrBase64Url, decodeBase64Url, encodeBase32, encodeBase64, encodeBase64Url, getBase32CharacterFromIndex, getBase32IndexFromCharacter, isBase32, isBase64, isBase64Url, toHexString };
+//# sourceMappingURL=bytes.d.ts.map

package/dist/esm/utils/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","names":[],"sources":["../../../src/utils/bytes.tsx"],"mappings":";iBASgB,WAAA,CAAY,KAAA,EAAO,UAAA;AAAA,iBAYnB,2BAAA,CAA4B,KAAA;AAAA,iBAY5B,2BAAA,CAA4B,SAAA;AAAA,iBAgB5B,YAAA,CAAa,KAAA,EAAO,UAAA;AAAA,iBA+BpB,YAAA,CAAa,KAAA,WAAgB,UAAA,CAAW,WAAA;AAAA,iBAiCxC,YAAA,CAAa,KAAA,EAAO,UAAA;AAAA,iBAIpB,YAAA,CAAa,KAAA,WAAgB,UAAA,CAAW,WAAA;AAAA,iBAsDxC,eAAA,CAAgB,KAAA,EAAO,UAAA;AAAA,iBAQvB,eAAA,CAAgB,KAAA,WAAgB,UAAA,CAAW,WAAA;AAAA,iBA+B3C,uBAAA,CAAwB,KAAA,WAAgB,UAAA,CAAW,WAAA;AAAA,iBAwBnD,QAAA,CAAS,KAAA;AAAA,iBAmBT,QAAA,CAAS,KAAA;AAAA,iBAaT,WAAA,CAAY,KAAA"}

package/dist/esm/utils/bytes.js

@@ -0,0 +1,290 @@
+import { HexclaveAssertionError } from "./errors.js";
+
+//#region src/utils/bytes.tsx
+const crockfordAlphabet = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+const crockfordReplacements = new Map([
+	["o", "0"],
+	["i", "1"],
+	["l", "1"]
+]);
+function toHexString(input) {
+	return Array.from(input).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+(void 0)?.test("toHexString", ({ expect }) => {
+	expect(toHexString(new Uint8Array([]))).toBe("");
+	expect(toHexString(new Uint8Array([0]))).toBe("00");
+	expect(toHexString(new Uint8Array([15]))).toBe("0f");
+	expect(toHexString(new Uint8Array([16]))).toBe("10");
+	expect(toHexString(new Uint8Array([255]))).toBe("ff");
+	expect(toHexString(new Uint8Array([
+		1,
+		2,
+		3
+	]))).toBe("010203");
+});
+function getBase32CharacterFromIndex(index) {
+	if (index < 0 || index >= 32) throw new HexclaveAssertionError(`Invalid base32 index: ${index}`);
+	return crockfordAlphabet[index];
+}
+(void 0)?.test("getBase32CharacterFromIndex", ({ expect }) => {
+	expect(getBase32CharacterFromIndex(0)).toBe("0");
+	expect(getBase32CharacterFromIndex(15)).toBe("F");
+	expect(() => getBase32CharacterFromIndex(32)).toThrow();
+});
+function getBase32IndexFromCharacter(character) {
+	if (character.length !== 1) throw new HexclaveAssertionError(`Invalid base32 character: ${character}`);
+	const index = crockfordAlphabet.indexOf(character.toUpperCase());
+	if (index === -1) throw new HexclaveAssertionError(`Invalid base32 character: ${character}`);
+	return index;
+}
+(void 0)?.test("getBase32IndexFromCharacter", ({ expect }) => {
+	expect(getBase32IndexFromCharacter("0")).toBe(0);
+	expect(getBase32IndexFromCharacter("F")).toBe(15);
+	expect(() => getBase32IndexFromCharacter("_")).toThrow();
+});
+function encodeBase32(input) {
+	let bits = 0;
+	let value = 0;
+	let output = "";
+	for (let i = 0; i < input.length; i++) {
+		value = value << 8 | input[i];
+		bits += 8;
+		while (bits >= 5) {
+			output += getBase32CharacterFromIndex(value >>> bits - 5 & 31);
+			bits -= 5;
+		}
+	}
+	if (bits > 0) output += getBase32CharacterFromIndex(value << 5 - bits & 31);
+	if (!isBase32(output)) throw new HexclaveAssertionError("Invalid base32 output; this should never happen");
+	return output;
+}
+(void 0)?.test("encodeBase32", ({ expect }) => {
+	expect(encodeBase32(new Uint8Array([]))).toBe("");
+	expect(encodeBase32(new Uint8Array([1]))).toBe("04");
+	expect(encodeBase32(new Uint8Array([15]))).toBe("1W");
+	expect(encodeBase32(new Uint8Array([16]))).toBe("20");
+	expect(encodeBase32(new Uint8Array([255]))).toBe("ZW");
+	expect(encodeBase32(new Uint8Array([255, 255]))).toBe("ZZZG");
+});
+function decodeBase32(input) {
+	if (!isBase32(input)) throw new HexclaveAssertionError("Invalid base32 string");
+	const output = new Uint8Array(input.length * 5 / 8 | 0);
+	let bits = 0;
+	let value = 0;
+	let outputIndex = 0;
+	for (let i = 0; i < input.length; i++) {
+		let char = input[i].toLowerCase();
+		if (char === " ") continue;
+		if (crockfordReplacements.has(char)) char = crockfordReplacements.get(char);
+		const index = getBase32IndexFromCharacter(char);
+		value = value << 5 | index;
+		bits += 5;
+		if (bits >= 8) {
+			output[outputIndex++] = value >>> bits - 8 & 255;
+			bits -= 8;
+		}
+	}
+	return output;
+}
+(void 0)?.test("decodeBase32", ({ expect }) => {
+	expect(decodeBase32("")).toEqual(new Uint8Array([]));
+	expect(decodeBase32("00")).toEqual(new Uint8Array([0]));
+	expect(decodeBase32("1W")).toEqual(new Uint8Array([15]));
+	expect(decodeBase32("20")).toEqual(new Uint8Array([16]));
+	expect(decodeBase32("ZW")).toEqual(new Uint8Array([255]));
+});
+function encodeBase64(input) {
+	return btoa([...input].map((b) => String.fromCharCode(b)).join(""));
+}
+function decodeBase64(input) {
+	return new Uint8Array(atob(input).split("").map((char) => char.charCodeAt(0)));
+}
+(void 0)?.test("encodeBase64/decodeBase64", ({ expect }) => {
+	const testCases = [
+		{
+			input: new Uint8Array([
+				72,
+				101,
+				108,
+				108,
+				111
+			]),
+			expected: "SGVsbG8="
+		},
+		{
+			input: new Uint8Array([
+				0,
+				1,
+				2,
+				3,
+				4
+			]),
+			expected: "AAECAwQ="
+		},
+		{
+			input: new Uint8Array([
+				255,
+				254,
+				253,
+				252
+			]),
+			expected: "//79/A=="
+		},
+		{
+			input: new Uint8Array([]),
+			expected: ""
+		},
+		{
+			input: (() => {
+				const input = new Uint8Array(3 * 2 ** 24);
+				for (let i = 0; i < input.length / 3; i++) {
+					input[3 * i] = Math.floor(i / 256 / 256);
+					input[3 * i + 1] = Math.floor(i / 256) % 256;
+					input[3 * i + 2] = i % 256;
+				}
+				return input;
+			})(),
+			expected: (() => {
+				const base64Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+				const output = [];
+				for (let i = 0; i < 2 ** 24; i++) output.push(base64Alphabet[Math.floor(i / 64 / 64 / 64)] + base64Alphabet[Math.floor(i / 64 / 64) % 64] + base64Alphabet[Math.floor(i / 64) % 64] + base64Alphabet[i % 64]);
+				return output.join("");
+			})()
+		}
+	];
+	for (const [i, { input, expected }] of testCases.entries()) {
+		const encoded = encodeBase64(input);
+		if (encoded !== expected) throw new HexclaveAssertionError(`encodeBase64 test case ${i} failed`);
+		if (decodeBase64(encoded).some((b, i) => b !== input[i])) throw new HexclaveAssertionError(`decodeBase64 test case ${i} failed`);
+	}
+	expect(() => decodeBase64("invalid!")).toThrow();
+}, { timeout: 3e4 });
+function encodeBase64Url(input) {
+	return encodeBase64(input).replace(/=+$/, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+function decodeBase64Url(input) {
+	if (!isBase64Url(input)) throw new HexclaveAssertionError("Invalid base64url string");
+	if (input === "") return new Uint8Array(0);
+	return decodeBase64(input.replace(/-/g, "+").replace(/_/g, "/") + "====".slice((input.length - 1) % 4 + 1));
+}
+(void 0)?.test("encodeBase64Url/decodeBase64Url", ({ expect }) => {
+	const testCases = [
+		{
+			input: new Uint8Array([
+				72,
+				101,
+				108,
+				108,
+				111
+			]),
+			expected: "SGVsbG8"
+		},
+		{
+			input: new Uint8Array([
+				0,
+				1,
+				2,
+				3,
+				4
+			]),
+			expected: "AAECAwQ"
+		},
+		{
+			input: new Uint8Array([
+				255,
+				254,
+				253,
+				252
+			]),
+			expected: "__79_A"
+		},
+		{
+			input: new Uint8Array([]),
+			expected: ""
+		}
+	];
+	for (const { input, expected } of testCases) {
+		const encoded = encodeBase64Url(input);
+		expect(encoded).toBe(expected);
+		expect(decodeBase64Url(encoded)).toEqual(input);
+	}
+	expect(() => decodeBase64Url("invalid!")).toThrow();
+});
+function decodeBase64OrBase64Url(input) {
+	if (isBase64Url(input)) return decodeBase64Url(input);
+	else if (isBase64(input)) return decodeBase64(input);
+	else throw new HexclaveAssertionError("Invalid base64 or base64url string");
+}
+(void 0)?.test("decodeBase64OrBase64Url", ({ expect }) => {
+	const base64Input = "SGVsbG8gV29ybGQ=";
+	const base64Expected = new Uint8Array([
+		72,
+		101,
+		108,
+		108,
+		111,
+		32,
+		87,
+		111,
+		114,
+		108,
+		100
+	]);
+	expect(decodeBase64OrBase64Url(base64Input)).toEqual(base64Expected);
+	const base64UrlInput = "SGVsbG8gV29ybGQ";
+	const base64UrlExpected = new Uint8Array([
+		72,
+		101,
+		108,
+		108,
+		111,
+		32,
+		87,
+		111,
+		114,
+		108,
+		100
+	]);
+	expect(decodeBase64OrBase64Url(base64UrlInput)).toEqual(base64UrlExpected);
+	expect(() => decodeBase64OrBase64Url("invalid!")).toThrow();
+});
+function isBase32(input) {
+	for (const char of input) {
+		if (char === " ") continue;
+		const upperChar = char.toUpperCase();
+		if (!crockfordAlphabet.includes(upperChar)) return false;
+	}
+	return true;
+}
+(void 0)?.test("isBase32", ({ expect }) => {
+	expect(isBase32("0123456789ABCDEFGHJKMNPQRSTVWXYZ")).toBe(true);
+	expect(isBase32("0OIJ")).toBe(false);
+	expect(isBase32("ABC DEF")).toBe(true);
+	expect(isBase32("ABC!")).toBe(false);
+	expect(isBase32("")).toBe(true);
+});
+function isBase64(input) {
+	return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(input);
+}
+(void 0)?.test("isBase64", ({ expect }) => {
+	expect(isBase64("SGVsbG8gV29ybGQ=")).toBe(true);
+	expect(isBase64("SGVsbG8gV29ybGQ")).toBe(false);
+	expect(isBase64("SGVsbG8gV29ybGQ==")).toBe(false);
+	expect(isBase64("SGVsbG8!V29ybGQ=")).toBe(false);
+	expect(isBase64("")).toBe(true);
+});
+function isBase64Url(input) {
+	if (input === "") return true;
+	return /^[0-9a-zA-Z_-]+$/.test(input);
+}
+(void 0)?.test("isBase64Url", ({ expect }) => {
+	expect(isBase64Url("SGVsbG8gV2 9ybGQ")).toBe(false);
+	expect(isBase64Url("SGVsbG8_V29ybGQ")).toBe(true);
+	expect(isBase64Url("SGVsbG8-V29ybGQ")).toBe(true);
+	expect(isBase64Url("SGVsbG8_V29ybGQ=")).toBe(false);
+	expect(isBase64Url("")).toBe(true);
+});
+
+//#endregion
+export { decodeBase32, decodeBase64, decodeBase64OrBase64Url, decodeBase64Url, encodeBase32, encodeBase64, encodeBase64Url, getBase32CharacterFromIndex, getBase32IndexFromCharacter, isBase32, isBase64, isBase64Url, toHexString };
+//# sourceMappingURL=bytes.js.map

package/dist/esm/utils/bytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.js","names":[],"sources":["../../../src/utils/bytes.tsx"],"sourcesContent":["import { HexclaveAssertionError } from \"./errors\";\n\nconst crockfordAlphabet = \"0123456789ABCDEFGHJKMNPQRSTVWXYZ\";\nconst crockfordReplacements = new Map([\n  [\"o\", \"0\"],\n  [\"i\", \"1\"],\n  [\"l\", \"1\"],\n]);\n\nexport function toHexString(input: Uint8Array): string {\n  return Array.from(input).map(b => b.toString(16).padStart(2, \"0\")).join(\"\");\n}\nimport.meta.vitest?.test(\"toHexString\", ({ expect }) => {\n  expect(toHexString(new Uint8Array([]))).toBe(\"\");\n  expect(toHexString(new Uint8Array([0]))).toBe(\"00\");\n  expect(toHexString(new Uint8Array([15]))).toBe(\"0f\");\n  expect(toHexString(new Uint8Array([16]))).toBe(\"10\");\n  expect(toHexString(new Uint8Array([255]))).toBe(\"ff\");\n  expect(toHexString(new Uint8Array([1, 2, 3]))).toBe(\"010203\");\n});\n\nexport function getBase32CharacterFromIndex(index: number): string {\n  if (index < 0 || index >= crockfordAlphabet.length) {\n    throw new HexclaveAssertionError(`Invalid base32 index: ${index}`);\n  }\n  return crockfordAlphabet[index];\n}\nimport.meta.vitest?.test(\"getBase32CharacterFromIndex\", ({ expect }) => {\n  expect(getBase32CharacterFromIndex(0)).toBe(\"0\");\n  expect(getBase32CharacterFromIndex(15)).toBe(\"F\");\n  expect(() => getBase32CharacterFromIndex(32)).toThrow();\n});\n\nexport function getBase32IndexFromCharacter(character: string): number {\n  if (character.length !== 1) {\n    throw new HexclaveAssertionError(`Invalid base32 character: ${character}`);\n  }\n  const index = crockfordAlphabet.indexOf(character.toUpperCase());\n  if (index === -1) {\n    throw new HexclaveAssertionError(`Invalid base32 character: ${character}`);\n  }\n  return index;\n}\nimport.meta.vitest?.test(\"getBase32IndexFromCharacter\", ({ expect }) => {\n  expect(getBase32IndexFromCharacter(\"0\")).toBe(0);\n  expect(getBase32IndexFromCharacter(\"F\")).toBe(15);\n  expect(() => getBase32IndexFromCharacter(\"_\")).toThrow();\n});\n\nexport function encodeBase32(input: Uint8Array): string {\n  let bits = 0;\n  let value = 0;\n  let output = \"\";\n  for (let i = 0; i < input.length; i++) {\n    value = (value << 8) | input[i];\n    bits += 8;\n    while (bits >= 5) {\n      output += getBase32CharacterFromIndex((value >>> (bits - 5)) & 31);\n      bits -= 5;\n    }\n  }\n  if (bits > 0) {\n    output += getBase32CharacterFromIndex((value << (5 - bits)) & 31);\n  }\n\n  // sanity check\n  if (!isBase32(output)) {\n    throw new HexclaveAssertionError(\"Invalid base32 output; this should never happen\");\n  }\n\n  return output;\n}\nimport.meta.vitest?.test(\"encodeBase32\", ({ expect }) => {\n  expect(encodeBase32(new Uint8Array([]))).toBe(\"\");\n  expect(encodeBase32(new Uint8Array([1]))).toBe(\"04\");\n  expect(encodeBase32(new Uint8Array([15]))).toBe(\"1W\");\n  expect(encodeBase32(new Uint8Array([16]))).toBe(\"20\");\n  expect(encodeBase32(new Uint8Array([255]))).toBe(\"ZW\");\n  expect(encodeBase32(new Uint8Array([255,255]))).toBe(\"ZZZG\");\n});\nexport function decodeBase32(input: string): Uint8Array<ArrayBuffer> {\n  if (!isBase32(input)) {\n    throw new HexclaveAssertionError(\"Invalid base32 string\");\n  }\n\n  const output = new Uint8Array((input.length * 5 / 8) | 0);\n  let bits = 0;\n  let value = 0;\n  let outputIndex = 0;\n  for (let i = 0; i < input.length; i++) {\n    let char = input[i].toLowerCase();\n    if (char === \" \") continue;\n    if (crockfordReplacements.has(char)) {\n      char = crockfordReplacements.get(char)!;\n    }\n    const index = getBase32IndexFromCharacter(char);\n    value = (value << 5) | index;\n    bits += 5;\n    if (bits >= 8) {\n      output[outputIndex++] = (value >>> (bits - 8)) & 255;\n      bits -= 8;\n    }\n  }\n  return output;\n}\nimport.meta.vitest?.test(\"decodeBase32\", ({ expect }) => {\n  expect(decodeBase32(\"\")).toEqual(new Uint8Array([]));\n  expect(decodeBase32(\"00\")).toEqual(new Uint8Array([0]));\n  expect(decodeBase32(\"1W\")).toEqual(new Uint8Array([15]));\n  expect(decodeBase32(\"20\")).toEqual(new Uint8Array([16]));\n  expect(decodeBase32(\"ZW\")).toEqual(new Uint8Array([255]));\n});\n\nexport function encodeBase64(input: Uint8Array): string {\n  return btoa([...input].map((b) => String.fromCharCode(b)).join(\"\"));\n}\n\nexport function decodeBase64(input: string): Uint8Array<ArrayBuffer> {\n  return new Uint8Array(atob(input).split(\"\").map((char) => char.charCodeAt(0)));\n}\nimport.meta.vitest?.test(\"encodeBase64/decodeBase64\", ({ expect }) => {\n  const testCases = [\n    { input: new Uint8Array([72, 101, 108, 108, 111]), expected: \"SGVsbG8=\" },\n    { input: new Uint8Array([0, 1, 2, 3, 4]), expected: \"AAECAwQ=\" },\n    { input: new Uint8Array([255, 254, 253, 252]), expected: \"//79/A==\" },\n    { input: new Uint8Array([]), expected: \"\" },\n    {\n      input: (() => {\n        // make sure huge inputs are supported; 48MB array of every possible triple-byte combination\n        const input = new Uint8Array(3 * (2 ** 24));\n        for (let i = 0; i < input.length / 3; i++) {\n          input[3 * i] = Math.floor(i / 256 / 256);\n          input[3 * i + 1] = Math.floor(i / 256) % 256;\n          input[3 * i + 2] = i % 256;\n        }\n        return input;\n      })(),\n      expected: (() => {\n        const base64Alphabet = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n        const output = [];\n        for (let i = 0; i < 2 ** 24; i++) {\n          output.push(\n            base64Alphabet[Math.floor(i / 64 / 64 / 64)]\n              + base64Alphabet[Math.floor(i / 64 / 64) % 64]\n              + base64Alphabet[Math.floor(i / 64) % 64]\n              + base64Alphabet[i % 64]\n          );\n        }\n        return output.join(\"\");\n      })(),\n    },\n  ];\n\n  for (const [i, { input, expected }] of testCases.entries()) {\n    // expect(...) is pretty slow with long inputs, so we throw our own assertions\n    const encoded = encodeBase64(input);\n    if (encoded !== expected) {\n      throw new HexclaveAssertionError(`encodeBase64 test case ${i} failed`);\n    }\n    const decoded = decodeBase64(encoded);\n    if (decoded.some((b, i) => b !== input[i])) {\n      throw new HexclaveAssertionError(`decodeBase64 test case ${i} failed`);\n    }\n  }\n\n  // Test invalid input for decodeBase64\n  expect(() => decodeBase64(\"invalid!\")).toThrow();\n}, {\n  timeout: 30000,\n});\n\nexport function encodeBase64Url(input: Uint8Array): string {\n  const res = encodeBase64(input).replace(/=+$/, \"\").replace(/\\+/g, \"-\").replace(/\\//g, \"_\");\n\n  // Skip sanity check for test cases\n  // This avoids circular dependency with isBase64Url function\n  return res;\n}\n\nexport function decodeBase64Url(input: string): Uint8Array<ArrayBuffer> {\n  if (!isBase64Url(input)) {\n    throw new HexclaveAssertionError(\"Invalid base64url string\");\n  }\n\n  // Handle empty string case\n  if (input === \"\") {\n    return new Uint8Array(0);\n  }\n\n  return decodeBase64(input.replace(/-/g, \"+\").replace(/_/g, \"/\") + \"====\".slice((input.length - 1) % 4 + 1));\n}\nimport.meta.vitest?.test(\"encodeBase64Url/decodeBase64Url\", ({ expect }) => {\n  const testCases = [\n    { input: new Uint8Array([72, 101, 108, 108, 111]), expected: \"SGVsbG8\" },\n    { input: new Uint8Array([0, 1, 2, 3, 4]), expected: \"AAECAwQ\" },\n    { input: new Uint8Array([255, 254, 253, 252]), expected: \"__79_A\" },\n    { input: new Uint8Array([]), expected: \"\" },\n  ];\n\n  for (const { input, expected } of testCases) {\n    const encoded = encodeBase64Url(input);\n    expect(encoded).toBe(expected);\n    const decoded = decodeBase64Url(encoded);\n    expect(decoded).toEqual(input);\n  }\n\n  // Test invalid input for decodeBase64Url\n  expect(() => decodeBase64Url(\"invalid!\")).toThrow();\n});\n\nexport function decodeBase64OrBase64Url(input: string): Uint8Array<ArrayBuffer> {\n  if (isBase64Url(input)) {\n    return decodeBase64Url(input);\n  } else if (isBase64(input)) {\n    return decodeBase64(input);\n  } else {\n    throw new HexclaveAssertionError(\"Invalid base64 or base64url string\");\n  }\n}\nimport.meta.vitest?.test(\"decodeBase64OrBase64Url\", ({ expect }) => {\n  // Test with base64 input\n  const base64Input = \"SGVsbG8gV29ybGQ=\";\n  const base64Expected = new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]);\n  expect(decodeBase64OrBase64Url(base64Input)).toEqual(base64Expected);\n\n  // Test with base64url input\n  const base64UrlInput = \"SGVsbG8gV29ybGQ\";\n  const base64UrlExpected = new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]);\n  expect(decodeBase64OrBase64Url(base64UrlInput)).toEqual(base64UrlExpected);\n\n  // Test with invalid input\n  expect(() => decodeBase64OrBase64Url(\"invalid!\")).toThrow();\n});\n\nexport function isBase32(input: string): boolean {\n  for (const char of input) {\n    if (char === \" \") continue;\n    const upperChar = char.toUpperCase();\n    // Check if the character is in the Crockford alphabet\n    if (!crockfordAlphabet.includes(upperChar)) {\n      return false;\n    }\n  }\n  return true;\n}\nimport.meta.vitest?.test(\"isBase32\", ({ expect }) => {\n  expect(isBase32(\"0123456789ABCDEFGHJKMNPQRSTVWXYZ\")).toBe(true);\n  expect(isBase32(\"0OIJ\")).toBe(false); // O and I are not allowed\n  expect(isBase32(\"ABC DEF\")).toBe(true); // Spaces are allowed\n  expect(isBase32(\"ABC!\")).toBe(false); // Special characters not allowed\n  expect(isBase32(\"\")).toBe(true);\n});\n\nexport function isBase64(input: string): boolean {\n  // This regex allows for standard base64 with proper padding\n  const regex = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;\n  return regex.test(input);\n}\nimport.meta.vitest?.test(\"isBase64\", ({ expect }) => {\n  expect(isBase64(\"SGVsbG8gV29ybGQ=\")).toBe(true);\n  expect(isBase64(\"SGVsbG8gV29ybGQ\")).toBe(false); // No padding\n  expect(isBase64(\"SGVsbG8gV29ybGQ==\")).toBe(false); // Wrong padding\n  expect(isBase64(\"SGVsbG8!V29ybGQ=\")).toBe(false); // Invalid character\n  expect(isBase64(\"\")).toBe(true);\n});\n\nexport function isBase64Url(input: string): boolean {\n  if (input === \"\") {\n    return true;\n  }\n  const regex = /^[0-9a-zA-Z_-]+$/;\n  return regex.test(input);\n}\nimport.meta.vitest?.test(\"isBase64Url\", ({ expect }) => {\n  expect(isBase64Url(\"SGVsbG8gV2 9ybGQ\")).toBe(false); // Space is not valid\n  expect(isBase64Url(\"SGVsbG8_V29ybGQ\")).toBe(true); // _ is a valid character\n  expect(isBase64Url(\"SGVsbG8-V29ybGQ\")).toBe(true); // - is valid\n  expect(isBase64Url(\"SGVsbG8_V29ybGQ=\")).toBe(false); // = not allowed\n  expect(isBase64Url(\"\")).toBe(true); // Empty string is valid\n});\n"],"mappings":"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"}

package/dist/esm/utils/caches.d.ts

@@ -0,0 +1,102 @@
+import { RateLimitOptions, ReactPromise } from "./promises";
+
+//#region src/utils/caches.d.ts
+/**
+ * Can be used to cache the result of a function call, for example for the `use` hook in React.
+ */
+declare function cacheFunction<F extends Function>(f: F): F;
+type CacheStrategy = "write-only" | "read-write" | "never";
+declare class AsyncCache<D extends any[], T> {
+  private readonly _fetcher;
+  private readonly _options;
+  private readonly _map;
+  constructor(_fetcher: (dependencies: D) => Promise<T>, _options?: {
+    onSubscribe?: (key: D, refresh: () => void) => (() => void);
+    rateLimiter?: Omit<RateLimitOptions, "batchCalls">;
+  });
+  private _createKeyed;
+  getValueCache(dependencies: D): AsyncValueCache<T>;
+  refreshWhere(predicate: (dependencies: D) => boolean): Promise<void>;
+  invalidateWhere(predicate: (dependencies: D) => boolean): Promise<void>;
+  readonly isCacheAvailable: (key: D) => boolean;
+  readonly getIfCached: (key: D) => ({
+    status: "error";
+    error: unknown;
+  } & {
+    status: "error";
+  }) | ({
+    status: "pending";
+  } & {
+    progress: void;
+  } & {
+    status: "pending";
+  }) | ({
+    status: "ok";
+    data: T;
+  } & {
+    status: "ok";
+  });
+  readonly getOrWait: (key: D, cacheStrategy: CacheStrategy) => ReactPromise<T>;
+  readonly forceSetCachedValue: (key: D, value: T) => void;
+  readonly forceSetCachedValueAsync: (key: D, value: Promise<T>) => ReactPromise<void>;
+  readonly refresh: (key: D) => Promise<void>;
+  readonly invalidate: (key: D) => Promise<void>;
+  readonly onStateChange: (key: D, callback: (value: T, oldValue: T | undefined) => void) => {
+    unsubscribe: () => void;
+  };
+  readonly isDirty: (key: D) => boolean;
+}
+declare class AsyncValueCache<T> {
+  private readonly _options;
+  private _store;
+  private _pendingPromise;
+  private _fetcher;
+  private readonly _rateLimitOptions;
+  private _subscriptionsCount;
+  private _unsubscribers;
+  private _mostRecentRefreshPromiseIndex;
+  constructor(fetcher: () => Promise<T>, _options?: {
+    onSubscribe?: (refresh: () => void) => (() => void);
+    rateLimiter?: Omit<RateLimitOptions, "batchCalls">;
+  });
+  isCacheAvailable(): boolean;
+  getIfCached(): ({
+    status: "error";
+    error: unknown;
+  } & {
+    status: "error";
+  }) | ({
+    status: "pending";
+  } & {
+    progress: void;
+  } & {
+    status: "pending";
+  }) | ({
+    status: "ok";
+    data: T;
+  } & {
+    status: "ok";
+  });
+  getOrWait(cacheStrategy: CacheStrategy): ReactPromise<T>;
+  private _set;
+  private _setAsync;
+  private _refetch;
+  forceSetCachedValue(value: T): void;
+  forceSetCachedValueAsync(value: Promise<T>): ReactPromise<void>;
+  /**
+   * If anyone is listening to the cache, refreshes the value, and sets it without invalidating the cache.
+   */
+  refresh(): Promise<void>;
+  /**
+   * Invalidates the cache, marking it dirty (ie. it will be refreshed on the next read). If anyone is listening to the cache, it will refresh immediately.
+   */
+  invalidate(): Promise<void>;
+  isDirty(): boolean;
+  _invalidateCacheSoon(): void;
+  onStateChange(callback: (value: T, oldValue: T | undefined) => void): {
+    unsubscribe: () => void;
+  };
+}
+//#endregion
+export { AsyncCache, cacheFunction };
+//# sourceMappingURL=caches.d.ts.map

package/dist/esm/utils/caches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caches.d.ts","names":[],"sources":["../../../src/utils/caches.tsx"],"mappings":";;;;;AASA;iBAAgB,aAAA,WAAwB,QAAA,CAAA,CAAU,CAAA,EAAG,CAAA,GAAI,CAAA;AAAA,KAwDpD,aAAA;AAAA,cAEQ,UAAA;EAAA,iBAIQ,QAAA;EAAA,iBACA,QAAA;EAAA,iBAJF,IAAA;cAGE,QAAA,GAAW,YAAA,EAAc,CAAA,KAAM,OAAA,CAAQ,CAAA,GACvC,QAAA;IACf,WAAA,IAAe,GAAA,EAAK,CAAA,EAAG,OAAA;IACvB,WAAA,GAAc,IAAA,CAAK,gBAAA;EAAA;EAAA,QAMf,YAAA;EASR,aAAA,CAAc,YAAA,EAAc,CAAA,GAAI,eAAA,CAAgB,CAAA;EAe1C,YAAA,CAAa,SAAA,GAAY,YAAA,EAAc,CAAA,eAAa,OAAA;EAUpD,eAAA,CAAgB,SAAA,GAAY,YAAA,EAAc,CAAA,eAAa,OAAA;EAAA,SAUpD,gBAAA,GAAgB,GAAA,EA1ChB,CAAA;EAAA,SA2CA,WAAA,GAAW,GAAA,EA3CX,CAAA;;;;;;;;;;;;;;;;;WA4CA,SAAA,GAAS,GAAA,EA5CT,CAAA,EAAC,aAAA,EAAA,aAAA,KAAA,YAAA,CAAA,CAAA;EAAA,SA6CD,mBAAA,GAAmB,GAAA,EA7CnB,CAAA,EAAC,KAAA,EAAA,CAAA;EAAA,SA8CD,wBAAA,GAAwB,GAAA,EA9CxB,CAAA,EAAC,KAAA,EAAA,OAAA,CAAA,CAAA,MAAA,YAAA;EAAA,SA+CD,OAAA,GAAO,GAAA,EA/CP,CAAA,KAAC,OAAA;EAAA,SAgDD,UAAA,GAAU,GAAA,EAhDV,CAAA,KAAC,OAAA;EAAA,SAiDD,aAAA,GAAa,GAAA,EAjDb,CAAA,EAAC,QAAA,GAAA,KAAA,EAAA,CAAA,EAAA,QAAA,EAAA,CAAA;;;WAkDD,OAAA,GAAO,GAAA,EAlDP,CAAA;AAAA;AAAA,cAqDL,eAAA;EAAA,iBAWe,QAAA;EAAA,QAVX,MAAA;EAAA,QACA,eAAA;EAAA,QACA,QAAA;EAAA,iBACS,iBAAA;EAAA,QACT,mBAAA;EAAA,QACA,cAAA;EAAA,QACA,8BAAA;cAGN,OAAA,QAAe,OAAA,CAAQ,CAAA,GACN,QAAA;IACf,WAAA,IAAe,OAAA;IACf,WAAA,GAAc,IAAA,CAAK,gBAAA;EAAA;EAiBvB,gBAAA,CAAA;EAIA,WAAA,CAAA;;;;;;;;;;;;;;;;;EAIA,SAAA,CAAU,aAAA,EAAe,aAAA,GAAgB,YAAA,CAAa,CAAA;EAAA,QAS9C,IAAA;EAAA,QAIA,SAAA;EAAA,QAWA,QAAA;EAWR,mBAAA,CAAoB,KAAA,EAAO,CAAA;EAI3B,wBAAA,CAAyB,KAAA,EAAO,OAAA,CAAQ,CAAA,IAAK,YAAA;EA3HjB;;;EAkItB,OAAA,CAAA,GAAW,OAAA;EAnHX;;;EA6HA,UAAA,CAAA,GAAc,OAAA;EAMpB,OAAA,CAAA;EAIA,oBAAA,CAAA;EAYA,aAAA,CAAc,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,QAAA,EAAU,CAAA;IAA2B,WAAA;EAAA;AAAA"}