@hexclave/shared 1.0.0

package/dist/hooks/use-hover.js

@@ -0,0 +1,61 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
+let react = require("react");
+let ___utils_react_js = require("../utils/react.js");
+
+//#region src/hooks/use-hover.tsx
+function useHover(ref, options = {}) {
+	const counter = (0, ___utils_react_js.useRefState)(0);
+	(0, react.useLayoutEffect)(() => {
+		const el = ref.current;
+		if (!el) return;
+		let incr = 0;
+		let prevInside = false;
+		const contains = (r, x, y) => x >= r.left && x <= r.right && y >= r.top && y <= r.bottom;
+		const enter = () => {
+			incr++;
+			counter.set((c) => c + 1);
+			if (counter.current === 1) options.onMouseEnter?.();
+		};
+		const leave = () => {
+			incr--;
+			requestAnimationFrame(() => {
+				requestAnimationFrame(() => {
+					counter.set((c) => c - 1);
+					if (counter.current === 0) options.onMouseLeave?.();
+				});
+			});
+		};
+		const topMatchesTarget = (x, y) => {
+			const top = document.elementFromPoint(x, y);
+			return !!(top && (top === el || el.contains(top)));
+		};
+		const processPoint = (x, y) => {
+			const inside = contains(el.getBoundingClientRect(), x, y) && topMatchesTarget(x, y);
+			if (inside && !prevInside) enter();
+			else if (!inside && prevInside) leave();
+			prevInside = inside;
+		};
+		const onMove = (e) => {
+			if (e.pointerType !== "mouse") return;
+			const batch = e.getCoalescedEvents();
+			if (batch.length) for (let eventIndex = 0; eventIndex < batch.length - 1; eventIndex++) {
+				const e1 = batch[eventIndex];
+				const e2 = batch[eventIndex + 1];
+				const steps = 10;
+				for (let i = 0; i <= steps; i++) processPoint(e1.clientX + (e2.clientX - e1.clientX) * i / steps, e1.clientY + (e2.clientY - e1.clientY) * i / steps);
+			}
+			else processPoint(e.clientX, e.clientY);
+		};
+		window.addEventListener("pointermove", onMove, { passive: true });
+		return () => {
+			window.removeEventListener("pointermove", onMove);
+			counter.set((c) => c - incr);
+		};
+	}, []);
+	return counter.current > 0;
+}
+
+//#endregion
+exports.useHover = useHover;
+//# sourceMappingURL=use-hover.js.map

