@hexclave/shared 1.0.41 → 1.0.42

package/dist/esm/utils/booleans.js

@@ -2,34 +2,10 @@
 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

@@ -1 +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"}
+{"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;CAC5D,OAAO,CAAC,CAAC;AACX;AAcA,SAAgB,QAAW,OAAiC;CAC1D,OAAO,CAAC;AACV"}

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

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

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

@@ -15,7 +15,7 @@ function getBrowserCompatibilityReport() {
 		cryptoUuid: test("crypto.randomUUID()")
 	};
 }
-
 //#endregion
 export { getBrowserCompatibilityReport };
+
 //# sourceMappingURL=browser-compat.js.map

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

@@ -1 +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"}
+{"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;EAChC,IAAI;GACF,CAAC,GAAG,KAAA,CAAM,OAAO;GACjB,OAAO;EACT,SAAS,GAAG;GACV,OAAO,WAAW;EACpB;CACF;CAEA,OAAO;EACL,kBAAkB,KAAK,YAAY;EACnC,mBAAmB,KAAK,QAAQ;EAChC,SAAS,KAAK,iBAAiB;EAC/B,YAAY,KAAK,qBAAqB;CACxC;AACF"}

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

@@ -1 +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"}
+{"version":3,"file":"bytes.d.ts","names":[],"sources":["../../../src/utils/bytes.tsx"],"mappings":";iBASgB,WAAA,CAAY,KAAiB,EAAV,UAAU;AAAA,iBAY7B,2BAAA,CAA4B,KAAa;AAAA,iBAYzC,2BAAA,CAA4B,SAAiB;AAAA,iBAgB7C,YAAA,CAAa,KAAiB,EAAV,UAAU;AAAA,iBA+B9B,YAAA,CAAa,KAAA,WAAgB,UAAU,CAAC,WAAA;AAAA,iBAiCxC,YAAA,CAAa,KAAiB,EAAV,UAAU;AAAA,iBAI9B,YAAA,CAAa,KAAA,WAAgB,UAAU,CAAC,WAAA;AAAA,iBAsDxC,eAAA,CAAgB,KAAiB,EAAV,UAAU;AAAA,iBAQjC,eAAA,CAAgB,KAAA,WAAgB,UAAU,CAAC,WAAA;AAAA,iBA+B3C,uBAAA,CAAwB,KAAA,WAAgB,UAAU,CAAC,WAAA;AAAA,iBAwBnD,QAAA,CAAS,KAAa;AAAA,iBAmBtB,QAAA,CAAS,KAAa;AAAA,iBAatB,WAAA,CAAY,KAAa"}

package/dist/esm/utils/bytes.js

@@ -1,8 +1,7 @@
 import { HexclaveAssertionError } from "./errors.js";
