@vincentt-xr/sdk 2.0.0-alpha.8 → 2.0.0-alpha.9

package/dist/instructions.js

@@ -0,0 +1,1507 @@
+import { jsxs as Vt, jsx as x } from "react/jsx-runtime";
+import { T as Ee, S as Rt } from "./TextLabel-c9BCucOI.js";
+import { useFrame as Z, useThree as De } from "@react-three/fiber";
+import { useState as Ct, useRef as E, useEffect as j, useMemo as R, useCallback as jt } from "react";
+import * as i from "three";
+import { u as Pe } from "./context-DTxSQvp4.js";
+import { s as st, u as qt } from "./useInstructionHold-DOu-RpCM.js";
+import { G as Oo, b as ko, c as Ro, d as vo, a as Ho } from "./useInstructionHold-DOu-RpCM.js";
+import { a as M, H as Ce, X as Kt } from "./index-CIe7eCMH.js";
+import { H as Ot, b as Ae, s as Be, r as vt, B as Le, a as ze, m as Ue } from "./index-JII7huPk.js";
+import { c as Io, d as No, e as Eo, f as Do, g as Po, h as Co, i as Ao, j as Bo, k as Lo } from "./index-JII7huPk.js";
+import { e as Yt, g as We } from "./selectors-DmNaKIwE.js";
+import { c as Ve } from "./SkeletonUtils-C2r90MtN.js";
+import { u as $t } from "./landmarks-bftdwq6Z.js";
+import { a as Fe, b as Ge } from "./getFaceInfo-Cu4xDWiL.js";
+const je = () => {
+  const n = document.createElement("canvas");
+  n.width = n.height = 128;
+  const e = n.getContext("2d"), o = e.createRadialGradient(
+    128 * 0.38,
+    128 * 0.32,
+    128 * 0.05,
+    128 / 2,
+    128 / 2,
+    128 * 0.55
+  );
+  o.addColorStop(0, "#ffffff"), o.addColorStop(0.5, "#eef2f7"), o.addColorStop(0.85, "#c9d3df"), o.addColorStop(1, "#9aa8b8"), e.fillStyle = o, e.fillRect(0, 0, 128, 128);
+  const s = new i.CanvasTexture(n);
+  return s.colorSpace = i.SRGBColorSpace, s;
+}, Ft = 96, qe = (t, n = {}) => {
+  const e = {
+    uHighlight: { value: new Float32Array(Ft) },
+    uHighlightGain: { value: 0 },
+    uCore: { value: n.core ?? 0.5 },
+    uRim: { value: n.rim ?? 0.95 },
+    uWhiten: { value: n.whiten ?? 0.6 },
+    uHighlightOpacity: { value: n.highlightOpacity ?? 0.9 },
+    uHighlightWhiten: { value: n.highlightWhiten ?? 0.55 }
+  }, o = new i.MeshMatcapMaterial({
+    matcap: t,
+    color: n.color ?? "#ffffff",
+    transparent: !0,
+    depthWrite: !1,
+    vertexColors: n.vertexColors ?? !0
+  });
+  return o.userData.ghost = e, o.onBeforeCompile = (s) => {
+    Object.assign(s.uniforms, e), s.vertexShader = s.vertexShader.replace(
+      "#include <common>",
+      `#include <common>
+        uniform float uHighlight[ ${Ft} ];
+        varying float vHighlight;`
+    ).replace(
+      "#include <skinning_vertex>",
+      `#include <skinning_vertex>
+        vHighlight = 0.0;
+        #ifdef USE_SKINNING
+          vHighlight = uHighlight[ int( skinIndex.x ) ] * skinWeight.x
+            + uHighlight[ int( skinIndex.y ) ] * skinWeight.y
+            + uHighlight[ int( skinIndex.z ) ] * skinWeight.z
+            + uHighlight[ int( skinIndex.w ) ] * skinWeight.w;
+        #endif`
+    ), s.fragmentShader = s.fragmentShader.replace(
+      "#include <common>",
+      `#include <common>
+        uniform float uHighlightGain;
+        uniform float uCore;
+        uniform float uRim;
+        uniform float uWhiten;
+        uniform float uHighlightOpacity;
+        uniform float uHighlightWhiten;
+        varying float vHighlight;`
+    ).replace(
+      "#include <opaque_fragment>",
+      `float ghostRim = 1.0 - abs( dot( normal, normalize( vViewPosition ) ) );
+        ghostRim = pow( ghostRim, 1.6 );
+        float lit = clamp( vHighlight, 0.0, 1.0 ) * uHighlightGain;
+        outgoingLight = mix( outgoingLight, vec3( 1.0 ), max( ghostRim * uWhiten, lit * uHighlightWhiten ) );
+        float ghostAlpha = mix( uCore, uRim, ghostRim );
+        diffuseColor.a *= mix( ghostAlpha, max( ghostAlpha, uHighlightOpacity ), lit );
+        #include <opaque_fragment>`
+    );
+  }, o.customProgramCacheKey = () => "instruction-hint-ghost", o;
+}, Ke = ({
+  width: t,
+  color: n = "#0f172a",
+  opacity: e = 0.3,
+  vertexColors: o = !0
+}) => {
+  const s = {
+    uHaloWidth: { value: t },
+    uHaloColor: { value: new i.Color(n) },
+    uHaloOpacity: { value: e }
+  }, r = new i.MeshMatcapMaterial({
+    transparent: !0,
+    depthWrite: !1,
+    side: i.BackSide,
+    vertexColors: o
+  });
+  return r.userData.halo = s, r.onBeforeCompile = (a) => {
+    Object.assign(a.uniforms, s), a.vertexShader = a.vertexShader.replace("#include <common>", `#include <common>
+uniform float uHaloWidth;`).replace(
+      "#include <skinning_vertex>",
+      `#include <skinning_vertex>
+        transformed += normalize( objectNormal ) * uHaloWidth;`
+    ), a.fragmentShader = a.fragmentShader.replace(
+      "#include <common>",
+      `#include <common>
+uniform vec3 uHaloColor;
+uniform float uHaloOpacity;`
+    ).replace(
+      "#include <opaque_fragment>",
+      `float haloFacing = abs( dot( normal, normalize( vViewPosition ) ) );
+        outgoingLight = uHaloColor;
+        diffuseColor.a *= uHaloOpacity * smoothstep( 0.0, 0.7, haloFacing );
+        #include <opaque_fragment>`
+    );
+  }, r.customProgramCacheKey = () => `instruction-hint-halo-${o}`, r;
+}, Ye = () => new i.MeshBasicMaterial({ colorWrite: !1, depthWrite: !0, transparent: !0 }), kt = "instructionHintTwin", $e = (t) => {
+  const n = [];
+  return t.traverse((e) => {
+    e.frustumCulled = !1, e instanceof i.Mesh && !e.userData[kt] && n.push(e);
+  }), n.map((e) => ({
+    mesh: e,
+    twins: ["prepass", "halo"].map((o) => {
+      var r;
+      const s = e.clone();
+      return s.userData[kt] = o, s.frustumCulled = !1, (r = e.parent) == null || r.add(s), s;
+    })
+  }));
+}, Qe = (t, {
+  main: n,
+  prepass: e,
+  halo: o,
+  showHalo: s,
+  renderOrder: r = 0
+}) => {
+  t.traverse((a) => {
+    if (!(a instanceof i.Mesh)) return;
+    const c = a.userData[kt];
+    c === "prepass" ? (a.material = e, a.renderOrder = r - 0.5) : c === "halo" ? (a.material = o, a.renderOrder = r - 0.25, a.visible = s) : (a.material = n(a), a.renderOrder = r);
+  });
+}, Xe = [-1, -0.5, 0, 0.5, 1], Qt = (t, n, e) => {
+  let o = 1e-6, s = 1e-6;
+  const r = new i.Vector3();
+  for (const a of Xe) {
+    const c = new i.Matrix4().makeRotationY(e * a);
+    for (const m of t)
+      r.copy(m).sub(n).applyMatrix4(c), o = Math.max(o, Math.abs(r.x)), s = Math.max(s, Math.abs(r.y));
+  }
+  return 2 * Math.max(o, s);
+}, it = (t) => t * t * (3 - 2 * t), Je = (t = "#ffffff", n = 0.75) => {
+  const o = document.createElement("canvas");
+  o.width = o.height = 128;
+  const s = o.getContext("2d"), r = new i.Color(t), a = `${Math.round(r.r * 255)},${Math.round(r.g * 255)},${Math.round(r.b * 255)}`, c = s.createRadialGradient(128 / 2, 128 / 2, 0, 128 / 2, 128 / 2, 128 / 2);
+  c.addColorStop(0, `rgba(${a},1)`), c.addColorStop(0.5, `rgba(${a},0.75)`), c.addColorStop(0.68, `rgba(${a},0.32)`), c.addColorStop(0.84, `rgba(${a},0.1)`), c.addColorStop(1, `rgba(${a},0)`), s.fillStyle = c, s.fillRect(0, 0, 128, 128);
+  const m = new i.CanvasTexture(o);
+  m.colorSpace = i.SRGBColorSpace;
+  const h = new i.MeshBasicMaterial({
+    map: m,
+    transparent: !0,
+    opacity: n,
+    depthWrite: !1,
+    depthTest: !1,
+    // A mirrored hint (negative scale) would otherwise turn the disc's back to the camera.
+    side: i.DoubleSide
+  });
+  return h.userData.glowTexture = m, h;
+}, Ze = (t) => {
+  var n;
+  (n = t.userData.glowTexture) == null || n.dispose(), t.dispose();
+}, tn = (t) => {
+  let n = !0;
+  return t.traverse((e) => {
+    e instanceof i.Mesh && !e.geometry.getAttribute("color") && (n = !1);
+  }), n;
+}, me = /* @__PURE__ */ new WeakMap(), de = (t) => {
+  const n = me.get(t);
+  if (n) return n;
+  const e = /* @__PURE__ */ new Map();
+  for (const o of t.tracks) {
+    const { nodeName: s, propertyName: r } = i.PropertyBinding.parseTrackName(o.name);
+    if (r !== "quaternion") continue;
+    const [a, c, m, h] = o.values;
+    e.set(s, new i.Quaternion(a, c, m, h).normalize());
+  }
+  return me.set(t, e), e;
+}, fe = /* @__PURE__ */ new WeakMap(), pe = (t) => {
+  const n = fe.get(t);
+  if (n) return n;
+  const e = /* @__PURE__ */ new Map();
+  for (const o of t.tracks) {
+    const { nodeName: s, propertyName: r } = i.PropertyBinding.parseTrackName(o.name);
+    if (r !== "position") continue;
+    const [a, c, m] = o.values;
+    e.set(s, new i.Vector3(a, c, m));
+  }
+  return fe.set(t, e), e;
+}, Ht = 2e3, en = { sm: 0.1, md: 0.14, lg: 0.19 }, At = 160, nn = 0.66, on = {
+  color: "#ffffff",
+  fontWeight: "bold",
+  textAlign: "center",
+  bgColor: "transparent",
+  padding: 4,
+  resolution: At,
+  fontSize: At * nn,
+  resizeToFit: !0,
+  minFontSize: At * 0.3,
+  shadowEnabled: !0,
+  shadowColor: "#000000",
+  shadowBlur: 10,
+  shadowOffsetY: 2,
+  shadowOpacity: 0.55
+}, Bt = (t, n) => {
+  t.traverse((e) => {
+    var s;
+    if (!(e instanceof i.Mesh)) return;
+    const o = Array.isArray(e.material) ? e.material : [e.material];
+    for (const r of o)
+      (s = r.userData).baseOpacity ?? (s.baseOpacity = r.opacity), r.opacity = r.userData.baseOpacity * n;
+  });
+}, _t = ({
+  text: t,
+  doneText: n,
+  nudgeText: e = null,
+  nudgeAfterMs: o = 3e3,
+  size: s = "md",
+  placement: r = "center",
+  offset: a = [0, 0],
+  color: c,
+  textStyle: m,
+  nudgeTextStyle: h,
+  renderText: f,
+  motion: u = {},
+  layout: b = {},
+  hideOnComplete: w = !0,
+  onStatusChange: p,
+  detector: y,
+  symbol: l,
+  symbolAspect: g = 1
+}) => {
+  const { width: d, height: T } = Pe(), S = y.status, {
+    fadeIn: B = 0.35,
+    fadeOut: _ = 0.5,
+    rise: q = 0.15,
+    bob: Q = 0.02,
+    pop: v = 0.1,
+    popSeconds: I = 0.3,
+    nudgePulse: K = 0.06,
+    ring: O = {}
+  } = u, L = O ? O.seconds ?? 0.6 : 0, D = O ? O.from ?? 0.45 : 0, N = O ? O.to ?? 0.95 : 0, U = O ? O.opacity ?? 0.7 : 0, C = typeof s == "number" ? s : en[s], V = Math.min(T * C, d * 0.42), F = Math.min(V * g, T * 0.62), nt = V * (b.textHeight ?? 0.3), at = V * (b.nudgeHeight ?? 0.2), ct = Math.min(d * 0.9, V * (b.textWidth ?? 6)), lt = T * (b.edgeMargin ?? 0.06), tt = F + V * (b.gap ?? 0.1) + nt, ut = (r === "top" ? T / 2 - lt - tt / 2 : r === "bottom" ? -T / 2 + lt + tt / 2 + (e !== null ? at : 0) : 0) + a[1] * T / 2, wt = tt / 2 - F / 2, ht = -tt / 2 + nt / 2, mt = ht - nt / 2 - at / 2, [It, ne] = Ct("waiting"), [z, P] = Ct(!1), X = E("waiting"), dt = E(performance.now()), A = E(p);
+  A.current = p;
+  const $ = E(y.isInView);
+  $.current = y.isInView;
+  const ft = E(!1);
+  j(() => {
+    var W;
+    ft.current || (ft.current = !0, (W = A.current) == null || W.call(A, X.current));
+  }, []);
+  const ot = E(null), et = E(null), pt = E(null), Nt = E(null), Mt = E(null), Et = R(() => new i.RingGeometry(0.94, 1, 72), []), oe = O ? O.color ?? "#ffffff" : "#ffffff", Tt = R(
+    () => new i.MeshBasicMaterial({
+      color: oe,
+      transparent: !0,
+      opacity: 0,
+      depthTest: !1,
+      depthWrite: !1
+    }),
+    [oe]
+  );
+  j(() => () => Et.dispose(), [Et]), j(() => () => Tt.dispose(), [Tt]);
+  const G = R(() => ({ age: 0, doneAge: 0, nudge: 0 }), []), [re, Ie] = Ct(!1);
+  if (Z((W, Dt) => {
+    var he;
+    const ae = performance.now(), ce = $.current();
+    ce && (dt.current = ae);
+    const J = S === "done" ? "done" : S === "holding" ? "holding" : ce ? "detected" : "waiting";
+    J !== X.current && (X.current = J, ne(J), ft.current = !0, (he = A.current) == null || he.call(A, J));
+    const Pt = e !== null && J === "waiting" && ae - dt.current > o;
+    Pt !== z && P(Pt), G.age += Dt, G.nudge = i.MathUtils.damp(G.nudge, Pt ? 1 : 0, 6, Dt);
+    const le = B > 0 ? it(Math.min(G.age / B, 1)) : 1;
+    let xt = le, ue = 1;
+    if (J === "done" && (G.doneAge += Dt, I > 0 && (ue = 1 + v * Math.sin(Math.min(G.doneAge / I, 1) * Math.PI)), w && (xt *= _ > 0 ? 1 - it(Math.min(G.doneAge / _, 1)) : 0, G.doneAge >= _ && !re && Ie(!0))), ot.current && (ot.current.position.y = ut - (1 - le) * F * q, ot.current.scale.setScalar(ue)), et.current) {
+      const rt = G.age;
+      et.current.position.y = wt + Math.sin(rt * 2.2) * F * Q, et.current.scale.setScalar(
+        1 + G.nudge * K * (0.5 + 0.5 * Math.sin(rt * 4))
+      ), Bt(et.current, xt);
+    }
+    if (Mt.current) {
+      const rt = J === "done" && L > 0 ? Math.min(G.doneAge / L, 1) : 1;
+      Mt.current.visible = J === "done" && rt < 1, Mt.current.scale.setScalar(F * (D + (N - D) * it(rt))), Tt.opacity = U * (1 - rt);
+    }
+    pt.current && Bt(pt.current, xt), Nt.current && Bt(Nt.current, xt * G.nudge * 0.85);
+  }), re) return null;
+  const gt = Ht, ie = {
+    ...on,
+    ...c !== void 0 ? { color: c } : {},
+    ...m
+  }, Ne = { ...ie, fontWeight: "normal", ...h }, se = (W) => f ? f(W) : /* @__PURE__ */ x(
+    Ee,
+    {
+      text: W.text,
+      ...W.style,
+      aspect: W.width / W.height,
+      scale: [W.width, W.height, 1],
+      renderOrder: W.renderOrder
+    }
+  );
+  return /* @__PURE__ */ Vt("group", { ref: ot, position: [a[0] * d / 2, ut, 0], children: [
+    /* @__PURE__ */ Vt("mesh", { renderOrder: gt, scale: [1e-4, 1e-4, 1], onBeforeRender: (W) => W.clearDepth(), children: [
+      /* @__PURE__ */ x("planeGeometry", { args: [1, 1] }),
+      /* @__PURE__ */ x("meshBasicMaterial", { colorWrite: !1, depthWrite: !1, transparent: !0 })
+    ] }),
+    /* @__PURE__ */ x("group", { ref: et, position: [0, wt, F * 0.5], children: l(F, gt + 1) }),
+    O && /* @__PURE__ */ x(
+      "mesh",
+      {
+        ref: Mt,
+        geometry: Et,
+        material: Tt,
+        position: [0, wt, 0],
+        renderOrder: gt + 3,
+        visible: !1
+      }
+    ),
+    /* @__PURE__ */ x("group", { ref: pt, position: [0, ht, 0], children: se({
+      text: It === "done" && n !== void 0 ? n : t,
+      role: "text",
+      width: ct,
+      height: nt,
+      renderOrder: gt + 2,
+      style: ie
+    }) }),
+    e !== null && /* @__PURE__ */ x("group", { ref: Nt, position: [0, mt, 0], visible: z || G.nudge > 0.01, children: se({
+      text: e,
+      role: "nudge",
+      width: ct,
+      height: at,
+      renderOrder: gt + 2,
+      style: Ne
+    }) })
+  ] });
+}, uo = ({ active: t = !0, ...n }) => t ? /* @__PURE__ */ x(Rt, { children: /* @__PURE__ */ x(_t, { ...n }) }) : null, bt = ["thumb", "index", "middle", "ring", "pinky"], rn = (t) => new i.Vector3(t.x, t.y, t.z), yt = (t, n, e) => {
+  const o = n.clone().sub(t), s = e.clone().sub(n);
+  return o.lengthSq() < 1e-12 || s.lengthSq() < 1e-12 ? 0 : o.angleTo(s);
+}, ge = Object.freeze({
+  /** A finger is extended when its PIP + DIP bends stay under this (radians, ~55°). */
+  fingerStraight: i.MathUtils.degToRad(55),
+  /** … and its MCP bend stays under this (~70°, a finger folded at the knuckle is not up). */
+  fingerKnuckle: i.MathUtils.degToRad(70),
+  /** The thumb is extended when its MCP + IP bends stay under this (~60°) … */
+  thumbStraight: i.MathUtils.degToRad(60),
+  /** … and its tip is at least this many palm widths from the index MCP (tucked thumbs sit closer). */
+  thumbReach: 0.75,
+  /** |cos| of the thumb's angle to screen-up for "up" / "down" (~45°). */
+  thumbVertical: Math.cos(i.MathUtils.degToRad(45)),
+  /** Thumb and index tips touch within this many palm lengths (~1.75 cm). */
+  touch: 0.2,
+  /** Full curl, radians summed over a finger's three bends (normalises `curl`). */
+  fullCurl: i.MathUtils.degToRad(255)
+}), ke = (t, { limits: n } = {}) => {
+  if (t.length < 21) throw new Error("analyzeHandShape needs 21 joints");
+  const e = t.map(rn), o = n ? { ...ge, ...n } : ge, s = e[M.middleMcp].distanceTo(e[M.wrist]), r = e[M.indexMcp].distanceTo(e[M.pinkyMcp]), a = {}, c = {};
+  for (const u of ["index", "middle", "ring", "pinky"]) {
+    const b = e[M[`${u}Mcp`]], w = e[M[`${u}Pip`]], p = e[M[`${u}Dip`]], y = e[M[`${u}Tip`]], l = yt(e[M.wrist], b, w), g = yt(b, w, p) + yt(w, p, y);
+    c[u] = i.MathUtils.clamp((l + g) / o.fullCurl, 0, 1), a[u] = g < o.fingerStraight && l < o.fingerKnuckle && y.distanceTo(e[M.wrist]) > w.distanceTo(e[M.wrist]);
+  }
+  const m = yt(e[M.thumbCmc], e[M.thumbMcp], e[M.thumbIp]) + yt(e[M.thumbMcp], e[M.thumbIp], e[M.thumbTip]);
+  c.thumb = i.MathUtils.clamp(m / i.MathUtils.degToRad(150), 0, 1), a.thumb = m < o.thumbStraight && e[M.thumbTip].distanceTo(e[M.indexMcp]) > o.thumbReach * r && e[M.thumbTip].distanceTo(e[M.pinkyMcp]) > e[M.thumbIp].distanceTo(e[M.pinkyMcp]);
+  const h = e[M.thumbTip].clone().sub(e[M.thumbMcp]).normalize(), f = a.thumb ? h.y >= o.thumbVertical ? "up" : h.y <= -o.thumbVertical ? "down" : "side" : "side";
+  return {
+    extended: a,
+    curl: c,
+    count: bt.filter((u) => a[u]).length,
+    thumbDirection: f,
+    thumbIndexTouch: e[M.thumbTip].distanceTo(e[M.indexTip]) < o.touch * s
+  };
+}, ho = (t) => {
+  if (!t.rule && !t.match)
+    throw new Error("defineHandGesture needs a rule or a match function");
+  return t;
+}, Lt = { index: !1, middle: !1, ring: !1, pinky: !1 }, Y = (t = {}) => ({
+  thumb: 1,
+  index: 1,
+  middle: 1,
+  ring: 1,
+  pinky: 1,
+  ...t
+}), Re = {
+  palm: {
+    label: "Show your palm",
+    rule: { count: 5 },
+    hint: { clip: "palm", spread: 0.8, thumbTuck: 0 }
+  },
+  fist: {
+    label: "Make a fist",
+    rule: { digits: { thumb: !1, ...Lt } },
+    // Thumb across the front of the index / middle middle segments.
+    hint: {
+      clip: "fist",
+      curl: Y(),
+      thumbTuck: 1,
+      thumbTo: { joint: "indexPip", offset: [-0.15, -0.1, 0.13] }
+    }
+  },
+  peace: {
+    label: "Show a peace sign",
+    rule: { digits: { index: !0, middle: !0, ring: !1, pinky: !1 } },
+    hint: {
+      clip: "peace",
+      curl: Y({ index: 0, middle: 0 }),
+      spread: 1,
+      thumbTuck: 1,
+      thumbTo: { joint: "ringPip", offset: [0, -0.08, 0.12] }
+    }
+  },
+  thumbUp: {
+    label: "Give a thumbs up",
+    rule: { digits: { thumb: !0, ...Lt }, thumbDirection: "up" },
+    hint: { clip: "thumbUp", curl: Y({ thumb: 0 }), thumbTuck: 0, aimThumb: "up" }
+  },
+  thumbDown: {
+    label: "Give a thumbs down",
+    rule: { digits: { thumb: !0, ...Lt }, thumbDirection: "down" },
+    hint: { clip: "thumbUp", curl: Y({ thumb: 0 }), thumbTuck: 0, aimThumb: "down" }
+  },
+  point: {
+    label: "Point your index finger",
+    rule: { digits: { index: !0, middle: !1, ring: !1, pinky: !1 } },
+    // The thumb holds the curled middle and ring fingers down.
+    hint: {
+      clip: "one",
+      curl: Y({ index: 0 }),
+      thumbTuck: 0.6,
+      thumbTo: { joint: "middlePip", offset: [0.1, -0.1, 0.1] }
+    }
+  },
+  one: {
+    label: "Show 1 finger",
+    rule: { count: 1 },
+    // Counting: the thumb must be folded away, or it counts as a second digit.
+    hint: {
+      clip: "one",
+      curl: Y({ index: 0 }),
+      thumbTuck: 1,
+      thumbTo: { joint: "middlePip", offset: [0, -0.08, 0.12] }
+    }
+  },
+  two: {
+    label: "Show 2 fingers",
+    rule: { count: 2 },
+    hint: {
+      clip: "peace",
+      curl: Y({ index: 0, middle: 0 }),
+      spread: 0.6,
+      thumbTuck: 1,
+      thumbTo: { joint: "ringPip", offset: [0, -0.08, 0.12] }
+    }
+  },
+  three: {
+    label: "Show 3 fingers",
+    rule: { count: 3 },
+    hint: {
+      clip: "three",
+      curl: Y({ index: 0, middle: 0, ring: 0 }),
+      spread: 0.6,
+      thumbTuck: 1,
+      thumbTo: { joint: "pinkyPip", offset: [0, -0.08, 0.12] }
+    }
+  },
+  four: {
+    label: "Show 4 fingers",
+    rule: { count: 4 },
+    hint: {
+      clip: "four",
+      curl: { thumb: 1 },
+      spread: 0.6,
+      thumbTuck: 1,
+      thumbTo: { joint: "ringMcp", offset: [0, -0.2, 0.1] }
+    }
+  },
+  five: {
+    label: "Show 5 fingers",
+    rule: { count: 5 },
+    hint: { clip: "palm", spread: 0.8, thumbTuck: 0 }
+  },
+  rock: {
+    label: "Rock on",
+    rule: { digits: { index: !0, middle: !1, ring: !1, pinky: !0 } },
+    hint: {
+      clip: "rock",
+      yaw: 180,
+      curl: Y({ index: 0, pinky: 0 }),
+      spread: 0.8,
+      thumbTuck: 1,
+      thumbTo: { joint: "middlePip", offset: [-0.05, -0.08, 0.12] }
+    }
+  },
+  loveYou: {
+    label: "Sign I love you",
+    rule: { digits: { thumb: !0, index: !0, middle: !1, ring: !1, pinky: !0 } },
+    hint: {
+      clip: "loveYou",
+      curl: Y({ thumb: 0, index: 0, pinky: 0 }),
+      spread: 0.8,
+      thumbTuck: 0
+    }
+  },
+  callMe: {
+    label: "Call me",
+    rule: { digits: { thumb: !0, index: !1, middle: !1, ring: !1, pinky: !0 } },
+    // Held sideways like a phone at the ear: thumb up, pinky down.
+    hint: {
+      clip: "callMe",
+      roll: 103,
+      curl: Y({ thumb: 0, pinky: 0 }),
+      spread: 0.8,
+      thumbTuck: 0
+    }
+  },
+  ok: {
+    label: "Make an OK sign",
+    rule: { thumbIndexTouch: !0, digits: { middle: !0, ring: !0, pinky: !0 } },
+    // Seen from the thumb side so the ring reads. Procedural fallback tuned on
+    // hand-v1 (grid search) so the thumb and index tips meet, 0.16 cm apart.
+    hint: {
+      clip: "ok",
+      yaw: 124,
+      curl: { thumb: 0.3, index: 0.5 },
+      spread: 0.6,
+      thumbTuck: 0.4
+    }
+  }
+}, sn = Object.keys(Re), Xt = (t) => typeof t == "string" ? Re[t] : typeof t == "object" && "hint" in t ? t : void 0, ye = (t, n) => {
+  var e;
+  if (n.count !== void 0 && t.count !== n.count || n.thumbDirection && t.thumbDirection !== n.thumbDirection || n.thumbIndexTouch !== void 0 && t.thumbIndexTouch !== n.thumbIndexTouch)
+    return !1;
+  for (const o of bt) {
+    const s = (e = n.digits) == null ? void 0 : e[o];
+    if (s !== void 0 && t.extended[o] !== s) return !1;
+  }
+  return !0;
+}, ve = (t, n, e) => {
+  if (typeof n == "function") return n(t, e);
+  const o = Xt(n);
+  return o ? o.rule && !ye(t, o.rule) ? !1 : o.match ? o.match(t, e) : !!o.rule : ye(t, n);
+}, mo = (t) => sn.filter((n) => ve(t, n)), be = {
+  finger: [85, 100, 70].map(i.MathUtils.degToRad),
+  thumb: [10, 45, 35].map(i.MathUtils.degToRad)
+}, an = { index: 12, middle: 3, ring: -8, pinky: -16 }, cn = i.MathUtils.degToRad(70), ln = 0.65, un = { 1: [1, 0.35], 2: [0.6, 1] }, hn = Object.fromEntries(
+  Ot.map(({ name: t }) => [
+    t,
+    t.endsWith("Cmc") || t.endsWith("Mcp") && !t.startsWith("thumb") ? 0 : t === "thumbMcp" || t.endsWith("Pip") ? 1 : 2
+  ])
+), we = (t) => bt.find((n) => t.startsWith(n)) ?? "index", H = {
+  thumbAxis: new i.Vector3(),
+  thumbSide: new i.Vector3(),
+  cross: new i.Vector3(),
+  delta: new i.Quaternion(),
+  restInv: new i.Quaternion(),
+  q: new i.Quaternion(),
+  D: new i.Quaternion(),
+  axis: new i.Vector3(),
+  dir: new i.Vector3(),
+  /** Root-space rotation of each joint as it is posed (parents before children). */
+  live: Object.fromEntries(
+    ["wrist", ...Ot.map((t) => t.name)].map((t) => [t, new i.Quaternion()])
+  )
+}, zt = (t, n) => i.MathUtils.clamp(typeof t == "number" ? t : t(n), 0, 1.1), mn = (t, n) => {
+  if (!(!t || !n)) {
+    for (const e of t) if (e.name === n) return e;
+  }
+}, Me = /* @__PURE__ */ new WeakMap(), dn = (t) => {
+  const n = Me.get(t);
+  if (n) return n;
+  const e = {};
+  for (const o of t.tracks) {
+    const { nodeName: s, propertyName: r } = i.PropertyBinding.parseTrackName(o.name);
+    if (r !== "quaternion" || !(s in M)) continue;
+    const [a, c, m, h] = o.values;
+    e[s] = new i.Quaternion(a, c, m, h).normalize();
+  }
+  return Me.set(t, e), e;
+}, Ut = (t, n, e = 1, o) => {
+  var f;
+  const s = mn(o, n.clip);
+  if (s) {
+    const u = dn(s);
+    for (const { name: b } of Ot) {
+      const w = t.bones[b], p = t.restLocal[b];
+      !w || !p || w.quaternion.copy(p).slerp(u[b] ?? p, zt(e, we(b)));
+    }
+    return;
+  }
+  const r = t.restPalmNormal, a = t.restPositions, c = H.thumbSide.subVectors(a[M.indexMcp], a[M.pinkyMcp]).normalize(), m = H.live;
+  m.wrist.copy(t.restQuaternions.wrist);
+  for (const { name: u, parent: b, child: w } of Ot) {
+    const p = we(u), y = zt(e, p), l = hn[u] ?? 0, g = (((f = n.curl) == null ? void 0 : f[p]) ?? 0) * y, d = (p === "thumb" ? be.thumb : be.finger)[l] * g;
+    H.restInv.copy(t.restQuaternions[b]).invert(), H.delta.copy(m[b]).multiply(H.restInv), H.dir.subVectors(a[M[w]], a[M[u]]).normalize(), H.axis.crossVectors(H.dir, r).normalize();
+    const T = Math.sign(H.cross.crossVectors(r, H.dir).dot(c)), S = H.D.identity();
+    if (p === "thumb") {
+      const _ = -T || -1, [q, Q] = un[l] ?? [0, 1];
+      H.q.setFromAxisAngle(
+        H.thumbAxis.copy(r).multiplyScalar(_ * q).addScaledVector(H.axis, Q).normalize(),
+        d
+      ), S.copy(H.q);
+    } else
+      S.setFromAxisAngle(H.axis, d);
+    if (l === 0 && p !== "thumb") {
+      const _ = i.MathUtils.degToRad(an[p]) * (n.spread ?? 0) * y;
+      S.premultiply(H.q.setFromAxisAngle(r, _ * (T || 1)));
+    }
+    if (p === "thumb" && l === 0) {
+      const _ = cn * (n.thumbTuck ?? 0) * y;
+      S.premultiply(H.q.setFromAxisAngle(r, -_ * (T || 1))), S.premultiply(H.q.setFromAxisAngle(H.axis, _ * ln));
+    }
+    m[u].copy(H.delta).multiply(S).multiply(t.restQuaternions[u]);
+    const B = t.bones[u];
+    B && B.quaternion.copy(H.q.copy(m[b]).invert().multiply(m[u]));
+  }
+  const h = Math.min(zt(e, "thumb"), 1);
+  n.thumbTo && h > 0 && yn(t, n.thumbTo, h);
+}, fn = {
+  thumbCmc: i.MathUtils.degToRad(75),
+  thumbMcp: i.MathUtils.degToRad(65),
+  thumbIp: i.MathUtils.degToRad(85)
+}, pn = ["thumbIp", "thumbMcp", "thumbCmc"], k = {
+  inv: new i.Matrix4(),
+  head: new i.Vector3(),
+  eff: new i.Vector3(),
+  target: new i.Vector3(),
+  start: new i.Vector3(),
+  a: new i.Vector3(),
+  b: new i.Vector3(),
+  q: new i.Quaternion(),
+  pq: new i.Quaternion(),
+  pqInv: new i.Quaternion(),
+  rq: new i.Quaternion(),
+  limited: new i.Quaternion(),
+  up: new i.Vector3(),
+  side: new i.Vector3()
+}, gn = [0, 0, 0], St = (t, n) => t.getWorldPosition(n).applyMatrix4(k.inv), yn = (t, n, e) => {
+  const o = t.root, s = t.restPositions, r = s[M.middleMcp].distanceTo(s[M.wrist]), a = k.up.subVectors(s[M.middleMcp], s[M.wrist]).normalize(), c = k.side.subVectors(s[M.indexMcp], s[M.pinkyMcp]);
+  c.addScaledVector(a, -c.dot(a)).normalize();
+  const [m, h, f] = n.offset ?? gn, u = t.bones.thumbTip ?? t.bones.thumbIp, b = t.bones[n.joint];
+  if (!b) return;
+  o.updateMatrixWorld(!0), k.inv.copy(o.matrixWorld).invert(), St(b, k.target).addScaledVector(c, m * r).addScaledVector(a, h * r).addScaledVector(t.restPalmNormal, f * r), St(u, k.start), k.target.lerp(k.start, 1 - e);
+  const w = o.getWorldQuaternion(k.rq).invert();
+  for (let p = 0; p < 10; p += 1)
+    for (const y of pn) {
+      const l = t.bones[y];
+      if (!(l != null && l.parent) || (o.updateMatrixWorld(!0), St(l, k.head), St(u, k.eff), k.a.subVectors(k.eff, k.head), k.b.subVectors(k.target, k.head), k.a.lengthSq() < 1e-10 || k.b.lengthSq() < 1e-10)) continue;
+      k.q.setFromUnitVectors(k.a.normalize(), k.b.normalize()), l.parent.getWorldQuaternion(k.pq).premultiply(w), l.quaternion.premultiply(k.pqInv.copy(k.pq).invert().multiply(k.q).multiply(k.pq));
+      const g = t.restLocal[y], d = fn[y] ?? Math.PI, T = l.quaternion.angleTo(g);
+      T > d && l.quaternion.copy(k.limited.copy(g).slerp(l.quaternion, d / T));
+    }
+}, bn = 2 * Math.acos(2 / 3) / Math.PI, Jt = (t, { seconds: n = 2.4, hold: e = bn, from: o = 0, easing: s = it } = {}) => {
+  if (n <= 0) return { phase: 0.5, drive: 1, closing: !1, amount: 1 };
+  const r = t % n / n, a = 1 / Math.max(Math.cos(Math.PI * i.MathUtils.clamp(e, 0, 0.95) / 2), 1e-3), c = i.MathUtils.clamp(Math.sin(r * Math.PI) * a, 0, 1);
+  return { phase: r, drive: c, closing: r < 0.5, amount: o + (1 - o) * s(c) };
+}, wn = (t, n, e) => e > 0 ? Math.sin(t / e * Math.PI * 2) * i.MathUtils.degToRad(n) : 0, Zt = ({
+  height: t,
+  span: n,
+  mirrored: e = !1,
+  orbit: o = 0,
+  orbitSeconds: s = 6,
+  glow: r = null,
+  glowSize: a = 1.75,
+  renderOrder: c = 0,
+  children: m
+}) => {
+  const h = E(null);
+  Z(({ clock: u }) => {
+    h.current && (h.current.rotation.y = wn(u.elapsedTime, o, s));
+  });
+  const f = t / n;
+  return /* @__PURE__ */ Vt("group", { scale: [f * (e ? -1 : 1), f, f], children: [
+    r && // Behind the hint, not orbiting: drawn first in the band (before the depth pre-pass).
+    /* @__PURE__ */ x(
+      "mesh",
+      {
+        material: r,
+        position: [0, 0, -n * 0.6],
+        scale: n * a,
+        renderOrder: c - 0.75,
+        children: /* @__PURE__ */ x("planeGeometry", { args: [1, 1] })
+      }
+    ),
+    /* @__PURE__ */ x("group", { ref: h, children: m })
+  ] });
+}, Mn = { width: 0.3, color: "#0f172a", opacity: 0.3 }, Tn = { color: "#ffffff", size: 1.75, idle: 0.5, full: 0.85 }, xn = { opacity: 0.9, whiten: 0.55, idle: 0.25 }, Wt = (t, n, e) => e === !1 || n === !1 && e === void 0 ? !1 : { ...t, ...n || {}, ...e || {} }, Sn = (t, n = {}) => {
+  var o;
+  const e = {};
+  for (const [s, r] of Object.entries({ ...t.parts, ...n.parts }))
+    r && (e[s] = { ...((o = t.parts) == null ? void 0 : o[s]) ?? {}, ...r });
+  return {
+    ghost: { ...t.ghost, ...n.ghost },
+    parts: e,
+    halo: Wt(Mn, t.halo, n.halo),
+    glow: Wt(Tn, t.glow, n.glow),
+    highlight: Wt(xn, t.highlight, n.highlight),
+    matcap: n.matcap ?? t.matcap,
+    material: n.material ?? t.material
+  };
+}, Te = (t) => JSON.stringify(
+  t ?? {},
+  (n, e) => n === "matcap" || n === "material" ? void 0 : e
+), te = (t, n, { base: e = {}, renderOrder: o } = {}) => {
+  const s = Te(n) + Te(e), r = R(
+    () => Sn(e, n),
+    [s, n == null ? void 0 : n.matcap, n == null ? void 0 : n.material, e.matcap, e.material]
+    // eslint-disable-line react-hooks/exhaustive-deps
+  ), { object: a, meshes: c } = R(() => {
+    const l = Ve(t);
+    return { object: l, meshes: $e(l) };
+  }, [t]), m = R(() => tn(a), [a]), h = R(() => r.matcap ? null : je(), [r.matcap]);
+  j(() => () => h == null ? void 0 : h.dispose(), [h]);
+  const f = r.matcap ?? h, u = R(() => {
+    const l = /* @__PURE__ */ new Map();
+    if (r.material) return l;
+    const { highlight: g } = r;
+    for (const { mesh: d } of c) {
+      const T = d.material.name;
+      l.has(T) || l.set(
+        T,
+        qe(f, {
+          vertexColors: m,
+          ...g ? { highlightOpacity: g.opacity, highlightWhiten: g.whiten } : {},
+          ...r.ghost,
+          ...r.parts[T] ?? {}
+        })
+      );
+    }
+    return l;
+  }, [c, f, m, r]);
+  j(() => () => u.forEach((l) => l.dispose()), [u]);
+  const b = R(
+    () => new Map(
+      c.map(({ mesh: l }) => [
+        l,
+        r.material ?? u.get(l.material.name)
+      ])
+    ),
+    [c, u, r.material]
+  ), w = R(() => Ye(), []);
+  j(() => () => w.dispose(), [w]);
+  const p = R(() => {
+    var d;
+    a.updateMatrixWorld(!0);
+    const l = ((d = c[0]) == null ? void 0 : d.mesh.getWorldScale(new i.Vector3()).x) || 1, g = r.halo || { width: 0, color: "#000000", opacity: 0 };
+    return Ke({ ...g, width: g.width / l, vertexColors: m });
+  }, [a, c, m, r.halo]);
+  j(() => () => p.dispose(), [p]);
+  const y = R(
+    () => r.glow ? Je(r.glow.color, r.glow.idle) : null,
+    [r.glow]
+  );
+  return j(
+    () => () => {
+      y && Ze(y);
+    },
+    [y]
+  ), j(() => {
+    Qe(a, {
+      main: (l) => b.get(l) ?? r.material ?? u.values().next().value,
+      prepass: w,
+      halo: p,
+      showHalo: r.halo !== !1,
+      renderOrder: o
+    });
+  }, [a, b, u, w, p, r, o]), R(() => {
+    const l = () => [...u.values()].map((g) => g.userData.ghost).filter((g) => !!g);
+    return {
+      object: a,
+      meshes: c,
+      materials: u,
+      glowMaterial: y,
+      look: r,
+      setHighlight: (g) => {
+        var d, T;
+        for (const S of l()) S.uHighlight.value.fill(0);
+        if (r.highlight)
+          for (const { mesh: S } of c) {
+            if (!(S instanceof i.SkinnedMesh)) continue;
+            const B = (T = (d = b.get(S)) == null ? void 0 : d.userData.ghost) == null ? void 0 : T.uHighlight;
+            B && S.skeleton.bones.forEach((_, q) => {
+              q < Ft && (B.value[q] = Math.max(B.value[q], g(_)));
+            });
+          }
+      },
+      setStrength: (g) => {
+        if (r.highlight) {
+          const { idle: d } = r.highlight;
+          for (const T of l()) T.uHighlightGain.value = d + (1 - d) * g;
+        }
+        if (y && r.glow) {
+          const d = r.glow.idle + (r.glow.full - r.glow.idle) * g;
+          y.userData.baseOpacity = d, y.opacity = d;
+        }
+      }
+    };
+  }, [a, c, u, b, y, r]);
+}, On = {
+  halo: { width: 0.35 },
+  glow: { size: 1.75 }
+}, xe = { seconds: 2.2, from: 0.35, stagger: 0.21 }, kn = {
+  thumb: ["thumbMcp", "thumbIp", "thumbTip"],
+  index: ["indexMcp", "indexPip", "indexDip", "indexTip"],
+  middle: ["middleMcp", "middlePip", "middleDip", "middleTip"],
+  ring: ["ringMcp", "ringPip", "ringDip", "ringTip"],
+  pinky: ["pinkyMcp", "pinkyPip", "pinkyDip", "pinkyTip"]
+}, Rn = (t, n) => {
+  const e = t == null ? void 0 : t.rule;
+  if (e != null && e.thumbIndexTouch) return ["thumb", "index"];
+  if (e != null && e.thumbDirection) return ["thumb"];
+  const o = bt.filter((s) => n[s]);
+  return o.length > 0 && o.length < bt.length ? o : [];
+}, vn = (t) => {
+  const e = t - 1;
+  return 1 + (0.9 + 1) * e * e * e + 0.9 * e * e;
+}, Se = {
+  pinky: 0,
+  ring: 1 / 3,
+  middle: 2 / 3,
+  thumb: 0.81,
+  index: 1
+}, Hn = ({
+  gesture: t,
+  model: n,
+  poses: e,
+  modelHand: o = "right",
+  showHand: s = "right",
+  height: r = 1,
+  loop: a,
+  look: c,
+  highlight: m,
+  orbit: h = 35,
+  orbitSeconds: f = 6,
+  renderOrder: u
+}) => {
+  const b = typeof t == "string" || "label" in t ? Xt(t) : void 0, w = JSON.stringify(b ? b.hint : t), p = R(
+    () => b ? b.hint : t,
+    [w]
+    // eslint-disable-line react-hooks/exhaustive-deps
+  ), y = JSON.stringify((b == null ? void 0 : b.rule) ?? null), l = te(n, c, { base: On, renderOrder: u }), g = l.object, d = R(() => Ae(g, o), [g, o]), T = (a == null ? void 0 : a.from) ?? xe.from, S = R(() => {
+    const O = (z) => d.restPositions[z], L = O(M.middleMcp).clone().sub(O(M.wrist)).normalize(), D = d.restPalmNormal.clone(), N = new i.Vector3().crossVectors(L, D).normalize(), U = new i.Vector3().crossVectors(D, N), C = new i.Matrix4().makeBasis(N, U, D).invert();
+    p.yaw && C.premultiply(new i.Matrix4().makeRotationY(-i.MathUtils.degToRad(p.yaw))), p.roll && C.premultiply(new i.Matrix4().makeRotationZ(i.MathUtils.degToRad(p.roll)));
+    const V = (z) => {
+      Ut(d, p, z, e), g.updateMatrixWorld(!0);
+      const P = g.matrixWorld.clone().invert(), X = Object.values(d.bones).filter((A) => !!A).map(
+        (A) => A.getWorldPosition(new i.Vector3()).applyMatrix4(P).applyMatrix4(C)
+      ), dt = [];
+      return g.traverse((A) => {
+        if (!(A instanceof i.SkinnedMesh) || A.userData[kt]) return;
+        A.skeleton.update(), A.computeBoundingBox();
+        const $ = A.boundingBox, ft = P.clone().multiply(A.matrixWorld);
+        for (const ot of [$.min.x, $.max.x])
+          for (const et of [$.min.y, $.max.y])
+            for (const pt of [$.min.z, $.max.z])
+              dt.push(new i.Vector3(ot, et, pt).applyMatrix4(ft).applyMatrix4(C));
+      }), [...X, ...dt];
+    }, F = V(1), nt = g.matrixWorld.clone().invert(), at = ke(
+      Ce.map((z) => {
+        var X;
+        const P = (X = d.bones[z]) == null ? void 0 : X.getWorldPosition(new i.Vector3()).applyMatrix4(nt);
+        return { x: (P == null ? void 0 : P.x) ?? 0, y: (P == null ? void 0 : P.y) ?? 0, z: (P == null ? void 0 : P.z) ?? 0 };
+      })
+    ), ct = (z) => F[Object.keys(d.bones).filter((P) => d.bones[P]).indexOf(z)];
+    let lt = 0;
+    if (p.aimThumb) {
+      const z = ct("thumbCmc"), P = ct(d.bones.thumbTip ? "thumbTip" : "thumbIp");
+      lt = (p.aimThumb === "up" ? Math.PI / 2 : -Math.PI / 2) - Math.atan2(P.y - z.y, P.x - z.x);
+    }
+    const tt = new i.Matrix4().makeRotationZ(lt), ut = [...V(T), ...V(0.7), ...F].map((z) => z.applyMatrix4(tt));
+    Ut(d, p, 0, e);
+    const ht = new i.Box3().setFromPoints(ut).getCenter(new i.Vector3()), mt = ht.clone().applyMatrix4(tt.clone().invert()), It = Qt(ut, ht, i.MathUtils.degToRad(h)) * 1.06;
+    return { matrix: new i.Matrix4().makeTranslation(-mt.x, -mt.y, -mt.z).multiply(C), span: It, extended: at.extended };
+  }, [d, g, p, e, h, T]), B = m === !1 ? "off" : (m ?? []).join();
+  j(() => {
+    const O = y === "null" ? void 0 : JSON.parse(y), L = m === !1 ? [] : m ?? p.highlight ?? Rn(O ? { rule: O } : void 0, S.extended), D = new Set(L.flatMap((N) => kn[N]));
+    l.setHighlight((N) => D.has(N.name) ? 1 : 0);
+  }, [l, p, y, B, S]);
+  const _ = E(null), q = R(() => ({ a: new i.Vector3(), b: new i.Vector3() }), []), Q = JSON.stringify(a ?? {}), v = R(
+    () => ({ ...xe, ...a }),
+    [Q, a == null ? void 0 : a.easing]
+    // eslint-disable-line react-hooks/exhaustive-deps
+  ), I = R(() => {
+    const O = { drive: 0, closing: !0 };
+    return { state: O, amount: (D) => {
+      const N = i.MathUtils.clamp(v.stagger ?? 0, 0, 0.9), U = O.closing ? Se[D] : 1 - Se[D], C = i.MathUtils.clamp((O.drive - U * N) / (1 - N), 0, 1), V = v.easing ? v.easing(C) : O.closing ? vn(C) : it(C), F = v.from ?? 0;
+      return F + (1 - F) * V;
+    } };
+  }, [v]);
+  Z(({ clock: O }) => {
+    const { drive: L, closing: D } = Jt(O.elapsedTime, v);
+    I.state.drive = L, I.state.closing = D, Ut(d, p, I.amount, e), l.setStrength(it(L));
+    const N = _.current;
+    if (N && (N.rotation.z = 0, p.aimThumb)) {
+      N.updateMatrixWorld(!0);
+      const U = d.bones.thumbCmc.getWorldPosition(q.a), C = (d.bones.thumbTip ?? d.bones.thumbIp).getWorldPosition(q.b);
+      N.worldToLocal(U), N.worldToLocal(C);
+      const V = Math.atan2(C.y - U.y, C.x - U.x);
+      N.rotation.z = (p.aimThumb === "up" ? Math.PI / 2 : -Math.PI / 2) - V;
+    }
+  });
+  const K = l.look.glow;
+  return /* @__PURE__ */ x(
+    Zt,
+    {
+      height: r,
+      span: S.span,
+      mirrored: s !== o,
+      orbit: h,
+      orbitSeconds: f,
+      glow: l.glowMaterial,
+      glowSize: K ? K.size : void 0,
+      renderOrder: u,
+      children: /* @__PURE__ */ x("group", { ref: _, children: /* @__PURE__ */ x("group", { matrixAutoUpdate: !1, matrix: S.matrix, children: /* @__PURE__ */ x("primitive", { object: g }) }) })
+    }
+  );
+}, _n = (t, { hand: n = "any", limits: e, active: o = !0, ...s } = {}) => {
+  const { node: r } = $t(Kt.HAND_TRACKER, void 0, o), a = st(t), c = qt(a, s), m = E({}), h = E(t);
+  h.current = t;
+  const f = JSON.stringify(e ?? null), u = R(() => ({ limits: e }), [f]), b = E(n);
+  b.current = n;
+  const w = jt(() => {
+    const p = m.current, y = b.current;
+    return y === "any" ? !!(p.left || p.right) : !!p[y];
+  }, []);
+  return Z(() => {
+    var y;
+    if (!o) return;
+    let p = !1;
+    for (const l of ["left", "right"]) {
+      const g = (y = r == null ? void 0 : r.poses) == null ? void 0 : y[l];
+      if (!g || g.held || g.world.length < 21) {
+        delete m.current[l];
+        continue;
+      }
+      const d = ke(g.world, u);
+      m.current[l] = d, (n === "any" || n === l) && ve(d, h.current, l) && (p = !0);
+    }
+    c.step(p);
+  }), {
+    status: c.status,
+    holdRef: c.holdRef,
+    matchedRef: c.matchedRef,
+    isInView: w,
+    reset: c.reset,
+    shapesRef: m
+  };
+}, fo = Ht, In = "Show your hand to the camera", Nn = ({
+  gesture: t,
+  model: n,
+  poses: e,
+  modelHand: o = "right",
+  hand: s = "any",
+  holdMs: r,
+  graceMs: a,
+  limits: c,
+  orbit: m,
+  look: h,
+  loop: f,
+  highlight: u,
+  onComplete: b,
+  nudgeText: w = In,
+  ...p
+}) => {
+  const y = Yt(), l = _n(t, { hand: s, holdMs: r, graceMs: a, limits: c, onComplete: b }), g = Be(s === "any" ? "right" : s, y);
+  return /* @__PURE__ */ x(
+    _t,
+    {
+      ...p,
+      nudgeText: w,
+      detector: l,
+      symbol: (d, T) => /* @__PURE__ */ x(
+        Hn,
+        {
+          gesture: t,
+          model: n,
+          poses: e,
+          modelHand: o,
+          showHand: g,
+          height: d,
+          loop: f,
+          look: h,
+          highlight: u,
+          orbit: m,
+          renderOrder: T
+        }
+      )
+    }
+  );
+}, po = ({ active: t = !0, text: n, ...e }) => t ? /* @__PURE__ */ x(Rt, { children: /* @__PURE__ */ x(
+  Nn,
+  {
+    ...e,
+    text: n ?? Xt(e.gesture).label
+  },
+  st(e.gesture)
+) }) : null, go = (t) => {
+  if (!t.rule && !t.match)
+    throw new Error("defineFaceExpression needs a rule or a match function");
+  return t;
+}, He = {
+  smile: {
+    label: "Give a big smile",
+    rule: { atLeast: { mouthSmileLeft: 0.45, mouthSmileRight: 0.45 } },
+    hint: { target: "smile" }
+  },
+  wink: {
+    label: "Wink at the camera",
+    rule: {
+      anyOf: [
+        { atLeast: { eyeBlinkLeft: 0.55 }, atMost: { eyeBlinkRight: 0.3 } },
+        { atLeast: { eyeBlinkRight: 0.55 }, atMost: { eyeBlinkLeft: 0.3 } }
+      ]
+    },
+    hint: { target: "wink" }
+  },
+  surprised: {
+    label: "Look surprised",
+    rule: { atLeast: { jawOpen: 0.35, browInnerUp: 0.4 } },
+    hint: { target: "surprised" }
+  },
+  kiss: {
+    label: "Blow a kiss",
+    rule: { atLeast: { mouthPucker: 0.5 }, atMost: { jawOpen: 0.3 } },
+    hint: { target: "kiss" }
+  },
+  puffCheeks: {
+    label: "Puff your cheeks",
+    rule: { atLeast: { cheekPuff: 0.3 } },
+    hint: { target: "puffCheeks" }
+  },
+  // Shares the brows-down signal with `scrunch`, so a scrunch also completes a
+  // frown prompt — deliberate (both read as a cross face); `scrunch` alone
+  // needs the nose sneer or the squint on top.
+  frown: {
+    label: "Frown",
+    rule: { atLeast: { browDownLeft: 0.4, browDownRight: 0.4 } },
+    hint: { target: "frown" }
+  },
+  scrunch: {
+    label: "Scrunch your face",
+    rule: {
+      anyOf: [
+        { atLeast: { noseSneerLeft: 0.3, noseSneerRight: 0.3 } },
+        {
+          atLeast: {
+            eyeSquintLeft: 0.45,
+            eyeSquintRight: 0.45,
+            browDownLeft: 0.3,
+            browDownRight: 0.3
+          }
+        }
+      ]
+    },
+    hint: { target: "scrunch" }
+  }
+}, En = Object.keys(He), Gt = (t, n) => {
+  for (const [e, o] of Object.entries(n.atLeast ?? {}))
+    if ((t[e] ?? 0) < (o ?? 0)) return !1;
+  for (const [e, o] of Object.entries(n.atMost ?? {}))
+    if ((t[e] ?? 0) > (o ?? 1)) return !1;
+  return !(n.anyOf && n.anyOf.length > 0 && !n.anyOf.some((e) => Gt(t, e)));
+}, ee = (t) => typeof t == "string" ? He[t] : typeof t == "object" && "hint" in t ? t : void 0, _e = (t, n, e) => {
+  if (typeof n == "function") return n(t, e);
+  const o = ee(n);
+  return o ? o.rule && !Gt(t, o.rule) ? !1 : o.match ? o.match(t, e) : !!o.rule : Gt(t, n);
+}, yo = (t) => En.filter((n) => _e(t, n)), Dn = (t, n, e) => {
+  const o = n ? de(n) : /* @__PURE__ */ new Map(), s = e ? de(e) : /* @__PURE__ */ new Map(), r = [];
+  for (const h of /* @__PURE__ */ new Set([...o.keys(), ...s.keys()])) {
+    const f = t.getObjectByName(h);
+    if (!f) continue;
+    const u = f.quaternion.clone();
+    r.push({ node: f, from: o.get(h) ?? u, to: s.get(h) ?? u });
+  }
+  const a = n ? pe(n) : /* @__PURE__ */ new Map(), c = e ? pe(e) : /* @__PURE__ */ new Map(), m = [];
+  for (const h of /* @__PURE__ */ new Set([...a.keys(), ...c.keys()])) {
+    const f = t.getObjectByName(h);
+    if (!f) continue;
+    const u = f.position.clone();
+    m.push({ node: f, from: a.get(h) ?? u, to: c.get(h) ?? u });
+  }
+  return {
+    apply: (h) => {
+      for (const f of r) f.node.quaternion.copy(f.from).slerp(f.to, h);
+      for (const f of m) f.node.position.lerpVectors(f.from, f.to, h);
+    }
+  };
+}, Pn = (t, n) => {
+  const e = t.filter((o) => o.morphTargetInfluences && o.morphTargetDictionary).map((o) => ({
+    influences: o.morphTargetInfluences,
+    weights: Object.entries(n).map(([s, r]) => [o.morphTargetDictionary[s] ?? -1, r]).filter(([s]) => s >= 0)
+  }));
+  return {
+    apply: (o) => {
+      for (const { influences: s, weights: r } of e) {
+        s.fill(0);
+        for (const [a, c] of r) s[a] = c * o;
+      }
+    }
+  };
+}, Cn = {
+  parts: {
+    eye_white: { core: 0.62 },
+    iris: { color: "#2a2732", core: 0.9, rim: 0.95, whiten: 0.12 },
+    sparkle: { core: 0.95, rim: 0.95 },
+    lash: { color: "#3b302c", core: 0.88, rim: 0.92, whiten: 0.12 },
+    brow: { color: "#4a3a33", core: 0.85, rim: 0.92, whiten: 0.15 },
+    lip: { color: "#c47878", core: 0.8, rim: 0.9, whiten: 0.2 },
+    mouth_inside: { color: "#2b1517", core: 0.9, rim: 0.92, whiten: 0.08 },
+    tongue: { color: "#e88a8a", core: 0.85, rim: 0.9, whiten: 0.15 }
+  },
+  halo: { width: 0.3 },
+  glow: { size: 1.75 }
+}, An = { seconds: 2.4 }, Bn = ({
+  expression: t,
+  model: n,
+  height: e = 1,
+  loop: o,
+  look: s,
+  orbit: r = 30,
+  orbitSeconds: a = 6,
+  renderOrder: c
+}) => {
+  const m = typeof t == "string" || "label" in t ? ee(t).hint : t, h = JSON.stringify("targets" in m ? m.targets : { [m.target]: 1 }), f = te(n, s, { base: Cn, renderOrder: c }), u = f.object, b = R(
+    () => Pn(
+      f.meshes.flatMap(({ mesh: g, twins: d }) => [g, ...d]),
+      JSON.parse(h)
+    ),
+    [f.meshes, h]
+  ), w = R(() => {
+    u.updateMatrixWorld(!0);
+    const g = [];
+    for (const { mesh: S } of f.meshes) {
+      const B = S.geometry.getAttribute("position");
+      for (let _ = 0; _ < B.count; _ += 3)
+        g.push(
+          new i.Vector3().fromBufferAttribute(B, _).applyMatrix4(S.matrixWorld)
+        );
+    }
+    const d = new i.Box3().setFromPoints(g).getCenter(new i.Vector3()), T = Qt(g, d, i.MathUtils.degToRad(r)) * 1.08;
+    return { offset: d.clone().negate(), span: T };
+  }, [u, f.meshes, r]), p = JSON.stringify(o ?? {}), y = R(
+    () => ({ ...An, ...o }),
+    [p, o == null ? void 0 : o.easing]
+    // eslint-disable-line react-hooks/exhaustive-deps
+  );
+  Z(({ clock: g }) => {
+    const { amount: d } = Jt(g.elapsedTime, y);
+    b.apply(d), f.setStrength(d);
+  });
+  const l = f.look.glow;
+  return /* @__PURE__ */ x(
+    Zt,
+    {
+      height: e,
+      span: w.span,
+      orbit: r,
+      orbitSeconds: a,
+      glow: f.glowMaterial,
+      glowSize: l ? l.size : void 0,
+      renderOrder: c,
+      children: /* @__PURE__ */ x("group", { position: w.offset, children: /* @__PURE__ */ x("primitive", { object: u }) })
+    }
+  );
+}, Ln = (t, { faceIndex: n = 0, active: e = !0, ...o } = {}) => {
+  const s = R(() => ({ numFaces: n + 1 }), [n]), { node: r, ready: a } = $t(
+    Kt.FACE_TRACKER,
+    s,
+    e
+  ), { camera: c } = De();
+  j(() => {
+    r == null || r.setCamera(c, n);
+  }, [c, n, r]);
+  const m = qt(st(t), o), h = E(null), f = E(Fe()), u = E(t);
+  u.current = t;
+  const b = jt(() => h.current !== null, []);
+  return Z(() => {
+    if (!e) return;
+    const w = a && r ? Ge(r, n, f.current) : null;
+    h.current = w, m.step(!!w && _e(w.blendshapes, u.current, w));
+  }), {
+    status: m.status,
+    holdRef: m.holdRef,
+    matchedRef: m.matchedRef,
+    isInView: b,
+    reset: m.reset,
+    faceRef: h
+  };
+}, bo = Ht, zn = "Show your face to the camera", Un = ({
+  expression: t,
+  model: n,
+  faceIndex: e,
+  holdMs: o,
+  graceMs: s,
+  orbit: r,
+  look: a,
+  loop: c,
+  onComplete: m,
+  nudgeText: h = zn,
+  ...f
+}) => {
+  const u = Ln(t, { faceIndex: e, holdMs: o, graceMs: s, onComplete: m });
+  return /* @__PURE__ */ x(
+    _t,
+    {
+      ...f,
+      nudgeText: h,
+      detector: u,
+      symbol: (b, w) => /* @__PURE__ */ x(
+        Bn,
+        {
+          expression: t,
+          model: n,
+          height: b,
+          orbit: r,
+          look: a,
+          loop: c,
+          renderOrder: w
+        }
+      )
+    }
+  );
+}, wo = ({ active: t = !0, text: n, ...e }) => t ? /* @__PURE__ */ x(Rt, { children: /* @__PURE__ */ x(
+  Un,
+  {
+    ...e,
+    text: n ?? ee(e.expression).label
+  },
+  st(e.expression)
+) }) : null, Wn = {
+  parts: { joints: { color: "#7c8aa0", core: 0.7, rim: 0.9, whiten: 0.35 } },
+  halo: { width: 1.2 },
+  glow: { size: 1.3 }
+}, Oe = /* @__PURE__ */ new Set(), Vn = { seconds: 2.6 }, Fn = (t) => {
+  for (const [n, e] of [
+    ["left", "Left"],
+    ["right", "Right"]
+  ])
+    if (t === `${e}Arm` || t === `${e}ForeArm` || t.startsWith(`${e}Hand`)) return n;
+  return null;
+}, Gn = (t) => {
+  for (const [n, e] of [
+    ["left", "Left"],
+    ["right", "Right"]
+  ])
+    if (t === `${e}UpLeg` || t === `${e}Leg` || t === `${e}Foot` || t.startsWith(`${e}Toe`))
+      return n;
+  return null;
+}, jn = ({
+  pose: t,
+  model: n,
+  poses: e,
+  idleClip: o = "idle",
+  height: s = 1,
+  mirrored: r = !1,
+  loop: a,
+  look: c,
+  highlight: m = !0,
+  boneSide: h = Fn,
+  legBoneSide: f = Gn,
+  orbit: u = 25,
+  orbitSeconds: b = 7,
+  renderOrder: w
+}) => {
+  const p = typeof t == "string" || "label" in t ? vt(t).hint : t, y = p.clip, l = (p.arms ?? []).join(), g = (p.legs ?? []).join(), d = te(n, c, { base: Wn, renderOrder: w }), T = d.object, S = R(
+    () => Dn(
+      T,
+      e.find((v) => v.name === o),
+      e.find((v) => v.name === y)
+    ),
+    [T, e, o, y]
+  );
+  j(() => {
+    const v = e.map((I) => I.name);
+    for (const [I, K] of [
+      [o, "rest"],
+      [y, "pose"]
+    ])
+      v.includes(I) || Oe.has(I) || (Oe.add(I), console.warn(
+        `[BodyPoseHint] the model has no "${I}" clip (the ${K === "rest" ? "rest pose the hint loops from" : "pose to show"}); the figure uses its bind pose there instead. Clips found: ${v.join(", ") || "none"}.`
+      ));
+  }, [e, o, y]), j(() => {
+    const v = l ? l.split(",") : [], I = g ? g.split(",") : [];
+    d.setHighlight((K) => {
+      if (!m) return 0;
+      const O = h(K.name);
+      if (O && v.includes(O)) return 1;
+      const L = f(K.name);
+      return L && I.includes(L) ? 1 : 0;
+    });
+  }, [d, l, g, m, h, f]);
+  const B = R(() => {
+    const v = [], I = new i.Matrix4();
+    for (const L of [0, 0.6, 1]) {
+      S.apply(L), T.updateMatrixWorld(!0), I.copy(T.matrixWorld).invert();
+      for (const { mesh: D } of d.meshes) {
+        if (!(D instanceof i.SkinnedMesh)) continue;
+        D.skeleton.update();
+        const N = D.geometry.getAttribute("position");
+        for (let U = 0; U < N.count; U += 12) {
+          const C = new i.Vector3().fromBufferAttribute(N, U);
+          D.applyBoneTransform(U, C), v.push(C.applyMatrix4(D.matrixWorld).applyMatrix4(I));
+        }
+      }
+    }
+    S.apply(0);
+    const K = new i.Box3().setFromPoints(v).getCenter(new i.Vector3()), O = Qt(v, K, i.MathUtils.degToRad(u)) * 1.06;
+    return { offset: K.clone().negate(), span: O };
+  }, [T, d.meshes, S, u]), _ = JSON.stringify(a ?? {}), q = R(
+    () => ({ ...Vn, ...a }),
+    [_, a == null ? void 0 : a.easing]
+    // eslint-disable-line react-hooks/exhaustive-deps
+  );
+  Z(({ clock: v }) => {
+    const { amount: I } = Jt(v.elapsedTime, q);
+    S.apply(I), d.setStrength(I);
+  });
+  const Q = d.look.glow;
+  return /* @__PURE__ */ x(
+    Zt,
+    {
+      height: s,
+      span: B.span,
+      mirrored: r,
+      orbit: u,
+      orbitSeconds: b,
+      glow: d.glowMaterial,
+      glowSize: Q ? Q.size : void 0,
+      renderOrder: w,
+      children: /* @__PURE__ */ x("group", { position: B.offset, children: /* @__PURE__ */ x("primitive", { object: T }) })
+    }
+  );
+}, qn = (t, { bodyIndex: n = 0, limits: e, active: o = !0, ...s } = {}) => {
+  const { node: r, ready: a } = $t(
+    Kt.BODY_TRACKER,
+    void 0,
+    o
+  ), c = Yt(), m = We(), h = qt(st(t), s), f = E(null), u = E(t);
+  u.current = t;
+  const b = JSON.stringify(e ?? null), w = R(() => e, [b]), p = jt(() => {
+    var l;
+    const y = f.current;
+    return y != null && y.upperBodyVisible ? ((l = vt(u.current)) == null ? void 0 : l.view) !== "full" || y.lowerBodyVisible : !1;
+  }, []);
+  return Z(() => {
+    var g;
+    if (!o) return;
+    const y = a && r ? r.getLandmarks2D(n) : void 0, l = y && y.length >= Le ? ze(y, {
+      mirrored: c,
+      visibility: (g = r == null ? void 0 : r.getVisibility) == null ? void 0 : g.call(r, n),
+      limits: w,
+      aspect: m
+    }) : null;
+    f.current = l, h.step(!!l && l.upperBodyVisible && Ue(l, u.current));
+  }), {
+    status: h.status,
+    holdRef: h.holdRef,
+    matchedRef: h.matchedRef,
+    isInView: p,
+    reset: h.reset,
+    shapeRef: f
+  };
+}, Mo = Ht, Kn = (t) => {
+  var n;
+  return ((n = vt(t)) == null ? void 0 : n.view) === "full";
+}, Yn = 2.1, $n = "Step back so your upper body is in view", Qn = "Step back so your whole body is in view", Xn = ({
+  pose: t,
+  model: n,
+  poses: e,
+  idleClip: o,
+  bodyIndex: s,
+  holdMs: r,
+  graceMs: a,
+  limits: c,
+  symbolAspect: m = Yn,
+  orbit: h,
+  look: f,
+  loop: u,
+  boneSide: b,
+  legBoneSide: w,
+  onComplete: p,
+  nudgeText: y,
+  ...l
+}) => {
+  const g = Yt(), d = qn(t, { bodyIndex: s, holdMs: r, graceMs: a, limits: c, onComplete: p });
+  return /* @__PURE__ */ x(
+    _t,
+    {
+      ...l,
+      nudgeText: y !== void 0 ? y : Kn(t) ? Qn : $n,
+      detector: d,
+      symbolAspect: m,
+      symbol: (T, S) => /* @__PURE__ */ x(
+        jn,
+        {
+          pose: t,
+          model: n,
+          poses: e,
+          idleClip: o,
+          height: T,
+          mirrored: g,
+          orbit: h,
+          look: f,
+          loop: u,
+          boneSide: b,
+          legBoneSide: w,
+          renderOrder: S
+        }
+      )
+    }
+  );
+}, To = ({ active: t = !0, text: n, ...e }) => t ? /* @__PURE__ */ x(Rt, { children: /* @__PURE__ */ x(
+  Xn,
+  {
+    ...e,
+    text: n ?? vt(e.pose).label
+  },
+  st(e.pose)
+) }) : null;
+export {
+  Wn as BODY_HINT_LOOK,
+  Vn as BODY_HINT_LOOP,
+  Qn as BODY_INSTRUCTION_FULL_NUDGE_TEXT,
+  $n as BODY_INSTRUCTION_NUDGE_TEXT,
+  Mo as BODY_INSTRUCTION_RENDER_ORDER,
+  Le as BODY_LANDMARK_COUNT,
+  Io as BODY_LOWER_JOINTS,
+  No as BODY_POSES,
+  Eo as BODY_POSE_JOINTS,
+  Do as BODY_POSE_NAMES,
+  Po as BODY_SHAPE_LIMITS,
+  Yn as BODY_SYMBOL_ASPECT,
+  Co as BODY_UPPER_JOINTS,
+  To as BodyInstruction,
+  jn as BodyPoseHint,
+  He as FACE_EXPRESSIONS,
+  En as FACE_EXPRESSION_NAMES,
+  Cn as FACE_HINT_LOOK,
+  An as FACE_HINT_LOOP,
+  zn as FACE_INSTRUCTION_NUDGE_TEXT,
+  bo as FACE_INSTRUCTION_RENDER_ORDER,
+  Bn as FaceExpressionHint,
+  wo as FaceInstruction,
+  Oo as GESTURE_HOLD_DEFAULT_MS,
+  ko as GESTURE_HOLD_GRACE_MS,
+  Ft as GHOST_MAX_BONES,
+  bt as HAND_DIGITS,
+  Re as HAND_GESTURES,
+  sn as HAND_GESTURE_NAMES,
+  On as HAND_HINT_LOOK,
+  xe as HAND_HINT_LOOP,
+  In as HAND_INSTRUCTION_NUDGE_TEXT,
+  fo as HAND_INSTRUCTION_RENDER_ORDER,
+  ge as HAND_SHAPE_LIMITS,
+  bn as HINT_LOOP_HOLD,
+  Hn as HandGestureHint,
+  po as HandInstruction,
+  Zt as HintStage,
+  Ht as INSTRUCTION_RENDER_ORDER,
+  on as INSTRUCTION_TEXT_STYLE,
+  uo as Instruction,
+  $e as addHintTwins,
+  ze as analyzeBodyShape,
+  ke as analyzeHandShape,
+  Ut as applyHandHintPose,
+  Qe as assignHintMaterials,
+  Dn as createClipBlend,
+  Ye as createDepthPrepassMaterial,
+  Ro as createGestureHoldState,
+  qe as createGhostMaterial,
+  Je as createGlowMaterial,
+  Ke as createHaloMaterial,
+  je as createHintMatcap,
+  Pn as createMorphBlend,
+  Ao as defineBodyPose,
+  go as defineFaceExpression,
+  ho as defineHandGesture,
+  Ze as disposeGlowMaterial,
+  it as ease,
+  tn as hasVertexColors,
+  Ue as matchBodyPose,
+  _e as matchFaceExpression,
+  ve as matchHandGesture,
+  Bo as matchingBodyPoses,
+  yo as matchingFaceExpressions,
+  mo as matchingHandGestures,
+  Sn as mergeHintLook,
+  Fn as mixamoBoneSide,
+  Gn as mixamoLegBoneSide,
+  Qt as orbitSpan,
+  de as readClipQuaternions,
+  dn as readHandClipPose,
+  vt as resolveBodyPose,
+  ee as resolveFaceExpression,
+  Xt as resolveHandGesture,
+  Jt as sampleHintLoop,
+  wn as sampleHintOrbit,
+  Lo as squareLandmarks,
+  vo as stepGestureHold,
+  qn as useBodyPose,
+  Ln as useFaceExpression,
+  te as useGhostModel,
+  _n as useHandGesture,
+  Ho as useInstructionHold
+};