package/dist/hooks/use-hover.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-hover.js","names":[],"sources":["../../src/hooks/use-hover.tsx"],"sourcesContent":["import { useLayoutEffect } from \"react\";\nimport { useRefState } from \"../utils/react\";\n\nexport function useHover<T extends HTMLElement>(\n  ref: React.RefObject<T>,\n  options: {\n    onMouseEnter?: () => void,\n    onMouseLeave?: () => void,\n  } = {},\n): boolean {\n  // Internal counter: mouseenter++ / mouseleave-- (isHovering = counter > 0)\n  const counter = useRefState(0);\n\n  useLayoutEffect(() => {\n    const el = ref.current;\n    if (!el) return;\n    let incr = 0;\n    let prevInside = false;\n\n    const contains = (r: DOMRect, x: number, y: number) =>\n      x >= r.left && x <= r.right && y >= r.top && y <= r.bottom;\n\n    const enter = () => {\n      incr++;\n      counter.set(c => c + 1);\n      if (counter.current === 1) {\n        options.onMouseEnter?.();\n      }\n    };\n\n    const leave = () => {\n      incr--;\n      requestAnimationFrame(() => {\n        requestAnimationFrame(() => {\n          counter.set(c => c - 1);\n          if (counter.current === 0) {\n            options.onMouseLeave?.();\n          }\n        });\n      });\n    };\n\n    const topMatchesTarget = (x: number, y: number) => {\n      const top = document.elementFromPoint(x, y);\n      return !!(top && (top === el || el.contains(top)));\n    };\n\n    const processPoint = (x: number, y: number) => {\n      const rect = el.getBoundingClientRect();\n\n      // True “hoverability”: inside rect AND not occluded by others\n      const inside = contains(rect, x, y) && topMatchesTarget(x, y);\n      if (inside && !prevInside) {\n        enter();\n      } else if (!inside && prevInside) {\n        leave();\n      }\n      prevInside = inside;\n    };\n\n    const onMove = (e: PointerEvent) => {\n      if (e.pointerType !== \"mouse\") return; // keep it hover-only\n      // Use coalesced points when available\n      const batch = e.getCoalescedEvents();\n      if (batch.length) {\n        for (let eventIndex = 0; eventIndex < batch.length - 1; eventIndex++) {\n          const e1 = batch[eventIndex];\n          const e2 = batch[eventIndex + 1];\n          const steps = 10;\n          for (let i = 0; i <= steps; i++) {\n            processPoint(e1.clientX + (e2.clientX - e1.clientX) * i / steps, e1.clientY + (e2.clientY - e1.clientY) * i / steps);\n          }\n        }\n      } else {\n        processPoint(e.clientX, e.clientY);\n      }\n    };\n\n    window.addEventListener(\"pointermove\", onMove, { passive: true });\n\n    return () => {\n      window.removeEventListener(\"pointermove\", onMove);\n      counter.set(c => c - incr);\n    };\n  }, []);\n\n  return counter.current > 0;\n}\n"],"mappings":";;;;;;AAGA,SAAgB,SACd,KACA,UAGI,EAAE,EACG;CAET,MAAM,6CAAsB,EAAE;AAE9B,kCAAsB;EACpB,MAAM,KAAK,IAAI;AACf,MAAI,CAAC,GAAI;EACT,IAAI,OAAO;EACX,IAAI,aAAa;EAEjB,MAAM,YAAY,GAAY,GAAW,MACvC,KAAK,EAAE,QAAQ,KAAK,EAAE,SAAS,KAAK,EAAE,OAAO,KAAK,EAAE;EAEtD,MAAM,cAAc;AAClB;AACA,WAAQ,KAAI,MAAK,IAAI,EAAE;AACvB,OAAI,QAAQ,YAAY,EACtB,SAAQ,gBAAgB;;EAI5B,MAAM,cAAc;AAClB;AACA,+BAA4B;AAC1B,gCAA4B;AAC1B,aAAQ,KAAI,MAAK,IAAI,EAAE;AACvB,SAAI,QAAQ,YAAY,EACtB,SAAQ,gBAAgB;MAE1B;KACF;;EAGJ,MAAM,oBAAoB,GAAW,MAAc;GACjD,MAAM,MAAM,SAAS,iBAAiB,GAAG,EAAE;AAC3C,UAAO,CAAC,EAAE,QAAQ,QAAQ,MAAM,GAAG,SAAS,IAAI;;EAGlD,MAAM,gBAAgB,GAAW,MAAc;GAI7C,MAAM,SAAS,SAHF,GAAG,uBAAuB,EAGT,GAAG,EAAE,IAAI,iBAAiB,GAAG,EAAE;AAC7D,OAAI,UAAU,CAAC,WACb,QAAO;YACE,CAAC,UAAU,WACpB,QAAO;AAET,gBAAa;;EAGf,MAAM,UAAU,MAAoB;AAClC,OAAI,EAAE,gBAAgB,QAAS;GAE/B,MAAM,QAAQ,EAAE,oBAAoB;AACpC,OAAI,MAAM,OACR,MAAK,IAAI,aAAa,GAAG,aAAa,MAAM,SAAS,GAAG,cAAc;IACpE,MAAM,KAAK,MAAM;IACjB,MAAM,KAAK,MAAM,aAAa;IAC9B,MAAM,QAAQ;AACd,SAAK,IAAI,IAAI,GAAG,KAAK,OAAO,IAC1B,cAAa,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,IAAI,OAAO,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,IAAI,MAAM;;OAIxH,cAAa,EAAE,SAAS,EAAE,QAAQ;;AAItC,SAAO,iBAAiB,eAAe,QAAQ,EAAE,SAAS,MAAM,CAAC;AAEjE,eAAa;AACX,UAAO,oBAAoB,eAAe,OAAO;AACjD,WAAQ,KAAI,MAAK,IAAI,KAAK;;IAE3B,EAAE,CAAC;AAEN,QAAO,QAAQ,UAAU"}

package/dist/hooks/use-strict-memo.d.ts

@@ -0,0 +1,10 @@
+//#region src/hooks/use-strict-memo.d.ts
+/**
+ * Like memo, but minimizes recomputation of the value at all costs (instead of useMemo which recomputes whenever the renderer feels like it).
+ *
+ * The most recent value will be kept from garbage collection until one of the dependencies becomes unreachable. This may be true even after the component no longer renders. Be wary of memory leaks.
+ */
+declare function useStrictMemo<T>(callback: () => T, dependencies: any[]): T;
+//#endregion
+export { useStrictMemo };
+//# sourceMappingURL=use-strict-memo.d.ts.map

package/dist/hooks/use-strict-memo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-strict-memo.d.ts","names":[],"sources":["../../src/hooks/use-strict-memo.tsx"],"mappings":";;AA0IA;;;;iBAAgB,aAAA,GAAA,CAAiB,QAAA,QAAgB,CAAA,EAAG,YAAA,UAAsB,CAAA"}

package/dist/hooks/use-strict-memo.js

