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

package/dist/tracking.js

@@ -1,20 +1,38 @@
-import { u as N, T as O } from "./index-ByoNj0QP.js";
-import { d as Ve, c as We, b as qe } from "./index-ByoNj0QP.js";
-import { jsx as A, Fragment as J } from "react/jsx-runtime";
-import { useThree as C, useFrame as b } from "@react-three/fiber";
-import { useRef as R, useMemo as _, useCallback as P, useEffect as L, useState as I } from "react";
-import * as U from "three";
-import { X as F, u as Q, f as ee } from "./index-9dlAQAhy.js";
-import { n as $e, t as Ze } from "./index-9dlAQAhy.js";
-import { R as z } from "./renderLayers-zrK2pv5O.js";
-import { B as Qe, D as et, F as tt, H as nt, T as rt, g as ot } from "./index-DyVF4vEW.js";
-import { u as ut } from "./useFaceResults-CtetsO9M.js";
-import { u as te } from "./useFaceInfo-Dk426LTu.js";
-import { a as ct } from "./useFaceInfo-Dk426LTu.js";
-import { a as T } from "./getFaceInfo-C4QpCQIY.js";
-import { D as lt, b as dt, h as ht } from "./getFaceInfo-C4QpCQIY.js";
-import { d as ne } from "./drawNormalizedCrop-CRdIDyl1.js";
-const re = {
+import { T as ie } from "./index-BavF06C6.js";
+import { a as Dn, F as bn } from "./index-BavF06C6.js";
+import { jsx as N, jsxs as ut, Fragment as lt } from "react/jsx-runtime";
+import { useThree as oe, useFrame as U, createPortal as dt } from "@react-three/fiber";
+import { useRef as E, useMemo as x, useCallback as j, useContext as De, useEffect as v, useState as V, createContext as ft, useSyncExternalStore as ht } from "react";
+import { X as W, t as q, C as Je, a5 as mt, k as Me, i as pt, u as Qe, j as Tt } from "./index-CIe7eCMH.js";
+import { aa as In, a8 as Nn, a7 as xn, a9 as Cn, a as Hn, H as Ln, a6 as Mn, w as wn, y as Fn, n as kn, b as Pn } from "./index-CIe7eCMH.js";
+import { R as ce } from "./uv-DJU_XfmN.js";
+import { u as $, r as gt } from "./landmarks-bftdwq6Z.js";
+import { a as Un } from "./landmarks-bftdwq6Z.js";
+import { r as Et, M as we, B as St, g as de, c as Fe, s as At, a as Rt } from "./SegmentationOverlay-vn5x_knv.js";
+import { b as jn, j as Kn, C as Wn, k as Vn, l as Yn, m as Xn, e as qn, D as zn, p as Jn, F as Qn, S as $n, f as Zn, v as es, h as ts, d as rs, q as ns, t as ss, i as os, n as as, u as is, o as cs } from "./SegmentationOverlay-vn5x_knv.js";
+import { H as _t, a as yt, O as Ot, m as Dt, b as te, c as ke, d as re, e as bt, f as vt, g as It, h as Nt, i as xt, r as Ct, s as ge, j as Ht, k as Lt, l as Mt, n as Pe } from "./trigger-IQeys0oS.js";
+import { L as ls, M as ds, N as fs, P as hs, q as ms, t as ps, u as Ts, F as gs, y as Es, B as Ss, C as As, J as Rs, D as _s, E as ys, K as Os, z as Ds, o as bs, A as vs, G as Is, T as Ns, v as xs, w as Cs, W as Hs, p as Ls, Q as Ms, R as ws, I as Fs, x as ks } from "./trigger-IQeys0oS.js";
+import * as K from "three";
+import { t as wt, B as Ft, g as kt } from "./index-JII7huPk.js";
+import { u as Bs, q as Us } from "./index-JII7huPk.js";
+import { H as $e } from "./settings-BJ7FMBsO.js";
+import { c as js, D as Ks, G as Ws, a as Vs, b as Ys, d as Xs, p as qs, e as zs, r as Js, t as Qs } from "./settings-BJ7FMBsO.js";
+import { b as Pt, e as be, g as Bt } from "./selectors-DmNaKIwE.js";
+import { a as Be } from "./segmentation-Cb3ouK6Z.js";
+import { S as Zs } from "./segmentation-Cb3ouK6Z.js";
+import { B as to, c as ro, F as no, H as so, l as oo, n as ao } from "./index-DBhQzvVa.js";
+import { r as Ue, c as Oe, s as Ze, a as Ut, g as Gt } from "./detector-K8aej4MB.js";
+import { D as co } from "./detector-K8aej4MB.js";
+import { d as Ge, a as jt, b as Kt } from "./getFaceInfo-Cu4xDWiL.js";
+import { D as lo, e as fo, h as ho } from "./getFaceInfo-Cu4xDWiL.js";
+import { s as Wt } from "./useInstructionHold-DOu-RpCM.js";
+import { u as Vt } from "./useFaceInfo-J4x7LsqL.js";
+import { D as po, a as To } from "./useFaceInfo-J4x7LsqL.js";
+import { d as Yt } from "./drawNormalizedCrop-CRdIDyl1.js";
+import { D as Eo, E as So, X as Ao, q as Ro, r as _o, u as yo, s as Oo } from "./select-pYRo_win.js";
+import { d as bo, e as vo, P as Io, f as No, g as xo, h as Co } from "./providers-C8rE26Uf.js";
+import { D as Lo, e as Mo, r as wo } from "./landmarkMask-BFDyBnKM.js";
+const et = {
   "hand.wrist": 0,
   "hand.thumbTip": 4,
   "hand.indexTip": 8,
@@ -26,9 +44,9 @@ const re = {
   "hand.ringBase": 13,
   "hand.pinkyBase": 17
 };
-function oe(e, t, r = 0) {
-  var o;
-  const n = (o = e == null ? void 0 : e.hands) != null && o.length ? e.hands : e != null && e.coordinates ? [
+function tt(e, r, t = 0) {
+  var s;
+  const n = (s = e == null ? void 0 : e.hands) != null && s.length ? e.hands : e != null && e.coordinates ? [
     {
       coordinates: e.coordinates,
       gesture: e.gesture,
@@ -36,60 +54,55 @@ function oe(e, t, r = 0) {
     }
   ] : [];
   if (n.length) {
-    if (t) {
-      const u = n.find((i) => i.handedness === t);
-      if (u) return u;
+    if (r) {
+      const c = n.find((u) => u.handedness === r);
+      if (c) return c;
     }
-    return n[r] ?? n[0];
+    return n[t] ?? n[0];
   }
 }
-const Ne = ({
+const sn = ({
   children: e,
-  hand: t,
-  handIndex: r = 0,
+  hand: r,
+  handIndex: t = 0,
   targetFps: n,
-  active: o = !0
+  active: s = !0
 }) => {
-  const u = R(null), i = _(
+  const c = E(null), u = x(
     () => n === void 0 ? void 0 : { targetFps: n },
     [n]
-  ), { ready: a, node: y } = N(
-    F.HAND_TRACKER,
-    i,
-    o
-  ), { camera: s } = C(), c = R(s);
-  c.current !== s && (c.current = s);
-  const l = R(null);
-  b(() => {
-    var m;
-    if (!a || !y || !u.current) return;
-    const g = oe(y, t, r);
-    l.current = g ?? null;
-    const d = (m = g == null ? void 0 : g.coordinates) == null ? void 0 : m[0];
-    if (!d) {
-      u.current.visible = !1;
+  ), { ready: o, node: a } = $(
+    W.HAND_TRACKER,
+    u,
+    s
+  ), { camera: i } = oe(), f = E(i);
+  f.current !== i && (f.current = i);
+  const d = E(null);
+  U(() => {
+    var l;
+    if (!o || !a || !c.current) return;
+    const A = tt(a, r, t);
+    d.current = A ?? null;
+    const p = (l = A == null ? void 0 : A.coordinates) == null ? void 0 : l[0];
+    if (!p) {
+      c.current.visible = !1;
       return;
     }
-    const p = K(d, c.current);
-    u.current.visible = !0, u.current.position.copy(p);
+    const S = q(p, f.current);
+    c.current.visible = !0, c.current.position.copy(S);
   });
-  const f = P((g) => {
-    var m, E;
-    const d = re[g];
-    if (d === void 0) return null;
-    const p = (E = (m = l.current) == null ? void 0 : m.coordinates) == null ? void 0 : E[d];
-    return p ? { position: K(p, c.current) } : null;
-  }, []), h = _(
-    () => ({ type: "hand", resolveLandmark: f }),
-    [f]
+  const h = j((A) => {
+    var l, T;
+    const p = et[A];
+    if (p === void 0) return null;
+    const S = (T = (l = d.current) == null ? void 0 : l.coordinates) == null ? void 0 : T[p];
+    return S ? { position: q(S, f.current) } : null;
+  }, []), m = x(
+    () => ({ type: "hand", resolveLandmark: h }),
+    [h]
   );
-  return /* @__PURE__ */ A(O.Provider, { value: h, children: /* @__PURE__ */ A("group", { ref: u, renderOrder: z.TRACKED, children: e }) });
-}, K = (e, t) => {
-  const r = new U.Vector3(e.x, e.y, e.z);
-  r.unproject(t);
-  const n = r.sub(t.position).normalize(), o = -t.position.z / n.z;
-  return t.position.clone().add(n.multiplyScalar(o));
-}, se = {
+  return /* @__PURE__ */ N(ie.Provider, { value: m, children: /* @__PURE__ */ N("group", { ref: c, renderOrder: ce.TRACKED, children: e }) });
+}, Xt = {
   "hand.wrist": 0,
   "hand.thumbTip": 4,
   "hand.indexTip": 8,
@@ -100,170 +113,1025 @@ const Ne = ({
   "hand.middleBase": 9,
   "hand.ringBase": 13,
   "hand.pinkyBase": 17
-}, Fe = ({ children: e, targetFps: t, active: r = !0 }) => {
-  const n = R(null), o = _(
-    () => t === void 0 ? void 0 : { targetFps: t },
-    [t]
-  ), { ready: u, node: i } = N(
-    F.GESTURE_TRACKER,
-    o,
-    r
-  ), { camera: a } = C(), y = R(a);
-  y.current !== a && (y.current = a);
-  const s = R(null);
-  b(() => {
-    var g;
-    if (!u || !i || !n.current) return;
-    s.current = i;
-    const f = (g = i == null ? void 0 : i.coordinates) == null ? void 0 : g[0];
-    if (!f) {
+}, on = ({ children: e, targetFps: r, active: t = !0 }) => {
+  const n = E(null), s = x(
+    () => r === void 0 ? void 0 : { targetFps: r },
+    [r]
+  ), { ready: c, node: u } = $(
+    W.GESTURE_TRACKER,
+    s,
+    t
+  ), { camera: o } = oe(), a = E(o);
+  a.current !== o && (a.current = o);
+  const i = E(null);
+  U(() => {
+    var A;
+    if (!c || !u || !n.current) return;
+    i.current = u;
+    const h = (A = u == null ? void 0 : u.coordinates) == null ? void 0 : A[0];
+    if (!h) {
       n.current.visible = !1;
       return;
     }
-    const h = G(f, y.current);
-    n.current.visible = !0, n.current.position.copy(h);
+    const m = q(h, a.current);
+    n.current.visible = !0, n.current.position.copy(m);
   });
-  const c = P((f) => {
-    var d, p;
-    const h = se[f];
-    if (h === void 0) return null;
-    const g = (p = (d = s.current) == null ? void 0 : d.coordinates) == null ? void 0 : p[h];
-    return g ? { position: G(g, y.current) } : null;
-  }, []), l = _(
-    () => ({ type: "hand", resolveLandmark: c }),
-    [c]
+  const f = j((h) => {
+    var p, S;
+    const m = Xt[h];
+    if (m === void 0) return null;
+    const A = (S = (p = i.current) == null ? void 0 : p.coordinates) == null ? void 0 : S[m];
+    return A ? { position: q(A, a.current) } : null;
+  }, []), d = x(
+    () => ({ type: "hand", resolveLandmark: f }),
+    [f]
   );
-  return /* @__PURE__ */ A(O.Provider, { value: l, children: /* @__PURE__ */ A("group", { ref: n, renderOrder: z.TRACKED, children: e }) });
-}, G = (e, t) => {
-  const r = new U.Vector3(e.x, e.y, e.z);
-  r.unproject(t);
-  const n = r.sub(t.position).normalize(), o = -t.position.z / n.z;
-  return t.position.clone().add(n.multiplyScalar(o));
-}, ue = {
-  "body.head": 0,
-  "body.leftShoulder": 11,
-  "body.rightShoulder": 12,
-  "body.leftElbow": 13,
-  "body.rightElbow": 14,
-  "body.leftWrist": 15,
-  "body.rightWrist": 16,
-  "body.leftHip": 23,
-  "body.rightHip": 24,
-  "body.leftKnee": 25,
-  "body.rightKnee": 26,
-  "body.leftAnkle": 27,
-  "body.rightAnkle": 28
-}, Me = ({ bodyIndex: e = 0, active: t = !0, children: r }) => {
-  const n = R(null), { ready: o, node: u } = N(
-    F.BODY_TRACKER,
-    void 0,
-    t
-  ), { camera: i } = C(), a = R(i);
-  a.current !== i && (a.current = i);
-  const y = R(null);
-  b(() => {
-    if (!o || !u || !n.current) return;
-    const l = u;
-    y.current = l;
-    const f = l.getLandmarks2D(e), h = f == null ? void 0 : f[0];
-    if (!h) {
-      n.current.visible = !1;
-      return;
+  return /* @__PURE__ */ N(ie.Provider, { value: d, children: /* @__PURE__ */ N("group", { ref: n, renderOrder: ce.TRACKED, children: e }) });
+}, an = ({ joint: e, along: r = 0.5, offset: t, children: n }) => {
+  const s = De(_t), c = E(null), u = x(
+    () => ({
+      transform: {
+        position: new K.Vector3(),
+        quaternion: new K.Quaternion()
+      },
+      offsetE: new K.Euler(),
+      offsetQ: new K.Quaternion(),
+      offsetP: new K.Vector3()
+    }),
+    []
+  );
+  U(() => {
+    var h, m, A, p, S, l;
+    const i = c.current;
+    if (!i || !s) return;
+    const { position: f, quaternion: d } = wt(s, e, r, u.transform);
+    u.offsetQ.setFromEuler(
+      u.offsetE.set(
+        ((h = t == null ? void 0 : t.rotation) == null ? void 0 : h[0]) ?? 0,
+        ((m = t == null ? void 0 : t.rotation) == null ? void 0 : m[1]) ?? 0,
+        ((A = t == null ? void 0 : t.rotation) == null ? void 0 : A[2]) ?? 0
+      )
+    ), u.offsetP.set(
+      ((p = t == null ? void 0 : t.position) == null ? void 0 : p[0]) ?? 0,
+      ((S = t == null ? void 0 : t.position) == null ? void 0 : S[1]) ?? 0,
+      ((l = t == null ? void 0 : t.position) == null ? void 0 : l[2]) ?? 0
+    ), i.position.copy(f).add(u.offsetP.applyQuaternion(d)), i.quaternion.copy(d).multiply(u.offsetQ), i.scale.setScalar((t == null ? void 0 : t.scale) ?? 1);
+  });
+  const o = !s;
+  if (v(() => {
+    o && console.warn(
+      `${Je.loggerPrefix} HandAttachment must be inside a HandRig or HandOccluder`
+    );
+  }, [o]), !s) return null;
+  const a = s.bones[e];
+  return a ? dt(/* @__PURE__ */ N("group", { ref: c, children: n }), a) : null;
+}, se = 10, J = [0, 1, 5, 9, 13, 17], qt = -0.5, je = J.length + $e.length * 2 + 21 * se + 2 + se, zt = (e, r, { inflate: t = 1, forearm: n = 1.4 }, s, c = 0) => {
+  let u = c;
+  const o = (g, _) => {
+    s[u * 2] = g, s[u * 2 + 1] = _, u += 1;
+  }, a = (g) => e[g].x * r, i = (g) => e[g].y, f = Math.hypot(a(0) - a(9), i(0) - i(9)), d = 0.12 * f * t;
+  let h = 0, m = 0;
+  for (const g of J)
+    h += a(g), m += i(g);
+  h /= J.length, m /= J.length;
+  for (let g = 0; g < J.length; g += 1) {
+    const _ = J[g], D = J[(g + 1) % J.length];
+    o(h / r, m), o(a(_) / r, i(_)), o(a(D) / r, i(D));
+  }
+  const A = (g, _, D, R, H) => {
+    const P = D - g, b = R - _, y = Math.hypot(P, b) || 1, M = -b / y * H, k = P / y * H;
+    o((g + M) / r, _ + k), o((D + M) / r, R + k), o((D - M) / r, R - k), o((g + M) / r, _ + k), o((D - M) / r, R - k), o((g - M) / r, _ - k);
+  }, p = (g, _, D) => {
+    for (let R = 0; R < se; R += 1) {
+      const H = R / se * Math.PI * 2, P = (R + 1) / se * Math.PI * 2;
+      o(g / r, _), o((g + Math.cos(H) * D) / r, _ + Math.sin(H) * D), o((g + Math.cos(P) * D) / r, _ + Math.sin(P) * D);
+    }
+  };
+  for (const [g, _] of $e) {
+    const D = g === 0 ? d * 1.4 : d;
+    A(a(g), i(g), a(_), i(_), D);
+  }
+  for (let g = 0; g < 21; g += 1) p(a(g), i(g), g === 0 ? d * 1.6 : d);
+  const S = a(0) - a(9), l = i(0) - i(9), T = Math.hypot(S, l) || 1, I = n * f, O = a(0) + S / T * I, C = i(0) + l / T * I;
+  if (n > 0) {
+    const g = d * 2, _ = -l / T * g, D = S / T * g;
+    o((a(0) + _) / r, i(0) + D), o((O + _) / r, C + D), o((O - _) / r, C - D), o((a(0) + _) / r, i(0) + D), o((O - _) / r, C - D), o((a(0) - _) / r, i(0) - D), p(O, C, g);
+  } else
+    for (let g = 0; g < (2 + se) * 3; g += 1) o(a(0) / r, i(0));
+  return u - c;
+}, Ee = 2, Jt = (
+  /* glsl */
+  `
+  void main() {
+    // On the near plane: in front of everything drawn after it.
+    gl_Position = vec4(position.xy, -1.0, 1.0);
+  }
+`
+), Qt = (
+  /* glsl */
+  `
+  void main() {
+    gl_FragColor = vec4(1.0, 0.2, 0.8, 0.35);
+  }
+`
+), $t = () => new K.ShaderMaterial({
+  name: "HandCutout",
+  vertexShader: Jt,
+  fragmentShader: Qt,
+  depthTest: !0,
+  depthFunc: K.AlwaysDepth,
+  depthWrite: !0,
+  colorWrite: !1,
+  side: K.DoubleSide
+}), cn = ({
+  inflate: e = 1,
+  forearm: r = 1.4,
+  debug: t = !1,
+  renderOrder: n = -900
+}) => {
+  const s = Pt(W.HAND_TRACKER), c = oe((h) => h.size), u = oe((h) => h.scene), o = x(() => {
+    const h = new K.BufferGeometry(), m = new K.BufferAttribute(
+      new Float32Array(Ee * je * 3 * 3),
+      3
+    );
+    return m.setUsage(K.DynamicDrawUsage), h.setAttribute("position", m), h.setDrawRange(0, 0), h;
+  }, []);
+  v(() => () => o.dispose(), [o]), v(() => Et(u, o), [u, o]);
+  const a = x($t, []);
+  v(() => () => a.dispose(), [a]), v(() => {
+    a.colorWrite = t, a.transparent = t, a.needsUpdate = !0;
+  }, [a, t]);
+  const i = x(() => new Float32Array(Ee * je * 3 * 2), []), f = E(null);
+  v(() => {
+    const h = f.current;
+    if (!(!h || t))
+      return h.layers.enable(we), () => h.layers.disable(we);
+  }, [t]);
+  const d = E({ inflate: e, forearm: r });
+  return d.current = { inflate: e, forearm: r }, U(() => {
+    const h = (s == null ? void 0 : s.hands) ?? [], m = c.width / Math.max(1, c.height);
+    let A = 0;
+    for (const l of h.slice(0, Ee)) {
+      const T = l.coordinates;
+      !T || T.length < 21 || (A += zt(T, m, d.current, i, A));
+    }
+    const p = o.getAttribute("position"), S = p.array;
+    for (let l = 0; l < A; l += 1)
+      S[l * 3] = i[l * 2], S[l * 3 + 1] = i[l * 2 + 1], S[l * 3 + 2] = 0;
+    p.needsUpdate = !0, o.setDrawRange(0, A);
+  }, qt), /* @__PURE__ */ N("group", { children: /* @__PURE__ */ N(
+    "mesh",
+    {
+      ref: f,
+      geometry: o,
+      material: a,
+      renderOrder: n,
+      frustumCulled: !1
     }
-    const g = B(h, a.current);
-    n.current.visible = !0, n.current.position.copy(g);
+  ) });
+}, Se = { hovered: !1, grabbed: !1, hand: null }, Zt = 1.08, un = ({
+  shape: e = "sphere",
+  size: r = 0.4,
+  position: t,
+  velocity: n,
+  mass: s,
+  bounce: c,
+  grabbable: u = !0,
+  pushable: o = !0,
+  gravity: a = !0,
+  color: i = "#f97316",
+  onGrab: f,
+  onRelease: d,
+  onTap: h,
+  onTouch: m,
+  onHoverChange: A,
+  children: p
+}) => {
+  const S = De(yt), l = E(null), [T, I] = V(Se), [O, C] = V(null), g = { onGrab: f, onRelease: d, onTap: h, onTouch: m, onHoverChange: A }, _ = E(g);
+  _.current = g;
+  const D = E((b) => {
+    var M, k, L, w, Q, Y;
+    const y = _.current;
+    switch (b.type) {
+      case "grab":
+        I({ hovered: !1, grabbed: !0, hand: b.hand }), (M = y.onGrab) == null || M.call(y, b);
+        break;
+      case "release":
+        I(Se), (k = y.onRelease) == null || k.call(y, b);
+        break;
+      case "hoverstart":
+        I((F) => F.grabbed ? F : { hovered: !0, grabbed: !1, hand: b.hand }), (L = y.onHoverChange) == null || L.call(y, !0, b.hand);
+        break;
+      case "hoverend":
+        I((F) => F.grabbed ? F : Se), (w = y.onHoverChange) == null || w.call(y, !1, b.hand);
+        break;
+      case "tap":
+        (Q = y.onTap) == null || Q.call(y, b);
+        break;
+      case "touch":
+        (Y = y.onTouch) == null || Y.call(y, b);
+        break;
+    }
+  }), R = E({
+    shape: e,
+    size: r,
+    position: t,
+    velocity: n,
+    mass: s,
+    bounce: c,
+    grabbable: u,
+    pushable: o,
+    gravity: a
   });
-  const s = P(
-    (l) => {
-      const f = y.current;
-      if (!f) return null;
-      const h = f.getLandmarks2D(e);
-      if (!h) return null;
-      if (l === "body.neck") {
-        const p = h[11], m = h[12];
-        if (!p || !m) return null;
-        const E = {
-          x: (p.x + m.x) / 2,
-          y: (p.y + m.y) / 2,
-          z: (p.z + m.z) / 2
-        };
-        return { position: B(E, a.current) };
-      }
-      const g = ue[l];
-      if (g === void 0) return null;
-      const d = h[g];
-      return d ? { position: B(d, a.current) } : null;
+  v(() => {
+    const b = l.current;
+    if (!S || !b) return;
+    const y = S.world.add(R.current);
+    b.position.copy(y.position);
+    const M = S.register(y, { object: b, onEvent: D });
+    return C(y), () => {
+      M(), S.world.remove(y), C(null);
+    };
+  }, [S]), v(() => {
+    O && (O.shape = e, O.size = Math.max(1e-4, r), O.radius = O.size / 2, O.mass = Math.max(1e-6, s ?? O.size ** 3), O.bounce = c, O.grabbable = u, O.pushable = o, O.gravity = a);
+  }, [O, e, r, s, c, u, o, a]);
+  const H = !S;
+  v(() => {
+    H && console.warn(`${Je.loggerPrefix} Touchable must be inside a HandTouch`);
+  }, [H]);
+  const P = p === void 0 ? /* @__PURE__ */ N(er, { shape: e, size: r, color: i, state: T }) : typeof p == "function" ? p(T) : p;
+  return /* @__PURE__ */ N("group", { ref: l, children: /* @__PURE__ */ N("group", { scale: T.grabbed ? Zt : 1, children: P }) });
+}, er = ({
+  shape: e,
+  size: r,
+  color: t,
+  state: n
+}) => /* @__PURE__ */ ut("mesh", { children: [
+  e === "box" ? /* @__PURE__ */ N("boxGeometry", { args: [r, r, r] }) : /* @__PURE__ */ N("sphereGeometry", { args: [r / 2, 32, 20] }),
+  /* @__PURE__ */ N(
+    "meshStandardMaterial",
+    {
+      color: t,
+      emissive: t,
+      emissiveIntensity: n.grabbed ? 0.45 : n.hovered ? 0.25 : 0,
+      roughness: 0.45,
+      metalness: 0.05
+    }
+  )
+] }), ue = { leftShoulder: 11, rightShoulder: 12, leftWrist: 15, rightWrist: 16 }, tr = 0, rr = [
+  [5, 8],
+  [9, 12],
+  [13, 16],
+  [17, 20]
+], ve = {
+  smile: 0.3,
+  mouthOpen: 0.25,
+  minVisibility: 0.5,
+  fingerExtension: 1.25
+}, nr = () => ({
+  facePresent: !1,
+  leftHandPresent: !1,
+  rightHandPresent: !1,
+  posePresent: !1,
+  smile: 0,
+  mouthOpen: 0,
+  smiling: !1,
+  mouthIsOpen: !1,
+  leftHandRaised: !1,
+  rightHandRaised: !1,
+  leftPalmOpen: !1,
+  rightPalmOpen: !1,
+  greeting: null
+}), Ke = (e, r) => Math.hypot(e.x - r.x, e.y - r.y), We = (e, r = ve.fingerExtension) => {
+  if (!e || e.landmarks.length < 21) return !1;
+  const t = e.landmarks[tr];
+  let n = 0;
+  for (const [s, c] of rr) {
+    const u = Ke(e.landmarks[s], t), o = Ke(e.landmarks[c], t);
+    u > 0 && o >= u * r && (n += 1);
+  }
+  return n >= 3;
+}, Ve = (e, r, t = ve.minVisibility) => {
+  const { pose: n } = e;
+  if (!n || n.landmarks.length < 33) return !1;
+  const s = r === "left" ? ue.leftWrist : ue.rightWrist, c = r === "left" ? ue.leftShoulder : ue.rightShoulder;
+  return n.visibility[s] < t || n.visibility[c] < t ? !1 : n.landmarks[s].y > n.landmarks[c].y;
+}, ln = (e, r = {}, t = nr()) => {
+  const n = { ...ve, ...r }, { face: s, leftHand: c, rightHand: u, pose: o } = e;
+  t.facePresent = s !== null, t.leftHandPresent = c !== null, t.rightHandPresent = u !== null, t.posePresent = o !== null;
+  const a = s == null ? void 0 : s.blendshapes;
+  return t.smile = a ? ((a.mouthSmileLeft ?? 0) + (a.mouthSmileRight ?? 0)) / 2 : 0, t.mouthOpen = (a == null ? void 0 : a.jawOpen) ?? 0, t.smiling = s !== null && t.smile >= n.smile, t.mouthIsOpen = s !== null && t.mouthOpen >= n.mouthOpen, t.leftHandRaised = Ve(e, "left", n.minVisibility), t.rightHandRaised = Ve(e, "right", n.minVisibility), t.leftPalmOpen = We(c, n.fingerExtension), t.rightPalmOpen = We(u, n.fingerExtension), t.smiling && t.rightHandRaised && t.rightPalmOpen ? t.greeting = "right" : t.smiling && t.leftHandRaised && t.leftPalmOpen ? t.greeting = "left" : t.greeting = null, t;
+}, sr = {
+  node: null,
+  ready: !1,
+  status: "loading",
+  error: null
+}, rt = ft(null), or = () => De(rt) ?? sr, Ye = (e, r) => r ? "error" : e ? e.getStatus() : "loading", ar = ({
+  children: e,
+  active: r = !0,
+  onStatusChange: t,
+  modelUrl: n,
+  delegate: s,
+  minFaceDetectionConfidence: c,
+  minFacePresenceConfidence: u,
+  minPoseDetectionConfidence: o,
+  minPosePresenceConfidence: a,
+  minHandLandmarksConfidence: i,
+  outputFaceBlendshapes: f,
+  targetFps: d,
+  hands: h,
+  analysisMaxDimension: m,
+  holdMs: A,
+  predictMs: p
+}) => {
+  const S = x(() => {
+    const R = {};
+    return n !== void 0 && (R.modelUrl = n), s !== void 0 && (R.delegate = s), c !== void 0 && (R.minFaceDetectionConfidence = c), u !== void 0 && (R.minFacePresenceConfidence = u), o !== void 0 && (R.minPoseDetectionConfidence = o), a !== void 0 && (R.minPosePresenceConfidence = a), i !== void 0 && (R.minHandLandmarksConfidence = i), f !== void 0 && (R.outputFaceBlendshapes = f), d !== void 0 && (R.targetFps = d), Object.keys(R).length > 0 ? R : void 0;
+  }, [
+    s,
+    c,
+    u,
+    i,
+    o,
+    a,
+    n,
+    f,
+    d
+  ]), { ready: l, node: T, error: I } = $(
+    W.HOLISTIC_TRACKER,
+    S,
+    r
+  );
+  v(() => {
+    T && T.setOptions(
+      mt({ hands: h, analysisMaxDimension: m, holdMs: A, predictMs: p })
+    );
+  }, [T, h, m, A, p]);
+  const [O, C] = V(() => Ye(T, I)), g = E(O), _ = E(t);
+  _.current = t, U(() => {
+    var H;
+    const R = Ye(T, I);
+    R !== g.current && (g.current = R, C(R), (H = _.current) == null || H.call(_, R, I ?? (T == null ? void 0 : T.getError()) ?? null));
+  });
+  const D = x(
+    () => ({
+      node: T,
+      ready: l && O === "ready",
+      status: O,
+      error: I ?? (T == null ? void 0 : T.getError()) ?? null
+    }),
+    [T, l, O, I]
+  );
+  return /* @__PURE__ */ N(rt.Provider, { value: D, children: e });
+}, ir = () => {
+  const { camera: e } = oe(), r = E(e);
+  return r.current !== e && (r.current = e), r;
+}, Ie = (e, r) => {
+  const t = E(null), { node: n, ready: s } = or(), c = ir();
+  return U(() => {
+    const u = t.current;
+    if (!u) return;
+    const o = s && n ? e(n.getResult()) : null;
+    if (!o) {
+      u.visible = !1;
+      return;
+    }
+    u.visible = !0, u.position.copy(r(o, c.current));
+  }), { groupRef: t, cameraRef: c, node: n };
+}, nt = ({ children: e }) => {
+  const r = E({ x: 0, y: 0, z: 0, visibility: 0 }), t = be(), { groupRef: n, cameraRef: s, node: c } = Ie(
+    (a) => {
+      var i;
+      return ((i = a.face) == null ? void 0 : i.landmarks[4]) ?? null;
+    },
+    (a, i) => Me(a, i)
+  ), u = j(
+    (a, i) => {
+      var h;
+      const f = (h = c == null ? void 0 : c.getResult().face) == null ? void 0 : h.landmarks;
+      if (!f || f.length === 0) return null;
+      const d = gt(
+        a,
+        f,
+        i,
+        r.current,
+        t
+      );
+      return d ? { position: Me(d, s.current) } : null;
     },
+    [s, c, t]
+  ), o = x(
+    () => ({ type: "face", resolveLandmark: u }),
+    [u]
+  );
+  return /* @__PURE__ */ N(ie.Provider, { value: o, children: /* @__PURE__ */ N("group", { ref: n, renderOrder: ce.TRACKED, visible: !1, children: e }) });
+};
+nt.displayName = "HolisticTracker.Face";
+const st = ({ hand: e, children: r }) => {
+  const t = j(
+    (a) => e === "left" ? a.leftHand : a.rightHand,
     [e]
-  ), c = _(
+  ), { groupRef: n, cameraRef: s, node: c } = Ie(
+    (a) => {
+      var i;
+      return ((i = t(a)) == null ? void 0 : i.landmarks[0]) ?? null;
+    },
+    q
+  ), u = j(
+    (a) => {
+      var d;
+      const i = et[a];
+      if (i === void 0 || !c) return null;
+      const f = (d = t(c.getResult())) == null ? void 0 : d.landmarks[i];
+      return f ? { position: q(f, s.current) } : null;
+    },
+    [s, c, t]
+  ), o = x(
+    () => ({ type: "hand", resolveLandmark: u }),
+    [u]
+  );
+  return /* @__PURE__ */ N(ie.Provider, { value: o, children: /* @__PURE__ */ N("group", { ref: n, renderOrder: ce.TRACKED, visible: !1, children: r }) });
+};
+st.displayName = "HolisticTracker.Hand";
+const ot = ({ children: e }) => {
+  const { groupRef: r, cameraRef: t, node: n } = Ie(
+    (u) => {
+      var o;
+      return ((o = u.pose) == null ? void 0 : o.landmarks[0]) ?? null;
+    },
+    q
+  ), s = j(
+    (u) => {
+      var f;
+      const o = (f = n == null ? void 0 : n.getResult().pose) == null ? void 0 : f.landmarks;
+      if (!o) return null;
+      if (u === "body.neck") {
+        const d = o[11], h = o[12];
+        if (!d || !h) return null;
+        const m = { x: (d.x + h.x) / 2, y: (d.y + h.y) / 2, z: (d.z + h.z) / 2 };
+        return { position: q(m, t.current) };
+      }
+      const a = St[u];
+      if (a === void 0) return null;
+      const i = o[a];
+      return i ? { position: q(i, t.current) } : null;
+    },
+    [t, n]
+  ), c = x(
     () => ({ type: "body", resolveLandmark: s }),
     [s]
   );
-  return /* @__PURE__ */ A(O.Provider, { value: c, children: /* @__PURE__ */ A("group", { ref: n, renderOrder: z.TRACKED, children: r }) });
-}, B = (e, t) => {
-  const r = new U.Vector3(e.x, e.y, e.z);
-  r.unproject(t);
-  const n = r.sub(t.position).normalize(), o = -t.position.z / n.z;
-  return t.position.clone().add(n.multiplyScalar(o));
-}, X = ["portrait"], Be = ({ type: e, active: t = !0, children: r }) => (N(F.BACKGROUND_SEGMENTATION, { type: e }, t), L(() => {
-  X.includes(e) || console.warn(
-    `[Segmentation] unsupported type "${e}"; valid values: ${X.join(", ")}`
+  return /* @__PURE__ */ N(ie.Provider, { value: c, children: /* @__PURE__ */ N("group", { ref: r, renderOrder: ce.TRACKED, visible: !1, children: e }) });
+};
+ot.displayName = "HolisticTracker.Body";
+const Ne = ar;
+Ne.Face = nt;
+Ne.Hand = st;
+Ne.Body = ot;
+const dn = ({ type: e, active: r = !0, children: t }) => ($(W.BACKGROUND_SEGMENTATION, { type: e }, r), v(() => {
+  Be.includes(e) || console.warn(
+    `[Segmentation] unsupported type "${e}"; valid values: ${Be.join(", ")}`
   );
-}, [e]), /* @__PURE__ */ A(J, { children: r })), ie = 800, ce = 200, ae = () => ({
+}, [e]), /* @__PURE__ */ N(lt, { children: t })), cr = 800, ur = 200, lr = () => ({
   armed: !1,
   armStart: null,
   holdStart: null,
   fired: !1
-}), le = (e, {
-  isTrigger: t,
-  gesture: r,
+}), dr = (e, {
+  isTrigger: r,
+  gesture: t,
   now: n,
-  mode: o,
-  debounceMs: u,
-  holdMs: i
+  mode: s,
+  debounceMs: c,
+  holdMs: u
 }) => {
   if (e.fired) return null;
-  if (o === "hold") {
-    if (t && r) {
-      if (e.holdStart === null && (e.holdStart = n), n - e.holdStart >= i)
-        return e.fired = !0, r;
+  if (s === "hold") {
+    if (r && t) {
+      if (e.holdStart === null && (e.holdStart = n), n - e.holdStart >= u)
+        return e.fired = !0, t;
     } else
       e.holdStart = null;
     return null;
   }
-  return e.armed ? t && r ? (e.fired = !0, r) : null : (t ? e.armStart = null : (e.armStart === null && (e.armStart = n), n - e.armStart >= u && (e.armed = !0)), null);
+  return e.armed ? r && t ? (e.fired = !0, t) : null : (r ? e.armStart = null : (e.armStart === null && (e.armStart = n), n - e.armStart >= c && (e.armed = !0)), null);
 };
-function de({
+function fr({
   gestures: e,
-  mode: t = "arm",
-  debounceMs: r = ie,
-  holdMs: n = ce,
-  onTrigger: o,
-  enabled: u = !0
+  mode: r = "arm",
+  debounceMs: t = cr,
+  holdMs: n = ur,
+  onTrigger: s,
+  enabled: c = !0
 }) {
-  const { ready: i, node: a } = N(F.GESTURE_TRACKER), y = R(o);
-  L(() => {
-    y.current = o;
-  }, [o]);
-  const s = R(/* @__PURE__ */ new Set());
-  L(() => {
-    s.current = new Set(Array.isArray(e) ? e : [e]);
+  const { ready: u, node: o } = $(W.GESTURE_TRACKER), a = E(s);
+  v(() => {
+    a.current = s;
+  }, [s]);
+  const i = E(/* @__PURE__ */ new Set());
+  v(() => {
+    i.current = new Set(Array.isArray(e) ? e : [e]);
   }, [e]);
-  const c = R(ae());
-  b(() => {
-    if (!u || !i || !a) return;
-    const l = a.gesture, f = !!(l && s.current.has(l)), h = le(c.current, {
-      isTrigger: f,
-      gesture: l,
+  const f = E(lr());
+  U(() => {
+    if (!c || !u || !o) return;
+    const d = o.gesture, h = !!(d && i.current.has(d)), m = dr(f.current, {
+      isTrigger: h,
+      gesture: d,
       now: performance.now(),
-      mode: t,
-      debounceMs: r,
+      mode: r,
+      debounceMs: t,
       holdMs: n
     });
-    h && y.current(h);
+    m && a.current(m);
   });
 }
-const je = (e) => (de(e), null), he = (e, t) => t && !e ? "begin" : !t && e ? "end" : t ? "stay" : "none", fe = {
+const fn = (e) => (fr(e), null), hr = ({
+  source: e,
+  face: r,
+  canvas: t,
+  outputSize: n,
+  padding: s = 0.2
+}) => Yt({ source: e, bounds: r.bounds, canvas: t, outputSize: n, padding: s }), he = (e) => ({ value: e, confidence: 1 }), le = (e, r, t, n) => ({
+  name: e,
+  kind: "face",
+  description: r,
+  defaults: n,
+  measure: (s) => s ? he(t(s)) : null
+}), B = (e, r, t, n) => ({
+  name: e,
+  kind: "hand",
+  description: r,
+  defaults: n,
+  measure: (s) => s && s.length >= 21 ? he(t(s)) : null
+}), ae = (e, r, t, n) => ({
+  name: e,
+  kind: "body",
+  description: r,
+  defaults: n,
+  measure: (s, c, u, o) => s && s.length >= 33 ? he(t(s, (o == null ? void 0 : o.mirrored) ?? !1)) : null
+}), Ae = (e) => () => ({
+  tracker: new Ot(e),
+  wasPresent: !1
+}), Re = (e, r, t) => r === null ? (e.wasPresent = !1, null) : (e.wasPresent || e.tracker.reset(), e.wasPresent = !0, he(e.tracker.push(r, t))), _e = {
+  enterThreshold: 0.99,
+  exitThreshold: 0.3,
+  cooldownMs: 600
+}, at = {
+  // ── Face ───────────────────────────────────────────────────────────────
+  mouthOpen: le(
+    "mouthOpen",
+    "Jaw open (blendshape jawOpen).",
+    (e) => de(e, "mouthOpen")
+  ),
+  smile: le(
+    "smile",
+    "Mean of the two mouthSmile blendshapes.",
+    (e) => (Ge(e, "mouthSmileLeft") + Ge(e, "mouthSmileRight")) / 2,
+    { enterThreshold: 0.4 }
+  ),
+  blink: le(
+    "blink",
+    "Both eyes closed (min of the eyeBlink blendshapes).",
+    (e) => de(e, "eyeBlink"),
+    { enterThreshold: 0.55, holdMs: 50 }
+  ),
+  browRaise: le(
+    "browRaise",
+    "Eyebrows raised (max of the brow-up blendshapes).",
+    (e) => de(e, "browRaise"),
+    { enterThreshold: 0.45 }
+  ),
+  headNod: {
+    name: "headNod",
+    kind: "face",
+    description: "Pitch oscillation: three turning points of at least 0.12 rad within 1.5 s.",
+    defaults: _e,
+    createMemory: Ae({ minAmplitude: 0.12, requiredReversals: 3, windowMs: 1500 }),
+    measure: (e, r, t) => Re(r, e ? e.pose.rotation.x : null, t)
+  },
+  headShake: {
+    name: "headShake",
+    kind: "face",
+    description: "Yaw oscillation: three turning points of at least 0.15 rad within 1.5 s.",
+    defaults: _e,
+    createMemory: Ae({ minAmplitude: 0.15, requiredReversals: 3, windowMs: 1500 }),
+    measure: (e, r, t) => Re(r, e ? e.pose.rotation.y : null, t)
+  },
+  // ── Hand ───────────────────────────────────────────────────────────────
+  pinch: B(
+    "pinch",
+    "Thumb and index tips touching, relative to palm size.",
+    Nt,
+    {
+      enterThreshold: 0.75,
+      exitThreshold: 0.5
+    }
+  ),
+  grab: B("grab", "Fist: index to pinky curled toward the wrist.", It, {
+    enterThreshold: 0.7,
+    exitThreshold: 0.45
+  }),
+  openPalm: B("openPalm", "Index to pinky extended.", vt, {
+    enterThreshold: 0.7,
+    exitThreshold: 0.45
+  }),
+  handRaised: B(
+    "handRaised",
+    "Wrist in the upper part of the frame (0 bottom edge, 1 top edge).",
+    bt,
+    { enterThreshold: 0.7, exitThreshold: 0.6 }
+  ),
+  // Finger-count signs: each required finger must agree; 1 only when all do.
+  oneFinger: B(
+    "oneFinger",
+    "Index extended, other fingers curled (pointing).",
+    (e) => re(e, { fingers: [!0, !1, !1, !1] }),
+    { enterThreshold: 0.65, exitThreshold: 0.45 }
+  ),
+  peaceSign: B(
+    "peaceSign",
+    "Index and middle extended, ring and pinky curled.",
+    (e) => re(e, { fingers: [!0, !0, !1, !1] }),
+    { enterThreshold: 0.65, exitThreshold: 0.45 }
+  ),
+  threeFingers: B(
+    "threeFingers",
+    "Index, middle and ring extended, pinky curled.",
+    (e) => re(e, { fingers: [!0, !0, !0, !1] }),
+    { enterThreshold: 0.65, exitThreshold: 0.45 }
+  ),
+  fourFingers: B(
+    "fourFingers",
+    "Index to pinky extended, thumb tucked.",
+    (e) => re(e, { fingers: [!0, !0, !0, !0], thumb: !1 }),
+    { enterThreshold: 0.65, exitThreshold: 0.45 }
+  ),
+  fist: B(
+    "fist",
+    "All four fingers curled and the thumb tucked.",
+    (e) => re(e, { fingers: [!1, !1, !1, !1], thumb: !1 }),
+    { enterThreshold: 0.65, exitThreshold: 0.45 }
+  ),
+  palm: B(
+    "palm",
+    "All four fingers extended and the thumb out.",
+    (e) => re(e, { fingers: [!0, !0, !0, !0], thumb: !0 }),
+    { enterThreshold: 0.65, exitThreshold: 0.45 }
+  ),
+  thumbUp: B(
+    "thumbUp",
+    "Thumb out and pointing up, fingers curled.",
+    (e) => ke(e, "up"),
+    { enterThreshold: 0.6, exitThreshold: 0.4 }
+  ),
+  thumbDown: B(
+    "thumbDown",
+    "Thumb out and pointing down, fingers curled.",
+    (e) => ke(e, "down"),
+    { enterThreshold: 0.6, exitThreshold: 0.4 }
+  ),
+  wave: {
+    name: "wave",
+    kind: "hand",
+    description: "Wrist swinging side to side: three turning points of at least 0.08 within 1.2 s.",
+    defaults: _e,
+    createMemory: Ae({ minAmplitude: 0.08, requiredReversals: 3, windowMs: 1200 }),
+    measure: (e, r, t) => Re(r, e && e.length >= 21 ? e[0].x : null, t)
+  },
+  // ── Body ───────────────────────────────────────────────────────────────
+  armRaisedLeft: ae(
+    "armRaisedLeft",
+    "Person's own left wrist above their left shoulder, in shoulder widths, on every feed.",
+    (e, r) => te(e, "left", r),
+    { enterThreshold: 0.3, exitThreshold: 0.15 }
+  ),
+  armRaisedRight: ae(
+    "armRaisedRight",
+    "Person's own right wrist above their right shoulder, in shoulder widths, on every feed.",
+    (e, r) => te(e, "right", r),
+    { enterThreshold: 0.3, exitThreshold: 0.15 }
+  ),
+  armRaised: ae(
+    "armRaised",
+    "Either wrist above its shoulder.",
+    (e) => Math.max(te(e, "left"), te(e, "right")),
+    { enterThreshold: 0.3, exitThreshold: 0.15 }
+  ),
+  bothArmsRaised: ae(
+    "bothArmsRaised",
+    "Both wrists above their shoulders.",
+    (e) => Math.min(te(e, "left"), te(e, "right")),
+    { enterThreshold: 0.3, exitThreshold: 0.15 }
+  ),
+  tPose: ae("tPose", "Both arms level and outstretched.", Dt, {
+    enterThreshold: 0.6,
+    exitThreshold: 0.4,
+    holdMs: 150
+  })
+}, hn = Object.keys(at), mr = (e) => typeof e == "string" ? at[e] : e, mn = (e) => e, pr = {
+  face: W.FACE_TRACKER,
+  hand: W.HAND_TRACKER,
+  body: W.BODY_TRACKER
+}, Xe = (e) => Ze(Oe(e)), Tr = (e, r = {}) => {
+  var k;
+  const t = x(() => mr(e), [e]), {
+    active: n = !0,
+    faceIndex: s = 0,
+    numFaces: c,
+    hand: u,
+    handIndex: o = 0,
+    bodyIndex: a = 0,
+    targetFps: i,
+    onBegin: f,
+    onEnd: d,
+    onChange: h,
+    ...m
+  } = r, A = pr[t.kind], p = Math.max(c ?? s + 1, s + 1), S = x(() => {
+    const L = {};
+    return t.kind === "face" && (L.numFaces = p), i !== void 0 && i > 0 && (L.targetFps = i), Object.keys(L).length > 0 ? L : void 0;
+  }, [t.kind, p, i]), { node: l, ready: T } = $(A, S, n), { camera: I } = oe();
+  v(() => {
+    !l || t.kind !== "face" || l.setCamera(I, s);
+  }, [I, t.kind, s, l]);
+  const O = x(
+    () => Ue(
+      m,
+      Ue(t.defaults)
+    ),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+      t,
+      m.enterThreshold,
+      m.exitThreshold,
+      m.holdMs,
+      m.cooldownMs,
+      m.minConfidence,
+      m.lostGraceMs
+    ]
+  ), C = E(Oe(t.name)), g = E((k = t.createMemory) == null ? void 0 : k.call(t)), _ = E(jt()), [D, R] = V(() => Xe(t.name)), H = E(D);
+  v(() => {
+    var w;
+    C.current = Oe(t.name), g.current = (w = t.createMemory) == null ? void 0 : w.call(t);
+    const L = Xe(t.name);
+    H.current = L, R(L);
+  }, [t]);
+  const P = E({ onBegin: f, onEnd: d, onChange: h });
+  P.current = { onBegin: f, onEnd: d, onChange: h };
+  const b = be(), y = E({ mirrored: b });
+  y.current.mirrored = b;
+  const M = E({ faceIndex: s, hand: u, handIndex: o, bodyIndex: a, active: n });
+  return M.current = { faceIndex: s, hand: u, handIndex: o, bodyIndex: a, active: n }, U(() => {
+    var ee;
+    const L = performance.now(), w = M.current;
+    let Q = null;
+    if (w.active && T && l) {
+      let z;
+      t.kind === "face" ? z = Kt(l, w.faceIndex, _.current) : t.kind === "hand" ? z = (ee = tt(
+        l,
+        w.hand,
+        w.handIndex
+      )) == null ? void 0 : ee.coordinates : z = l.getLandmarks2D(w.bodyIndex), Q = t.measure(z, g.current, L, y.current);
+    }
+    const Y = Ut(C.current, Q, L, O);
+    if (Gt(H.current, Y)) return;
+    const F = Ze(Y);
+    H.current = F, R(F);
+    const { onBegin: X, onEnd: Z, onChange: G } = P.current;
+    F.justBegan && (X == null || X(F)), F.justEnded && (Z == null || Z(F)), G == null || G(F);
+  }), D;
+}, pn = ({ gesture: e, ...r }) => (Tr(e, r), null), qe = /* @__PURE__ */ new WeakMap(), gr = (e, r) => {
+  const { visibility: t, mirrored: n, aspect: s, shapeLimits: c, view: u } = r;
+  if (c || u)
+    return Pe(e, {
+      mirrored: n,
+      visibility: t,
+      aspect: s,
+      limits: c,
+      view: u
+    });
+  const o = qe.get(e);
+  if (o && o.mirrored === n && o.aspect === s) return o;
+  const a = Pe(e, { mirrored: n, visibility: t, aspect: s });
+  return qe.set(e, a), a;
+}, Er = (e) => {
+  if (!e) return;
+  const r = {};
+  let t = !1;
+  for (const n of Object.keys(e))
+    n in kt && e[n] !== void 0 && (r[n] = e[n], t = !0);
+  return t ? r : void 0;
+}, Sr = (e) => {
+  const {
+    pose: r,
+    move: t,
+    bodyIndex: n = 0,
+    active: s = !0,
+    targetFps: c,
+    limits: u,
+    view: o,
+    onBegin: a,
+    onEnd: i,
+    onChange: f,
+    ...d
+  } = e, h = t !== void 0 ? { move: t } : { pose: r }, m = t !== void 0 ? `move:${typeof t == "string" ? t : t.name}` : `pose:${Wt(r)}`, A = x(
+    () => c !== void 0 && c > 0 ? { targetFps: c } : void 0,
+    [c]
+  ), { node: p, ready: S } = $(
+    W.BODY_TRACKER,
+    A,
+    s
+  ), l = be(), T = Bt(), I = JSON.stringify(u ?? null), O = x(() => Er(u), [I]), C = JSON.stringify(o ?? null), g = x(() => o, [C]), _ = JSON.stringify(d) + I, D = { ...d, limits: u }, R = E(null), H = E("");
+  (R.current === null || H.current !== m) && (R.current = xt(h, D), H.current = m), t !== void 0 ? R.current.move = Ct(t) : R.current.pose = r;
+  const [P, b] = V(
+    () => ge(R.current)
+  ), y = E(P);
+  v(() => {
+    const w = ge(R.current);
+    y.current = w, b(w);
+  }, [m]), v(() => {
+    R.current && Ht(R.current, h, D);
+  }, [_]);
+  const M = E({ onBegin: a, onEnd: i, onChange: f });
+  M.current = { onBegin: a, onEnd: i, onChange: f };
+  const k = E(null), L = E(null);
+  return U(() => {
+    var Le;
+    const w = R.current;
+    if (!w) return;
+    const Q = performance.now();
+    let Y = null, F = !0;
+    const X = s && S && p ? p.getLandmarks2D(n) : void 0;
+    X && X.length >= Ft ? (F = X !== k.current || !L.current, Y = F ? gr(X, {
+      visibility: (Le = p == null ? void 0 : p.getVisibility) == null ? void 0 : Le.call(p, n),
+      mirrored: l,
+      aspect: T,
+      shapeLimits: O,
+      view: g
+    }) : L.current, k.current = X, L.current = Y) : (k.current = null, L.current = null);
+    const Z = Lt(w, Y, Q, F);
+    if (Mt(y.current, Z)) return;
+    const G = ge(Z);
+    y.current = G, b(G);
+    const { onBegin: ee, onEnd: z, onChange: Te } = M.current;
+    G.justBegan && (ee == null || ee(G)), G.justEnded && (z == null || z(G)), Te == null || Te(G);
+  }), P;
+}, Tn = (e) => (Sr(e), null), xe = 1, Ce = Object.freeze({
+  version: xe,
+  orientation: 0,
+  mirrored: "auto",
+  scale: 1,
+  offset: Object.freeze({ x: 0, y: 0 }),
+  face: null,
+  body: null,
+  updatedAt: 0
+}), Ar = (e = {}) => me(Ce, e, 0), Rr = [0, 90, 180, 270], _r = (e) => Math.min(4, Math.max(0.25, e)), me = (e, r, t = Date.now()) => ({
+  version: xe,
+  orientation: r.orientation !== void 0 && Rr.includes(r.orientation) ? r.orientation : e.orientation,
+  mirrored: r.mirrored === !0 || r.mirrored === !1 || r.mirrored === "auto" ? r.mirrored : e.mirrored,
+  scale: r.scale !== void 0 && Number.isFinite(r.scale) && r.scale > 0 ? _r(r.scale) : e.scale,
+  offset: r.offset && Number.isFinite(r.offset.x) && Number.isFinite(r.offset.y) ? { x: r.offset.x, y: r.offset.y } : { ...e.offset },
+  face: r.face !== void 0 ? r.face : e.face,
+  body: r.body !== void 0 ? r.body : e.body,
+  updatedAt: t
+}), yr = (e = Date.now()) => me(Ce, {}, e), gn = (e) => e.orientation === 0 && e.mirrored === "auto" && e.scale === 1 && e.offset.x === 0 && e.offset.y === 0, Or = (e, r) => e.mirrored === "auto" ? !1 : e.mirrored !== pt(r), Dr = (e, r, t, n = { x: 0, y: 0 }) => {
+  let { x: s, y: c } = e;
+  switch (r.orientation) {
+    case 90:
+      [s, c] = [1 - c, s];
+      break;
+    case 180:
+      [s, c] = [1 - s, 1 - c];
+      break;
+    case 270:
+      [s, c] = [c, 1 - s];
+      break;
+  }
+  return Or(r, t) && (s = 1 - s), s = 0.5 + (s - 0.5) * r.scale + r.offset.x, c = 0.5 + (c - 0.5) * r.scale + r.offset.y, n.x = s, n.y = c, e.z !== void 0 && (n.z = e.z), n;
+}, fe = (e, r) => e && r ? Math.hypot(e.x - r.x, e.y - r.y) : null, br = Object.freeze({
+  leftTemple: 454,
+  rightTemple: 234,
+  leftEyeOuter: 263,
+  rightEyeOuter: 33
+}), it = (e, r = Date.now()) => {
+  if (!e || e.length < 468) return null;
+  const { leftTemple: t, rightTemple: n, leftEyeOuter: s, rightEyeOuter: c } = br, u = fe(e[t], e[n]), o = fe(e[s], e[c]);
+  return !u || !o ? null : { faceWidth: u, eyeDistance: o, capturedAt: r };
+}, vr = Object.freeze({
+  leftShoulder: 11,
+  rightShoulder: 12,
+  leftHip: 23,
+  rightHip: 24
+}), ct = (e, r = Date.now()) => {
+  if (!e || e.length < 33) return null;
+  const { leftShoulder: t, rightShoulder: n, leftHip: s, rightHip: c } = vr, u = fe(e[t], e[n]), o = fe(e[s], e[c]), a = e[t], i = e[n], f = e[s], d = e[c];
+  if (!u || !o || !a || !i || !f || !d) return null;
+  const h = Math.hypot(
+    (a.x + i.x) / 2 - (f.x + d.x) / 2,
+    (a.y + i.y) / 2 - (f.y + d.y) / 2
+  );
+  return { shoulderWidth: u, hipWidth: o, torsoLength: h, capturedAt: r };
+}, Ir = (e, r) => {
+  const t = r.face, n = it(e, 0);
+  return !t || !n ? null : t.faceWidth > 0 && n.faceWidth > 0 ? n.faceWidth / t.faceWidth : t.eyeDistance > 0 && n.eyeDistance > 0 ? n.eyeDistance / t.eyeDistance : null;
+}, Nr = (e, r) => {
+  const t = r.body, n = ct(e, 0);
+  return !t || !n || t.shoulderWidth <= 0 ? null : n.shoulderWidth / t.shoulderWidth;
+}, pe = "vincentt.xr.calibration", He = () => {
+  try {
+    return typeof localStorage < "u" ? localStorage : null;
+  } catch {
+    return null;
+  }
+}, xr = (e = pe, r = He()) => {
+  if (!r) return null;
+  try {
+    const t = r.getItem(e);
+    if (!t) return null;
+    const n = JSON.parse(t);
+    return !n || typeof n != "object" || n.version !== xe ? null : me(
+      Ce,
+      {
+        orientation: n.orientation,
+        mirrored: n.mirrored,
+        scale: n.scale,
+        offset: n.offset,
+        face: n.face ?? null,
+        body: n.body ?? null
+      },
+      typeof n.updatedAt == "number" ? n.updatedAt : 0
+    );
+  } catch {
+    return null;
+  }
+}, Cr = (e, r = pe, t = He()) => {
+  if (!t) return !1;
+  try {
+    return t.setItem(r, JSON.stringify(e)), !0;
+  } catch {
+    return !1;
+  }
+}, Hr = (e = pe, r = He()) => {
+  if (r)
+    try {
+      r.removeItem(e);
+    } catch {
+    }
+}, En = (e = {}) => {
+  const { storageKey: r = pe, persist: t = !0 } = e, n = e.storage === void 0 ? void 0 : e.storage, s = E(e.initial), { session: c } = Qe(), u = ht(
+    (l) => c.store.subscribe(l),
+    () => c.store.getSnapshot().sourceKind,
+    () => {
+    }
+  ), [o, a] = V(
+    () => Ar(s.current)
+  ), [i, f] = V(!t), d = E(o);
+  d.current = o, v(() => {
+    if (!t) {
+      f(!0);
+      return;
+    }
+    const l = xr(r, n);
+    l && (d.current = l, a(l)), f(!0);
+  }, [t, r, n]);
+  const h = j(
+    (l) => (d.current = l, a(l), t && Cr(l, r, n), l),
+    [t, r, n]
+  ), m = j(
+    (l) => h(me(d.current, l)),
+    [h]
+  ), A = j(() => {
+    const l = yr();
+    return d.current = l, a(l), t && Hr(r, n), l;
+  }, [t, r, n]), p = j(
+    (l) => {
+      const T = it(l);
+      return T ? (m({ face: T }), !0) : !1;
+    },
+    [m]
+  ), S = j(
+    (l) => {
+      const T = ct(l);
+      return T ? (m({ body: T }), !0) : !1;
+    },
+    [m]
+  );
+  return x(
+    () => ({
+      calibration: o,
+      hydrated: i,
+      update: m,
+      reset: A,
+      calibrateFace: p,
+      calibrateBody: S,
+      applyToFeedPoint: (l, T) => Dr(l, o, u, T),
+      faceDistance: (l) => Ir(l, o),
+      bodyScale: (l) => Nr(l, o),
+      sourceKind: u
+    }),
+    [o, i, m, A, p, S, u]
+  );
+}, Lr = (e, r) => r && !e ? "begin" : !r && e ? "end" : r ? "stay" : "none", Mr = {
   face: null,
   faces: [],
   faceCount: 0,
@@ -271,239 +1139,67 @@ const je = (e) => (de(e), null), he = (e, t) => t && !e ? "begin" : !t && e ? "e
   justDetected: !1,
   justLost: !1,
   phase: "none"
-}, Oe = ({
+}, Sn = ({
   faceIndex: e = 0,
-  numFaces: t,
-  ...r
+  numFaces: r,
+  ...t
 } = {}) => {
-  const n = Number.isFinite(e) ? Math.max(0, Math.round(e)) : 0, o = te({
-    ...r,
-    numFaces: Math.max(t ?? n + 1, n + 1)
-  }), u = R([]), i = R(n), a = R({ detected: !1, faceIndex: n }), [y, s] = I(fe), c = R(y);
-  return L(() => {
-    u.current = o, i.current = n;
-  }, [o, n]), b(() => {
-    const l = u.current, f = i.current, h = l[f] ?? null, g = !!h, d = a.current.faceIndex === f && a.current.detected, p = he(d, g);
-    a.current = { detected: g, faceIndex: f };
-    const m = {
-      face: h,
-      faces: l,
-      faceCount: l.length,
-      detected: g,
-      justDetected: p === "begin",
-      justLost: p === "end",
-      phase: p
-    }, E = c.current;
-    E.face === m.face && E.faces === m.faces && E.faceCount === m.faceCount && E.detected === m.detected && E.justDetected === m.justDetected && E.justLost === m.justLost && E.phase === m.phase || (c.current = m, s(m));
-  }), y;
-}, Ce = [
-  "_neutral",
-  "browDownLeft",
-  "browDownRight",
-  "browInnerUp",
-  "browOuterUpLeft",
-  "browOuterUpRight",
-  "cheekPuff",
-  "cheekSquintLeft",
-  "cheekSquintRight",
-  "eyeBlinkLeft",
-  "eyeBlinkRight",
-  "eyeLookDownLeft",
-  "eyeLookDownRight",
-  "eyeLookInLeft",
-  "eyeLookInRight",
-  "eyeLookOutLeft",
-  "eyeLookOutRight",
-  "eyeLookUpLeft",
-  "eyeLookUpRight",
-  "eyeSquintLeft",
-  "eyeSquintRight",
-  "eyeWideLeft",
-  "eyeWideRight",
-  "jawForward",
-  "jawLeft",
-  "jawOpen",
-  "jawRight",
-  "mouthClose",
-  "mouthDimpleLeft",
-  "mouthDimpleRight",
-  "mouthFrownLeft",
-  "mouthFrownRight",
-  "mouthFunnel",
-  "mouthLeft",
-  "mouthLowerDownLeft",
-  "mouthLowerDownRight",
-  "mouthPressLeft",
-  "mouthPressRight",
-  "mouthPucker",
-  "mouthRight",
-  "mouthRollLower",
-  "mouthRollUpper",
-  "mouthShrugLower",
-  "mouthShrugUpper",
-  "mouthSmileLeft",
-  "mouthSmileRight",
-  "mouthStretchLeft",
-  "mouthStretchRight",
-  "mouthUpperUpLeft",
-  "mouthUpperUpRight",
-  "noseSneerLeft",
-  "noseSneerRight"
-], pe = ({
-  source: e,
-  face: t,
-  canvas: r,
-  outputSize: n,
-  padding: o = 0.2
-}) => ne({ source: e, bounds: t.bounds, canvas: r, outputSize: n, padding: o }), Pe = [
-  "browRaise",
-  "eyeBlink",
-  "eyeBlinkLeft",
-  "eyeBlinkRight",
-  "eyeBlinkEither",
-  "headUp",
-  "headDown",
-  "headTurnLeft",
-  "headTurnRight",
-  "mouthOpen",
-  "mouthPout",
-  "headTiltLeft",
-  "headTiltRight"
-], S = (e = 0.5) => ({
-  threshold: e,
-  releaseThreshold: Math.max(0, e - 0.15),
-  holdMs: 50
-}), w = {
-  threshold: Math.PI / 18,
-  releaseThreshold: Math.PI / 30,
-  holdMs: 80
-}, me = {
-  browRaise: S(0.45),
-  eyeBlink: S(0.55),
-  eyeBlinkLeft: S(0.55),
-  eyeBlinkRight: S(0.55),
-  eyeBlinkEither: S(0.55),
-  headUp: w,
-  headDown: w,
-  headTurnLeft: w,
-  headTurnRight: w,
-  mouthOpen: S(0.45),
-  mouthPout: S(0.5),
-  headTiltLeft: w,
-  headTiltRight: w
-}, x = (e) => Math.max(0, e), v = (e, t) => e !== void 0 && Number.isFinite(e) ? e : t, q = (e, t = {}) => {
-  const r = me[e], n = Math.max(0, v(t.threshold, r.threshold));
-  return {
-    threshold: n,
-    releaseThreshold: Math.min(
-      n,
-      Math.max(0, v(t.releaseThreshold, r.releaseThreshold))
-    ),
-    holdMs: Math.max(0, v(t.holdMs, r.holdMs))
-  };
-}, H = (e, t, { neutralRotation: r = { x: 0, y: 0, z: 0 } } = {}) => {
-  const n = v(r.x, 0), o = v(r.y, 0), u = v(r.z, 0);
-  switch (t) {
-    case "browRaise":
-      return Math.max(
-        T(e, "browInnerUp"),
-        T(e, "browOuterUpLeft"),
-        T(e, "browOuterUpRight")
-      );
-    case "eyeBlink":
-      return Math.min(
-        T(e, "eyeBlinkLeft"),
-        T(e, "eyeBlinkRight")
-      );
-    case "eyeBlinkLeft":
-      return T(e, "eyeBlinkRight");
-    case "eyeBlinkRight":
-      return T(e, "eyeBlinkLeft");
-    case "eyeBlinkEither":
-      return Math.max(
-        T(e, "eyeBlinkLeft"),
-        T(e, "eyeBlinkRight")
-      );
-    case "mouthOpen":
-      return T(e, "jawOpen");
-    case "mouthPout":
-      return T(e, "mouthPucker");
-    case "headUp":
-      return x(e.pose.rotation.x - n);
-    case "headDown":
-      return x(n - e.pose.rotation.x);
-    case "headTurnLeft":
-      return x(e.pose.rotation.y - o);
-    case "headTurnRight":
-      return x(o - e.pose.rotation.y);
-    case "headTiltLeft":
-      return x(e.pose.rotation.z - u);
-    case "headTiltRight":
-      return x(u - e.pose.rotation.z);
-  }
-}, Ie = (e, t, r = {}) => H(e, t, r) >= q(t, r).threshold, Ue = (e, t, r = {}) => {
-  let n = null, o = 0;
-  for (const u of e) {
-    const i = H(u, t, r);
-    (!n || i > o) && (n = u, o = i);
-  }
-  return { face: n, value: o };
-}, V = (e) => ({
-  action: e,
-  active: !1,
-  value: 0,
-  justStarted: !1,
-  justEnded: !1,
-  phase: "none",
-  holdStartedAt: null
-}), Re = (e, t, r, n, o) => {
-  const u = e.phase === "begin";
-  if (e.value = t, e.justStarted = !1, e.justEnded = !1, e.phase = e.active ? "stay" : "none", !n)
-    return e.holdStartedAt = null, e.active && (e.active = !1, e.justEnded = !0, e.phase = "end"), e;
-  if (e.active) {
-    if (t <= o.releaseThreshold) {
-      if (u) return e;
-      e.active = !1, e.justEnded = !0, e.phase = "end";
-    }
-    return e;
-  }
-  return t < o.threshold ? (e.holdStartedAt = null, e) : (e.holdStartedAt === null && (e.holdStartedAt = r), r - e.holdStartedAt >= o.holdMs && (e.active = !0, e.justStarted = !0, e.phase = "begin", e.holdStartedAt = null), e);
-}, W = (e) => ({
+  const n = Number.isFinite(e) ? Math.max(0, Math.round(e)) : 0, s = Vt({
+    ...t,
+    numFaces: Math.max(r ?? n + 1, n + 1)
+  }), c = E([]), u = E(n), o = E({ detected: !1, faceIndex: n }), [a, i] = V(Mr), f = E(a);
+  return v(() => {
+    c.current = s, u.current = n;
+  }, [s, n]), U(() => {
+    const d = c.current, h = u.current, m = d[h] ?? null, A = !!m, p = o.current.faceIndex === h && o.current.detected, S = Lr(p, A);
+    o.current = { detected: A, faceIndex: h };
+    const l = {
+      face: m,
+      faces: d,
+      faceCount: d.length,
+      detected: A,
+      justDetected: S === "begin",
+      justLost: S === "end",
+      phase: S
+    }, T = f.current;
+    T.face === l.face && T.faces === l.faces && T.faceCount === l.faceCount && T.detected === l.detected && T.justDetected === l.justDetected && T.justLost === l.justLost && T.phase === l.phase || (f.current = l, i(l));
+  }), a;
+}, ze = (e) => ({
   action: e,
   active: !1,
   value: 0,
   justStarted: !1,
   justEnded: !1,
   phase: "none"
-}), ze = (e, t, r = {}) => {
-  const n = R(V(t)), o = R(null), u = R(t), i = R({}), [a, y] = I(() => W(t)), s = R(a);
-  return L(() => {
-    o.current = e, i.current = r;
-  }, [e, r]), L(() => {
-    u.current = t, n.current = V(t);
-    const c = W(t);
-    s.current = c, y(c);
-  }, [t]), b(({ clock: c }) => {
-    const l = o.current, f = u.current, h = i.current, g = l ? H(l, f, h) : 0, d = Re(
+}), An = (e, r, t = {}) => {
+  const n = E(Fe(r)), s = E(null), c = E(r), u = E({}), [o, a] = V(() => ze(r)), i = E(o);
+  return v(() => {
+    s.current = e, u.current = t;
+  }, [e, t]), v(() => {
+    c.current = r, n.current = Fe(r);
+    const f = ze(r);
+    i.current = f, a(f);
+  }, [r]), U(({ clock: f }) => {
+    const d = s.current, h = c.current, m = u.current, A = d ? de(d, h, m) : 0, p = At(
       n.current,
-      g,
-      c.elapsedTime * 1e3,
-      !!l,
-      q(f, h)
-    ), p = s.current;
-    if (p.action === d.action && p.active === d.active && p.value === d.value && p.justStarted === d.justStarted && p.justEnded === d.justEnded && p.phase === d.phase)
+      A,
+      f.elapsedTime * 1e3,
+      !!d,
+      Rt(h, m)
+    ), S = i.current;
+    if (S.action === p.action && S.active === p.active && S.value === p.value && S.justStarted === p.justStarted && S.justEnded === p.justEnded && S.phase === p.phase)
       return;
-    const m = {
-      action: d.action,
-      active: d.active,
-      value: d.value,
-      justStarted: d.justStarted,
-      justEnded: d.justEnded,
-      phase: d.phase
+    const l = {
+      action: p.action,
+      active: p.active,
+      value: p.value,
+      justStarted: p.justStarted,
+      justEnded: p.justEnded,
+      phase: p.phase
     };
-    s.current = m, y(m);
-  }), a;
-}, He = [
+    i.current = l, a(l);
+  }), o;
+}, Rn = [
   "angry",
   "disgust",
   "fear",
@@ -512,7 +1208,7 @@ const je = (e) => (de(e), null), he = (e, t) => t && !e ? "begin" : !t && e ? "e
   "sad",
   "surprise",
   "unknown"
-], k = [
+], ne = [
   "angry",
   "disgust",
   "fear",
@@ -520,112 +1216,236 @@ const je = (e) => (de(e), null), he = (e, t) => t && !e ? "begin" : !t && e ? "e
   "neutral",
   "sad",
   "surprise"
-], ye = (e, t = 0.55) => {
-  let r = -1 / 0;
-  for (let s = 0; s < k.length; s += 1)
-    r = Math.max(r, Number(e[s]) || 0);
-  const n = new Array(k.length);
-  let o = 0;
-  for (let s = 0; s < k.length; s += 1) {
-    const c = Math.exp((Number(e[s]) || 0) - r);
-    n[s] = c, o += c;
+], wr = (e, r = 0.55) => {
+  let t = -1 / 0;
+  for (let i = 0; i < ne.length; i += 1)
+    t = Math.max(t, Number(e[i]) || 0);
+  const n = new Array(ne.length);
+  let s = 0;
+  for (let i = 0; i < ne.length; i += 1) {
+    const f = Math.exp((Number(e[i]) || 0) - t);
+    n[i] = f, s += f;
   }
-  const u = Object.fromEntries(k.map((s) => [s, 0]));
-  let i = "unknown", a = 0;
-  for (let s = 0; s < k.length; s += 1) {
-    const c = o ? n[s] / o : 0, l = k[s];
-    u[l] = c, c > a && (i = l, a = c);
+  const c = Object.fromEntries(ne.map((i) => [i, 0]));
+  let u = "unknown", o = 0;
+  for (let i = 0; i < ne.length; i += 1) {
+    const f = s ? n[i] / s : 0, d = ne[i];
+    c[d] = f, f > o && (u = d, o = f);
   }
-  const y = Number.isFinite(t) ? Math.min(1, Math.max(0, t)) : 0.55;
-  return { expression: a >= y ? i : "unknown", confidence: a, scores: u };
-}, ge = (e) => {
-  const t = e.width * e.height, r = new Float32Array(t * 3);
-  for (let n = 0, o = 0; n < t; n += 1, o += 4)
-    r[n] = e.data[o] / 127.5 - 1, r[t + n] = e.data[o + 1] / 127.5 - 1, r[t * 2 + n] = e.data[o + 2] / 127.5 - 1;
-  return r;
-}, Ee = "https://huggingface.co/opencv/facial_expression_recognition/resolve/main/facial_expression_recognition_mobilefacenet_2022july_int8.onnx", Te = (e) => `https://cdn.jsdelivr.net/npm/onnxruntime-web@${e.env.versions.web}/dist/`, j = /* @__PURE__ */ new Map(), Se = (e) => {
-  let t = j.get(e);
-  return t || (t = Promise.all([import("onnxruntime-web/wasm"), ee(e)]).then(([r, n]) => (r.env.wasm.wasmPaths = Te(r), r.InferenceSession.create(n, { executionProviders: ["wasm"] }))).catch((r) => {
-    throw j.delete(e), r;
-  }), j.set(e, t)), t;
-}, Ke = (e, {
-  active: t = !0,
-  targetFps: r = 5,
+  const a = Number.isFinite(r) ? Math.min(1, Math.max(0, r)) : 0.55;
+  return { expression: o >= a ? u : "unknown", confidence: o, scores: c };
+}, Fr = (e) => {
+  const r = e.width * e.height, t = new Float32Array(r * 3);
+  for (let n = 0, s = 0; n < r; n += 1, s += 4)
+    t[n] = e.data[s] / 127.5 - 1, t[r + n] = e.data[s + 1] / 127.5 - 1, t[r * 2 + n] = e.data[s + 2] / 127.5 - 1;
+  return t;
+}, kr = "https://huggingface.co/opencv/facial_expression_recognition/resolve/main/facial_expression_recognition_mobilefacenet_2022july_int8.onnx", Pr = (e) => `https://cdn.jsdelivr.net/npm/onnxruntime-web@${e.env.versions.web}/dist/`, ye = /* @__PURE__ */ new Map(), Br = (e) => {
+  let r = ye.get(e);
+  return r || (r = Promise.all([import("onnxruntime-web/wasm"), Tt(e)]).then(([t, n]) => (t.env.wasm.wasmPaths = Pr(t), t.InferenceSession.create(n, { executionProviders: ["wasm"] }))).catch((t) => {
+    throw ye.delete(e), t;
+  }), ye.set(e, r)), r;
+}, _n = (e, {
+  active: r = !0,
+  targetFps: t = 5,
   minConfidence: n = 0.55,
-  modelUrl: o = Ee
+  modelUrl: s = kr
 } = {}) => {
-  const { session: u } = Q(), i = R(null), a = R(null), y = R(!1), s = R(-1 / 0), c = R(!0), [l, f] = I({
+  const { session: c } = Qe(), u = E(null), o = E(null), a = E(!1), i = E(-1 / 0), f = E(!0), [d, h] = V({
     status: "idle",
     result: null,
     error: null
   });
-  return L(() => {
-    const h = document.createElement("canvas");
-    return i.current = h, a.current = h.getContext("2d", { willReadFrequently: !0 }), c.current = !0, () => {
-      c.current = !1, i.current = null, a.current = null;
+  return v(() => {
+    const m = document.createElement("canvas");
+    return u.current = m, o.current = m.getContext("2d", { willReadFrequently: !0 }), f.current = !0, () => {
+      f.current = !1, u.current = null, o.current = null;
     };
-  }, []), b(({ clock: h }) => {
-    if (!t || !e || y.current || l.status === "error") return;
-    const g = Number.isFinite(r) && r > 0 ? r : 5, d = h.elapsedTime * 1e3;
-    if (d - s.current < 1e3 / g) return;
-    const p = u.getInputFrame(), m = i.current, E = a.current;
-    if (!p || !m || !E || !pe({ source: p, face: e, canvas: m, outputSize: { width: 112, height: 112 } })) return;
-    s.current = d, y.current = !0, l.status === "idle" && f({ status: "loading", result: null, error: null });
-    const Y = ge(E.getImageData(0, 0, 112, 112));
-    Promise.all([import("onnxruntime-web/wasm"), Se(o)]).then(async ([D, M]) => {
-      const $ = await M.run({
-        [M.inputNames[0]]: new D.Tensor("float32", Y, [1, 3, 112, 112])
-      }), Z = ye(
-        $[M.outputNames[0]].data,
+  }, []), U(({ clock: m }) => {
+    if (!r || !e || a.current || d.status === "error") return;
+    const A = Number.isFinite(t) && t > 0 ? t : 5, p = m.elapsedTime * 1e3;
+    if (p - i.current < 1e3 / A) return;
+    const S = c.getInputFrame(), l = u.current, T = o.current;
+    if (!S || !l || !T || !hr({ source: S, face: e, canvas: l, outputSize: { width: 112, height: 112 } })) return;
+    i.current = p, a.current = !0, d.status === "idle" && h({ status: "loading", result: null, error: null });
+    const I = Fr(T.getImageData(0, 0, 112, 112));
+    Promise.all([import("onnxruntime-web/wasm"), Br(s)]).then(async ([O, C]) => {
+      const g = await C.run({
+        [C.inputNames[0]]: new O.Tensor("float32", I, [1, 3, 112, 112])
+      }), _ = wr(
+        g[C.outputNames[0]].data,
         n
       );
-      c.current && f({ status: "ready", result: Z, error: null });
-    }).catch((D) => {
-      c.current && f({
+      f.current && h({ status: "ready", result: _, error: null });
+    }).catch((O) => {
+      f.current && h({
         status: "error",
         result: null,
-        error: D instanceof Error ? D : new Error(String(D))
+        error: O instanceof Error ? O : new Error(String(O))
       });
     }).finally(() => {
-      y.current = !1;
+      a.current = !1;
     });
-  }), l;
+  }), d;
 };
 export {
-  Qe as BODY_TARGETS,
-  Me as BodyTracker,
-  me as DEFAULT_FACE_ACTION_OPTIONS,
-  Ee as DEFAULT_FACE_ATTRIBUTE_EXPRESSION_MODEL_URL,
-  lt as DEFAULT_FACE_EXPRESSION_THRESHOLD,
-  et as DEFAULT_TRACKING_ANCHOR,
-  Pe as FACE_ACTION_NAMES,
-  He as FACE_ATTRIBUTE_EXPRESSION_NAMES,
-  Ce as FACE_BLENDSHAPE_NAMES,
-  Ve as FACE_LANDMARK_INDICES,
-  tt as FACE_TARGETS,
-  We as FaceMesh,
-  qe as FaceTracker,
-  Fe as GestureTracker,
-  je as GestureTrigger,
-  nt as HAND_TARGETS,
-  Ne as HandTracker,
-  X as SEGMENTATION_TYPES,
-  Be as Segmentation,
-  rt as TrackingAnchor,
-  pe as drawFaceCrop,
-  H as getFaceActionValue,
-  T as getFaceBlendshape,
-  dt as getFaceEyeDistance,
-  Ue as getStrongestFaceAction,
-  ot as getTargetNamespace,
-  Ie as hasFaceAction,
-  ht as hasFaceExpression,
-  $e as normalizedTrackerPointToTrackerPoint,
-  Ze as trackerPointToNormalizedTrackerPoint,
-  ze as useFaceAction,
-  Ke as useFaceAttributeExpression,
-  Oe as useFaceDetection,
-  ct as useFaceInfo,
-  te as useFaceInfos,
-  ut as useFaceResults
+  vr as BODY_CALIBRATION_LANDMARKS,
+  St as BODY_LANDMARK_INDEX,
+  ls as BODY_MOVES,
+  ds as BODY_MOVE_LIMITS,
+  fs as BODY_MOVE_NAMES,
+  hs as BODY_MOVE_VIEW_LIMITS,
+  to as BODY_TARGETS,
+  jn as BodyTracker,
+  Tn as BodyTrigger,
+  pe as CALIBRATION_STORAGE_KEY,
+  xe as CALIBRATION_VERSION,
+  Kn as CANONICAL_SHOULDER_DISTANCE,
+  Wn as CANONICAL_TORSO_FIT_DEFAULT_SMOOTHING,
+  Vn as CANONICAL_TORSO_INDICES,
+  Yn as CANONICAL_TORSO_LANDMARKS,
+  Xn as CANONICAL_TORSO_POINTS,
+  qn as CanonicalTorsoFrame,
+  Ce as DEFAULT_CALIBRATION,
+  zn as DEFAULT_FACE_ACTION_OPTIONS,
+  kr as DEFAULT_FACE_ATTRIBUTE_EXPRESSION_MODEL_URL,
+  lo as DEFAULT_FACE_EXPRESSION_THRESHOLD,
+  co as DEFAULT_GESTURE_DETECTOR_OPTIONS,
+  js as DEFAULT_GESTURE_SETTINGS,
+  In as DEFAULT_HOLISTIC_ANALYSIS_MAX_DIMENSION,
+  Nn as DEFAULT_HOLISTIC_HOLD_MS,
+  xn as DEFAULT_HOLISTIC_MODEL_URL,
+  Cn as DEFAULT_HOLISTIC_PREDICT_MS,
+  ve as DEFAULT_HOLISTIC_SIGNAL_THRESHOLDS,
+  Ks as DEFAULT_HOLISTIC_TRACKER_SETTINGS,
+  po as DEFAULT_POLICY_NUM_FACES,
+  Lo as DEFAULT_SEGMENTATION_OVERLAY_SETTINGS,
+  Eo as DEFAULT_SUBJECT_POLICY,
+  ro as DEFAULT_TRACKING_ANCHOR,
+  So as EMPTY_SUBJECT_MEMORY,
+  Jn as FACE_ACTION_NAMES,
+  Rn as FACE_ATTRIBUTE_EXPRESSION_NAMES,
+  Qn as FACE_BLENDSHAPE_NAMES,
+  br as FACE_CALIBRATION_LANDMARKS,
+  Un as FACE_LANDMARK_INDICES,
+  no as FACE_TARGETS,
+  ms as FOREARM_OCCLUDER_FLARE,
+  ps as FOREARM_OCCLUDER_LENGTH,
+  Ts as FOREARM_OCCLUDER_OVERLAP,
+  Dn as FaceMesh,
+  bn as FaceTracker,
+  gs as ForearmOccluder,
+  at as GESTURES,
+  hn as GESTURE_NAMES,
+  Ws as GESTURE_SETTINGS_FIELDS,
+  pn as GestureListener,
+  on as GestureTracker,
+  fn as GestureTrigger,
+  je as HAND_CUTOUT_TRIANGLES,
+  Hn as HAND_JOINT_INDEX,
+  Ln as HAND_JOINT_NAMES,
+  Es as HAND_OCCLUDER_RENDER_ORDER,
+  Mn as HAND_POSE_DEFAULT_HOLD_MS,
+  Bs as HAND_RIG_REQUIRED_JOINTS,
+  so as HAND_TARGETS,
+  Ss as HAND_TATTOO_DEFAULT_SIZE,
+  As as HAND_TATTOO_RENDER_ORDER,
+  Rs as HAND_TOUCH_DEFAULTS,
+  _s as HAND_TOUCH_DEPTH,
+  ys as HAND_TOUCH_POINTER_RADIUS,
+  Os as HAND_TOUCH_TIPS,
+  Vs as HOLISTIC_HANDS_OPTIONS,
+  Ys as HOLISTIC_TRACKER_SETTINGS_FIELDS,
+  an as HandAttachment,
+  cn as HandCutout,
+  Ds as HandOccluder,
+  bs as HandRig,
+  vs as HandTattoo,
+  Is as HandTouch,
+  sn as HandTracker,
+  Ne as HolisticTracker,
+  bo as IRIS_LANDMARKS,
+  vo as IRIS_LANDMARK_COUNT,
+  Io as PERSON_MASK_LABELS,
+  Be as SEGMENTATION_TYPES,
+  Zs as SEMANTIC_SEGMENTATION_PRESETS,
+  $n as SHOULDER_OCCLUDER_DEFAULT_OPACITY,
+  Zn as SHOULDER_OCCLUDER_V1_PATH,
+  dn as Segmentation,
+  es as SegmentationOverlay,
+  ts as ShoulderOccluder,
+  Ns as TOUCH_WORLD_DEFAULTS,
+  un as Touchable,
+  oo as TrackingAnchor,
+  xs as WRIST_DEPTH_OF_WIDTH,
+  Cs as WRIST_WIDTH_OF_PALM,
+  Hs as WristAttachment,
+  Ao as XR_MAX_SUBJECTS,
+  Dr as applyCalibrationToFeedPoint,
+  Ro as associateSubjects,
+  rs as bodyLandmarkIndex,
+  Hr as clearCalibration,
+  wn as clearSemanticMask,
+  Ar as createCalibration,
+  Ls as createForearmGeometry,
+  nr as createHolisticSignals,
+  Fn as createSemanticMask,
+  Ms as defineBodyMove,
+  mn as defineGesture,
+  hr as drawFaceCrop,
+  Nr as estimateBodyScale,
+  Ir as estimateFaceDistance,
+  _o as faceCandidates,
+  de as getFaceActionValue,
+  Ge as getFaceBlendshape,
+  fo as getFaceEyeDistance,
+  ln as getHolisticSignals,
+  ns as getStrongestFaceAction,
+  ao as getTargetNamespace,
+  Us as handPoseToScene,
+  ss as hasFaceAction,
+  ho as hasFaceExpression,
+  Ve as isHandRaised,
+  gn as isIdentityCalibration,
+  We as isPalmOpen,
+  yo as jointCandidates,
+  xr as loadCalibration,
+  ct as measureBodyCalibration,
+  it as measureFaceCalibration,
+  kn as normalizedTrackerPointToTrackerPoint,
+  Xs as patchGestureSettings,
+  qs as patchHolisticTrackerSettings,
+  Mo as patchSegmentationOverlaySettings,
+  yr as resetCalibration,
+  Ct as resolveBodyMove,
+  Or as resolveCalibrationMirror,
+  mr as resolveGestureDefinition,
+  Ue as resolveGestureDetectorOptions,
+  zs as resolveGestureSettings,
+  Js as resolveHolisticTrackerSettings,
+  wo as resolveSegmentationOverlaySettings,
+  Cr as saveCalibration,
+  Oo as selectSubject,
+  os as shoulderOccluderUrl,
+  as as solveShoulderPose,
+  Qs as toHolisticTrackerProps,
+  Pn as trackerPointToNormalizedTrackerPoint,
+  me as updateCalibration,
+  Sr as useBodyTrigger,
+  is as useCanonicalTorsoFit,
+  An as useFaceAction,
+  _n as useFaceAttributeExpression,
+  Sn as useFaceDetection,
+  To as useFaceInfo,
+  Vt as useFaceInfos,
+  ws as useFaceResults,
+  Tr as useGesture,
+  No as useHairMask,
+  Fs as useHandTouch,
+  or as useHolisticTracking,
+  cs as useIrisTracking,
+  xo as usePersonMask,
+  Co as useSemanticSegmentationMask,
+  En as useXRCalibration,
+  ks as wristSizeOf,
+  zt as writeHandCutout
 };