@vincentt-xr/sdk 2.0.0-alpha.0 → 2.0.0-alpha.10

package/dist/instructions.js

@@ -0,0 +1,1528 @@
+import { jsxs as Vt, jsx as S } 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 D, useEffect as q, 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 Ro, b as vo, c as Ho, d as Io, a as _o } from "./useInstructionHold-DOu-RpCM.js";
+import { e as T, H as Ce, j as Se } from "./index-CKRN-xJp.js";
+import { H as kt, b as Ae, s as Be, r as vt, B as Le, a as ze, m as Ue } from "./index-DiIoHK_4.js";
+import { c as Eo, d as Do, e as Po, f as Co, g as Ao, h as Bo, i as Lo, j as zo, k as Uo } from "./index-DiIoHK_4.js";
+import { f as Kt, g as We } from "./selectors-BvJepq6H.js";
+import { c as Ve } from "./SkeletonUtils-C2r90MtN.js";
+import { u as ke } from "./landmarks-DtCAFV_m.js";
+import { a as Fe, b as Ge } from "./getFaceInfo-BafgGT27.js";
+import { u as je } from "./useBodies-BYzJpQ4L.js";
+const qe = () => {
+  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, Ke = (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;
+}, $e = ({
+  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 }), Ot = "instructionHintTwin", Qe = (t) => {
+  const n = [];
+  return t.traverse((e) => {
+    e.frustumCulled = !1, e instanceof i.Mesh && !e.userData[Ot] && n.push(e);
+  }), n.map((e) => ({
+    mesh: e,
+    twins: ["prepass", "halo"].map((o) => {
+      var r;
+      const s = e.clone();
+      return s.userData[Ot] = o, s.frustumCulled = !1, (r = e.parent) == null || r.add(s), s;
+    })
+  }));
+}, Xe = (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[Ot];
+    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);
+  });
+}, Je = [-1, -0.5, 0, 0.5, 1], $t = (t, n, e) => {
+  let o = 1e-6, s = 1e-6;
+  const r = new i.Vector3();
+  for (const a of Je) {
+    const c = new i.Matrix4().makeRotationY(e * a);
+    for (const l of t)
+      r.copy(l).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), Ze = (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 l = new i.CanvasTexture(o);
+  l.colorSpace = i.SRGBColorSpace;
+  const d = new i.MeshBasicMaterial({
+    map: l,
+    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 d.userData.glowTexture = l, d;
+}, tn = (t) => {
+  var n;
+  (n = t.userData.glowTexture) == null || n.dispose(), t.dispose();
+}, en = (t) => {
+  let n = !0;
+  return t.traverse((e) => {
+    e instanceof i.Mesh && !e.geometry.getAttribute("color") && (n = !1);
+  }), n;
+}, ue = /* @__PURE__ */ new WeakMap(), he = (t) => {
+  const n = ue.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, l, d] = o.values;
+    e.set(s, new i.Quaternion(a, c, l, d).normalize());
+  }
+  return ue.set(t, e), e;
+}, 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 !== "position") continue;
+    const [a, c, l] = o.values;
+    e.set(s, new i.Vector3(a, c, l));
+  }
+  return me.set(t, e), e;
+}, Ht = 2e3, nn = { sm: 0.1, md: 0.14, lg: 0.19 }, At = 160, on = 0.66, rn = {
+  color: "#ffffff",
+  fontWeight: "bold",
+  textAlign: "center",
+  bgColor: "transparent",
+  padding: 4,
+  resolution: At,
+  fontSize: At * on,
+  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;
+  });
+}, It = ({
+  text: t,
+  doneText: n,
+  nudgeText: e = null,
+  nudgeAfterMs: o = 3e3,
+  size: s = "md",
+  placement: r = "center",
+  offset: a = [0, 0],
+  color: c,
+  textStyle: l,
+  nudgeTextStyle: d,
+  renderText: p,
+  motion: u = {},
+  layout: y = {},
+  hideOnComplete: M = !0,
+  onStatusChange: f,
+  detector: b,
+  symbol: h,
+  symbolAspect: g = 1
+}) => {
+  const { width: m, height: w } = Pe(), x = b.status, {
+    fadeIn: H = 0.35,
+    fadeOut: v = 0.5,
+    rise: U = 0.15,
+    bob: Q = 0.02,
+    pop: I = 0.1,
+    popSeconds: N = 0.3,
+    nudgePulse: K = 0.06,
+    ring: k = {}
+  } = u, L = k ? k.seconds ?? 0.6 : 0, P = k ? k.from ?? 0.45 : 0, E = k ? k.to ?? 0.95 : 0, W = k ? k.opacity ?? 0.7 : 0, A = typeof s == "number" ? s : nn[s], F = Math.min(w * A, m * 0.42), G = Math.min(F * g, w * 0.62), nt = F * (y.textHeight ?? 0.3), at = F * (y.nudgeHeight ?? 0.2), ct = Math.min(m * 0.9, F * (y.textWidth ?? 6)), lt = w * (y.edgeMargin ?? 0.06), tt = G + F * (y.gap ?? 0.1) + nt, ut = (r === "top" ? w / 2 - lt - tt / 2 : r === "bottom" ? -w / 2 + lt + tt / 2 + (e !== null ? at : 0) : 0) + a[1] * w / 2, wt = tt / 2 - G / 2, ht = -tt / 2 + nt / 2, mt = ht - nt / 2 - at / 2, [_t, te] = Ct("waiting"), [z, C] = Ct(!1), X = D("waiting"), dt = D(performance.now()), B = D(f);
+  B.current = f;
+  const Y = D(b.isInView);
+  Y.current = b.isInView;
+  const ft = D(!1);
+  q(() => {
+    var V;
+    ft.current || (ft.current = !0, (V = B.current) == null || V.call(B, X.current));
+  }, []);
+  const ot = D(null), et = D(null), pt = D(null), Nt = D(null), Mt = D(null), Et = R(() => new i.RingGeometry(0.94, 1, 72), []), ee = k ? k.color ?? "#ffffff" : "#ffffff", Tt = R(
+    () => new i.MeshBasicMaterial({
+      color: ee,
+      transparent: !0,
+      opacity: 0,
+      depthTest: !1,
+      depthWrite: !1
+    }),
+    [ee]
+  );
+  q(() => () => Et.dispose(), [Et]), q(() => () => Tt.dispose(), [Tt]);
+  const j = R(() => ({ age: 0, doneAge: 0, nudge: 0 }), []), [ne, _e] = Ct(!1);
+  if (Z((V, Dt) => {
+    var le;
+    const ie = performance.now(), se = Y.current();
+    se && (dt.current = ie);
+    const J = x === "done" ? "done" : x === "holding" ? "holding" : se ? "detected" : "waiting";
+    J !== X.current && (X.current = J, te(J), ft.current = !0, (le = B.current) == null || le.call(B, J));
+    const Pt = e !== null && J === "waiting" && ie - dt.current > o;
+    Pt !== z && C(Pt), j.age += Dt, j.nudge = i.MathUtils.damp(j.nudge, Pt ? 1 : 0, 6, Dt);
+    const ae = H > 0 ? it(Math.min(j.age / H, 1)) : 1;
+    let xt = ae, ce = 1;
+    if (J === "done" && (j.doneAge += Dt, N > 0 && (ce = 1 + I * Math.sin(Math.min(j.doneAge / N, 1) * Math.PI)), M && (xt *= v > 0 ? 1 - it(Math.min(j.doneAge / v, 1)) : 0, j.doneAge >= v && !ne && _e(!0))), ot.current && (ot.current.position.y = ut - (1 - ae) * G * U, ot.current.scale.setScalar(ce)), et.current) {
+      const rt = j.age;
+      et.current.position.y = wt + Math.sin(rt * 2.2) * G * Q, et.current.scale.setScalar(
+        1 + j.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(j.doneAge / L, 1) : 1;
+      Mt.current.visible = J === "done" && rt < 1, Mt.current.scale.setScalar(G * (P + (E - P) * it(rt))), Tt.opacity = W * (1 - rt);
+    }
+    pt.current && Bt(pt.current, xt), Nt.current && Bt(Nt.current, xt * j.nudge * 0.85);
+  }), ne) return null;
+  const gt = Ht, oe = {
+    ...rn,
+    ...c !== void 0 ? { color: c } : {},
+    ...l
+  }, Ne = { ...oe, fontWeight: "normal", ...d }, re = (V) => p ? p(V) : /* @__PURE__ */ S(
+    Ee,
+    {
+      text: V.text,
+      ...V.style,
+      aspect: V.width / V.height,
+      scale: [V.width, V.height, 1],
+      renderOrder: V.renderOrder
+    }
+  );
+  return /* @__PURE__ */ Vt("group", { ref: ot, position: [a[0] * m / 2, ut, 0], children: [
+    /* @__PURE__ */ Vt("mesh", { renderOrder: gt, scale: [1e-4, 1e-4, 1], onBeforeRender: (V) => V.clearDepth(), children: [
+      /* @__PURE__ */ S("planeGeometry", { args: [1, 1] }),
+      /* @__PURE__ */ S("meshBasicMaterial", { colorWrite: !1, depthWrite: !1, transparent: !0 })
+    ] }),
+    /* @__PURE__ */ S("group", { ref: et, position: [0, wt, G * 0.5], children: h(G, gt + 1) }),
+    k && /* @__PURE__ */ S(
+      "mesh",
+      {
+        ref: Mt,
+        geometry: Et,
+        material: Tt,
+        position: [0, wt, 0],
+        renderOrder: gt + 3,
+        visible: !1
+      }
+    ),
+    /* @__PURE__ */ S("group", { ref: pt, position: [0, ht, 0], children: re({
+      text: _t === "done" && n !== void 0 ? n : t,
+      role: "text",
+      width: ct,
+      height: nt,
+      renderOrder: gt + 2,
+      style: oe
+    }) }),
+    e !== null && /* @__PURE__ */ S("group", { ref: Nt, position: [0, mt, 0], visible: z || j.nudge > 0.01, children: re({
+      text: e,
+      role: "nudge",
+      width: ct,
+      height: at,
+      renderOrder: gt + 2,
+      style: Ne
+    }) })
+  ] });
+}, mo = ({ active: t = !0, ...n }) => t ? /* @__PURE__ */ S(Rt, { children: /* @__PURE__ */ S(It, { ...n }) }) : null, bt = ["thumb", "index", "middle", "ring", "pinky"], sn = (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);
+}, fe = 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)
+}), Oe = (t, { limits: n } = {}) => {
+  if (t.length < 21) throw new Error("analyzeHandShape needs 21 joints");
+  const e = t.map(sn), o = n ? { ...fe, ...n } : fe, s = e[T.middleMcp].distanceTo(e[T.wrist]), r = e[T.indexMcp].distanceTo(e[T.pinkyMcp]), a = {}, c = {};
+  for (const u of ["index", "middle", "ring", "pinky"]) {
+    const y = e[T[`${u}Mcp`]], M = e[T[`${u}Pip`]], f = e[T[`${u}Dip`]], b = e[T[`${u}Tip`]], h = yt(e[T.wrist], y, M), g = yt(y, M, f) + yt(M, f, b);
+    c[u] = i.MathUtils.clamp((h + g) / o.fullCurl, 0, 1), a[u] = g < o.fingerStraight && h < o.fingerKnuckle && b.distanceTo(e[T.wrist]) > M.distanceTo(e[T.wrist]);
+  }
+  const l = yt(e[T.thumbCmc], e[T.thumbMcp], e[T.thumbIp]) + yt(e[T.thumbMcp], e[T.thumbIp], e[T.thumbTip]);
+  c.thumb = i.MathUtils.clamp(l / i.MathUtils.degToRad(150), 0, 1), a.thumb = l < o.thumbStraight && e[T.thumbTip].distanceTo(e[T.indexMcp]) > o.thumbReach * r && e[T.thumbTip].distanceTo(e[T.pinkyMcp]) > e[T.thumbIp].distanceTo(e[T.pinkyMcp]);
+  const d = e[T.thumbTip].clone().sub(e[T.thumbMcp]).normalize(), p = a.thumb ? d.y >= o.thumbVertical ? "up" : d.y <= -o.thumbVertical ? "down" : "side" : "side";
+  return {
+    extended: a,
+    curl: c,
+    count: bt.filter((u) => a[u]).length,
+    thumbDirection: p,
+    thumbIndexTouch: e[T.thumbTip].distanceTo(e[T.indexTip]) < o.touch * s
+  };
+}, fo = (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 }, $ = (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: $(),
+      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: $({ 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: $({ thumb: 0 }), thumbTuck: 0, aimThumb: "up" }
+  },
+  thumbDown: {
+    label: "Give a thumbs down",
+    rule: { digits: { thumb: !0, ...Lt }, thumbDirection: "down" },
+    hint: { clip: "thumbUp", curl: $({ 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: $({ 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: $({ 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: $({ 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: $({ 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: $({ 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: $({ 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: $({ 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
+    }
+  }
+}, an = Object.keys(Re), Yt = (t) => typeof t == "string" ? Re[t] : typeof t == "object" && "hint" in t ? t : void 0, pe = (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 = Yt(n);
+  return o ? o.rule && !pe(t, o.rule) ? !1 : o.match ? o.match(t, e) : !!o.rule : pe(t, n);
+}, po = (t) => an.filter((n) => ve(t, n)), ge = {
+  finger: [85, 100, 70].map(i.MathUtils.degToRad),
+  thumb: [10, 45, 35].map(i.MathUtils.degToRad)
+}, cn = { index: 12, middle: 3, ring: -8, pinky: -16 }, ln = i.MathUtils.degToRad(70), un = 0.65, hn = { 1: [1, 0.35], 2: [0.6, 1] }, mn = Object.fromEntries(
+  kt.map(({ name: t }) => [
+    t,
+    t.endsWith("Cmc") || t.endsWith("Mcp") && !t.startsWith("thumb") ? 0 : t === "thumbMcp" || t.endsWith("Pip") ? 1 : 2
+  ])
+), ye = (t) => bt.find((n) => t.startsWith(n)) ?? "index", _ = {
+  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", ...kt.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), dn = (t, n) => {
+  if (!(!t || !n)) {
+    for (const e of t) if (e.name === n) return e;
+  }
+}, be = /* @__PURE__ */ new WeakMap(), fn = (t) => {
+  const n = be.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 T)) continue;
+    const [a, c, l, d] = o.values;
+    e[s] = new i.Quaternion(a, c, l, d).normalize();
+  }
+  return be.set(t, e), e;
+}, Ut = (t, n, e = 1, o) => {
+  var p;
+  const s = dn(o, n.clip);
+  if (s) {
+    const u = fn(s);
+    for (const { name: y } of kt) {
+      const M = t.bones[y], f = t.restLocal[y];
+      !M || !f || M.quaternion.copy(f).slerp(u[y] ?? f, zt(e, ye(y)));
+    }
+    return;
+  }
+  const r = t.restPalmNormal, a = t.restPositions, c = _.thumbSide.subVectors(a[T.indexMcp], a[T.pinkyMcp]).normalize(), l = _.live;
+  l.wrist.copy(t.restQuaternions.wrist);
+  for (const { name: u, parent: y, child: M } of kt) {
+    const f = ye(u), b = zt(e, f), h = mn[u] ?? 0, g = (((p = n.curl) == null ? void 0 : p[f]) ?? 0) * b, m = (f === "thumb" ? ge.thumb : ge.finger)[h] * g;
+    _.restInv.copy(t.restQuaternions[y]).invert(), _.delta.copy(l[y]).multiply(_.restInv), _.dir.subVectors(a[T[M]], a[T[u]]).normalize(), _.axis.crossVectors(_.dir, r).normalize();
+    const w = Math.sign(_.cross.crossVectors(r, _.dir).dot(c)), x = _.D.identity();
+    if (f === "thumb") {
+      const v = -w || -1, [U, Q] = hn[h] ?? [0, 1];
+      _.q.setFromAxisAngle(
+        _.thumbAxis.copy(r).multiplyScalar(v * U).addScaledVector(_.axis, Q).normalize(),
+        m
+      ), x.copy(_.q);
+    } else
+      x.setFromAxisAngle(_.axis, m);
+    if (h === 0 && f !== "thumb") {
+      const v = i.MathUtils.degToRad(cn[f]) * (n.spread ?? 0) * b;
+      x.premultiply(_.q.setFromAxisAngle(r, v * (w || 1)));
+    }
+    if (f === "thumb" && h === 0) {
+      const v = ln * (n.thumbTuck ?? 0) * b;
+      x.premultiply(_.q.setFromAxisAngle(r, -v * (w || 1))), x.premultiply(_.q.setFromAxisAngle(_.axis, v * un));
+    }
+    l[u].copy(_.delta).multiply(x).multiply(t.restQuaternions[u]);
+    const H = t.bones[u];
+    H && H.quaternion.copy(_.q.copy(l[y]).invert().multiply(l[u]));
+  }
+  const d = Math.min(zt(e, "thumb"), 1);
+  n.thumbTo && d > 0 && bn(t, n.thumbTo, d);
+}, pn = {
+  thumbCmc: i.MathUtils.degToRad(75),
+  thumbMcp: i.MathUtils.degToRad(65),
+  thumbIp: i.MathUtils.degToRad(85)
+}, gn = ["thumbIp", "thumbMcp", "thumbCmc"], O = {
+  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()
+}, yn = [0, 0, 0], St = (t, n) => t.getWorldPosition(n).applyMatrix4(O.inv), bn = (t, n, e) => {
+  const o = t.root, s = t.restPositions, r = s[T.middleMcp].distanceTo(s[T.wrist]), a = O.up.subVectors(s[T.middleMcp], s[T.wrist]).normalize(), c = O.side.subVectors(s[T.indexMcp], s[T.pinkyMcp]);
+  c.addScaledVector(a, -c.dot(a)).normalize();
+  const [l, d, p] = n.offset ?? yn, u = t.bones.thumbTip ?? t.bones.thumbIp, y = t.bones[n.joint];
+  if (!y) return;
+  o.updateMatrixWorld(!0), O.inv.copy(o.matrixWorld).invert(), St(y, O.target).addScaledVector(c, l * r).addScaledVector(a, d * r).addScaledVector(t.restPalmNormal, p * r), St(u, O.start), O.target.lerp(O.start, 1 - e);
+  const M = o.getWorldQuaternion(O.rq).invert();
+  for (let f = 0; f < 10; f += 1)
+    for (const b of gn) {
+      const h = t.bones[b];
+      if (!(h != null && h.parent) || (o.updateMatrixWorld(!0), St(h, O.head), St(u, O.eff), O.a.subVectors(O.eff, O.head), O.b.subVectors(O.target, O.head), O.a.lengthSq() < 1e-10 || O.b.lengthSq() < 1e-10)) continue;
+      O.q.setFromUnitVectors(O.a.normalize(), O.b.normalize()), h.parent.getWorldQuaternion(O.pq).premultiply(M), h.quaternion.premultiply(O.pqInv.copy(O.pq).invert().multiply(O.q).multiply(O.pq));
+      const g = t.restLocal[b], m = pn[b] ?? Math.PI, w = h.quaternion.angleTo(g);
+      w > m && h.quaternion.copy(O.limited.copy(g).slerp(h.quaternion, m / w));
+    }
+}, wn = 2 * Math.acos(2 / 3) / Math.PI, Qt = (t, { seconds: n = 2.4, hold: e = wn, 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) };
+}, Mn = (t, n, e) => e > 0 ? Math.sin(t / e * Math.PI * 2) * i.MathUtils.degToRad(n) : 0, Xt = ({
+  height: t,
+  span: n,
+  mirrored: e = !1,
+  orbit: o = 0,
+  orbitSeconds: s = 6,
+  glow: r = null,
+  glowSize: a = 1.75,
+  renderOrder: c = 0,
+  children: l
+}) => {
+  const d = D(null);
+  Z(({ clock: u }) => {
+    d.current && (d.current.rotation.y = Mn(u.elapsedTime, o, s));
+  });
+  const p = t / n;
+  return /* @__PURE__ */ Vt("group", { scale: [p * (e ? -1 : 1), p, p], children: [
+    r && // Behind the hint, not orbiting: drawn first in the band (before the depth pre-pass).
+    /* @__PURE__ */ S(
+      "mesh",
+      {
+        material: r,
+        position: [0, 0, -n * 0.6],
+        scale: n * a,
+        renderOrder: c - 0.75,
+        children: /* @__PURE__ */ S("planeGeometry", { args: [1, 1] })
+      }
+    ),
+    /* @__PURE__ */ S("group", { ref: d, children: l })
+  ] });
+}, Tn = { width: 0.3, color: "#0f172a", opacity: 0.3 }, xn = { color: "#ffffff", size: 1.75, idle: 0.5, full: 0.85 }, Sn = { opacity: 0.9, whiten: 0.55, idle: 0.25 }, Wt = (t, n, e) => e === !1 || n === !1 && e === void 0 ? !1 : { ...t, ...n || {}, ...e || {} }, kn = (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(Tn, t.halo, n.halo),
+    glow: Wt(xn, t.glow, n.glow),
+    highlight: Wt(Sn, t.highlight, n.highlight),
+    matcap: n.matcap ?? t.matcap,
+    material: n.material ?? t.material
+  };
+}, we = (t) => JSON.stringify(
+  t ?? {},
+  (n, e) => n === "matcap" || n === "material" ? void 0 : e
+), Jt = (t, n, { base: e = {}, renderOrder: o } = {}) => {
+  const s = we(n) + we(e), r = R(
+    () => kn(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 h = Ve(t);
+    return { object: h, meshes: Qe(h) };
+  }, [t]), l = R(() => en(a), [a]), d = R(() => r.matcap ? null : qe(), [r.matcap]);
+  q(() => () => d == null ? void 0 : d.dispose(), [d]);
+  const p = r.matcap ?? d, u = R(() => {
+    const h = /* @__PURE__ */ new Map();
+    if (r.material) return h;
+    const { highlight: g } = r;
+    for (const { mesh: m } of c) {
+      const w = m.material.name;
+      h.has(w) || h.set(
+        w,
+        Ke(p, {
+          vertexColors: l,
+          ...g ? { highlightOpacity: g.opacity, highlightWhiten: g.whiten } : {},
+          ...r.ghost,
+          ...r.parts[w] ?? {}
+        })
+      );
+    }
+    return h;
+  }, [c, p, l, r]);
+  q(() => () => u.forEach((h) => h.dispose()), [u]);
+  const y = R(
+    () => new Map(
+      c.map(({ mesh: h }) => [
+        h,
+        r.material ?? u.get(h.material.name)
+      ])
+    ),
+    [c, u, r.material]
+  ), M = R(() => Ye(), []);
+  q(() => () => M.dispose(), [M]);
+  const f = R(() => {
+    var m;
+    a.updateMatrixWorld(!0);
+    const h = ((m = c[0]) == null ? void 0 : m.mesh.getWorldScale(new i.Vector3()).x) || 1, g = r.halo || { width: 0, color: "#000000", opacity: 0 };
+    return $e({ ...g, width: g.width / h, vertexColors: l });
+  }, [a, c, l, r.halo]);
+  q(() => () => f.dispose(), [f]);
+  const b = R(
+    () => r.glow ? Ze(r.glow.color, r.glow.idle) : null,
+    [r.glow]
+  );
+  return q(
+    () => () => {
+      b && tn(b);
+    },
+    [b]
+  ), q(() => {
+    Xe(a, {
+      main: (h) => y.get(h) ?? r.material ?? u.values().next().value,
+      prepass: M,
+      halo: f,
+      showHalo: r.halo !== !1,
+      renderOrder: o
+    });
+  }, [a, y, u, M, f, r, o]), R(() => {
+    const h = () => [...u.values()].map((g) => g.userData.ghost).filter((g) => !!g);
+    return {
+      object: a,
+      meshes: c,
+      materials: u,
+      glowMaterial: b,
+      look: r,
+      setHighlight: (g) => {
+        var m, w;
+        for (const x of h()) x.uHighlight.value.fill(0);
+        if (r.highlight)
+          for (const { mesh: x } of c) {
+            if (!(x instanceof i.SkinnedMesh)) continue;
+            const H = (w = (m = y.get(x)) == null ? void 0 : m.userData.ghost) == null ? void 0 : w.uHighlight;
+            H && x.skeleton.bones.forEach((v, U) => {
+              U < Ft && (H.value[U] = Math.max(H.value[U], g(v)));
+            });
+          }
+      },
+      setStrength: (g) => {
+        if (r.highlight) {
+          const { idle: m } = r.highlight;
+          for (const w of h()) w.uHighlightGain.value = m + (1 - m) * g;
+        }
+        if (b && r.glow) {
+          const m = r.glow.idle + (r.glow.full - r.glow.idle) * g;
+          b.userData.baseOpacity = m, b.opacity = m;
+        }
+      }
+    };
+  }, [a, c, u, y, b, r]);
+}, On = {
+  halo: { width: 0.35 },
+  glow: { size: 1.75 }
+}, Me = { seconds: 2.2, from: 0.35, stagger: 0.21 }, Rn = {
+  thumb: ["thumbMcp", "thumbIp", "thumbTip"],
+  index: ["indexMcp", "indexPip", "indexDip", "indexTip"],
+  middle: ["middleMcp", "middlePip", "middleDip", "middleTip"],
+  ring: ["ringMcp", "ringPip", "ringDip", "ringTip"],
+  pinky: ["pinkyMcp", "pinkyPip", "pinkyDip", "pinkyTip"]
+}, vn = (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 : [];
+}, Hn = (t) => {
+  const e = t - 1;
+  return 1 + (0.9 + 1) * e * e * e + 0.9 * e * e;
+}, Te = {
+  pinky: 0,
+  ring: 1 / 3,
+  middle: 2 / 3,
+  thumb: 0.81,
+  index: 1
+}, In = ({
+  gesture: t,
+  model: n,
+  poses: e,
+  modelHand: o = "right",
+  showHand: s = "right",
+  height: r = 1,
+  loop: a,
+  look: c,
+  highlight: l,
+  orbit: d = 35,
+  orbitSeconds: p = 6,
+  renderOrder: u
+}) => {
+  const y = typeof t == "string" || "label" in t ? Yt(t) : void 0, M = JSON.stringify(y ? y.hint : t), f = R(
+    () => y ? y.hint : t,
+    [M]
+    // eslint-disable-line react-hooks/exhaustive-deps
+  ), b = JSON.stringify((y == null ? void 0 : y.rule) ?? null), h = Jt(n, c, { base: On, renderOrder: u }), g = h.object, m = R(() => Ae(g, o), [g, o]), w = (a == null ? void 0 : a.from) ?? Me.from, x = R(() => {
+    const k = (z) => m.restPositions[z], L = k(T.middleMcp).clone().sub(k(T.wrist)).normalize(), P = m.restPalmNormal.clone(), E = new i.Vector3().crossVectors(L, P).normalize(), W = new i.Vector3().crossVectors(P, E), A = new i.Matrix4().makeBasis(E, W, P).invert();
+    f.yaw && A.premultiply(new i.Matrix4().makeRotationY(-i.MathUtils.degToRad(f.yaw))), f.roll && A.premultiply(new i.Matrix4().makeRotationZ(i.MathUtils.degToRad(f.roll)));
+    const F = (z) => {
+      Ut(m, f, z, e), g.updateMatrixWorld(!0);
+      const C = g.matrixWorld.clone().invert(), X = Object.values(m.bones).filter((B) => !!B).map(
+        (B) => B.getWorldPosition(new i.Vector3()).applyMatrix4(C).applyMatrix4(A)
+      ), dt = [];
+      return g.traverse((B) => {
+        if (!(B instanceof i.SkinnedMesh) || B.userData[Ot]) return;
+        B.skeleton.update(), B.computeBoundingBox();
+        const Y = B.boundingBox, ft = C.clone().multiply(B.matrixWorld);
+        for (const ot of [Y.min.x, Y.max.x])
+          for (const et of [Y.min.y, Y.max.y])
+            for (const pt of [Y.min.z, Y.max.z])
+              dt.push(new i.Vector3(ot, et, pt).applyMatrix4(ft).applyMatrix4(A));
+      }), [...X, ...dt];
+    }, G = F(1), nt = g.matrixWorld.clone().invert(), at = Oe(
+      Ce.map((z) => {
+        var X;
+        const C = (X = m.bones[z]) == null ? void 0 : X.getWorldPosition(new i.Vector3()).applyMatrix4(nt);
+        return { x: (C == null ? void 0 : C.x) ?? 0, y: (C == null ? void 0 : C.y) ?? 0, z: (C == null ? void 0 : C.z) ?? 0 };
+      })
+    ), ct = (z) => G[Object.keys(m.bones).filter((C) => m.bones[C]).indexOf(z)];
+    let lt = 0;
+    if (f.aimThumb) {
+      const z = ct("thumbCmc"), C = ct(m.bones.thumbTip ? "thumbTip" : "thumbIp");
+      lt = (f.aimThumb === "up" ? Math.PI / 2 : -Math.PI / 2) - Math.atan2(C.y - z.y, C.x - z.x);
+    }
+    const tt = new i.Matrix4().makeRotationZ(lt), ut = [...F(w), ...F(0.7), ...G].map((z) => z.applyMatrix4(tt));
+    Ut(m, f, 0, e);
+    const ht = new i.Box3().setFromPoints(ut).getCenter(new i.Vector3()), mt = ht.clone().applyMatrix4(tt.clone().invert()), _t = $t(ut, ht, i.MathUtils.degToRad(d)) * 1.06;
+    return { matrix: new i.Matrix4().makeTranslation(-mt.x, -mt.y, -mt.z).multiply(A), span: _t, extended: at.extended };
+  }, [m, g, f, e, d, w]), H = l === !1 ? "off" : (l ?? []).join();
+  q(() => {
+    const k = b === "null" ? void 0 : JSON.parse(b), L = l === !1 ? [] : l ?? f.highlight ?? vn(k ? { rule: k } : void 0, x.extended), P = new Set(L.flatMap((E) => Rn[E]));
+    h.setHighlight((E) => P.has(E.name) ? 1 : 0);
+  }, [h, f, b, H, x]);
+  const v = D(null), U = R(() => ({ a: new i.Vector3(), b: new i.Vector3() }), []), Q = JSON.stringify(a ?? {}), I = R(
+    () => ({ ...Me, ...a }),
+    [Q, a == null ? void 0 : a.easing]
+    // eslint-disable-line react-hooks/exhaustive-deps
+  ), N = R(() => {
+    const k = { drive: 0, closing: !0 };
+    return { state: k, amount: (P) => {
+      const E = i.MathUtils.clamp(I.stagger ?? 0, 0, 0.9), W = k.closing ? Te[P] : 1 - Te[P], A = i.MathUtils.clamp((k.drive - W * E) / (1 - E), 0, 1), F = I.easing ? I.easing(A) : k.closing ? Hn(A) : it(A), G = I.from ?? 0;
+      return G + (1 - G) * F;
+    } };
+  }, [I]);
+  Z(({ clock: k }) => {
+    const { drive: L, closing: P } = Qt(k.elapsedTime, I);
+    N.state.drive = L, N.state.closing = P, Ut(m, f, N.amount, e), h.setStrength(it(L));
+    const E = v.current;
+    if (E && (E.rotation.z = 0, f.aimThumb)) {
+      E.updateMatrixWorld(!0);
+      const W = m.bones.thumbCmc.getWorldPosition(U.a), A = (m.bones.thumbTip ?? m.bones.thumbIp).getWorldPosition(U.b);
+      E.worldToLocal(W), E.worldToLocal(A);
+      const F = Math.atan2(A.y - W.y, A.x - W.x);
+      E.rotation.z = (f.aimThumb === "up" ? Math.PI / 2 : -Math.PI / 2) - F;
+    }
+  });
+  const K = h.look.glow;
+  return /* @__PURE__ */ S(
+    Xt,
+    {
+      height: r,
+      span: x.span,
+      mirrored: s !== o,
+      orbit: d,
+      orbitSeconds: p,
+      glow: h.glowMaterial,
+      glowSize: K ? K.size : void 0,
+      renderOrder: u,
+      children: /* @__PURE__ */ S("group", { ref: v, children: /* @__PURE__ */ S("group", { matrixAutoUpdate: !1, matrix: x.matrix, children: /* @__PURE__ */ S("primitive", { object: g }) }) })
+    }
+  );
+}, _n = (t, { hand: n = "any", limits: e, active: o = !0, ...s } = {}) => {
+  const { node: r } = ke(Se.HAND_TRACKER, void 0, o), a = st(t), c = qt(a, s), l = D({}), d = D(t);
+  d.current = t;
+  const p = JSON.stringify(e ?? null), u = R(() => ({ limits: e }), [p]), y = D(n);
+  y.current = n;
+  const M = jt(() => {
+    const f = l.current, b = y.current;
+    return b === "any" ? !!(f.left || f.right) : !!f[b];
+  }, []);
+  return Z(() => {
+    var b;
+    if (!o) return;
+    let f = !1;
+    for (const h of ["left", "right"]) {
+      const g = (b = r == null ? void 0 : r.poses) == null ? void 0 : b[h];
+      if (!g || g.held || g.world.length < 21) {
+        delete l.current[h];
+        continue;
+      }
+      const m = Oe(g.world, u);
+      l.current[h] = m, (n === "any" || n === h) && ve(m, d.current, h) && (f = !0);
+    }
+    c.step(f);
+  }), {
+    status: c.status,
+    holdRef: c.holdRef,
+    matchedRef: c.matchedRef,
+    isInView: M,
+    reset: c.reset,
+    shapesRef: l
+  };
+}, go = Ht, Nn = "Show your hand to the camera", En = ({
+  gesture: t,
+  model: n,
+  poses: e,
+  modelHand: o = "right",
+  hand: s = "any",
+  holdMs: r,
+  graceMs: a,
+  limits: c,
+  orbit: l,
+  look: d,
+  loop: p,
+  highlight: u,
+  onComplete: y,
+  nudgeText: M = Nn,
+  ...f
+}) => {
+  const b = Kt(), h = _n(t, { hand: s, holdMs: r, graceMs: a, limits: c, onComplete: y }), g = Be(s === "any" ? "right" : s, b);
+  return /* @__PURE__ */ S(
+    It,
+    {
+      ...f,
+      nudgeText: M,
+      detector: h,
+      symbol: (m, w) => /* @__PURE__ */ S(
+        In,
+        {
+          gesture: t,
+          model: n,
+          poses: e,
+          modelHand: o,
+          showHand: g,
+          height: m,
+          loop: p,
+          look: d,
+          highlight: u,
+          orbit: l,
+          renderOrder: w
+        }
+      )
+    }
+  );
+}, yo = ({ active: t = !0, text: n, ...e }) => t ? /* @__PURE__ */ S(Rt, { children: /* @__PURE__ */ S(
+  En,
+  {
+    ...e,
+    text: n ?? Yt(e.gesture).label
+  },
+  st(e.gesture)
+) }) : null, bo = (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" }
+  }
+}, Dn = 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)));
+}, Zt = (t) => typeof t == "string" ? He[t] : typeof t == "object" && "hint" in t ? t : void 0, Ie = (t, n, e) => {
+  if (typeof n == "function") return n(t, e);
+  const o = Zt(n);
+  return o ? o.rule && !Gt(t, o.rule) ? !1 : o.match ? o.match(t, e) : !!o.rule : Gt(t, n);
+}, wo = (t) => Dn.filter((n) => Ie(t, n)), Pn = (t, n, e) => {
+  const o = n ? he(n) : /* @__PURE__ */ new Map(), s = e ? he(e) : /* @__PURE__ */ new Map(), r = [];
+  for (const d of /* @__PURE__ */ new Set([...o.keys(), ...s.keys()])) {
+    const p = t.getObjectByName(d);
+    if (!p) continue;
+    const u = p.quaternion.clone();
+    r.push({ node: p, from: o.get(d) ?? u, to: s.get(d) ?? u });
+  }
+  const a = n ? de(n) : /* @__PURE__ */ new Map(), c = e ? de(e) : /* @__PURE__ */ new Map(), l = [];
+  for (const d of /* @__PURE__ */ new Set([...a.keys(), ...c.keys()])) {
+    const p = t.getObjectByName(d);
+    if (!p) continue;
+    const u = p.position.clone();
+    l.push({ node: p, from: a.get(d) ?? u, to: c.get(d) ?? u });
+  }
+  return {
+    apply: (d) => {
+      for (const p of r) p.node.quaternion.copy(p.from).slerp(p.to, d);
+      for (const p of l) p.node.position.lerpVectors(p.from, p.to, d);
+    }
+  };
+}, Cn = (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;
+      }
+    }
+  };
+}, An = {
+  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 }
+}, Bn = { seconds: 2.4 }, Ln = ({
+  expression: t,
+  model: n,
+  height: e = 1,
+  loop: o,
+  look: s,
+  orbit: r = 30,
+  orbitSeconds: a = 6,
+  renderOrder: c
+}) => {
+  const l = typeof t == "string" || "label" in t ? Zt(t).hint : t, d = JSON.stringify("targets" in l ? l.targets : { [l.target]: 1 }), p = Jt(n, s, { base: An, renderOrder: c }), u = p.object, y = R(
+    () => Cn(
+      p.meshes.flatMap(({ mesh: g, twins: m }) => [g, ...m]),
+      JSON.parse(d)
+    ),
+    [p.meshes, d]
+  ), M = R(() => {
+    u.updateMatrixWorld(!0);
+    const g = [];
+    for (const { mesh: x } of p.meshes) {
+      const H = x.geometry.getAttribute("position");
+      for (let v = 0; v < H.count; v += 3)
+        g.push(
+          new i.Vector3().fromBufferAttribute(H, v).applyMatrix4(x.matrixWorld)
+        );
+    }
+    const m = new i.Box3().setFromPoints(g).getCenter(new i.Vector3()), w = $t(g, m, i.MathUtils.degToRad(r)) * 1.08;
+    return { offset: m.clone().negate(), span: w };
+  }, [u, p.meshes, r]), f = JSON.stringify(o ?? {}), b = R(
+    () => ({ ...Bn, ...o }),
+    [f, o == null ? void 0 : o.easing]
+    // eslint-disable-line react-hooks/exhaustive-deps
+  );
+  Z(({ clock: g }) => {
+    const { amount: m } = Qt(g.elapsedTime, b);
+    y.apply(m), p.setStrength(m);
+  });
+  const h = p.look.glow;
+  return /* @__PURE__ */ S(
+    Xt,
+    {
+      height: e,
+      span: M.span,
+      orbit: r,
+      orbitSeconds: a,
+      glow: p.glowMaterial,
+      glowSize: h ? h.size : void 0,
+      renderOrder: c,
+      children: /* @__PURE__ */ S("group", { position: M.offset, children: /* @__PURE__ */ S("primitive", { object: u }) })
+    }
+  );
+}, zn = (t, { faceIndex: n = 0, active: e = !0, ...o } = {}) => {
+  const s = R(() => ({ numFaces: n + 1 }), [n]), { node: r, ready: a } = ke(
+    Se.FACE_TRACKER,
+    s,
+    e
+  ), { camera: c } = De();
+  q(() => {
+    r == null || r.setCamera(c, n);
+  }, [c, n, r]);
+  const l = qt(st(t), o), d = D(null), p = D(Fe()), u = D(t);
+  u.current = t;
+  const y = jt(() => d.current !== null, []);
+  return Z(() => {
+    if (!e) return;
+    const M = a && r ? Ge(r, n, p.current) : null;
+    d.current = M, l.step(!!M && Ie(M.blendshapes, u.current, M));
+  }), {
+    status: l.status,
+    holdRef: l.holdRef,
+    matchedRef: l.matchedRef,
+    isInView: y,
+    reset: l.reset,
+    faceRef: d
+  };
+}, Mo = Ht, Un = "Show your face to the camera", Wn = ({
+  expression: t,
+  model: n,
+  faceIndex: e,
+  holdMs: o,
+  graceMs: s,
+  orbit: r,
+  look: a,
+  loop: c,
+  onComplete: l,
+  nudgeText: d = Un,
+  ...p
+}) => {
+  const u = zn(t, { faceIndex: e, holdMs: o, graceMs: s, onComplete: l });
+  return /* @__PURE__ */ S(
+    It,
+    {
+      ...p,
+      nudgeText: d,
+      detector: u,
+      symbol: (y, M) => /* @__PURE__ */ S(
+        Ln,
+        {
+          expression: t,
+          model: n,
+          height: y,
+          orbit: r,
+          look: a,
+          loop: c,
+          renderOrder: M
+        }
+      )
+    }
+  );
+}, To = ({ active: t = !0, text: n, ...e }) => t ? /* @__PURE__ */ S(Rt, { children: /* @__PURE__ */ S(
+  Wn,
+  {
+    ...e,
+    text: n ?? Zt(e.expression).label
+  },
+  st(e.expression)
+) }) : null, Vn = {
+  parts: { joints: { color: "#7c8aa0", core: 0.7, rim: 0.9, whiten: 0.35 } },
+  halo: { width: 1.2 },
+  glow: { size: 1.3 }
+}, xe = /* @__PURE__ */ new Set(), Fn = { seconds: 2.6 }, Gn = (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;
+}, jn = (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;
+}, qn = ({
+  pose: t,
+  model: n,
+  poses: e,
+  idleClip: o = "idle",
+  height: s = 1,
+  mirrored: r = !1,
+  loop: a,
+  look: c,
+  highlight: l = !0,
+  boneSide: d = Gn,
+  legBoneSide: p = jn,
+  orbit: u = 25,
+  orbitSeconds: y = 7,
+  renderOrder: M
+}) => {
+  const f = typeof t == "string" || "label" in t ? vt(t).hint : t, b = f.clip, h = (f.arms ?? []).join(), g = (f.legs ?? []).join(), m = Jt(n, c, { base: Vn, renderOrder: M }), w = m.object, x = R(
+    () => Pn(
+      w,
+      e.find((I) => I.name === o),
+      e.find((I) => I.name === b)
+    ),
+    [w, e, o, b]
+  );
+  q(() => {
+    const I = e.map((N) => N.name);
+    for (const [N, K] of [
+      [o, "rest"],
+      [b, "pose"]
+    ])
+      I.includes(N) || xe.has(N) || (xe.add(N), console.warn(
+        `[BodyPoseHint] the model has no "${N}" clip (the ${K === "rest" ? "rest pose the hint loops from" : "pose to show"}); the figure uses its bind pose there instead. Clips found: ${I.join(", ") || "none"}.`
+      ));
+  }, [e, o, b]), q(() => {
+    const I = h ? h.split(",") : [], N = g ? g.split(",") : [];
+    m.setHighlight((K) => {
+      if (!l) return 0;
+      const k = d(K.name);
+      if (k && I.includes(k)) return 1;
+      const L = p(K.name);
+      return L && N.includes(L) ? 1 : 0;
+    });
+  }, [m, h, g, l, d, p]);
+  const H = R(() => {
+    const I = [], N = new i.Matrix4();
+    for (const L of [0, 0.6, 1]) {
+      x.apply(L), w.updateMatrixWorld(!0), N.copy(w.matrixWorld).invert();
+      for (const { mesh: P } of m.meshes) {
+        if (!(P instanceof i.SkinnedMesh)) continue;
+        P.skeleton.update();
+        const E = P.geometry.getAttribute("position");
+        for (let W = 0; W < E.count; W += 12) {
+          const A = new i.Vector3().fromBufferAttribute(E, W);
+          P.applyBoneTransform(W, A), I.push(A.applyMatrix4(P.matrixWorld).applyMatrix4(N));
+        }
+      }
+    }
+    x.apply(0);
+    const K = new i.Box3().setFromPoints(I).getCenter(new i.Vector3()), k = $t(I, K, i.MathUtils.degToRad(u)) * 1.06;
+    return { offset: K.clone().negate(), span: k };
+  }, [w, m.meshes, x, u]), v = JSON.stringify(a ?? {}), U = R(
+    () => ({ ...Fn, ...a }),
+    [v, a == null ? void 0 : a.easing]
+    // eslint-disable-line react-hooks/exhaustive-deps
+  );
+  Z(({ clock: I }) => {
+    const { amount: N } = Qt(I.elapsedTime, U);
+    x.apply(N), m.setStrength(N);
+  });
+  const Q = m.look.glow;
+  return /* @__PURE__ */ S(
+    Xt,
+    {
+      height: s,
+      span: H.span,
+      mirrored: r,
+      orbit: u,
+      orbitSeconds: y,
+      glow: m.glowMaterial,
+      glowSize: Q ? Q.size : void 0,
+      renderOrder: M,
+      children: /* @__PURE__ */ S("group", { position: H.offset, children: /* @__PURE__ */ S("primitive", { object: w }) })
+    }
+  );
+}, Kn = (t, {
+  bodyIndex: n = 0,
+  bodyId: e,
+  subject: o,
+  numBodies: s,
+  limits: r,
+  active: a = !0,
+  ...c
+} = {}) => {
+  const {
+    node: l,
+    ready: d,
+    index: p
+  } = je({ bodyIndex: n, bodyId: e, subject: o, numBodies: s, active: a }), u = Kt(), y = We(), M = qt(st(t), c), f = D(null), b = D(t);
+  b.current = t;
+  const h = JSON.stringify(r ?? null), g = R(() => r, [h]), m = jt(() => {
+    var x;
+    const w = f.current;
+    return w != null && w.upperBodyVisible ? ((x = vt(b.current)) == null ? void 0 : x.view) !== "full" || w.lowerBodyVisible : !1;
+  }, []);
+  return Z(() => {
+    var v;
+    if (!a) return;
+    const w = (d && l ? p() : null) ?? -1, x = w < 0 || l == null ? void 0 : l.getLandmarks2D(w), H = x && x.length >= Le ? ze(x, {
+      mirrored: u,
+      visibility: (v = l == null ? void 0 : l.getVisibility) == null ? void 0 : v.call(l, w),
+      limits: g,
+      aspect: y
+    }) : null;
+    f.current = H, M.step(!!H && H.upperBodyVisible && Ue(H, b.current));
+  }), {
+    status: M.status,
+    holdRef: M.holdRef,
+    matchedRef: M.matchedRef,
+    isInView: m,
+    reset: M.reset,
+    shapeRef: f
+  };
+}, xo = Ht, $n = (t) => {
+  var n;
+  return ((n = vt(t)) == null ? void 0 : n.view) === "full";
+}, Yn = 2.1, Qn = "Step back so your upper body is in view", Xn = "Step back so your whole body is in view", Jn = ({
+  pose: t,
+  model: n,
+  poses: e,
+  idleClip: o,
+  bodyIndex: s,
+  bodyId: r,
+  subject: a,
+  numBodies: c,
+  holdMs: l,
+  graceMs: d,
+  limits: p,
+  symbolAspect: u = Yn,
+  orbit: y,
+  look: M,
+  loop: f,
+  boneSide: b,
+  legBoneSide: h,
+  onComplete: g,
+  nudgeText: m,
+  ...w
+}) => {
+  const x = Kt(), H = Kn(t, {
+    bodyIndex: s,
+    bodyId: r,
+    subject: a,
+    numBodies: c,
+    holdMs: l,
+    graceMs: d,
+    limits: p,
+    onComplete: g
+  });
+  return /* @__PURE__ */ S(
+    It,
+    {
+      ...w,
+      nudgeText: m !== void 0 ? m : $n(t) ? Xn : Qn,
+      detector: H,
+      symbolAspect: u,
+      symbol: (v, U) => /* @__PURE__ */ S(
+        qn,
+        {
+          pose: t,
+          model: n,
+          poses: e,
+          idleClip: o,
+          height: v,
+          mirrored: x,
+          orbit: y,
+          look: M,
+          loop: f,
+          boneSide: b,
+          legBoneSide: h,
+          renderOrder: U
+        }
+      )
+    }
+  );
+}, So = ({ active: t = !0, text: n, ...e }) => t ? /* @__PURE__ */ S(Rt, { children: /* @__PURE__ */ S(
+  Jn,
+  {
+    ...e,
+    text: n ?? vt(e.pose).label
+  },
+  st(e.pose)
+) }) : null;
+export {
+  Vn as BODY_HINT_LOOK,
+  Fn as BODY_HINT_LOOP,
+  Xn as BODY_INSTRUCTION_FULL_NUDGE_TEXT,
+  Qn as BODY_INSTRUCTION_NUDGE_TEXT,
+  xo as BODY_INSTRUCTION_RENDER_ORDER,
+  Le as BODY_LANDMARK_COUNT,
+  Eo as BODY_LOWER_JOINTS,
+  Do as BODY_POSES,
+  Po as BODY_POSE_JOINTS,
+  Co as BODY_POSE_NAMES,
+  Ao as BODY_SHAPE_LIMITS,
+  Yn as BODY_SYMBOL_ASPECT,
+  Bo as BODY_UPPER_JOINTS,
+  So as BodyInstruction,
+  qn as BodyPoseHint,
+  He as FACE_EXPRESSIONS,
+  Dn as FACE_EXPRESSION_NAMES,
+  An as FACE_HINT_LOOK,
+  Bn as FACE_HINT_LOOP,
+  Un as FACE_INSTRUCTION_NUDGE_TEXT,
+  Mo as FACE_INSTRUCTION_RENDER_ORDER,
+  Ln as FaceExpressionHint,
+  To as FaceInstruction,
+  Ro as GESTURE_HOLD_DEFAULT_MS,
+  vo as GESTURE_HOLD_GRACE_MS,
+  Ft as GHOST_MAX_BONES,
+  bt as HAND_DIGITS,
+  Re as HAND_GESTURES,
+  an as HAND_GESTURE_NAMES,
+  On as HAND_HINT_LOOK,
+  Me as HAND_HINT_LOOP,
+  Nn as HAND_INSTRUCTION_NUDGE_TEXT,
+  go as HAND_INSTRUCTION_RENDER_ORDER,
+  fe as HAND_SHAPE_LIMITS,
+  wn as HINT_LOOP_HOLD,
+  In as HandGestureHint,
+  yo as HandInstruction,
+  Xt as HintStage,
+  Ht as INSTRUCTION_RENDER_ORDER,
+  rn as INSTRUCTION_TEXT_STYLE,
+  mo as Instruction,
+  Qe as addHintTwins,
+  ze as analyzeBodyShape,
+  Oe as analyzeHandShape,
+  Ut as applyHandHintPose,
+  Xe as assignHintMaterials,
+  Pn as createClipBlend,
+  Ye as createDepthPrepassMaterial,
+  Ho as createGestureHoldState,
+  Ke as createGhostMaterial,
+  Ze as createGlowMaterial,
+  $e as createHaloMaterial,
+  qe as createHintMatcap,
+  Cn as createMorphBlend,
+  Lo as defineBodyPose,
+  bo as defineFaceExpression,
+  fo as defineHandGesture,
+  tn as disposeGlowMaterial,
+  it as ease,
+  en as hasVertexColors,
+  Ue as matchBodyPose,
+  Ie as matchFaceExpression,
+  ve as matchHandGesture,
+  zo as matchingBodyPoses,
+  wo as matchingFaceExpressions,
+  po as matchingHandGestures,
+  kn as mergeHintLook,
+  Gn as mixamoBoneSide,
+  jn as mixamoLegBoneSide,
+  $t as orbitSpan,
+  he as readClipQuaternions,
+  fn as readHandClipPose,
+  vt as resolveBodyPose,
+  Zt as resolveFaceExpression,
+  Yt as resolveHandGesture,
+  Qt as sampleHintLoop,
+  Mn as sampleHintOrbit,
+  Uo as squareLandmarks,
+  Io as stepGestureHold,
+  Kn as useBodyPose,
+  zn as useFaceExpression,
+  Jt as useGhostModel,
+  _n as useHandGesture,
+  _o as useInstructionHold
+};