@@ -0,0 +1,121 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
+let react = require("react");
+let ___utils_results_js = require("../utils/results.js");
+
+//#region src/hooks/use-strict-memo.tsx
+const cached = /* @__PURE__ */ new Map();
+function unwrapFromInner(dependencies, inner) {
+	if (dependencies.length === 0 !== "isNotNestedMap" in inner) return ___utils_results_js.Result.error(void 0);
+	if ("isNotNestedMap" in inner) if (dependencies.length === 0) return ___utils_results_js.Result.ok(inner.value);
+	else return ___utils_results_js.Result.error(void 0);
+	else if (dependencies.length === 0) return ___utils_results_js.Result.error(void 0);
+	else {
+		const [key, ...rest] = dependencies;
+		const newInner = inner.get(key);
+		if (!newInner) return ___utils_results_js.Result.error(void 0);
+		return unwrapFromInner(rest, newInner);
+	}
+}
+(void 0)?.test("unwrapFromInner", ({ expect }) => {
+	const nonNestedMap = {
+		isNotNestedMap: true,
+		value: "test"
+	};
+	const result1 = unwrapFromInner([], nonNestedMap);
+	expect(result1.status).toBe("ok");
+	if (result1.status === "ok") expect(result1.data).toBe("test");
+	expect(unwrapFromInner(["key"], nonNestedMap).status).toBe("error");
+	const nestedMap = new Map([["key", {
+		isNotNestedMap: true,
+		value: "test"
+	}]]);
+	expect(unwrapFromInner([], nestedMap).status).toBe("error");
+	const result2 = unwrapFromInner(["key"], nestedMap);
+	expect(result2.status).toBe("ok");
+	if (result2.status === "ok") expect(result2.data).toBe("test");
+	expect(unwrapFromInner(["wrongKey"], nestedMap).status).toBe("error");
+	const deeplyNestedMap = new Map([["key1", new Map([["key2", {
+		isNotNestedMap: true,
+		value: "nested"
+	}]])]]);
+	const result3 = unwrapFromInner(["key1", "key2"], deeplyNestedMap);
+	expect(result3.status).toBe("ok");
+	if (result3.status === "ok") expect(result3.data).toBe("nested");
+	expect(unwrapFromInner(["key1", "wrongKey"], deeplyNestedMap).status).toBe("error");
+});
+function wrapToInner(dependencies, value) {
+	if (dependencies.length === 0) return {
+		isNotNestedMap: true,
+		value
+	};
+	const [key, ...rest] = dependencies;
+	const inner = wrapToInner(rest, value);
+	return new (typeof key === "object" && key !== null || typeof key === "symbol" && Symbol.keyFor(key) === void 0 ? WeakMap : Map)([[key, inner]]);
+}
+(void 0)?.test("wrapToInner", ({ expect }) => {
+	expect(wrapToInner([], "test")).toEqual({
+		isNotNestedMap: true,
+		value: "test"
+	});
+	const singleResult = wrapToInner(["key"], "test");
+	expect(singleResult instanceof Map).toBe(true);
+	expect(singleResult.get("key")).toEqual({
+		isNotNestedMap: true,
+		value: "test"
+	});
+	const multiResult = wrapToInner(["key1", "key2"], "test");
+	expect(multiResult instanceof Map).toBe(true);
+	const innerMap = multiResult.get("key1");
+	expect(innerMap instanceof Map).toBe(true);
+	expect(innerMap.get("key2")).toEqual({
+		isNotNestedMap: true,
+		value: "test"
+	});
+	const obj = { test: true };
+	const objResult = wrapToInner([obj], "test");
+	expect(objResult instanceof WeakMap).toBe(true);
+	expect(objResult.get(obj)).toEqual({
+		isNotNestedMap: true,
+		value: "test"
+	});
+	const symbolObj = Symbol("test");
+	const symbolResult = wrapToInner([symbolObj], "test");
+	expect(symbolResult instanceof WeakMap).toBe(true);
+	expect(symbolResult.get(symbolObj)).toEqual({
+		isNotNestedMap: true,
+		value: "test"
+	});
+	const registeredSymbol = Symbol.for("test");
+	const registeredSymbolResult = wrapToInner([registeredSymbol], "test");
+	expect(registeredSymbolResult instanceof Map).toBe(true);
+	expect(registeredSymbolResult.get(registeredSymbol)).toEqual({
+		isNotNestedMap: true,
+		value: "test"
+	});
+});
+/**
+* Like memo, but minimizes recomputation of the value at all costs (instead of useMemo which recomputes whenever the renderer feels like it).
+*
+* The most recent value will be kept from garbage collection until one of the dependencies becomes unreachable. This may be true even after the component no longer renders. Be wary of memory leaks.
+*/
+function useStrictMemo(callback, dependencies) {
+	const id = (0, react.useId)();
+	(0, react.useInsertionEffect)(() => {
+		return () => {
+			cached.delete(id);
+		};
+	}, [id]);
+	const c = cached.get(id);
+	if (c) {
+		const unwrapped = unwrapFromInner(dependencies, c);
+		if (unwrapped.status === "ok") return unwrapped.data;
+	}
+	const value = callback();
+	cached.set(id, wrapToInner(dependencies, value));
+	return value;
+}
+
+//#endregion
+exports.useStrictMemo = useStrictMemo;
+//# sourceMappingURL=use-strict-memo.js.map