-
 //#region src/utils/bytes.tsx
 const crockfordAlphabet = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-const crockfordReplacements = new Map([
+const crockfordReplacements = /* @__PURE__ */ new Map([
 	["o", "0"],
 	["i", "1"],
 	["l", "1"]
@@ -10,38 +9,16 @@ const crockfordReplacements = new Map([
 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;
@@ -58,14 +35,6 @@ function encodeBase32(input) {
 	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);
@@ -86,168 +55,25 @@ function decodeBase32(input) {
 	}
 	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);
+	if (input === "") return /* @__PURE__ */ 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;
@@ -256,35 +82,14 @@ function isBase32(input) {
 	}
 	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

@@ -1 +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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"}
+{"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

@@ -1,4 +1,4 @@
-import { RateLimitOptions, ReactPromise } from "./promises";
+import { RateLimitOptions, ReactPromise } from "./promises.js";
 
 //#region src/utils/caches.d.ts
 /**

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

@@ -1 +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"}
+{"version":3,"file":"caches.d.ts","names":[],"sources":["../../../src/utils/caches.tsx"],"mappings":";;;;;AASA;iBAAgB,aAAA,WAAwB,QAAA,EAAU,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;EAIA,WAAA;;;;;;;;;;;;;;;;;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,IAAW,OAAA;EAnHX;;;EA6HA,UAAA,IAAc,OAAA;EAMpB,OAAA;EAIA,oBAAA;EAYA,aAAA,CAAc,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,QAAA,EAAU,CAAA;IAA2B,WAAA;EAAA;AAAA"}

package/dist/esm/utils/caches.js

@@ -3,7 +3,6 @@ import { DependenciesMap } from "./maps.js";
 import { filterUndefined } from "./objects.js";
 import { pending, rateLimited, resolved, runAsynchronously, wait } from "./promises.js";
 import { AsyncStore } from "./stores.js";
-
 //#region src/utils/caches.tsx
 /**
 * Can be used to cache the result of a function call, for example for the `use` hook in React.
@@ -17,31 +16,6 @@ function cacheFunction(f) {
 		return value;
 	});
 }
-(void 0)?.test("cacheFunction", ({ expect }) => {
-	let callCount = 0;
-	const add = (a, b) => {
-		callCount++;
-		return a + b;
-	};
-	const cachedAdd = cacheFunction(add);
-	expect(cachedAdd(1, 2)).toBe(3);
-	expect(callCount).toBe(1);
-	expect(cachedAdd(1, 2)).toBe(3);
-	expect(callCount).toBe(1);
-	expect(cachedAdd(2, 3)).toBe(5);
-	expect(callCount).toBe(2);
-	let objectCallCount = 0;
-	const createObject = (id) => {
-		objectCallCount++;
-		return { id };
-	};
-	const cachedCreateObject = cacheFunction(createObject);
-	const obj1 = cachedCreateObject(1);
-	expect(obj1).toEqual({ id: 1 });
-	expect(objectCallCount).toBe(1);
-	expect(cachedCreateObject(1)).toBe(obj1);
-	expect(objectCallCount).toBe(1);
-});
 var AsyncCache = class {
 	constructor(_fetcher, _options = {}) {
 		this._fetcher = _fetcher;
@@ -179,7 +153,7 @@ var AsyncValueCache = class {
 		} };
 	}
 };
-
 //#endregion
 export { AsyncCache, cacheFunction };
+
 //# sourceMappingURL=caches.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"caches.js","names":[],"sources":["../../../src/utils/caches.tsx"],"sourcesContent":["import { isBrowserLike } from \"./env\";\nimport { DependenciesMap } from \"./maps\";\nimport { filterUndefined } from \"./objects\";\nimport { RateLimitOptions, ReactPromise, pending, rateLimited, resolved, runAsynchronously, wait } from \"./promises\";\nimport { AsyncStore } from \"./stores\";\n\n/**\n * Can be used to cache the result of a function call, for example for the `use` hook in React.\n */\nexport function cacheFunction<F extends Function>(f: F): F {\n  const dependenciesMap = new DependenciesMap<any, any>();\n\n  return ((...args: any) => {\n    if (dependenciesMap.has(args)) {\n      return dependenciesMap.get(args);\n    }\n\n    const value = f(...args);\n    dependenciesMap.set(args, value);\n    return value;\n  }) as any as F;\n}\nimport.meta.vitest?.test(\"cacheFunction\", ({ expect }) => {\n  // Test with a simple function\n  let callCount = 0;\n  const add = (a: number, b: number) => {\n    callCount++;\n    return a + b;\n  };\n\n  const cachedAdd = cacheFunction(add);\n\n  // First call should execute the function\n  expect(cachedAdd(1, 2)).toBe(3);\n  expect(callCount).toBe(1);\n\n  // Second call with same args should use cached result\n  expect(cachedAdd(1, 2)).toBe(3);\n  expect(callCount).toBe(1);\n\n  // Call with different args should execute the function again\n  expect(cachedAdd(2, 3)).toBe(5);\n  expect(callCount).toBe(2);\n\n  // Test with a function that returns objects\n  let objectCallCount = 0;\n  const createObject = (id: number) => {\n    objectCallCount++;\n    return { id };\n  };\n\n  const cachedCreateObject = cacheFunction(createObject);\n\n  // First call should execute the function\n  const obj1 = cachedCreateObject(1);\n  expect(obj1).toEqual({ id: 1 });\n  expect(objectCallCount).toBe(1);\n\n  // Second call with same args should use cached result\n  const obj2 = cachedCreateObject(1);\n  expect(obj2).toBe(obj1); // Same reference\n  expect(objectCallCount).toBe(1);\n});\n\n\ntype CacheStrategy = \"write-only\" | \"read-write\" | \"never\";\n\nexport class AsyncCache<D extends any[], T> {\n  private readonly _map = new DependenciesMap<D, AsyncValueCache<T>>();\n\n  constructor(\n    private readonly _fetcher: (dependencies: D) => Promise<T>,\n    private readonly _options: {\n      onSubscribe?: (key: D, refresh: () => void) => (() => void),\n      rateLimiter?: Omit<RateLimitOptions, \"batchCalls\">,\n    } = {},\n  ) {\n    // nothing here yet\n  }\n\n  private _createKeyed<FunctionName extends keyof AsyncValueCache<T>>(\n    functionName: FunctionName,\n  ): (key: D, ...args: Parameters<AsyncValueCache<T>[FunctionName]>) => ReturnType<AsyncValueCache<T>[FunctionName]> {\n    return (key: D, ...args) => {\n      const valueCache = this.getValueCache(key);\n      return (valueCache[functionName] as any).apply(valueCache, args);\n    };\n  }\n\n  getValueCache(dependencies: D): AsyncValueCache<T> {\n    let cache = this._map.get(dependencies);\n    if (!cache) {\n      cache = new AsyncValueCache(\n        async () => await this._fetcher(dependencies),\n        {\n          ...this._options,\n          onSubscribe: this._options.onSubscribe ? (cb) => this._options.onSubscribe!(dependencies, cb) : undefined,\n        },\n      );\n      this._map.set(dependencies, cache);\n    }\n    return cache;\n  }\n\n  async refreshWhere(predicate: (dependencies: D) => boolean) {\n    const promises: Promise<void>[] = [];\n    for (const [dependencies, cache] of this._map) {\n      if (predicate(dependencies)) {\n        promises.push(cache.refresh());\n      }\n    }\n    await Promise.all(promises);\n  }\n\n  async invalidateWhere(predicate: (dependencies: D) => boolean) {\n    const promises: Promise<void>[] = [];\n    for (const [dependencies, cache] of this._map) {\n      if (predicate(dependencies)) {\n        promises.push(cache.invalidate().catch(() => undefined));\n      }\n    }\n    await Promise.all(promises);\n  }\n\n  readonly isCacheAvailable = this._createKeyed(\"isCacheAvailable\");\n  readonly getIfCached = this._createKeyed(\"getIfCached\");\n  readonly getOrWait = this._createKeyed(\"getOrWait\");\n  readonly forceSetCachedValue = this._createKeyed(\"forceSetCachedValue\");\n  readonly forceSetCachedValueAsync = this._createKeyed(\"forceSetCachedValueAsync\");\n  readonly refresh = this._createKeyed(\"refresh\");\n  readonly invalidate = this._createKeyed(\"invalidate\");\n  readonly onStateChange = this._createKeyed(\"onStateChange\");\n  readonly isDirty = this._createKeyed(\"isDirty\");\n}\n\nclass AsyncValueCache<T> {\n  private _store: AsyncStore<T>;\n  private _pendingPromise: ReactPromise<T> | undefined;\n  private _fetcher: () => Promise<T>;\n  private readonly _rateLimitOptions: Omit<RateLimitOptions, \"batchCalls\">;\n  private _subscriptionsCount = 0;\n  private _unsubscribers: (() => void)[] = [];\n  private _mostRecentRefreshPromiseIndex = 0;\n\n  constructor(\n    fetcher: () => Promise<T>,\n    private readonly _options: {\n      onSubscribe?: (refresh: () => void) => (() => void),\n      rateLimiter?: Omit<RateLimitOptions, \"batchCalls\">,\n    } = {},\n  ) {\n    this._store = new AsyncStore();\n    this._rateLimitOptions = {\n      concurrency: 1,\n      throttleMs: 300,\n      ...filterUndefined(_options.rateLimiter ?? {}),\n    };\n\n\n    this._fetcher = rateLimited(fetcher, {\n      ...this._rateLimitOptions,\n      batchCalls: true,\n    });\n  }\n\n  isCacheAvailable(): boolean {\n    return this._store.isAvailable();\n  }\n\n  getIfCached() {\n    return this._store.get();\n  }\n\n  getOrWait(cacheStrategy: CacheStrategy): ReactPromise<T> {\n    const cached = this.getIfCached();\n    if (cacheStrategy === \"read-write\" && cached.status === \"ok\") {\n      return resolved(cached.data);\n    }\n\n    return this._refetch(cacheStrategy);\n  }\n\n  private _set(value: T): void {\n    this._store.set(value);\n  }\n\n  private _setAsync(value: Promise<T>): ReactPromise<void> {\n    if (this._subscriptionsCount === 0 && !isBrowserLike()) {\n      // if we're in a server-like environment, we'd rather cache less aggressively to avoid memory leaks.\n      // hence, if no one is listening to this cache, let's invalidate it\n      this._invalidateCacheSoon();\n    }\n    const promise = pending(value);\n    this._pendingPromise = promise;\n    return pending(this._store.setAsync(promise).then(() => undefined));\n  }\n\n  private _refetch(cacheStrategy: CacheStrategy): ReactPromise<T> {\n    if (cacheStrategy === \"read-write\" && this._pendingPromise) {\n      return this._pendingPromise;\n    }\n    const promise = pending(this._fetcher());\n    if (cacheStrategy === \"never\") {\n      return promise;\n    }\n    return pending(this._setAsync(promise).then(() => promise));\n  }\n\n  forceSetCachedValue(value: T): void {\n    this._set(value);\n  }\n\n  forceSetCachedValueAsync(value: Promise<T>): ReactPromise<void> {\n    return this._setAsync(value);\n  }\n\n  /**\n   * If anyone is listening to the cache, refreshes the value, and sets it without invalidating the cache.\n   */\n  async refresh(): Promise<void> {\n    // note that we do the extra check here to save a request if no one is listening to the cache anyway\n    if (this._subscriptionsCount > 0) {\n      await this.getOrWait(\"write-only\");\n    }\n  }\n\n  /**\n   * 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.\n   */\n  async invalidate(): Promise<void> {\n    this._store.setUnavailable();\n    this._pendingPromise = undefined;\n    await this.refresh();\n  }\n\n  isDirty(): boolean {\n    return this._pendingPromise === undefined;\n  }\n\n  _invalidateCacheSoon(): void {\n    // wait a few seconds; we want to keep the cache up during this time\n    // else we do unnecessary requests if we unsubscribe and then subscribe again immediately\n    const currentRefreshPromiseIndex = ++this._mostRecentRefreshPromiseIndex;\n    runAsynchronously(async () => {\n      await wait(5000);\n      if (this._subscriptionsCount === 0 && currentRefreshPromiseIndex === this._mostRecentRefreshPromiseIndex) {\n        await this.invalidate();\n      }\n    });\n  }\n\n  onStateChange(callback: (value: T, oldValue: T | undefined) => void): { unsubscribe: () => void } {\n    const storeObj = this._store.onChange(callback);\n\n    runAsynchronously(this.getOrWait(\"read-write\"));\n\n    if (this._subscriptionsCount++ === 0 && this._options.onSubscribe) {\n      const unsubscribe = this._options.onSubscribe(() => {\n        runAsynchronously(this.refresh());\n      });\n      this._unsubscribers.push(unsubscribe);\n    }\n\n    let hasUnsubscribed = false;\n    return {\n      unsubscribe: () => {\n        if (hasUnsubscribed) return;\n        hasUnsubscribed = true;\n        storeObj.unsubscribe();\n        if (--this._subscriptionsCount === 0) {\n          this._invalidateCacheSoon();\n\n          for (const unsubscribe of this._unsubscribers) {\n            unsubscribe();\n          }\n        }\n      },\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;AASA,SAAgB,cAAkC,GAAS;CACzD,MAAM,kBAAkB,IAAI,iBAA2B;AAEvD,UAAS,GAAG,SAAc;AACxB,MAAI,gBAAgB,IAAI,KAAK,CAC3B,QAAO,gBAAgB,IAAI,KAAK;EAGlC,MAAM,QAAQ,EAAE,GAAG,KAAK;AACxB,kBAAgB,IAAI,MAAM,MAAM;AAChC,SAAO;;;CAGX,SAAW,KAAC,kBAAc,EAAA,aAAmB;CAE3C,IAAI,YAAY;CAChB,MAAM,OAAO,GAAW,MAAc;AACpC;AACA,SAAO,IAAI;;CAGb,MAAM,YAAY,cAAc,IAAI;AAGpC,QAAO,UAAU,GAAG,EAAE,CAAC,CAAC,KAAK,EAAE;AAC/B,QAAO,UAAU,CAAC,KAAK,EAAE;AAGzB,QAAO,UAAU,GAAG,EAAE,CAAC,CAAC,KAAK,EAAE;AAC/B,QAAO,UAAU,CAAC,KAAK,EAAE;AAGzB,QAAO,UAAU,GAAG,EAAE,CAAC,CAAC,KAAK,EAAE;AAC/B,QAAO,UAAU,CAAC,KAAK,EAAE;CAGzB,IAAI,kBAAkB;CACtB,MAAM,gBAAgB,OAAe;AACnC;AACA,SAAO,EAAE,IAAI;;CAGf,MAAM,qBAAqB,cAAc,aAAa;CAGtD,MAAM,OAAO,mBAAmB,EAAE;AAClC,QAAO,KAAK,CAAC,QAAQ,EAAE,IAAI,GAAG,CAAC;AAC/B,QAAO,gBAAgB,CAAC,KAAK,EAAE;AAI/B,QADa,mBAAmB,EAAE,CACtB,CAAC,KAAK,KAAK;AACvB,QAAO,gBAAgB,CAAC,KAAK,EAAE;EAC/B;AAKF,IAAa,aAAb,MAA4C;CAG1C,YACE,AAAiB,UACjB,AAAiB,WAGb,EAAE,EACN;EALiB;EACA;cAJK,IAAI,iBAAwC;0BAwDxC,KAAK,aAAa,mBAAmB;qBAC1C,KAAK,aAAa,cAAc;mBAClC,KAAK,aAAa,YAAY;6BACpB,KAAK,aAAa,sBAAsB;kCACnC,KAAK,aAAa,2BAA2B;iBAC9D,KAAK,aAAa,UAAU;oBACzB,KAAK,aAAa,aAAa;uBAC5B,KAAK,aAAa,gBAAgB;iBACxC,KAAK,aAAa,UAAU;;CApD/C,AAAQ,aACN,cACiH;AACjH,UAAQ,KAAQ,GAAG,SAAS;GAC1B,MAAM,aAAa,KAAK,cAAc,IAAI;AAC1C,UAAQ,WAAW,cAAsB,MAAM,YAAY,KAAK;;;CAIpE,cAAc,cAAqC;EACjD,IAAI,QAAQ,KAAK,KAAK,IAAI,aAAa;AACvC,MAAI,CAAC,OAAO;AACV,WAAQ,IAAI,gBACV,YAAY,MAAM,KAAK,SAAS,aAAa,EAC7C;IACE,GAAG,KAAK;IACR,aAAa,KAAK,SAAS,eAAe,OAAO,KAAK,SAAS,YAAa,cAAc,GAAG,GAAG;IACjG,CACF;AACD,QAAK,KAAK,IAAI,cAAc,MAAM;;AAEpC,SAAO;;CAGT,MAAM,aAAa,WAAyC;EAC1D,MAAM,WAA4B,EAAE;AACpC,OAAK,MAAM,CAAC,cAAc,UAAU,KAAK,KACvC,KAAI,UAAU,aAAa,CACzB,UAAS,KAAK,MAAM,SAAS,CAAC;AAGlC,QAAM,QAAQ,IAAI,SAAS;;CAG7B,MAAM,gBAAgB,WAAyC;EAC7D,MAAM,WAA4B,EAAE;AACpC,OAAK,MAAM,CAAC,cAAc,UAAU,KAAK,KACvC,KAAI,UAAU,aAAa,CACzB,UAAS,KAAK,MAAM,YAAY,CAAC,YAAY,OAAU,CAAC;AAG5D,QAAM,QAAQ,IAAI,SAAS;;;AAc/B,IAAM,kBAAN,MAAyB;CASvB,YACE,SACA,AAAiB,WAGb,EAAE,EACN;EAJiB;6BANW;wBACW,EAAE;wCACF;AASvC,OAAK,SAAS,IAAI,YAAY;AAC9B,OAAK,oBAAoB;GACvB,aAAa;GACb,YAAY;GACZ,GAAG,gBAAgB,SAAS,eAAe,EAAE,CAAC;GAC/C;AAGD,OAAK,WAAW,YAAY,SAAS;GACnC,GAAG,KAAK;GACR,YAAY;GACb,CAAC;;CAGJ,mBAA4B;AAC1B,SAAO,KAAK,OAAO,aAAa;;CAGlC,cAAc;AACZ,SAAO,KAAK,OAAO,KAAK;;CAG1B,UAAU,eAA+C;EACvD,MAAM,SAAS,KAAK,aAAa;AACjC,MAAI,kBAAkB,gBAAgB,OAAO,WAAW,KACtD,QAAO,SAAS,OAAO,KAAK;AAG9B,SAAO,KAAK,SAAS,cAAc;;CAGrC,AAAQ,KAAK,OAAgB;AAC3B,OAAK,OAAO,IAAI,MAAM;;CAGxB,AAAQ,UAAU,OAAuC;AACvD,MAAI,KAAK,wBAAwB,KAAK,CAAC,eAAe,CAGpD,MAAK,sBAAsB;EAE7B,MAAM,UAAU,QAAQ,MAAM;AAC9B,OAAK,kBAAkB;AACvB,SAAO,QAAQ,KAAK,OAAO,SAAS,QAAQ,CAAC,WAAW,OAAU,CAAC;;CAGrE,AAAQ,SAAS,eAA+C;AAC9D,MAAI,kBAAkB,gBAAgB,KAAK,gBACzC,QAAO,KAAK;EAEd,MAAM,UAAU,QAAQ,KAAK,UAAU,CAAC;AACxC,MAAI,kBAAkB,QACpB,QAAO;AAET,SAAO,QAAQ,KAAK,UAAU,QAAQ,CAAC,WAAW,QAAQ,CAAC;;CAG7D,oBAAoB,OAAgB;AAClC,OAAK,KAAK,MAAM;;CAGlB,yBAAyB,OAAuC;AAC9D,SAAO,KAAK,UAAU,MAAM;;;;;CAM9B,MAAM,UAAyB;AAE7B,MAAI,KAAK,sBAAsB,EAC7B,OAAM,KAAK,UAAU,aAAa;;;;;CAOtC,MAAM,aAA4B;AAChC,OAAK,OAAO,gBAAgB;AAC5B,OAAK,kBAAkB;AACvB,QAAM,KAAK,SAAS;;CAGtB,UAAmB;AACjB,SAAO,KAAK,oBAAoB;;CAGlC,uBAA6B;EAG3B,MAAM,6BAA6B,EAAE,KAAK;AAC1C,oBAAkB,YAAY;AAC5B,SAAM,KAAK,IAAK;AAChB,OAAI,KAAK,wBAAwB,KAAK,+BAA+B,KAAK,+BACxE,OAAM,KAAK,YAAY;IAEzB;;CAGJ,cAAc,UAAoF;EAChG,MAAM,WAAW,KAAK,OAAO,SAAS,SAAS;AAE/C,oBAAkB,KAAK,UAAU,aAAa,CAAC;AAE/C,MAAI,KAAK,0BAA0B,KAAK,KAAK,SAAS,aAAa;GACjE,MAAM,cAAc,KAAK,SAAS,kBAAkB;AAClD,sBAAkB,KAAK,SAAS,CAAC;KACjC;AACF,QAAK,eAAe,KAAK,YAAY;;EAGvC,IAAI,kBAAkB;AACtB,SAAO,EACL,mBAAmB;AACjB,OAAI,gBAAiB;AACrB,qBAAkB;AAClB,YAAS,aAAa;AACtB,OAAI,EAAE,KAAK,wBAAwB,GAAG;AACpC,SAAK,sBAAsB;AAE3B,SAAK,MAAM,eAAe,KAAK,eAC7B,cAAa;;KAIpB"}
+{"version":3,"file":"caches.js","names":[],"sources":["../../../src/utils/caches.tsx"],"sourcesContent":["import { isBrowserLike } from \"./env\";\nimport { DependenciesMap } from \"./maps\";\nimport { filterUndefined } from \"./objects\";\nimport { RateLimitOptions, ReactPromise, pending, rateLimited, resolved, runAsynchronously, wait } from \"./promises\";\nimport { AsyncStore } from \"./stores\";\n\n/**\n * Can be used to cache the result of a function call, for example for the `use` hook in React.\n */\nexport function cacheFunction<F extends Function>(f: F): F {\n  const dependenciesMap = new DependenciesMap<any, any>();\n\n  return ((...args: any) => {\n    if (dependenciesMap.has(args)) {\n      return dependenciesMap.get(args);\n    }\n\n    const value = f(...args);\n    dependenciesMap.set(args, value);\n    return value;\n  }) as any as F;\n}\nimport.meta.vitest?.test(\"cacheFunction\", ({ expect }) => {\n  // Test with a simple function\n  let callCount = 0;\n  const add = (a: number, b: number) => {\n    callCount++;\n    return a + b;\n  };\n\n  const cachedAdd = cacheFunction(add);\n\n  // First call should execute the function\n  expect(cachedAdd(1, 2)).toBe(3);\n  expect(callCount).toBe(1);\n\n  // Second call with same args should use cached result\n  expect(cachedAdd(1, 2)).toBe(3);\n  expect(callCount).toBe(1);\n\n  // Call with different args should execute the function again\n  expect(cachedAdd(2, 3)).toBe(5);\n  expect(callCount).toBe(2);\n\n  // Test with a function that returns objects\n  let objectCallCount = 0;\n  const createObject = (id: number) => {\n    objectCallCount++;\n    return { id };\n  };\n\n  const cachedCreateObject = cacheFunction(createObject);\n\n  // First call should execute the function\n  const obj1 = cachedCreateObject(1);\n  expect(obj1).toEqual({ id: 1 });\n  expect(objectCallCount).toBe(1);\n\n  // Second call with same args should use cached result\n  const obj2 = cachedCreateObject(1);\n  expect(obj2).toBe(obj1); // Same reference\n  expect(objectCallCount).toBe(1);\n});\n\n\ntype CacheStrategy = \"write-only\" | \"read-write\" | \"never\";\n\nexport class AsyncCache<D extends any[], T> {\n  private readonly _map = new DependenciesMap<D, AsyncValueCache<T>>();\n\n  constructor(\n    private readonly _fetcher: (dependencies: D) => Promise<T>,\n    private readonly _options: {\n      onSubscribe?: (key: D, refresh: () => void) => (() => void),\n      rateLimiter?: Omit<RateLimitOptions, \"batchCalls\">,\n    } = {},\n  ) {\n    // nothing here yet\n  }\n\n  private _createKeyed<FunctionName extends keyof AsyncValueCache<T>>(\n    functionName: FunctionName,\n  ): (key: D, ...args: Parameters<AsyncValueCache<T>[FunctionName]>) => ReturnType<AsyncValueCache<T>[FunctionName]> {\n    return (key: D, ...args) => {\n      const valueCache = this.getValueCache(key);\n      return (valueCache[functionName] as any).apply(valueCache, args);\n    };\n  }\n\n  getValueCache(dependencies: D): AsyncValueCache<T> {\n    let cache = this._map.get(dependencies);\n    if (!cache) {\n      cache = new AsyncValueCache(\n        async () => await this._fetcher(dependencies),\n        {\n          ...this._options,\n          onSubscribe: this._options.onSubscribe ? (cb) => this._options.onSubscribe!(dependencies, cb) : undefined,\n        },\n      );\n      this._map.set(dependencies, cache);\n    }\n    return cache;\n  }\n\n  async refreshWhere(predicate: (dependencies: D) => boolean) {\n    const promises: Promise<void>[] = [];\n    for (const [dependencies, cache] of this._map) {\n      if (predicate(dependencies)) {\n        promises.push(cache.refresh());\n      }\n    }\n    await Promise.all(promises);\n  }\n\n  async invalidateWhere(predicate: (dependencies: D) => boolean) {\n    const promises: Promise<void>[] = [];\n    for (const [dependencies, cache] of this._map) {\n      if (predicate(dependencies)) {\n        promises.push(cache.invalidate().catch(() => undefined));\n      }\n    }\n    await Promise.all(promises);\n  }\n\n  readonly isCacheAvailable = this._createKeyed(\"isCacheAvailable\");\n  readonly getIfCached = this._createKeyed(\"getIfCached\");\n  readonly getOrWait = this._createKeyed(\"getOrWait\");\n  readonly forceSetCachedValue = this._createKeyed(\"forceSetCachedValue\");\n  readonly forceSetCachedValueAsync = this._createKeyed(\"forceSetCachedValueAsync\");\n  readonly refresh = this._createKeyed(\"refresh\");\n  readonly invalidate = this._createKeyed(\"invalidate\");\n  readonly onStateChange = this._createKeyed(\"onStateChange\");\n  readonly isDirty = this._createKeyed(\"isDirty\");\n}\n\nclass AsyncValueCache<T> {\n  private _store: AsyncStore<T>;\n  private _pendingPromise: ReactPromise<T> | undefined;\n  private _fetcher: () => Promise<T>;\n  private readonly _rateLimitOptions: Omit<RateLimitOptions, \"batchCalls\">;\n  private _subscriptionsCount = 0;\n  private _unsubscribers: (() => void)[] = [];\n  private _mostRecentRefreshPromiseIndex = 0;\n\n  constructor(\n    fetcher: () => Promise<T>,\n    private readonly _options: {\n      onSubscribe?: (refresh: () => void) => (() => void),\n      rateLimiter?: Omit<RateLimitOptions, \"batchCalls\">,\n    } = {},\n  ) {\n    this._store = new AsyncStore();\n    this._rateLimitOptions = {\n      concurrency: 1,\n      throttleMs: 300,\n      ...filterUndefined(_options.rateLimiter ?? {}),\n    };\n\n\n    this._fetcher = rateLimited(fetcher, {\n      ...this._rateLimitOptions,\n      batchCalls: true,\n    });\n  }\n\n  isCacheAvailable(): boolean {\n    return this._store.isAvailable();\n  }\n\n  getIfCached() {\n    return this._store.get();\n  }\n\n  getOrWait(cacheStrategy: CacheStrategy): ReactPromise<T> {\n    const cached = this.getIfCached();\n    if (cacheStrategy === \"read-write\" && cached.status === \"ok\") {\n      return resolved(cached.data);\n    }\n\n    return this._refetch(cacheStrategy);\n  }\n\n  private _set(value: T): void {\n    this._store.set(value);\n  }\n\n  private _setAsync(value: Promise<T>): ReactPromise<void> {\n    if (this._subscriptionsCount === 0 && !isBrowserLike()) {\n      // if we're in a server-like environment, we'd rather cache less aggressively to avoid memory leaks.\n      // hence, if no one is listening to this cache, let's invalidate it\n      this._invalidateCacheSoon();\n    }\n    const promise = pending(value);\n    this._pendingPromise = promise;\n    return pending(this._store.setAsync(promise).then(() => undefined));\n  }\n\n  private _refetch(cacheStrategy: CacheStrategy): ReactPromise<T> {\n    if (cacheStrategy === \"read-write\" && this._pendingPromise) {\n      return this._pendingPromise;\n    }\n    const promise = pending(this._fetcher());\n    if (cacheStrategy === \"never\") {\n      return promise;\n    }\n    return pending(this._setAsync(promise).then(() => promise));\n  }\n\n  forceSetCachedValue(value: T): void {\n    this._set(value);\n  }\n\n  forceSetCachedValueAsync(value: Promise<T>): ReactPromise<void> {\n    return this._setAsync(value);\n  }\n\n  /**\n   * If anyone is listening to the cache, refreshes the value, and sets it without invalidating the cache.\n   */\n  async refresh(): Promise<void> {\n    // note that we do the extra check here to save a request if no one is listening to the cache anyway\n    if (this._subscriptionsCount > 0) {\n      await this.getOrWait(\"write-only\");\n    }\n  }\n\n  /**\n   * 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.\n   */\n  async invalidate(): Promise<void> {\n    this._store.setUnavailable();\n    this._pendingPromise = undefined;\n    await this.refresh();\n  }\n\n  isDirty(): boolean {\n    return this._pendingPromise === undefined;\n  }\n\n  _invalidateCacheSoon(): void {\n    // wait a few seconds; we want to keep the cache up during this time\n    // else we do unnecessary requests if we unsubscribe and then subscribe again immediately\n    const currentRefreshPromiseIndex = ++this._mostRecentRefreshPromiseIndex;\n    runAsynchronously(async () => {\n      await wait(5000);\n      if (this._subscriptionsCount === 0 && currentRefreshPromiseIndex === this._mostRecentRefreshPromiseIndex) {\n        await this.invalidate();\n      }\n    });\n  }\n\n  onStateChange(callback: (value: T, oldValue: T | undefined) => void): { unsubscribe: () => void } {\n    const storeObj = this._store.onChange(callback);\n\n    runAsynchronously(this.getOrWait(\"read-write\"));\n\n    if (this._subscriptionsCount++ === 0 && this._options.onSubscribe) {\n      const unsubscribe = this._options.onSubscribe(() => {\n        runAsynchronously(this.refresh());\n      });\n      this._unsubscribers.push(unsubscribe);\n    }\n\n    let hasUnsubscribed = false;\n    return {\n      unsubscribe: () => {\n        if (hasUnsubscribed) return;\n        hasUnsubscribed = true;\n        storeObj.unsubscribe();\n        if (--this._subscriptionsCount === 0) {\n          this._invalidateCacheSoon();\n\n          for (const unsubscribe of this._unsubscribers) {\n            unsubscribe();\n          }\n        }\n      },\n    };\n  }\n}\n"],"mappings":"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"}

package/dist/esm/utils/cel-fields.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cel-fields.d.ts","names":[],"sources":["../../../src/utils/cel-fields.ts"],"mappings":";KAKY,cAAA;AAAA,KASA,iBAAA;AAAA,iBAeI,cAAA,CAAe,KAAA,EAAO,cAAA;;;;AAftC;iBAuBgB,yBAAA,CAA0B,KAAA,UAAe,KAAA;AAAA,iBAczC,eAAA,CAAgB,KAAA;AAAA,iBAIhB,iBAAA,CAAkB,KAAA;AAAA,KAUtB,kBAAA;EACV,KAAA;EACA,SAAA,EAAW,iBAAA;EACX,gBAAA;AAAA;AAAA,cAGW,aAAA,EAAe,MAAA,CAAO,cAAA,EAAgB,kBAAA;AAAA,cAUtC,eAAA,EAAgD,cAAA;AAAA,cAEhD,kBAAA,EAAoB,iBAAA;AAAA,iBAMjB,oBAAA,CAAqB,KAAA,EAAO,cAAA,GAAiB,iBAAA"}
+{"version":3,"file":"cel-fields.d.ts","names":[],"sources":["../../../src/utils/cel-fields.ts"],"mappings":";KAKY,cAAA;AAAA,KASA,iBAAA;AAAA,iBAeI,cAAA,CAAe,KAAqB,EAAd,cAAc;;;AAxB1B;AAS1B;iBAuBgB,yBAAA,CAA0B,KAAA,UAAe,KAAsB;AAAA,iBAc/D,eAAA,CAAgB,KAAa;AAAA,iBAI7B,iBAAA,CAAkB,KAAa;AAAA,KAUnC,kBAAA;EACV,KAAA;EACA,SAAA,EAAW,iBAAiB;EAC5B,gBAAA;AAAA;AAAA,cAGW,aAAA,EAAe,MAAA,CAAO,cAAA,EAAgB,kBAAA;AAAA,cAUtC,eAAA,EAAgD,cAAc;AAAA,cAE9D,kBAAA,EAAoB,iBAAiB;AAAA,iBAMlC,oBAAA,CAAqB,KAAA,EAAO,cAAA,GAAiB,iBAAiB"}

package/dist/esm/utils/cel-fields.js

@@ -1,6 +1,5 @@
 import { signUpAuthMethodValues } from "./auth-methods.js";
 import { standardProviders } from "./oauth.js";
-
 //#region src/utils/cel-fields.ts
 function isNumericField(field) {
 	return field === "riskScores.bot" || field === "riskScores.free_trial_abuse";
@@ -93,7 +92,7 @@ const conditionOperators = [
 function getOperatorsForField(field) {
 	return fieldMetadata[field].operators;
 }
-
 //#endregion
 export { conditionFields, conditionOperators, escapeCelString, fieldMetadata, getOperatorsForField, isNumericField, unescapeCelString, validateNumericFieldValue };
+
 //# sourceMappingURL=cel-fields.js.map

package/dist/esm/utils/cel-fields.js.map

@@ -1 +1 @@
-{"version":3,"file":"cel-fields.js","names":[],"sources":["../../../src/utils/cel-fields.ts"],"sourcesContent":["import { signUpAuthMethodValues } from \"./auth-methods\";\nimport { standardProviders } from \"./oauth\";\n\n// ── Types ──────────────────────────────────────────────────────────────\n\nexport type ConditionField =\n  | 'email'\n  | 'countryCode'\n  | 'emailDomain'\n  | 'authMethod'\n  | 'oauthProvider'\n  | 'riskScores.bot'\n  | 'riskScores.free_trial_abuse';\n\nexport type ConditionOperator =\n  | 'equals'\n  | 'not_equals'\n  | 'greater_than'\n  | 'greater_or_equal'\n  | 'less_than'\n  | 'less_or_equal'\n  | 'matches'\n  | 'ends_with'\n  | 'starts_with'\n  | 'contains'\n  | 'in_list';\n\n// ── Helpers ────────────────────────────────────────────────────────────\n\nexport function isNumericField(field: ConditionField): boolean {\n  return field === 'riskScores.bot' || field === 'riskScores.free_trial_abuse';\n}\n\n/**\n * Validates a numeric field value is a finite integer within [0, 100].\n * Returns null if valid, or an error message string if invalid.\n */\nexport function validateNumericFieldValue(field: string, value: string | number): string | null {\n  const num = typeof value === 'number' ? value : Number(value);\n  if (!Number.isFinite(num)) {\n    return `Expected a finite number for field \"${field}\", got \"${String(value)}\"`;\n  }\n  if (!Number.isInteger(num)) {\n    return `Expected an integer for field \"${field}\", got \"${String(value)}\"`;\n  }\n  if (num < 0 || num > 100) {\n    return `Value for field \"${field}\" must be between 0 and 100, got ${num}`;\n  }\n  return null;\n}\n\nexport function escapeCelString(value: string): string {\n  return value.replace(/\\\\/g, '\\\\\\\\').replace(/\"/g, '\\\\\"');\n}\n\nexport function unescapeCelString(value: string): string {\n  return value.replace(/\\\\\\\\/g, '\\\\').replace(/\\\\\"/g, '\"');\n}\n\n// ── Field metadata ─────────────────────────────────────────────────────\n\nconst numericOperators: ConditionOperator[] = ['equals', 'not_equals', 'greater_than', 'greater_or_equal', 'less_than', 'less_or_equal'];\nconst enumOperators: ConditionOperator[] = ['equals', 'not_equals', 'in_list'];\nconst stringOperators: ConditionOperator[] = ['equals', 'not_equals', 'contains', 'starts_with', 'ends_with', 'matches', 'in_list'];\n\nexport type FieldMetadataEntry = {\n  label: string,\n  operators: ConditionOperator[],\n  predefinedValues?: string[],\n};\n\nexport const fieldMetadata: Record<ConditionField, FieldMetadataEntry> = {\n  email: { label: 'Email', operators: stringOperators },\n  countryCode: { label: 'Country Code', operators: enumOperators },\n  emailDomain: { label: 'Email Domain', operators: stringOperators },\n  authMethod: { label: 'Auth Method', operators: enumOperators, predefinedValues: [...signUpAuthMethodValues] },\n  oauthProvider: { label: 'OAuth Provider', operators: enumOperators, predefinedValues: [...standardProviders] },\n  'riskScores.bot': { label: 'Risk Score: Bot', operators: numericOperators },\n  'riskScores.free_trial_abuse': { label: 'Risk Score: Free Trial Abuse', operators: numericOperators },\n};\n\nexport const conditionFields = Object.keys(fieldMetadata) as ConditionField[];\n\nexport const conditionOperators: ConditionOperator[] = [\n  'equals', 'not_equals', 'greater_than', 'greater_or_equal',\n  'less_than', 'less_or_equal', 'matches', 'ends_with',\n  'starts_with', 'contains', 'in_list',\n];\n\nexport function getOperatorsForField(field: ConditionField): ConditionOperator[] {\n  return fieldMetadata[field].operators;\n}\n"],"mappings":";;;;AA6BA,SAAgB,eAAe,OAAgC;AAC7D,QAAO,UAAU,oBAAoB,UAAU;;;;;;AAOjD,SAAgB,0BAA0B,OAAe,OAAuC;CAC9F,MAAM,MAAM,OAAO,UAAU,WAAW,QAAQ,OAAO,MAAM;AAC7D,KAAI,CAAC,OAAO,SAAS,IAAI,CACvB,QAAO,uCAAuC,MAAM,UAAU,OAAO,MAAM,CAAC;AAE9E,KAAI,CAAC,OAAO,UAAU,IAAI,CACxB,QAAO,kCAAkC,MAAM,UAAU,OAAO,MAAM,CAAC;AAEzE,KAAI,MAAM,KAAK,MAAM,IACnB,QAAO,oBAAoB,MAAM,mCAAmC;AAEtE,QAAO;;AAGT,SAAgB,gBAAgB,OAAuB;AACrD,QAAO,MAAM,QAAQ,OAAO,OAAO,CAAC,QAAQ,MAAM,OAAM;;AAG1D,SAAgB,kBAAkB,OAAuB;AACvD,QAAO,MAAM,QAAQ,SAAS,KAAK,CAAC,QAAQ,QAAQ,KAAI;;AAK1D,MAAM,mBAAwC;CAAC;CAAU;CAAc;CAAgB;CAAoB;CAAa;CAAgB;AACxI,MAAM,gBAAqC;CAAC;CAAU;CAAc;CAAU;AAC9E,MAAM,kBAAuC;CAAC;CAAU;CAAc;CAAY;CAAe;CAAa;CAAW;CAAU;AAQnI,MAAa,gBAA4D;CACvE,OAAO;EAAE,OAAO;EAAS,WAAW;EAAiB;CACrD,aAAa;EAAE,OAAO;EAAgB,WAAW;EAAe;CAChE,aAAa;EAAE,OAAO;EAAgB,WAAW;EAAiB;CAClE,YAAY;EAAE,OAAO;EAAe,WAAW;EAAe,kBAAkB,CAAC,GAAG,uBAAuB;EAAE;CAC7G,eAAe;EAAE,OAAO;EAAkB,WAAW;EAAe,kBAAkB,CAAC,GAAG,kBAAkB;EAAE;CAC9G,kBAAkB;EAAE,OAAO;EAAmB,WAAW;EAAkB;CAC3E,+BAA+B;EAAE,OAAO;EAAgC,WAAW;EAAkB;CACtG;AAED,MAAa,kBAAkB,OAAO,KAAK,cAAc;AAEzD,MAAa,qBAA0C;CACrD;CAAU;CAAc;CAAgB;CACxC;CAAa;CAAiB;CAAW;CACzC;CAAe;CAAY;CAC5B;AAED,SAAgB,qBAAqB,OAA4C;AAC/E,QAAO,cAAc,OAAO"}
+{"version":3,"file":"cel-fields.js","names":[],"sources":["../../../src/utils/cel-fields.ts"],"sourcesContent":["import { signUpAuthMethodValues } from \"./auth-methods\";\nimport { standardProviders } from \"./oauth\";\n\n// ── Types ──────────────────────────────────────────────────────────────\n\nexport type ConditionField =\n  | 'email'\n  | 'countryCode'\n  | 'emailDomain'\n  | 'authMethod'\n  | 'oauthProvider'\n  | 'riskScores.bot'\n  | 'riskScores.free_trial_abuse';\n\nexport type ConditionOperator =\n  | 'equals'\n  | 'not_equals'\n  | 'greater_than'\n  | 'greater_or_equal'\n  | 'less_than'\n  | 'less_or_equal'\n  | 'matches'\n  | 'ends_with'\n  | 'starts_with'\n  | 'contains'\n  | 'in_list';\n\n// ── Helpers ────────────────────────────────────────────────────────────\n\nexport function isNumericField(field: ConditionField): boolean {\n  return field === 'riskScores.bot' || field === 'riskScores.free_trial_abuse';\n}\n\n/**\n * Validates a numeric field value is a finite integer within [0, 100].\n * Returns null if valid, or an error message string if invalid.\n */\nexport function validateNumericFieldValue(field: string, value: string | number): string | null {\n  const num = typeof value === 'number' ? value : Number(value);\n  if (!Number.isFinite(num)) {\n    return `Expected a finite number for field \"${field}\", got \"${String(value)}\"`;\n  }\n  if (!Number.isInteger(num)) {\n    return `Expected an integer for field \"${field}\", got \"${String(value)}\"`;\n  }\n  if (num < 0 || num > 100) {\n    return `Value for field \"${field}\" must be between 0 and 100, got ${num}`;\n  }\n  return null;\n}\n\nexport function escapeCelString(value: string): string {\n  return value.replace(/\\\\/g, '\\\\\\\\').replace(/\"/g, '\\\\\"');\n}\n\nexport function unescapeCelString(value: string): string {\n  return value.replace(/\\\\\\\\/g, '\\\\').replace(/\\\\\"/g, '\"');\n}\n\n// ── Field metadata ─────────────────────────────────────────────────────\n\nconst numericOperators: ConditionOperator[] = ['equals', 'not_equals', 'greater_than', 'greater_or_equal', 'less_than', 'less_or_equal'];\nconst enumOperators: ConditionOperator[] = ['equals', 'not_equals', 'in_list'];\nconst stringOperators: ConditionOperator[] = ['equals', 'not_equals', 'contains', 'starts_with', 'ends_with', 'matches', 'in_list'];\n\nexport type FieldMetadataEntry = {\n  label: string,\n  operators: ConditionOperator[],\n  predefinedValues?: string[],\n};\n\nexport const fieldMetadata: Record<ConditionField, FieldMetadataEntry> = {\n  email: { label: 'Email', operators: stringOperators },\n  countryCode: { label: 'Country Code', operators: enumOperators },\n  emailDomain: { label: 'Email Domain', operators: stringOperators },\n  authMethod: { label: 'Auth Method', operators: enumOperators, predefinedValues: [...signUpAuthMethodValues] },\n  oauthProvider: { label: 'OAuth Provider', operators: enumOperators, predefinedValues: [...standardProviders] },\n  'riskScores.bot': { label: 'Risk Score: Bot', operators: numericOperators },\n  'riskScores.free_trial_abuse': { label: 'Risk Score: Free Trial Abuse', operators: numericOperators },\n};\n\nexport const conditionFields = Object.keys(fieldMetadata) as ConditionField[];\n\nexport const conditionOperators: ConditionOperator[] = [\n  'equals', 'not_equals', 'greater_than', 'greater_or_equal',\n  'less_than', 'less_or_equal', 'matches', 'ends_with',\n  'starts_with', 'contains', 'in_list',\n];\n\nexport function getOperatorsForField(field: ConditionField): ConditionOperator[] {\n  return fieldMetadata[field].operators;\n}\n"],"mappings":";;;AA6BA,SAAgB,eAAe,OAAgC;CAC7D,OAAO,UAAU,oBAAoB,UAAU;AACjD;;;;;AAMA,SAAgB,0BAA0B,OAAe,OAAuC;CAC9F,MAAM,MAAM,OAAO,UAAU,WAAW,QAAQ,OAAO,KAAK;CAC5D,IAAI,CAAC,OAAO,SAAS,GAAG,GACtB,OAAO,uCAAuC,MAAM,UAAU,OAAO,KAAK,EAAE;CAE9E,IAAI,CAAC,OAAO,UAAU,GAAG,GACvB,OAAO,kCAAkC,MAAM,UAAU,OAAO,KAAK,EAAE;CAEzE,IAAI,MAAM,KAAK,MAAM,KACnB,OAAO,oBAAoB,MAAM,mCAAmC;CAEtE,OAAO;AACT;AAEA,SAAgB,gBAAgB,OAAuB;CACrD,OAAO,MAAM,QAAQ,OAAO,MAAM,CAAC,CAAC,QAAQ,MAAM,MAAK;AACzD;AAEA,SAAgB,kBAAkB,OAAuB;CACvD,OAAO,MAAM,QAAQ,SAAS,IAAI,CAAC,CAAC,QAAQ,QAAQ,IAAG;AACzD;AAIA,MAAM,mBAAwC;CAAC;CAAU;CAAc;CAAgB;CAAoB;CAAa;AAAe;AACvI,MAAM,gBAAqC;CAAC;CAAU;CAAc;AAAS;AAC7E,MAAM,kBAAuC;CAAC;CAAU;CAAc;CAAY;CAAe;CAAa;CAAW;AAAS;AAQlI,MAAa,gBAA4D;CACvE,OAAO;EAAE,OAAO;EAAS,WAAW;CAAgB;CACpD,aAAa;EAAE,OAAO;EAAgB,WAAW;CAAc;CAC/D,aAAa;EAAE,OAAO;EAAgB,WAAW;CAAgB;CACjE,YAAY;EAAE,OAAO;EAAe,WAAW;EAAe,kBAAkB,CAAC,GAAG,sBAAsB;CAAE;CAC5G,eAAe;EAAE,OAAO;EAAkB,WAAW;EAAe,kBAAkB,CAAC,GAAG,iBAAiB;CAAE;CAC7G,kBAAkB;EAAE,OAAO;EAAmB,WAAW;CAAiB;CAC1E,+BAA+B;EAAE,OAAO;EAAgC,WAAW;CAAiB;AACtG;AAEA,MAAa,kBAAkB,OAAO,KAAK,aAAa;AAExD,MAAa,qBAA0C;CACrD;CAAU;CAAc;CAAgB;CACxC;CAAa;CAAiB;CAAW;CACzC;CAAe;CAAY;AAC7B;AAEA,SAAgB,qBAAqB,OAA4C;CAC/E,OAAO,cAAc,MAAM,CAAC;AAC9B"}

package/dist/esm/utils/cloud-hosts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloud-hosts.d.ts","names":[],"sources":["../../../src/utils/cloud-hosts.tsx"],"mappings":";;AAcA;;;;;AAsBA;;;;;;;;cAtBa,gBAAA,EAAkB,aAAA;AAwC/B;;;;;AASA;AATA,iBAlBgB,sBAAA,CAAuB,YAAA;EAA4C,SAAA;EAAmB,QAAA;AAAA;;;;;;;iBAkBtF,sBAAA,CAAuB,MAAA;;;;;;iBASvB,qBAAA,CAAsB,MAAA"}
+{"version":3,"file":"cloud-hosts.d.ts","names":[],"sources":["../../../src/utils/cloud-hosts.tsx"],"mappings":";;AAcA;;;;AAA4C;AAsB5C;;;;;;;;cAtBa,gBAAA,EAAkB,aAAa;AAwC5C;;;;AAAqD;AASrD;AATA,iBAlBgB,sBAAA,CAAuB,YAAA;EAA4C,SAAA;EAAmB,QAAA;AAAA;;;;;;;iBAkBtF,sBAAA,CAAuB,MAAc;;;;;;iBASrC,qBAAA,CAAsB,MAAc"}