@hexclave/shared 1.0.41 → 1.0.43

package/dist/utils/auth-methods.js

@@ -1,5 +1,4 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/utils/auth-methods.ts
 const signUpAuthMethodValues = [
 	"password",
@@ -7,7 +6,7 @@ const signUpAuthMethodValues = [
 	"oauth",
 	"passkey"
 ];
-
 //#endregion
 exports.signUpAuthMethodValues = signUpAuthMethodValues;
+
 //# sourceMappingURL=auth-methods.js.map

package/dist/utils/auth-methods.js.map

@@ -1 +1 @@
-{"version":3,"file":"auth-methods.js","names":[],"sources":["../../src/utils/auth-methods.ts"],"sourcesContent":["export const signUpAuthMethodValues = [\n  \"password\",\n  \"otp\",\n  \"oauth\",\n  \"passkey\",\n] as const;\n\nexport type SignUpAuthMethod = typeof signUpAuthMethodValues[number];\n"],"mappings":";;;AAAA,MAAa,yBAAyB;CACpC;CACA;CACA;CACA;CACD"}
+{"version":3,"file":"auth-methods.js","names":[],"sources":["../../src/utils/auth-methods.ts"],"sourcesContent":["export const signUpAuthMethodValues = [\n  \"password\",\n  \"otp\",\n  \"oauth\",\n  \"passkey\",\n] as const;\n\nexport type SignUpAuthMethod = typeof signUpAuthMethodValues[number];\n"],"mappings":";;AAAA,MAAa,yBAAyB;CACpC;CACA;CACA;CACA;AACF"}

package/dist/utils/base64.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base64.d.ts","names":[],"sources":["../../src/utils/base64.tsx"],"mappings":";iBAAgB,YAAA,CAAa,IAAA,EAAM,IAAA,GAAO,OAAA;AAAA,iBAS1B,mBAAA,CAAoB,MAAA"}
+{"version":3,"file":"base64.d.ts","names":[],"sources":["../../src/utils/base64.tsx"],"mappings":";iBAAgB,YAAA,CAAa,IAAA,EAAM,IAAA,GAAO,OAAO;AAAA,iBASjC,mBAAA,CAAoB,MAAc"}

package/dist/utils/base64.js

@@ -1,5 +1,4 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/utils/base64.tsx
 function fileToBase64(file) {
 	return new Promise((resolve, reject) => {
@@ -12,17 +11,8 @@ function fileToBase64(file) {
 function validateBase64Image(base64) {
 	return /^data:image\/(png|jpg|jpeg|gif|bmp|webp);base64,[A-Za-z0-9+/]+={0,2}$|^[A-Za-z0-9+/]+={0,2}$/.test(base64);
 }
-(void 0)?.test("validateBase64Image", ({ expect }) => {
-	expect(validateBase64Image("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==")).toBe(true);
-	expect(validateBase64Image("data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAABAAEDASIAAhEBAxEB/8QAHwAAAQUBA")).toBe(true);
-	expect(validateBase64Image("ABC123")).toBe(true);
-	expect(validateBase64Image("data:text/plain;base64,SGVsbG8gV29ybGQ=")).toBe(false);
-	expect(validateBase64Image("data:image/png;base64,invalid!base64")).toBe(false);
-	expect(validateBase64Image("not a base64 string")).toBe(false);
-	expect(validateBase64Image("")).toBe(false);
-});
-
 //#endregion
 exports.fileToBase64 = fileToBase64;
 exports.validateBase64Image = validateBase64Image;
+
 //# sourceMappingURL=base64.js.map

package/dist/utils/base64.js.map

@@ -1 +1 @@
-{"version":3,"file":"base64.js","names":[],"sources":["../../src/utils/base64.tsx"],"sourcesContent":["export function fileToBase64(file: File): Promise<string> {\n  return new Promise((resolve, reject) => {\n    const reader = new FileReader();\n    reader.readAsDataURL(file);\n    reader.onload = () => resolve(reader.result as string);\n    reader.onerror = error => reject(error);\n  });\n}\n\nexport function validateBase64Image(base64: string): boolean {\n  const base64ImageRegex = /^data:image\\/(png|jpg|jpeg|gif|bmp|webp);base64,[A-Za-z0-9+/]+={0,2}$|^[A-Za-z0-9+/]+={0,2}$/;\n  return base64ImageRegex.test(base64);\n}\nimport.meta.vitest?.test(\"validateBase64Image\", ({ expect }) => {\n  // Valid base64 image strings\n  expect(validateBase64Image(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==\")).toBe(true);\n  expect(validateBase64Image(\"data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAABAAEDASIAAhEBAxEB/8QAHwAAAQUBA\")).toBe(true);\n  expect(validateBase64Image(\"ABC123\")).toBe(true);\n  // Invalid base64 image strings\n  expect(validateBase64Image(\"data:text/plain;base64,SGVsbG8gV29ybGQ=\")).toBe(false);\n  expect(validateBase64Image(\"data:image/png;base64,invalid!base64\")).toBe(false);\n  expect(validateBase64Image(\"not a base64 string\")).toBe(false);\n  expect(validateBase64Image(\"\")).toBe(false);\n});\n"],"mappings":";;;AAAA,SAAgB,aAAa,MAA6B;AACxD,QAAO,IAAI,SAAS,SAAS,WAAW;EACtC,MAAM,SAAS,IAAI,YAAY;AAC/B,SAAO,cAAc,KAAK;AAC1B,SAAO,eAAe,QAAQ,OAAO,OAAiB;AACtD,SAAO,WAAU,UAAS,OAAO,MAAM;GACvC;;AAGJ,SAAgB,oBAAoB,QAAyB;AAE3D,QADyB,+FACD,KAAK,OAAO;;CAEtC,SAAW,KAAC,wBAAc,EAAA,aAAyB;AAEjD,QAAO,oBAAoB,yHAAyH,CAAC,CAAC,KAAK,KAAK;AAChK,QAAO,oBAAoB,mRAAmR,CAAC,CAAC,KAAK,KAAK;AAC1T,QAAO,oBAAoB,SAAS,CAAC,CAAC,KAAK,KAAK;AAEhD,QAAO,oBAAoB,0CAA0C,CAAC,CAAC,KAAK,MAAM;AAClF,QAAO,oBAAoB,uCAAuC,CAAC,CAAC,KAAK,MAAM;AAC/E,QAAO,oBAAoB,sBAAsB,CAAC,CAAC,KAAK,MAAM;AAC9D,QAAO,oBAAoB,GAAG,CAAC,CAAC,KAAK,MAAM;EAC3C"}
+{"version":3,"file":"base64.js","names":[],"sources":["../../src/utils/base64.tsx"],"sourcesContent":["export function fileToBase64(file: File): Promise<string> {\n  return new Promise((resolve, reject) => {\n    const reader = new FileReader();\n    reader.readAsDataURL(file);\n    reader.onload = () => resolve(reader.result as string);\n    reader.onerror = error => reject(error);\n  });\n}\n\nexport function validateBase64Image(base64: string): boolean {\n  const base64ImageRegex = /^data:image\\/(png|jpg|jpeg|gif|bmp|webp);base64,[A-Za-z0-9+/]+={0,2}$|^[A-Za-z0-9+/]+={0,2}$/;\n  return base64ImageRegex.test(base64);\n}\nimport.meta.vitest?.test(\"validateBase64Image\", ({ expect }) => {\n  // Valid base64 image strings\n  expect(validateBase64Image(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==\")).toBe(true);\n  expect(validateBase64Image(\"data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAABAAEDASIAAhEBAxEB/8QAHwAAAQUBA\")).toBe(true);\n  expect(validateBase64Image(\"ABC123\")).toBe(true);\n  // Invalid base64 image strings\n  expect(validateBase64Image(\"data:text/plain;base64,SGVsbG8gV29ybGQ=\")).toBe(false);\n  expect(validateBase64Image(\"data:image/png;base64,invalid!base64\")).toBe(false);\n  expect(validateBase64Image(\"not a base64 string\")).toBe(false);\n  expect(validateBase64Image(\"\")).toBe(false);\n});\n"],"mappings":";;AAAA,SAAgB,aAAa,MAA6B;CACxD,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,MAAM,SAAS,IAAI,WAAW;EAC9B,OAAO,cAAc,IAAI;EACzB,OAAO,eAAe,QAAQ,OAAO,MAAgB;EACrD,OAAO,WAAU,UAAS,OAAO,KAAK;CACxC,CAAC;AACH;AAEA,SAAgB,oBAAoB,QAAyB;CAE3D,OAAO,+FAAiB,KAAK,MAAM;AACrC"}

package/dist/utils/booleans.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"booleans.d.ts","names":[],"sources":["../../src/utils/booleans.tsx"],"mappings":";KAAY,MAAA,MAAY,CAAA;AAAA,KACZ,KAAA,MAAW,CAAA;AAAA,iBAEP,QAAA,GAAA,CAAY,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,CAAA,GAAI,MAAA,CAAO,CAAA;AAAA,iBAgB3C,OAAA,GAAA,CAAW,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,CAAA,GAAI,KAAA,CAAM,CAAA"}
+{"version":3,"file":"booleans.d.ts","names":[],"sources":["../../src/utils/booleans.tsx"],"mappings":";KAAY,MAAA,MAAY,CAAC;AAAA,KACb,KAAA,MAAW,CAAC;AAAA,iBAER,QAAA,IAAY,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,CAAA,GAAI,MAAA,CAAO,CAAA;AAAA,iBAgB3C,OAAA,IAAW,KAAA,EAAO,CAAA,GAAI,KAAA,IAAS,CAAA,GAAI,KAAA,CAAM,CAAA"}

package/dist/utils/booleans.js

@@ -1,38 +1,13 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#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
 exports.isFalsy = isFalsy;
 exports.isTruthy = isTruthy;
+
 //# sourceMappingURL=booleans.js.map

package/dist/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/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/utils/browser-compat.js

@@ -1,5 +1,4 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/utils/browser-compat.tsx
 function getBrowserCompatibilityReport() {
 	const test = (snippet) => {
@@ -17,7 +16,7 @@ function getBrowserCompatibilityReport() {
 		cryptoUuid: test("crypto.randomUUID()")
 	};
 }
-
 //#endregion
 exports.getBrowserCompatibilityReport = getBrowserCompatibilityReport;
+
 //# sourceMappingURL=browser-compat.js.map

package/dist/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/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/utils/bytes.js

@@ -1,10 +1,8 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_chunk = require('../chunk-BE-pF4vm.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let __errors_js = require("./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"]
@@ -12,38 +10,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 __errors_js.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 __errors_js.HexclaveAssertionError(`Invalid base32 character: ${character}`);
 	const index = crockfordAlphabet.indexOf(character.toUpperCase());
 	if (index === -1) throw new __errors_js.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;
@@ -60,14 +36,6 @@ function encodeBase32(input) {
 	if (!isBase32(output)) throw new __errors_js.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 __errors_js.HexclaveAssertionError("Invalid base32 string");
 	const output = new Uint8Array(input.length * 5 / 8 | 0);
@@ -88,168 +56,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 __errors_js.HexclaveAssertionError(`encodeBase64 test case ${i} failed`);
-		if (decodeBase64(encoded).some((b, i) => b !== input[i])) throw new __errors_js.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 __errors_js.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 __errors_js.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;
@@ -258,35 +83,13 @@ 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
 exports.decodeBase32 = decodeBase32;
 exports.decodeBase64 = decodeBase64;
@@ -301,4 +104,5 @@ exports.isBase32 = isBase32;
 exports.isBase64 = isBase64;
 exports.isBase64Url = isBase64Url;
 exports.toHexString = toHexString;
+
 //# sourceMappingURL=bytes.js.map

package/dist/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":["HexclaveAssertionError"],"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/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/utils/caches.js

@@ -1,11 +1,9 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_chunk = require('../chunk-BE-pF4vm.js');
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 let __env_js = require("./env.js");
 let __maps_js = require("./maps.js");
 let __objects_js = require("./objects.js");
 let __promises_js = require("./promises.js");
 let __stores_js = require("./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.
@@ -19,31 +17,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;
@@ -181,8 +154,8 @@ var AsyncValueCache = class {
 		} };
 	}
 };
-
 //#endregion
 exports.AsyncCache = AsyncCache;
 exports.cacheFunction = cacheFunction;
+
 //# sourceMappingURL=caches.js.map