package/dist/hooks/use-strict-memo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-strict-memo.js","names":[],"sources":["../../src/hooks/use-strict-memo.tsx"],"sourcesContent":["import { useId, useInsertionEffect, useMemo } from \"react\";\nimport { Result } from \"../utils/results\";\n\ntype CacheInner = Map<unknown, CacheInner> | WeakMap<WeakKey, CacheInner> | { isNotNestedMap: true, value: any };\n\nconst cached = new Map<string, CacheInner>();\n\nfunction unwrapFromInner(dependencies: any[], inner: CacheInner): Result<any, void> {\n  if ((dependencies.length === 0) !== (\"isNotNestedMap\" in inner)) {\n    return Result.error(undefined);\n  }\n  if (\"isNotNestedMap\" in inner) {\n    if (dependencies.length === 0) {\n      return Result.ok(inner.value);\n    } else {\n      return Result.error(undefined);\n    }\n  } else {\n    if (dependencies.length === 0) {\n      return Result.error(undefined);\n    } else {\n      const [key, ...rest] = dependencies;\n      const newInner = inner.get(key);\n      if (!newInner) {\n        return Result.error(undefined);\n      }\n      return unwrapFromInner(rest, newInner);\n    }\n  }\n}\nimport.meta.vitest?.test(\"unwrapFromInner\", ({ expect }) => {\n  // Test with empty dependencies and non-nested map\n  const nonNestedMap = { isNotNestedMap: true, value: \"test\" } as CacheInner;\n  const result1 = unwrapFromInner([], nonNestedMap);\n  expect(result1.status).toBe(\"ok\");\n  if (result1.status === \"ok\") {\n    expect(result1.data).toBe(\"test\");\n  }\n\n  // Test with non-empty dependencies and non-nested map (should error)\n  expect(unwrapFromInner([\"key\"], nonNestedMap).status).toBe(\"error\");\n\n  // Test with empty dependencies and nested map (should error)\n  const nestedMap = new Map([[\"key\", { isNotNestedMap: true, value: \"test\" } as CacheInner]]) as CacheInner;\n  expect(unwrapFromInner([], nestedMap).status).toBe(\"error\");\n\n  // Test with matching dependencies and nested map\n  const result2 = unwrapFromInner([\"key\"], nestedMap);\n  expect(result2.status).toBe(\"ok\");\n  if (result2.status === \"ok\") {\n    expect(result2.data).toBe(\"test\");\n  }\n\n  // Test with non-matching dependencies and nested map\n  expect(unwrapFromInner([\"wrongKey\"], nestedMap).status).toBe(\"error\");\n\n  // Test with deeply nested map\n  const deeplyNestedMap = new Map([\n    [\"key1\", new Map([\n      [\"key2\", { isNotNestedMap: true, value: \"nested\" } as CacheInner]\n    ]) as CacheInner]\n  ]) as CacheInner;\n\n  const result3 = unwrapFromInner([\"key1\", \"key2\"], deeplyNestedMap);\n  expect(result3.status).toBe(\"ok\");\n  if (result3.status === \"ok\") {\n    expect(result3.data).toBe(\"nested\");\n  }\n\n  // Test with partial match in deeply nested map\n  expect(unwrapFromInner([\"key1\", \"wrongKey\"], deeplyNestedMap).status).toBe(\"error\");\n});\n\nfunction wrapToInner(dependencies: any[], value: any): CacheInner {\n  if (dependencies.length === 0) {\n    return { isNotNestedMap: true, value };\n  }\n  const [key, ...rest] = dependencies;\n  const inner = wrapToInner(rest, value);\n\n  const isObject = (typeof key === \"object\" && key !== null);\n  const isUnregisteredSymbol = (typeof key === \"symbol\" && Symbol.keyFor(key) === undefined);\n  const isWeak = isObject || isUnregisteredSymbol;\n  const mapType = isWeak ? WeakMap : Map;\n\n  return new mapType([[key, inner]]);\n}\nimport.meta.vitest?.test(\"wrapToInner\", ({ expect }) => {\n  // Test with empty dependencies\n  const emptyResult = wrapToInner([], \"test\");\n  expect(emptyResult).toEqual({ isNotNestedMap: true, value: \"test\" });\n\n  // Test with single string dependency\n  const singleResult = wrapToInner([\"key\"], \"test\");\n  expect(singleResult instanceof Map).toBe(true);\n  // Need to cast to access Map methods\n  const singleMap = singleResult as Map<unknown, CacheInner>;\n  expect(singleMap.get(\"key\")).toEqual({ isNotNestedMap: true, value: \"test\" });\n\n  // Test with multiple string dependencies\n  const multiResult = wrapToInner([\"key1\", \"key2\"], \"test\");\n  expect(multiResult instanceof Map).toBe(true);\n  // Need to cast to access Map methods\n  const multiMap = multiResult as Map<unknown, CacheInner>;\n  const innerMap = multiMap.get(\"key1\") as Map<unknown, CacheInner>;\n  expect(innerMap instanceof Map).toBe(true);\n  expect(innerMap.get(\"key2\")).toEqual({ isNotNestedMap: true, value: \"test\" });\n\n  // Test with object dependency (should use WeakMap)\n  const obj = { test: true };\n  const objResult = wrapToInner([obj], \"test\");\n  expect(objResult instanceof WeakMap).toBe(true);\n  // Need to cast to access WeakMap methods\n  const objMap = objResult as WeakMap<WeakKey, CacheInner>;\n  expect(objMap.get(obj)).toEqual({ isNotNestedMap: true, value: \"test\" });\n\n  // Test with unregistered symbol dependency (should use WeakMap)\n  const symbolObj = Symbol(\"test\");\n  const symbolResult = wrapToInner([symbolObj], \"test\");\n  expect(symbolResult instanceof WeakMap).toBe(true);\n  // Need to cast to access WeakMap methods\n  const symbolMap = symbolResult as WeakMap<WeakKey, CacheInner>;\n  expect(symbolMap.get(symbolObj as unknown as object)).toEqual({ isNotNestedMap: true, value: \"test\" });\n\n  // Test with registered symbol dependency (should use Map)\n  const registeredSymbol = Symbol.for(\"test\");\n  const registeredSymbolResult = wrapToInner([registeredSymbol], \"test\");\n  expect(registeredSymbolResult instanceof Map).toBe(true);\n  // Need to cast to access Map methods\n  const registeredSymbolMap = registeredSymbolResult as Map<unknown, CacheInner>;\n  expect(registeredSymbolMap.get(registeredSymbol)).toEqual({ isNotNestedMap: true, value: \"test\" });\n});\n\n/**\n * Like memo, but minimizes recomputation of the value at all costs (instead of useMemo which recomputes whenever the renderer feels like it).\n *\n * The most recent value will be kept from garbage collection until one of the dependencies becomes unreachable. This may be true even after the component no longer renders. Be wary of memory leaks.\n */\nexport function useStrictMemo<T>(callback: () => T, dependencies: any[]): T {\n  const id = useId();\n  useInsertionEffect(() => {\n    return () => {\n      cached.delete(id);\n    };\n  }, [id]);\n\n  const c = cached.get(id);\n  if (c) {\n    const unwrapped = unwrapFromInner(dependencies, c);\n    if (unwrapped.status === \"ok\") {\n      return unwrapped.data;\n    }\n  }\n  const value = callback();\n  cached.set(id, wrapToInner(dependencies, value));\n  return value;\n}\n"],"mappings":"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"}

package/dist/index-D9ysacya.d.ts

@@ -0,0 +1,153 @@
+//#region ../../node_modules/.pnpm/@simplewebauthn+types@11.0.0/node_modules/@simplewebauthn/types/types/dom.d.ts
+interface AuthenticationExtensionsClientInputs {
+  appid?: string;
+  credProps?: boolean;
+  hmacCreateSecret?: boolean;
+}
+interface AuthenticationExtensionsClientOutputs {
+  appid?: boolean;
+  credProps?: CredentialPropertiesOutput;
+  hmacCreateSecret?: boolean;
+}
+interface AuthenticatorSelectionCriteria {
+  authenticatorAttachment?: AuthenticatorAttachment;
+  requireResidentKey?: boolean;
+  residentKey?: ResidentKeyRequirement;
+  userVerification?: UserVerificationRequirement;
+}
+interface PublicKeyCredentialParameters {
+  alg: COSEAlgorithmIdentifier;
+  type: PublicKeyCredentialType;
+}
+interface CredentialPropertiesOutput {
+  rk?: boolean;
+}
+interface PublicKeyCredentialRpEntity extends PublicKeyCredentialEntity {
+  id?: string;
+}
+interface PublicKeyCredentialEntity {
+  name: string;
+}
+type AttestationConveyancePreference = "direct" | "enterprise" | "indirect" | "none";
+type COSEAlgorithmIdentifier = number;
+type UserVerificationRequirement = "discouraged" | "preferred" | "required";
+type AuthenticatorAttachment = "cross-platform" | "platform";
+type ResidentKeyRequirement = "discouraged" | "preferred" | "required";
+type PublicKeyCredentialType = "public-key";
+//#endregion
+//#region ../../node_modules/.pnpm/@simplewebauthn+types@11.0.0/node_modules/@simplewebauthn/types/types/index.d.ts
+/**
+ * A variant of PublicKeyCredentialCreationOptions suitable for JSON transmission to the browser to
+ * (eventually) get passed into navigator.credentials.create(...) in the browser.
+ *
+ * This should eventually get replaced with official TypeScript DOM types when WebAuthn L3 types
+ * eventually make it into the language:
+ *
+ * https://w3c.github.io/webauthn/#dictdef-publickeycredentialcreationoptionsjson
+ */
+interface PublicKeyCredentialCreationOptionsJSON {
+  rp: PublicKeyCredentialRpEntity;
+  user: PublicKeyCredentialUserEntityJSON;
+  challenge: Base64URLString;
+  pubKeyCredParams: PublicKeyCredentialParameters[];
+  timeout?: number;
+  excludeCredentials?: PublicKeyCredentialDescriptorJSON[];
+  authenticatorSelection?: AuthenticatorSelectionCriteria;
+  attestation?: AttestationConveyancePreference;
+  extensions?: AuthenticationExtensionsClientInputs;
+}
+/**
+ * A variant of PublicKeyCredentialRequestOptions suitable for JSON transmission to the browser to
+ * (eventually) get passed into navigator.credentials.get(...) in the browser.
+ */
+interface PublicKeyCredentialRequestOptionsJSON {
+  challenge: Base64URLString;
+  timeout?: number;
+  rpId?: string;
+  allowCredentials?: PublicKeyCredentialDescriptorJSON[];
+  userVerification?: UserVerificationRequirement;
+  extensions?: AuthenticationExtensionsClientInputs;
+}
+/**
+ * https://w3c.github.io/webauthn/#dictdef-publickeycredentialdescriptorjson
+ */
+interface PublicKeyCredentialDescriptorJSON {
+  id: Base64URLString;
+  type: PublicKeyCredentialType;
+  transports?: AuthenticatorTransportFuture[];
+}
+/**
+ * https://w3c.github.io/webauthn/#dictdef-publickeycredentialuserentityjson
+ */
+interface PublicKeyCredentialUserEntityJSON {
+  id: string;
+  name: string;
+  displayName: string;
+}
+/**
+ * A slightly-modified RegistrationCredential to simplify working with ArrayBuffers that
+ * are Base64URL-encoded in the browser so that they can be sent as JSON to the server.
+ *
+ * https://w3c.github.io/webauthn/#dictdef-registrationresponsejson
+ */
+interface RegistrationResponseJSON {
+  id: Base64URLString;
+  rawId: Base64URLString;
+  response: AuthenticatorAttestationResponseJSON;
+  authenticatorAttachment?: AuthenticatorAttachment;
+  clientExtensionResults: AuthenticationExtensionsClientOutputs;
+  type: PublicKeyCredentialType;
+}
+/**
+ * A slightly-modified AuthenticationCredential to simplify working with ArrayBuffers that
+ * are Base64URL-encoded in the browser so that they can be sent as JSON to the server.
+ *
+ * https://w3c.github.io/webauthn/#dictdef-authenticationresponsejson
+ */
+interface AuthenticationResponseJSON {
+  id: Base64URLString;
+  rawId: Base64URLString;
+  response: AuthenticatorAssertionResponseJSON;
+  authenticatorAttachment?: AuthenticatorAttachment;
+  clientExtensionResults: AuthenticationExtensionsClientOutputs;
+  type: PublicKeyCredentialType;
+}
+/**
+ * A slightly-modified AuthenticatorAttestationResponse to simplify working with ArrayBuffers that
+ * are Base64URL-encoded in the browser so that they can be sent as JSON to the server.
+ *
+ * https://w3c.github.io/webauthn/#dictdef-authenticatorattestationresponsejson
+ */
+interface AuthenticatorAttestationResponseJSON {
+  clientDataJSON: Base64URLString;
+  attestationObject: Base64URLString;
+  authenticatorData?: Base64URLString;
+  transports?: AuthenticatorTransportFuture[];
+  publicKeyAlgorithm?: COSEAlgorithmIdentifier;
+  publicKey?: Base64URLString;
+}
+/**
+ * A slightly-modified AuthenticatorAssertionResponse to simplify working with ArrayBuffers that
+ * are Base64URL-encoded in the browser so that they can be sent as JSON to the server.
+ *
+ * https://w3c.github.io/webauthn/#dictdef-authenticatorassertionresponsejson
+ */
+interface AuthenticatorAssertionResponseJSON {
+  clientDataJSON: Base64URLString;
+  authenticatorData: Base64URLString;
+  signature: Base64URLString;
+  userHandle?: Base64URLString;
+}
+/**
+ * An attempt to communicate that this isn't just any string, but a Base64URL-encoded string
+ */
+type Base64URLString = string;
+/**
+ * A super class of TypeScript's `AuthenticatorTransport` that includes support for the latest
+ * transports. Should eventually be replaced by TypeScript's when TypeScript gets updated to
+ * know about it (sometime after 4.6.3)
+ */
+type AuthenticatorTransportFuture = 'ble' | 'cable' | 'hybrid' | 'internal' | 'nfc' | 'smart-card' | 'usb';
+//#endregion
+export { RegistrationResponseJSON as a, PublicKeyCredentialRequestOptionsJSON as i, AuthenticatorAttestationResponseJSON as n, PublicKeyCredentialCreationOptionsJSON as r, AuthenticationResponseJSON as t };
+//# sourceMappingURL=index-D9ysacya.d.ts.map

package/dist/index-D9ysacya.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-D9ysacya.d.ts","names":["AuthenticatorAssertionResponse","ArrayBuffer","AuthenticatorResponse","authenticatorData","signature","userHandle","AuthenticatorAttestationResponse","COSEAlgorithmIdentifier","attestationObject","getAuthenticatorData","getPublicKey","getPublicKeyAlgorithm","getTransports","AuthenticationExtensionsClientInputs","appid","credProps","hmacCreateSecret","AuthenticationExtensionsClientOutputs","CredentialPropertiesOutput","AuthenticatorSelectionCriteria","AuthenticatorAttachment","ResidentKeyRequirement","UserVerificationRequirement","authenticatorAttachment","requireResidentKey","residentKey","userVerification","Crypto","T","SubtleCrypto","ArrayBufferView","subtle","getRandomValues","array","randomUUID","PublicKeyCredential","Credential","rawId","response","getClientExtensionResults","PublicKeyCredentialCreationOptions","AttestationConveyancePreference","BufferSource","PublicKeyCredentialDescriptor","PublicKeyCredentialParameters","PublicKeyCredentialRpEntity","PublicKeyCredentialUserEntity","attestation","authenticatorSelection","challenge","excludeCredentials","extensions","pubKeyCredParams","rp","timeout","user","AuthenticatorTransport","PublicKeyCredentialType","id","transports","type","alg","PublicKeyCredentialRequestOptions","allowCredentials","rpId","PublicKeyCredentialEntity","displayName","clientDataJSON","rk","AlgorithmIdentifier","RsaOaepParams","AesCtrParams","AesCbcParams","AesGcmParams","CryptoKey","Promise","EcdhKeyDeriveParams","HkdfParams","Pbkdf2Params","AesDerivedKeyParams","HmacImportParams","KeyUsage","JsonWebKey","KeyFormat","Exclude","RsaHashedKeyGenParams","EcKeyGenParams","ReadonlyArray","CryptoKeyPair","AesKeyGenParams","HmacKeyGenParams","RsaHashedImportParams","EcKeyImportParams","AesKeyAlgorithm","RsaPssParams","EcdsaParams","decrypt","algorithm","key","data","deriveBits","baseKey","length","deriveKey","derivedKeyType","extractable","keyUsages","digest","encrypt","exportKey","format","generateKey","importKey","keyData","sign","unwrapKey","wrappedKey","unwrappingKey","unwrapAlgorithm","unwrappedKeyAlgorithm","verify","wrapKey","wrappingKey","wrapAlgorithm","name","Algorithm","label","counter","iv","additionalData","tagLength","KeyAlgorithm","KeyType","usages","public","HashAlgorithmIdentifier","hash","info","salt","iterations","RsaOtherPrimesInfo","crv","d","dp","dq","e","ext","k","key_ops","kty","n","oth","p","q","qi","use","x","y","RsaKeyGenParams","NamedCurve","namedCurve","privateKey","publicKey","saltLength","r","t","BigInteger","modulusLength","publicExponent","Uint8Array","AttestationConveyancePreference","AuthenticationExtensionsClientInputs","AuthenticationExtensionsClientOutputs","AuthenticatorAssertionResponse","AuthenticatorAttachment","AuthenticatorAttestationResponse","AuthenticatorSelectionCriteria","COSEAlgorithmIdentifier","PublicKeyCredential","PublicKeyCredentialCreationOptions","PublicKeyCredentialDescriptor","PublicKeyCredentialParameters","PublicKeyCredentialRequestOptions","PublicKeyCredentialRpEntity","PublicKeyCredentialType","UserVerificationRequirement","AuthenticatorTransport","Crypto","PublicKeyCredentialUserEntity","PublicKeyCredentialCreationOptionsJSON","PublicKeyCredentialUserEntityJSON","Base64URLString","PublicKeyCredentialDescriptorJSON","rp","user","challenge","pubKeyCredParams","timeout","excludeCredentials","authenticatorSelection","attestation","extensions","PublicKeyCredentialRequestOptionsJSON","rpId","allowCredentials","userVerification","AuthenticatorTransportFuture","id","type","transports","name","displayName","RegistrationCredential","AuthenticatorAttestationResponseFuture","PublicKeyCredentialFuture","response","RegistrationResponseJSON","AuthenticatorAttestationResponseJSON","rawId","authenticatorAttachment","clientExtensionResults","AuthenticationCredential","AuthenticationResponseJSON","AuthenticatorAssertionResponseJSON","clientDataJSON","attestationObject","authenticatorData","publicKeyAlgorithm","publicKey","signature","userHandle","WebAuthnCredential","Uint8Array","counter","getTransports","PublicKeyCredentialDescriptorFuture","Omit","PublicKeyCredentialJSON","Promise","isConditionalMediationAvailable","parseCreationOptionsFromJSON","options","parseRequestOptionsFromJSON","toJSON","CredentialDeviceType"],"sources":["../../../node_modules/.pnpm/@simplewebauthn+types@11.0.0/node_modules/@simplewebauthn/types/types/dom.d.ts","../../../node_modules/.pnpm/@simplewebauthn+types@11.0.0/node_modules/@simplewebauthn/types/types/index.d.ts"],"x_google_ignoreList":[0,1],"mappings":";UAgCiBa,oCAAAA;EACbC,KAAAA;EACAC,SAAAA;EACAC,gBAAAA;AAAAA;AAAAA,UAEaC,qCAAAA;EACbH,KAAAA;EACAC,SAAAA,GAAYG,0BAAAA;EACZF,gBAAAA;AAAAA;AAAAA,UAEaG,8BAAAA;EACbI,uBAAAA,GAA0BH,uBAAAA;EAC1BI,kBAAAA;EACAC,WAAAA,GAAcJ,sBAAAA;EACdK,gBAAAA,GAAmBJ,2BAAAA;AAAAA;AAAAA,UAqDNsB,6BAAAA;EACbiB,GAAAA,EAAKtD,uBAAAA;EACLqD,IAAAA,EAAMH,uBAAAA;AAAAA;AAAAA,UAuBOvC,0BAAAA;EACbkD,EAAAA;AAAAA;AAAAA,UAiDavB,2BAAAA,SAAoCoB,yBAAAA;EACjDP,EAAAA;AAAAA;AAAAA,UAEaO,yBAAAA;EACb2D,IAAAA;AAAAA;AAAAA,KAwHQnF,+BAAAA;AAAAA,KAEAlC,uBAAAA;AAAAA,KACAe,2BAAAA;AAAAA,KACAF,uBAAAA;AAAAA,KACAC,sBAAAA;AAAAA,KAEAoC,uBAAAA;;;;;;;AA5QZ;;;;;UCtBiBoI,sCAAAA;EACbI,EAAAA,EAAIV,2BAAAA;EACJW,IAAAA,EAAMJ,iCAAAA;EACNK,SAAAA,EAAWJ,eAAAA;EACXK,gBAAAA,EAAkBf,6BAAAA;EAClBgB,OAAAA;EACAC,kBAAAA,GAAqBN,iCAAAA;EACrBO,sBAAAA,GAAyBvB,8BAAAA;EACzBwB,WAAAA,GAAc9B,+BAAAA;EACd+B,UAAAA,GAAa9B,oCAAAA;AAAAA;;;;;UAMA+B,qCAAAA;EACbP,SAAAA,EAAWJ,eAAAA;EACXM,OAAAA;EACAM,IAAAA;EACAC,gBAAAA,GAAmBZ,iCAAAA;EACnBa,gBAAAA,GAAmBpB,2BAAAA;EACnBgB,UAAAA,GAAa9B,oCAAAA;AAAAA;;;;UAKAqB,iCAAAA;EACbe,EAAAA,EAAIhB,eAAAA;EACJiB,IAAAA,EAAMxB,uBAAAA;EACNyB,UAAAA,GAAaH,4BAAAA;AAAAA;;ADgFjB;;UC3EiBhB,iCAAAA;EACbiB,EAAAA;EACAG,IAAAA;EACAC,WAAAA;AAAAA;;;ADsPJ;;;;UCxOiBK,wBAAAA;EACbT,EAAAA,EAAIhB,eAAAA;EACJ2B,KAAAA,EAAO3B,eAAAA;EACPwB,QAAAA,EAAUE,oCAAAA;EACVE,uBAAAA,GAA0B7C,uBAAAA;EAC1B8C,sBAAAA,EAAwBhD,qCAAAA;EACxBoC,IAAAA,EAAMxB,uBAAAA;AAAAA;;;ADuOV;;;;UCzNiBsC,0BAAAA;EACbf,EAAAA,EAAIhB,eAAAA;EACJ2B,KAAAA,EAAO3B,eAAAA;EACPwB,QAAAA,EAAUQ,kCAAAA;EACVJ,uBAAAA,GAA0B7C,uBAAAA;EAC1B8C,sBAAAA,EAAwBhD,qCAAAA;EACxBoC,IAAAA,EAAMxB,uBAAAA;AAAAA;;AA7EV;;;;;UAqFiBiC,oCAAAA;EACbO,cAAAA,EAAgBjC,eAAAA;EAChBkC,iBAAAA,EAAmBlC,eAAAA;EACnBmC,iBAAAA,GAAoBnC,eAAAA;EACpBkB,UAAAA,GAAaH,4BAAAA;EACbqB,kBAAAA,GAAqBlD,uBAAAA;EACrBmD,SAAAA,GAAYrC,eAAAA;AAAAA;;;;;;;UAQCgC,kCAAAA;EACbC,cAAAA,EAAgBjC,eAAAA;EAChBmC,iBAAAA,EAAmBnC,eAAAA;EACnBsC,SAAAA,EAAWtC,eAAAA;EACXuC,UAAAA,GAAavC,eAAAA;AAAAA;;;;KAcLA,eAAAA;;;;AA3FZ;;KA6GYe,4BAAAA"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { KnownError, KnownErrors } from "./known-errors.js";
+import { HexclaveClientInterface } from "./interface/client-interface.js";
+import { HexclaveServerInterface } from "./interface/server-interface.js";
+import { HexclaveAdminInterface } from "./interface/admin-interface.js";
+export { HexclaveAdminInterface, HexclaveClientInterface, HexclaveServerInterface, KnownError, KnownErrors };

package/dist/index.js

@@ -0,0 +1,37 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('./chunk-BE-pF4vm.js');
+let __interface_admin_interface_js = require("./interface/admin-interface.js");
+let __interface_client_interface_js = require("./interface/client-interface.js");
+let __interface_server_interface_js = require("./interface/server-interface.js");
+let __known_errors_js = require("./known-errors.js");
+
+Object.defineProperty(exports, 'HexclaveAdminInterface', {
+  enumerable: true,
+  get: function () {
+    return __interface_admin_interface_js.HexclaveAdminInterface;
+  }
+});
+Object.defineProperty(exports, 'HexclaveClientInterface', {
+  enumerable: true,
+  get: function () {
+    return __interface_client_interface_js.HexclaveClientInterface;
+  }
+});
+Object.defineProperty(exports, 'HexclaveServerInterface', {
+  enumerable: true,
+  get: function () {
+    return __interface_server_interface_js.HexclaveServerInterface;
+  }
+});
+Object.defineProperty(exports, 'KnownError', {
+  enumerable: true,
+  get: function () {
+    return __known_errors_js.KnownError;
+  }
+});
+Object.defineProperty(exports, 'KnownErrors', {
+  enumerable: true,
+  get: function () {
+    return __known_errors_js.KnownErrors;
+  }
+});