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

package/dist/trigger-IQeys0oS.js

@@ -0,0 +1,2128 @@
+var Ue = Object.defineProperty;
+var Ce = (e, t, s) => t in e ? Ue(e, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : e[t] = s;
+var x = (e, t, s) => Ce(e, typeof t != "symbol" ? t + "" : t, s);
+import { useCallback as Me, useMemo as j, createContext as Pt, useRef as Y, useEffect as L, useContext as Et, useState as ze } from "react";
+import { p as Le, u as Ke } from "./useFaceResultReader-BvEo5REG.js";
+import { jsx as tt, jsxs as Ut } from "react/jsx-runtime";
+import * as h from "three";
+import { useThree as gt, useFrame as Ct, createPortal as Ge } from "@react-three/fiber";
+import { a as it, X as mt, C as zt, H as Zt, t as Dt, q as Ye, f as Qe } from "./index-CIe7eCMH.js";
+import { a as we, s as te, L as $e } from "./useLandmarkPoseFit-Bmb3h6Mw.js";
+import { c as Xe } from "./SkeletonUtils-C2r90MtN.js";
+import { b as Je, l as Ze, n as ts, H as ee, o as es, p as ss, q as ns, B as se, k as is, a as os, e as G, r as xe, m as rs } from "./index-JII7huPk.js";
+import { b as ne, e as as } from "./selectors-DmNaKIwE.js";
+import { u as Ot } from "./landmarks-bftdwq6Z.js";
+import { g as ls, r as ie, c as cs, s as ve, a as hs } from "./detector-K8aej4MB.js";
+const fi = ({
+  node: e,
+  enabled: t,
+  selectedSource: s,
+  throttleMs: n = 16,
+  holdMs: i = 250,
+  onFrame: o
+}) => {
+  const r = Me(
+    (a) => Le(a.faceLandmarks ?? []),
+    [s]
+  );
+  return Ke({ enabled: t, holdMs: i, node: e, onFrame: o, prepare: r, throttleMs: n });
+}, us = 7, ps = Object.freeze({
+  along: Object.freeze([2, 4, 6, 8]),
+  widthAt: 1.5,
+  maxWidth: 11,
+  minWidth: 2.5,
+  maxTurn: 95
+}), ds = (e, t) => {
+  const { image: s, world: n } = e;
+  if (s.length < 21 || n.length < 21) return null;
+  const i = (V) => (s[V].x + 1) / 2 * t, o = (V) => (1 - s[V].y) / 2;
+  let r = 0, a = 0, l = 0, u = 0;
+  const c = 21;
+  for (let V = 0; V < c; V += 1)
+    r += i(V), a += o(V), l += n[V].x, u -= n[V].y;
+  r /= c, a /= c, l /= c, u /= c;
+  let f = 0, p = 0, g = 0;
+  for (let V = 0; V < c; V += 1) {
+    const N = n[V].x - l, F = -n[V].y - u, C = i(V) - r, Q = o(V) - a;
+    f += N * C + F * Q, p += N * Q - F * C, g += N * N + F * F;
+  }
+  const w = Math.hypot(f, p) / Math.max(g, 1e-12), T = it.wrist, m = it.middleMcp, k = i(T) - i(m), I = o(T) - o(m), _ = Math.hypot(k, I), J = Math.hypot(
+    n[T].x - n[m].x,
+    n[T].y - n[m].y,
+    n[T].z - n[m].z
+  );
+  return !(w > 0) || _ < 0.3 * J * w ? null : {
+    wrist: { x: i(T), y: o(T) },
+    toElbow: { x: k / _, y: I / _ },
+    unitsPerCm: w,
+    aspect: t
+  };
+}, nt = (e, t, s) => ({ x: e.x + t.x * s, y: e.y + t.y * s }), fs = (e, t, s = {}) => {
+  const n = { ...ps, ...s }, { wrist: i, toElbow: o, unitsPerCm: r, aspect: a } = t, { width: l, height: u } = e;
+  if (l <= 0 || u <= 0 || !(r > 0)) return null;
+  const c = Math.min(1 / u, a / l), f = n.maxWidth * r, p = n.minWidth * r, g = (S) => {
+    const M = S.x / a, b = S.y;
+    return M < 0 || b < 0 || M >= 1 || b >= 1 ? null : e.inside(Math.floor(b * u) * l + Math.floor(M * l));
+  }, w = (S, M) => {
+    if (g(S) === null) return null;
+    const b = { x: -M.y, y: M.x };
+    let D = null;
+    for (let R = 0; R * c <= f / 2; R += 1) {
+      if (g(nt(S, b, R * c))) {
+        D = R * c;
+        break;
+      }
+      if (R > 0 && g(nt(S, b, -R * c))) {
+        D = -R * c;
+        break;
+      }
+    }
+    if (D === null) return null;
+    let O = !1;
+    const E = (R) => {
+      let Z = D;
+      for (; ; ) {
+        const pt = g(nt(S, b, Z + R * c));
+        if (pt === null)
+          return O = !0, Z;
+        if (!pt) return Z;
+        if (Z += R * c, Math.abs(Z - D) > f)
+          return O = !0, Z;
+      }
+    }, q = E(-1), W = E(1), A = W - q + c;
+    return {
+      mid: nt(S, b, (q + W) / 2),
+      width: A,
+      a: nt(S, b, q),
+      b: nt(S, b, W),
+      ok: !O && A >= p && A <= f
+    };
+  }, T = (S) => n.along.map((M) => w(nt(i, S, M * r), S)), m = (S) => {
+    const M = [i, ...S.filter((y) => !!(y != null && y.ok)).map((y) => y.mid)];
+    if (M.length < 3) return null;
+    const b = M.reduce((y, R) => y + R.x, 0) / M.length, D = M.reduce((y, R) => y + R.y, 0) / M.length;
+    let O = 0, E = 0, q = 0;
+    for (const y of M)
+      O += (y.x - b) ** 2, E += (y.x - b) * (y.y - D), q += (y.y - D) ** 2;
+    const W = 0.5 * Math.atan2(2 * E, O - q), A = { x: Math.cos(W), y: Math.sin(W) };
+    return A.x * o.x + A.y * o.y < 0 ? { x: -A.x, y: -A.y } : A;
+  }, k = n.maxTurn * Math.PI / 180, I = (S) => Math.atan2(o.x * S.y - o.y * S.x, o.x * S.x + o.y * S.y), _ = (S) => ({
+    x: o.x * Math.cos(S) - o.y * Math.sin(S),
+    y: o.x * Math.sin(S) + o.y * Math.cos(S)
+  }), V = T((() => {
+    const S = k + 40 * Math.PI / 180, M = us * r, b = Math.min(1 * Math.PI / 180, c / M), D = Math.ceil(S / b), O = [];
+    let E = null;
+    for (let y = -D; y <= D + 1; y += 1) {
+      const R = y * b, Z = y <= D && g(nt(i, _(R), M)) === !0;
+      Z && E === null && (E = R), !Z && E !== null && (E > -D * b && R <= D * b && O.push([E, R - b]), E = null);
+    }
+    const q = ([y, R]) => (R - y) * M, W = O.filter((y) => q(y) >= p && q(y) <= f * 1.5);
+    if (!W.length) return null;
+    const A = W.reduce(
+      (y, R) => Math.abs((R[0] + R[1]) / 2) < Math.abs((y[0] + y[1]) / 2) ? R : y
+    );
+    return _((A[0] + A[1]) / 2);
+  })() ?? o);
+  let N = m(V);
+  if (!N || Math.abs(I(N)) > k) return null;
+  const F = T(N), C = m(F);
+  C && Math.abs(I(C)) <= k && (N = C);
+  const Q = C ? F : V, et = Q.filter((S) => !!(S != null && S.ok)), P = w(nt(i, N, n.widthAt * r), N), st = Math.min(...et.map((S) => S.width), P != null && P.ok ? P.width : 1 / 0), ut = P != null && P.ok ? P.mid : nt(i, N, n.widthAt * r), H = Q.filter((S) => !!S).map(({ a: S, b: M, ok: b }) => ({ a: S, b: M, ok: b }));
+  return P && H.push({ a: P.a, b: P.b, ok: P.ok }), {
+    direction: N,
+    bend: I(N),
+    width: st / r,
+    center: ut,
+    confidence: et.length / Math.max(1, n.along.length),
+    sections: H
+  };
+}, be = Object.freeze({
+  smoothing: 0.4,
+  holdMs: 400,
+  fadeMs: 300,
+  maxSkewMs: 70,
+  maxShift: 2
+}), ms = 24, gs = 0.5, ys = Math.cos(3 * Math.PI / 180);
+class Ms {
+  constructor(t = {}) {
+    /** Radians, clockwise on screen, from the hand's axis to the arm's. */
+    x(this, "bend", 0);
+    /** The arm's width, cm (null until measured). */
+    x(this, "width", null);
+    /** How far the arm's middle is from the hand's axis, across it, cm (+ = clockwise side). */
+    x(this, "shift", 0);
+    /** 0..1, how much of the fit applies (found, held or fading). */
+    x(this, "weight", 0);
+    /** 0..1, how sure the measures are (closed cross-sections, eased): blends the fit with the hand. */
+    x(this, "confidence", 0);
+    /** The last measure, for drawing. */
+    x(this, "last", null);
+    x(this, "settings");
+    x(this, "history", []);
+    /** There is a fit (measured, not yet faded out). */
+    x(this, "found", !1);
+    /** When a mask first came without the arm since the last fit. */
+    x(this, "lostAtMs", null);
+    this.settings = { ...be, ...t };
+  }
+  /**
+   * The hand's query at a detection (`HandPose.timestampMs`); `null` when the
+   * hand's axis can't be used (it points at the camera): `query` reads null
+   * then, and nothing steers by an old axis.
+   */
+  pushHand(t, s) {
+    const n = this.history[this.history.length - 1];
+    n && n.timeMs === t || (this.history.push({ timeMs: t, query: s }), this.history.length > ms && this.history.shift());
+  }
+  /** The newest hand query (the hand now), null while its axis is unusable. */
+  get query() {
+    var t;
+    return ((t = this.history[this.history.length - 1]) == null ? void 0 : t.query) ?? null;
+  }
+  /**
+   * The hand hasn't moved over the kept history (within 0.5 cm and 3°): any
+   * of its poses matches a mask from within that time.
+   */
+  still() {
+    const t = this.query;
+    if (!t || this.history.length < 2) return !1;
+    const s = gs * t.unitsPerCm;
+    return this.history.every(
+      ({ query: n }) => !!n && Math.hypot(n.wrist.x - t.wrist.x, n.wrist.y - t.wrist.y) <= s && n.toElbow.x * t.toElbow.x + n.toElbow.y * t.toElbow.y >= ys
+    );
+  }
+  /**
+   * Measures a new mask (taken at `maskTimeMs`, or now when unknown) against
+   * the hand from the same moment (or the newest, while the hand is still).
+   * Returns the measure, or null when the arm wasn't found (that starts the
+   * hold, then the fade) or no hand pose matches the mask's time (nothing
+   * changes: wait for the next mask).
+   */
+  measure(t, s, n = {}) {
+    const i = this.history.filter((g) => g.query !== null), o = i[i.length - 1];
+    let r = s === void 0 ? o : i.reduce(
+      (g, w) => !g || Math.abs(w.timeMs - s) < Math.abs(g.timeMs - s) ? w : g,
+      void 0
+    );
+    if (!r) return null;
+    if (s !== void 0 && Math.abs(r.timeMs - s) > this.settings.maxSkewMs) {
+      const g = this.history[0];
+      if (!g || g.timeMs > s || !this.still()) return null;
+      r = o;
+    }
+    const a = fs(t, r.query, n);
+    if (this.last = a, !a)
+      return this.found && this.lostAtMs === null && (this.lostAtMs = s ?? r.timeMs), null;
+    const { wrist: l, unitsPerCm: u } = r.query, c = ((a.center.x - l.x) * -a.direction.y + (a.center.y - l.y) * a.direction.x) / u, f = Math.max(-this.settings.maxShift, Math.min(this.settings.maxShift, c)), p = this.found ? Math.min(1, Math.max(0.01, this.settings.smoothing)) : 1;
+    return this.bend += (a.bend - this.bend) * p, this.confidence += (a.confidence - this.confidence) * p, this.width = this.width === null ? a.width : this.width + (a.width - this.width) * p, this.shift += (f - this.shift) * p, this.found = !0, this.lostAtMs = null, a;
+  }
+  /**
+   * Advances the hold and fade (call every frame with `performance.now()`).
+   * A fit holds until a mask comes without the arm, then for `holdMs`, then
+   * fades over `fadeMs`; no new mask changes nothing.
+   */
+  step(t) {
+    if (!this.found) {
+      this.weight = 0;
+      return;
+    }
+    const s = this.lostAtMs === null ? -1 / 0 : t - this.lostAtMs - this.settings.holdMs;
+    this.weight = s <= 0 ? 1 : Math.max(0, 1 - s / Math.max(1, this.settings.fadeMs)), this.weight === 0 && this.clear();
+  }
+  clear() {
+    this.found = !1, this.lostAtMs = null, this.confidence = 0, this.bend = 0, this.shift = 0, this.width = null, this.weight = 0;
+  }
+  /** Forget everything (the hand was lost). */
+  reset() {
+    this.history.length = 0, this.clear(), this.last = null;
+  }
+}
+const ws = 15, xs = (e) => {
+  Ot(mt.BACKGROUND_SEGMENTATION, { type: "portrait" }, e === "portrait"), Ot(mt.SEMANTIC_SEGMENTATION, { preset: "multiclass" }, e === "skin");
+  const t = ne(mt.BACKGROUND_SEGMENTATION), s = ne(mt.SEMANTIC_SEGMENTATION);
+  return j(() => {
+    if (!e) return null;
+    let n = 0, i = 0, o = 0, r, a = -1 / 0, l = null, u = null, c = null, f = -1, p = -1;
+    return {
+      kind: e,
+      get width() {
+        return n;
+      },
+      get height() {
+        return i;
+      },
+      get version() {
+        return o;
+      },
+      get timestampMs() {
+        return r;
+      },
+      // The portrait segmenter's category mask reads 0 on the person, 255 on
+      // the background (see `usePersonMask`).
+      inside: e === "portrait" ? (g) => l !== null && l[g] <= 127 : (g) => c !== null && c[g] === f,
+      refresh: (g) => {
+        var T;
+        if (e === "portrait") {
+          if (!t || g - a < 1e3 / ws) return !1;
+          const m = (T = t.getRawSegmentationData) == null ? void 0 : T.call(t);
+          return !(m != null && m.maskData) || m === u || m.width <= 0 ? !1 : (a = g, u = m, l = m.maskData, n = m.width, i = m.height, r = m.timestampMs, o += 1, !0);
+        }
+        const w = s == null ? void 0 : s.getMask();
+        return !w || w.version === 0 || w.version === p ? !1 : (p = w.version, f = w.labels.indexOf("body_skin"), c = w.indices, n = w.width, i = w.height, r = w.timestampMs, o += 1, f >= 0);
+      }
+    };
+  }, [e, t, s]);
+}, d = {
+  c: new h.Vector3(),
+  y: new h.Vector3(),
+  p: new h.Vector3(),
+  ndc: new h.Vector3(),
+  axis: new h.Vector3(),
+  q: new h.Quaternion(),
+  m: new h.Matrix4(),
+  t: new h.Matrix4(),
+  turned: new h.Matrix4(),
+  a: { x: 0, y: 0 },
+  b: { x: 0, y: 0 }
+}, xt = (e, t, s, n = { x: 0, y: 0 }) => (d.ndc.copy(e).project(t), n.x = (d.ndc.x + 1) / 2 * s, n.y = (1 - d.ndc.y) / 2, n), vs = (e, t) => Math.atan2(e.x * t.y - e.y * t.x, e.x * t.x + e.y * t.y), Se = (e, t, s, n = { x: 0, y: 0 }) => {
+  d.c.setFromMatrixPosition(e), d.y.setFromMatrixColumn(e, 1).normalize(), xt(d.c, t, s, d.a);
+  const i = Math.max(1e-4, d.c.distanceTo(t.position) * 1e-3);
+  xt(d.p.copy(d.c).addScaledVector(d.y, -i), t, s, d.b);
+  const o = d.b.x - d.a.x, r = d.b.y - d.a.y, a = Math.hypot(o, r) || 1;
+  return n.x = o / a, n.y = r / a, n;
+}, bs = (e, t, s) => {
+  d.c.setFromMatrixPosition(e);
+  const n = Math.max(1e-4, d.c.distanceTo(t.position) * 1e-3);
+  xt(d.c, t, s, d.a);
+  const i = (u) => (d.y.setFromMatrixColumn(e, u).normalize(), xt(d.p.copy(d.c).addScaledVector(d.y, n), t, s, d.b), Math.hypot(d.b.x - d.a.x, d.b.y - d.a.y)), o = i(1), r = Math.max(i(0), i(2), 1e-12), a = o / r, l = Math.min(1, Math.max(0, (a - oe) / (Ss - oe)));
+  return l * l * (3 - 2 * l);
+}, oe = 0.25, Ss = 0.45, ks = (e, t, s, n, i, o) => {
+  const r = -n.y, a = n.x;
+  let l = 1 / 0, u = -1 / 0;
+  for (let c = 0; c < 24; c += 1) {
+    const f = c / 24 * Math.PI * 2;
+    d.p.set(t * Math.cos(f), 0, s * Math.sin(f)).applyMatrix4(e), xt(d.p, i, o, d.a);
+    const p = d.a.x * r + d.a.y * a;
+    l = Math.min(l, p), u = Math.max(u, p);
+  }
+  return u - l;
+}, As = (e, t, s, n, i, o) => {
+  const r = Math.min(1, Math.max(0, i));
+  if (r === 0)
+    return o.copy(e), 1;
+  const a = Se(e, t, s, { x: 0, y: 0 }), l = vs(a, n.up) * r * bs(e, t, s);
+  if (d.c.setFromMatrixPosition(e), d.axis.copy(d.c).sub(t.getWorldPosition(d.p)).normalize(), t.isOrthographicCamera && t.getWorldDirection(d.axis), d.q.setFromAxisAngle(d.axis, l), d.m.makeRotationFromQuaternion(d.q), d.t.makeTranslation(d.c.x, d.c.y, d.c.z), d.turned.copy(d.t).multiply(d.m), d.t.makeTranslation(-d.c.x, -d.c.y, -d.c.z), d.turned.multiply(d.t).multiply(e), n.shift !== 0) {
+    d.ndc.copy(d.c).project(t);
+    const c = -n.up.y * n.shift * r, f = n.up.x * n.shift * r;
+    d.p.set(d.ndc.x + c * 2 / s, d.ndc.y - f * 2, d.ndc.z).unproject(t).sub(d.c), d.t.makeTranslation(d.p.x, d.p.y, d.p.z), d.turned.premultiply(d.t);
+  }
+  o.copy(d.turned);
+  let u = 1;
+  if (n.width !== null && n.width > 0) {
+    const c = ks(
+      d.turned,
+      n.halfWidth,
+      n.halfDepth,
+      n.up,
+      t,
+      s
+    );
+    if (c > 1e-9) {
+      const [f, p] = n.scaleRange ?? [0.85, 1.2];
+      u = 1 + (Math.min(p, Math.max(f, n.width / c)) - 1) * r;
+    }
+  }
+  return u;
+}, Ts = 0.9, Es = 0.7, ke = (e) => {
+  const t = e.restPositions, s = t[it.indexMcp].distanceTo(t[it.pinkyMcp]), n = t[it.wrist].distanceTo(t[it.middleMcp]), i = s * Ts;
+  return { width: i, depth: i * Es, palmWidth: s, palmLength: n };
+}, z = {
+  inv: new h.Quaternion(),
+  x: new h.Vector3(),
+  y: new h.Vector3(),
+  z: new h.Vector3(),
+  basis: new h.Matrix4()
+}, Os = (e, t = { position: new h.Vector3(), quaternion: new h.Quaternion() }) => {
+  const s = e.restQuaternions.wrist;
+  if (!s) throw new Error('WristAttachment: the rig has no "wrist" node');
+  z.inv.copy(s).invert();
+  const n = e.restPositions;
+  return z.y.subVectors(n[it.middleMcp], n[it.wrist]).applyQuaternion(z.inv).normalize(), z.z.copy(e.restPalmNormal).applyQuaternion(z.inv), z.z.addScaledVector(z.y, -z.z.dot(z.y)).normalize(), z.x.crossVectors(z.y, z.z), z.basis.makeBasis(z.x, z.y, z.z), t.position.set(0, 0, 0), t.quaternion.setFromRotationMatrix(z.basis), t;
+}, _s = 2.5, Rs = 1.25, Vs = 0.15, Is = Object.freeze({
+  jump: 35,
+  confirmMs: 200,
+  confirmSamples: 4,
+  smoothing: 0.6
+});
+class Ws {
+  constructor(t = {}) {
+    x(this, "settings");
+    x(this, "q", new h.Quaternion());
+    x(this, "has", !1);
+    x(this, "pending", null);
+    this.settings = { ...Is, ...t };
+  }
+  /**
+   * Filters this frame's wrist rotation (`target`) at `nowMs`; writes into
+   * `out`. `sample` names the hand detection it comes from (its timestamp);
+   * omitted, every call counts as one.
+   */
+  apply(t, s, n, i) {
+    const o = h.MathUtils.degToRad(this.settings.jump);
+    if (!this.has)
+      return this.q.copy(t), this.has = !0, this.pending = null, n.copy(this.q);
+    if (this.q.angleTo(t) > o) {
+      const { pending: r } = this;
+      return r && r.q.angleTo(t) < o / 2 ? ((i === void 0 || i !== r.lastSample) && (r.samples += 1, r.lastSample = i), s - r.sinceMs >= this.settings.confirmMs && r.samples >= this.settings.confirmSamples && (this.q.copy(t), this.pending = null)) : this.pending = { q: t.clone(), sinceMs: s, samples: 1, lastSample: i }, n.copy(this.q);
+    }
+    return this.pending = null, this.q.slerp(t, h.MathUtils.clamp(this.settings.smoothing, 0.01, 1)), n.copy(this.q);
+  }
+  /** Forget the wrist (the hand was lost): the next pose is taken as it is. */
+  reset() {
+    this.has = !1, this.pending = null;
+  }
+}
+const re = "forearm", Ds = new h.Vector3(1, 1, 1), Fs = 0.2, Ns = 0.45;
+class Bs {
+  /** `forearm`: the rig's forearm bone, at rest, a child of the wrist bone. */
+  constructor(t, s) {
+    x(this, "filter", new Ws());
+    /** The arm fit (null without `armMask`). */
+    x(this, "arm", null);
+    /** The wrist frame this frame, world (rigid). */
+    x(this, "world", new h.Matrix4());
+    /** Across the arm (X, Z) to fit the arm's width; 1 without a fit. */
+    x(this, "crossScale", 1);
+    x(this, "size");
+    /**
+     * The wrist frame in the forearm bone's space (+Y toward the fingers, +Z
+     * out of the palm, origin on the wrist joint): where wristwear is authored.
+     */
+    x(this, "forearmFrame", new h.Matrix4());
+    x(this, "wristFrame", new h.Matrix4());
+    /** inverse(wrist frame in the wrist bone) × the forearm's rest (in the wrist bone). */
+    x(this, "toForearm", new h.Matrix4());
+    x(this, "frame", 0);
+    x(this, "solved", -1);
+    /** The hand detection behind this frame (`HandPose.timestampMs`), for the filter. */
+    x(this, "sample");
+    /** The arm's way up on screen and the scale it was aimed with, last frame. */
+    x(this, "last", { up: { x: 0, y: 0 }, units: 0 });
+    x(this, "w", {
+      raw: new h.Matrix4(),
+      steady: new h.Matrix4(),
+      local: new h.Matrix4(),
+      p: new h.Vector3(),
+      q: new h.Quaternion(),
+      s: new h.Vector3(),
+      up: { x: 0, y: 0 }
+    });
+    this.binding = t, this.forearm = s;
+    const { position: n, quaternion: i } = Os(t);
+    this.wristFrame.compose(n, i, Ds), this.size = ke(t);
+    const o = new h.Matrix4().compose(s.position, s.quaternion, s.scale);
+    this.forearmFrame.copy(o).invert().multiply(this.wristFrame), this.toForearm.copy(this.wristFrame).invert().multiply(o);
+  }
+  /** A new frame (the rig moved; `sample`: its detection): the next `solve` works it out again. */
+  tick(t) {
+    this.frame += 1, this.sample = t;
+  }
+  /** The hand was lost: the next pose is taken as it is. */
+  reset() {
+    this.filter.reset();
+  }
+  /**
+   * Aims the forearm bone for this frame (once; later calls are free) and
+   * returns the wrist frame (world), or null without a wrist bone. Call
+   * before render, after the rig has posed the hand.
+   */
+  solve(t, s, n = performance.now()) {
+    const i = this.binding.bones.wrist;
+    if (!i) return null;
+    if (this.solved === this.frame) return this.world;
+    this.solved = this.frame;
+    const { w: o } = this;
+    o.raw.multiplyMatrices(i.matrixWorld, this.wristFrame), o.raw.decompose(o.p, o.q, o.s), this.filter.apply(o.q, n, o.q, this.sample), o.steady.compose(o.p, o.q, o.s);
+    const r = this.arm, a = r == null ? void 0 : r.tracker, l = a == null ? void 0 : a.query;
+    this.crossScale = 1;
+    const u = !l && this.last.units > 0;
+    if (!r || !a || a.weight <= 0 || !l && !u)
+      this.world.copy(o.steady), this.last.units = 0;
+    else {
+      const c = l ? l.unitsPerCm : this.last.units;
+      if (!r.turn)
+        Se(o.steady, t, s, o.up);
+      else if (l) {
+        const { x: p, y: g } = l.toElbow;
+        o.up.x = p * Math.cos(a.bend) - g * Math.sin(a.bend), o.up.y = p * Math.sin(a.bend) + g * Math.cos(a.bend);
+      } else
+        o.up.x = this.last.up.x, o.up.y = this.last.up.y;
+      this.last.up.x = o.up.x, this.last.up.y = o.up.y, this.last.units = c;
+      const f = h.MathUtils.smoothstep(a.confidence, Fs, Ns);
+      this.crossScale = As(
+        o.steady,
+        t,
+        s,
+        {
+          up: o.up,
+          shift: r.fitWidth ? a.shift * c : 0,
+          width: r.fitWidth && a.width !== null ? a.width * c : null,
+          halfWidth: this.size.width / 2,
+          halfDepth: this.size.depth / 2
+        },
+        a.weight * f,
+        this.world
+      );
+    }
+    return o.local.copy(i.matrixWorld).invert().multiply(this.world).multiply(this.toForearm).decompose(this.forearm.position, this.forearm.quaternion, this.forearm.scale), this.forearm.updateMatrixWorld(!0), this.world;
+  }
+}
+const Hs = (e) => {
+  const t = e.bones.wrist;
+  if (!t) return null;
+  const s = t.getObjectByName(re);
+  if (s) return s;
+  const n = new h.Bone();
+  return n.name = re, t.add(n), n;
+}, Ae = Pt(null), Lt = "vincenttHandRigModelMesh", Kt = Pt(null), js = new h.Matrix4(), Ft = new h.Matrix4(), qs = ({
+  hand: e,
+  model: t,
+  modelHand: s = "right",
+  smoothing: n = $e,
+  fingerLengths: i = "tracked",
+  showHeld: o = !0,
+  onTrackingChange: r,
+  material: a,
+  onModel: l,
+  active: u = !0,
+  armMask: c,
+  children: f
+}) => {
+  const { node: p } = Ot(mt.HAND_TRACKER, void 0, u), g = as(), { camera: w, size: T } = gt(), m = c ? typeof c == "string" ? { kind: c } : c : null, k = m ? m.kind ?? "skin" : !1, I = xs(k), _ = j(
+    () => k ? { tracker: new Ms(), turn: !0, fitWidth: !0, mask: null } : null,
+    [k]
+  );
+  _ && m && (_.mask = I, _.turn = m.turn ?? !0, _.fitWidth = m.fitWidth ?? !0, _.tracker.settings = { ...be, ...ae(m, Ps) });
+  const J = Y({});
+  J.current = m ? ae(m, Us) : {};
+  const V = Y(null), N = j(() => {
+    const O = Xe(t);
+    return O.traverse((E) => {
+      E.frustumCulled = !1, E instanceof h.Mesh && (E.userData[Lt] = !0);
+    }), O;
+  }, [t]), F = j(() => Je(N, s), [N, s]), C = j(
+    () => new Bs(F, Hs(F)),
+    [F]
+  );
+  C.arm = _;
+  const Q = Y(1);
+  Q.current = T.width / Math.max(1, T.height);
+  const et = gt((O) => O.scene);
+  L(
+    () => we(
+      et,
+      (O, E, q) => C.solve(q, Q.current)
+    ),
+    [et, C]
+  );
+  const P = j(() => Ze(F), [F]), st = Y(l);
+  st.current = l, L(() => {
+    var O;
+    return (O = st.current) == null ? void 0 : O.call(st, N);
+  }, [N]);
+  const ut = j(() => {
+    const O = /* @__PURE__ */ new Map();
+    return N.traverse((E) => {
+      E instanceof h.Mesh && O.set(E, E.material);
+    }), O;
+  }, [N]);
+  L(() => {
+    for (const [O, E] of ut) O.material = a ?? E;
+  }, [a, ut]);
+  const H = Y(void 0), S = Y({
+    tracked: !1,
+    quaternion: new h.Quaternion(),
+    position: new h.Vector3(),
+    scale: 1,
+    mirrored: !1
+  }), M = Y({}), b = Y({}), D = Y({});
+  return Ct(() => {
+    var Qt, $t, Xt;
+    const O = V.current;
+    if (!O) return;
+    const E = ((Qt = p == null ? void 0 : p.getHandPose) == null ? void 0 : Qt.call(p, e)) ?? (($t = p == null ? void 0 : p.poses) == null ? void 0 : $t[e]) ?? null, q = E && E.world.length >= 21 && E.image.length >= 21 && (o || !E.held), W = S.current;
+    if (C.tick(E == null ? void 0 : E.timestampMs), !q) {
+      O.visible = !1, C.reset(), _ == null || _.tracker.reset(), te(W, null, n, P) && (r == null || r(!1));
+      return;
+    }
+    if (_) {
+      const K = performance.now();
+      _.tracker.pushHand(
+        E.timestampMs,
+        ds(E, T.width / Math.max(1, T.height))
+      ), I != null && I.refresh(K) && _.tracker.measure(I, I.timestampMs, J.current), _.tracker.step(K);
+    }
+    const A = ts(F, E, w, g, H.current);
+    H.current = A, W.tracked && W.mirrored !== A.mirrored && (W.tracked = !1);
+    const y = te(W, A.fit, n, P);
+    W.mirrored = A.mirrored, y && (r == null || r(!0));
+    const R = h.MathUtils.clamp(n, 0.01, 1), Z = Math.min(R, 0.1), pt = b.current;
+    for (const { name: K } of ee) {
+      const dt = A.local[K], ct = F.bones[K];
+      if (!dt || !ct) continue;
+      const ft = (Xt = M.current)[K] ?? (Xt[K] = dt.clone());
+      y || R >= 1 ? ft.copy(dt) : ft.slerp(dt, R), ct.quaternion.copy(ft);
+      const Jt = i === "tracked" ? A.lengths[K] ?? 1 : 1, Wt = pt[K];
+      pt[K] = y || Wt === void 0 ? Jt : Wt + (Jt - Wt) * Z;
+    }
+    const kt = D.current;
+    for (const { name: K, parent: dt } of ee) {
+      if (dt !== "wrist") continue;
+      const ct = A.knuckles[K];
+      if (!ct) continue;
+      const ft = kt[K] ?? (kt[K] = ct.clone());
+      y ? ft.copy(ct) : ft.lerp(ct, Z);
+    }
+    es(F, pt, i === "tracked" ? kt : null), ss(
+      { scale: W.scale, quaternion: W.quaternion, translation: W.position },
+      W.mirrored,
+      Ft
+    ), O.parent && (O.parent.updateMatrixWorld(), Ft.premultiply(js.copy(O.parent.matrixWorld).invert())), O.matrix.copy(Ft), O.matrixWorldNeedsUpdate = !0, O.visible = !0;
+  }), /* @__PURE__ */ tt(Kt.Provider, { value: F, children: /* @__PURE__ */ Ut(Ae.Provider, { value: C, children: [
+    /* @__PURE__ */ tt("group", { ref: V, matrixAutoUpdate: !1, visible: !1, children: /* @__PURE__ */ tt("primitive", { object: N }) }),
+    f
+  ] }) });
+}, Ps = ["smoothing", "holdMs", "fadeMs", "maxSkewMs", "maxShift"], Us = ["along", "widthAt", "maxWidth", "minWidth", "maxTurn"], ae = (e, t) => Object.fromEntries(t.filter((s) => e[s] !== void 0).map((s) => [s, e[s]])), Cs = ({ along: e = 1, offset: t, children: s }) => {
+  const n = Et(Kt), i = Et(Ae), o = gt((g) => g.scene), r = gt((g) => g.size), a = Y(null), l = j(() => n ? ke(n) : null, [n]), u = Y(1);
+  u.current = r.width / Math.max(1, r.height), L(() => {
+    if (!i) return;
+    const g = new h.Matrix4();
+    return we(o, (w, T, m) => {
+      const k = a.current;
+      if (!k) return;
+      i.solve(m, u.current);
+      const I = i.crossScale;
+      k.matrix.multiplyMatrices(i.forearmFrame, g.makeScale(I, 1, I)), k.matrixWorldNeedsUpdate = !0, k.updateMatrixWorld(!0);
+    });
+  }, [i, o]);
+  const c = !n;
+  if (L(() => {
+    c && console.warn(
+      `${zt.loggerPrefix} WristAttachment must be inside a HandRig or HandOccluder`
+    );
+  }, [c]), !n || !l || !i) return null;
+  const f = i.forearm, p = (t == null ? void 0 : t.position) ?? [0, 0, 0];
+  return Ge(
+    /* @__PURE__ */ tt("group", { ref: a, matrixAutoUpdate: !1, children: /* @__PURE__ */ tt(
+      "group",
+      {
+        position: [p[0], p[1] - e, p[2]],
+        rotation: (t == null ? void 0 : t.rotation) ?? [0, 0, 0],
+        scale: (t == null ? void 0 : t.scale) ?? 1,
+        children: typeof s == "function" ? s(l) : s
+      }
+    ) }),
+    f
+  );
+}, zs = -1, Ls = (e, { length: t = _s, scale: s = 1 } = {}) => {
+  const n = e.palmLength * t, i = e.palmLength * Vs, o = e.width / 2 * s, r = new h.CylinderGeometry(
+    o,
+    o * Rs,
+    n + i,
+    24,
+    1,
+    !1
+  );
+  return r.translate(0, (i - n) / 2, 0), r.scale(1, 1, e.depth / e.width), r;
+}, Ks = ({
+  length: e,
+  scale: t,
+  showDebugMaterial: s = !1,
+  opacity: n = 0.5
+}) => {
+  const i = j(
+    () => new h.MeshBasicMaterial({
+      color: 13948120,
+      colorWrite: !1,
+      depthWrite: !0,
+      side: h.DoubleSide
+    }),
+    []
+  );
+  return L(() => () => i.dispose(), [i]), L(() => {
+    i.colorWrite = s, i.transparent = s, i.opacity = s ? n : 1, i.needsUpdate = !0;
+  }, [i, s, n]), /* @__PURE__ */ tt(Cs, { along: 0, children: (o) => /* @__PURE__ */ tt(Gs, { wrist: o, length: e, scale: t, material: i }) });
+}, Gs = ({
+  wrist: e,
+  length: t,
+  scale: s,
+  material: n
+}) => {
+  const i = j(
+    () => Ls(e, { length: t, scale: s }),
+    [e, t, s]
+  );
+  return L(() => () => i.dispose(), [i]), /* @__PURE__ */ tt(
+    "mesh",
+    {
+      name: "ForearmOccluder",
+      geometry: i,
+      material: n,
+      renderOrder: zs,
+      frustumCulled: !1
+    }
+  );
+}, Ys = -1, Nt = "void main() {", jt = "#include <skinning_vertex>", Qs = [
+  jt,
+  "#ifdef USE_SKINNING",
+  "  transformed += normalize( objectNormal ) * inflate;",
+  "#endif"
+].join(`
+`), $s = (e) => !e.includes(Nt) || !e.includes(jt) ? e : e.replace(Nt, `uniform float inflate;
+${Nt}`).replace(jt, Qs), Xs = () => {
+  const e = new h.MeshBasicMaterial({
+    color: 13948120,
+    colorWrite: !1,
+    depthWrite: !0,
+    side: h.FrontSide
+  }), t = { value: 0 };
+  return e.userData.inflate = t, e.onBeforeCompile = (s) => {
+    s.uniforms.inflate = t, s.vertexShader = $s(s.vertexShader);
+  }, e.customProgramCacheKey = () => "vincentt-hand-occluder", e;
+}, mi = ({
+  inflate: e = 0,
+  showDebugMaterial: t = !1,
+  opacity: s = 0.5,
+  onModel: n,
+  forearm: i = !1,
+  children: o,
+  ...r
+}) => {
+  const a = j(() => Xs(), []);
+  L(() => () => a.dispose(), [a]), L(() => {
+    a.colorWrite = t, a.transparent = t, a.opacity = t ? s : 1, a.needsUpdate = !0;
+  }, [a, t, s]), L(() => {
+    a.userData.inflate.value = e;
+  }, [a, e]);
+  const l = Me(
+    (u) => {
+      u.traverse((c) => {
+        c instanceof h.Mesh && c.userData[Lt] && (c.renderOrder = Ys);
+      }), n == null || n(u);
+    },
+    [n]
+  );
+  return /* @__PURE__ */ Ut(qs, { ...r, material: a, onModel: l, children: [
+    i && /* @__PURE__ */ tt(
+      Ks,
+      {
+        ...i === !0 ? {} : i,
+        showDebugMaterial: t,
+        opacity: s
+      }
+    ),
+    o
+  ] });
+}, Js = 0.55, Zs = 1, tn = [0.1, 0.4], le = ["indexMcp", "middleMcp", "ringMcp", "pinkyMcp"], en = (e, t) => {
+  const s = (u) => e.restPositions[it[u]], n = new h.Vector3();
+  for (const u of le) n.add(s(u));
+  n.multiplyScalar(1 / le.length);
+  const i = new h.Vector3().addVectors(s("wrist"), n).multiplyScalar(0.5), o = e.restPalmNormal.clone().normalize();
+  t === "back" && o.negate();
+  const r = n.clone().sub(s("wrist"));
+  r.addScaledVector(o, -r.dot(o)).normalize();
+  const a = new h.Vector3().crossVectors(r, o).normalize(), l = Math.sign(s("thumbCmc").clone().sub(i).dot(a)) || 1;
+  return {
+    origin: i,
+    normal: o,
+    up: r,
+    right: a,
+    thumb: a.clone().multiplyScalar(l),
+    palm: s("middleMcp").distanceTo(s("wrist"))
+  };
+}, sn = {
+  basis: new h.Matrix4(),
+  shift: new h.Matrix4(),
+  centre: new h.Vector3()
+}, nn = (e, t, { size: s, offset: n }, i = new h.Matrix4()) => {
+  const { basis: o, shift: r, centre: a } = sn;
+  a.copy(e.origin).addScaledVector(e.thumb, (n == null ? void 0 : n[0]) ?? 0).addScaledVector(e.up, (n == null ? void 0 : n[1]) ?? 0), o.makeBasis(e.right, e.up, e.normal).transpose(), r.makeTranslation(-a.x, -a.y, -a.z);
+  const l = 1 / Math.max(s, 1e-9);
+  return i.makeScale(l, l, l).multiply(o).multiply(r).multiply(t);
+}, on = new h.Matrix4(), ce = (e, t, s) => {
+  s.identity();
+  for (let n = e; n && n !== t; n = n.parent)
+    n.updateMatrix(), s.premultiply(n.matrix);
+  return s;
+}, rn = (e, t, s = new h.Matrix4()) => {
+  const n = t, i = e.bones.wrist, o = n.isSkinnedMesh && i ? n.skeleton.bones.indexOf(i) : -1;
+  return o < 0 ? ce(t, e.root, s) : (ce(i, e.root, s), s.multiply(on.copy(n.skeleton.boneInverses[o])).multiply(n.bindMatrix));
+}, gi = (e, { rotation: t = 0, aspect: s = 1, mirrored: n = !1 } = {}, i = new h.Vector2()) => {
+  if (e.z < 0) return null;
+  const o = n ? -e.x : e.x, r = Math.cos(t), a = Math.sin(t), l = r * o + a * e.y + 0.5, u = (-a * o + r * e.y) * s + 0.5;
+  return l < 0 || l > 1 || u < 0 || u > 1 ? null : i.set(l, u);
+}, an = (
+  /* glsl */
+  `
+#include <common>
+#include <skinning_pars_vertex>
+#include <logdepthbuf_pars_vertex>
+uniform mat4 decalMatrix;
+varying vec3 vDecal;
+varying float vFacing;
+varying float vMirror;
+void main() {
+  // Decal space from the REST surface (before skinning): the art deforms with the skin.
+  vDecal = ( decalMatrix * vec4( position, 1.0 ) ).xyz;
+  vFacing = normalize( mat3( decalMatrix ) * normal ).z;
+  // A mirrored hand (the model's other chirality): the art is flipped back.
+  vMirror = determinant( mat3( modelMatrix ) ) < 0.0 ? 1.0 : 0.0;
+  #include <begin_vertex>
+  #include <skinbase_vertex>
+  #include <skinning_vertex>
+  #include <project_vertex>
+  #include <logdepthbuf_vertex>
+}
+`
+), ln = (
+  /* glsl */
+  `
+#include <common>
+#include <logdepthbuf_pars_fragment>
+uniform sampler2D map;
+uniform float opacity;
+uniform vec2 turn;
+uniform float aspect;
+uniform vec2 fade;
+varying vec3 vDecal;
+varying float vFacing;
+varying float vMirror;
+void main() {
+  #include <logdepthbuf_fragment>
+  if ( vDecal.z < 0.0 ) discard;
+  vec2 p = vDecal.xy;
+  if ( vMirror > 0.5 ) p.x = -p.x;
+  vec2 uv = vec2( turn.x * p.x + turn.y * p.y, ( -turn.y * p.x + turn.x * p.y ) * aspect ) + 0.5;
+  if ( uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0 ) discard;
+  vec4 art = texture2D( map, uv );
+  float a = art.a * opacity * smoothstep( fade.x, fade.y, vFacing );
+  if ( a < 0.002 ) discard;
+  gl_FragColor = vec4( art.rgb, 1.0 );
+  #include <colorspace_fragment>
+  // Premultiplied: the blend factors (setHandTattooBlend) mix by alpha.
+  gl_FragColor = vec4( gl_FragColor.rgb * a, a );
+}
+`
+), Te = (e, t) => {
+  e.blending = h.CustomBlending, e.blendEquation = h.AddEquation, e.blendEquationAlpha = h.AddEquation, t === "multiply" ? (e.blendSrc = h.DstColorFactor, e.blendDst = h.OneMinusSrcAlphaFactor, e.blendSrcAlpha = h.ZeroFactor, e.blendDstAlpha = h.OneFactor) : (e.blendSrc = h.OneFactor, e.blendDst = h.OneMinusSrcAlphaFactor, e.blendSrcAlpha = h.OneFactor, e.blendDstAlpha = h.OneMinusSrcAlphaFactor);
+}, cn = (e = "multiply") => {
+  const t = new h.ShaderMaterial({
+    uniforms: {
+      map: { value: null },
+      decalMatrix: { value: new h.Matrix4() },
+      opacity: { value: 1 },
+      turn: { value: new h.Vector2(1, 0) },
+      aspect: { value: 1 },
+      fade: { value: new h.Vector2(...tn) }
+    },
+    vertexShader: an,
+    fragmentShader: ln,
+    transparent: !0,
+    depthWrite: !1,
+    premultipliedAlpha: !0,
+    polygonOffset: !0,
+    polygonOffsetFactor: -1,
+    polygonOffsetUnits: -1,
+    toneMapped: !1
+  });
+  return Te(t, e), t;
+}, hn = (e) => {
+  const [t, s] = ze(null), n = typeof e == "string" ? e : null;
+  return L(() => {
+    if (!n) return;
+    let i = !0, o = null;
+    return new h.TextureLoader().load(
+      n,
+      (r) => {
+        if (o = r, !i) {
+          r.dispose();
+          return;
+        }
+        r.colorSpace = h.SRGBColorSpace, s({ url: n, texture: r });
+      },
+      void 0,
+      () => console.warn(`${zt.loggerPrefix} HandTattoo could not load ${n}`)
+    ), () => {
+      i = !1, o == null || o.dispose();
+    };
+  }, [n]), typeof e != "string" ? e : (t == null ? void 0 : t.url) === e ? t.texture : null;
+}, un = (e) => {
+  const t = e.image;
+  return t != null && t.width && (t != null && t.height) ? t.width / t.height : 1;
+}, yi = ({
+  src: e,
+  placement: t = "back",
+  size: s,
+  offset: n,
+  rotation: i = 0,
+  opacity: o = 0.9,
+  blend: r = "multiply",
+  renderOrder: a = Zs
+}) => {
+  const l = Et(Kt), u = hn(e), c = j(() => {
+    if (!l) return [];
+    const T = [];
+    return l.root.traverse((m) => {
+      m instanceof h.Mesh && m.userData[Lt] && T.push(m);
+    }), T.map((m) => {
+      const k = cn(), I = m;
+      let _;
+      if (I.isSkinnedMesh) {
+        const J = new h.SkinnedMesh(m.geometry, k);
+        J.bindMode = I.bindMode, J.bind(I.skeleton, I.bindMatrix), _ = J;
+      } else
+        _ = new h.Mesh(m.geometry, k);
+      return _.name = `${m.name}_tattoo`, _.frustumCulled = !1, _.position.copy(m.position), _.quaternion.copy(m.quaternion), _.scale.copy(m.scale), {
+        mesh: _,
+        source: m,
+        material: k,
+        geometryToRoot: rn(l, m)
+      };
+    });
+  }, [l]);
+  L(() => {
+    var T;
+    for (const { mesh: m, source: k } of c) (T = k.parent) == null || T.add(m);
+    return () => {
+      for (const { mesh: m, material: k } of c)
+        m.removeFromParent(), k.dispose();
+    };
+  }, [c]);
+  const f = j(
+    () => l ? en(l, t) : null,
+    [l, t]
+  ), p = (n == null ? void 0 : n[0]) ?? 0, g = (n == null ? void 0 : n[1]) ?? 0;
+  L(() => {
+    if (!f) return;
+    const T = s ?? Js * f.palm;
+    for (const { mesh: m, material: k, geometryToRoot: I } of c) {
+      const _ = k.uniforms;
+      nn(
+        f,
+        I,
+        { size: T, offset: [p, g] },
+        _.decalMatrix.value
+      ), _.map.value = u, _.opacity.value = h.MathUtils.clamp(o, 0, 1), _.turn.value.set(Math.cos(i), Math.sin(i)), _.aspect.value = u ? un(u) : 1, Te(k, r), m.renderOrder = a, m.visible = !!u;
+    }
+  }, [c, f, u, s, p, g, i, o, r, a]);
+  const w = !l;
+  return L(() => {
+    w && console.warn(`${zt.loggerPrefix} HandTattoo must be inside a HandRig or HandOccluder`);
+  }, [w]), null;
+}, bt = [
+  "thumbTip",
+  "indexTip",
+  "middleTip",
+  "ringTip",
+  "pinkyTip"
+], Ee = Object.freeze({
+  palmRadius: 0.5,
+  tipRadius: 0.12,
+  pinchStart: 0.3,
+  pinchEnd: 0.45,
+  pinchReady: 0.6,
+  smoothing: 0.6
+}), pn = 100, dn = 8, fn = 0.05, he = () => ({
+  center: new h.Vector3(),
+  velocity: new h.Vector3(),
+  radius: 0
+}), Bt = (e) => ({
+  hand: e,
+  tracked: !1,
+  palmLength: 0,
+  palm: he(),
+  tips: Object.fromEntries(bt.map((t) => [t, he()])),
+  pinchDistance: 1 / 0,
+  pinching: !1,
+  pinch: new h.Vector3(),
+  pinchVelocity: new h.Vector3(),
+  timeMs: null,
+  history: []
+}), at = {
+  palm: new h.Vector3(),
+  knuckles: new h.Vector3(),
+  previous: new h.Vector3(),
+  raw: new h.Vector3()
+}, _t = (e, t, s, n, i, o) => {
+  if (e.radius = s, n || o <= 0) {
+    e.center.copy(t), e.velocity.set(0, 0, 0);
+    return;
+  }
+  at.previous.copy(e.center), e.center.lerp(t, i), at.raw.subVectors(e.center, at.previous).divideScalar(o), e.velocity.lerp(at.raw, 1 - Math.exp(-o / fn));
+}, Oe = (e, t) => {
+  const { history: s } = e;
+  for (s.length >= dn && s.shift(), s.push({ timeMs: t, point: e.pinch.clone() }); s.length > 2 && t - s[1].timeMs >= pn; ) s.shift();
+  const n = s[0], i = (t - n.timeMs) / 1e3;
+  i > 0 ? e.pinchVelocity.subVectors(e.pinch, n.point).divideScalar(i) : e.pinchVelocity.set(0, 0, 0);
+}, _e = (e) => (e.tracked = !1, e.pinching = !1, e.pinchDistance = 1 / 0, e.timeMs = null, e.history.length = 0, e.pinchVelocity.set(0, 0, 0), e), ue = (e, t, s, n = {}) => {
+  const i = { ...Ee, ...n };
+  if (!t || t.length < 21)
+    return _e(e);
+  if (e.tracked && e.timeMs === s) return e;
+  const o = !e.tracked || e.timeMs === null, r = o ? 0 : Math.max(0, (s - e.timeMs) / 1e3), a = h.MathUtils.clamp(i.smoothing, 0.01, 1), l = (p) => t[it[p]], u = l("wrist").distanceTo(l("middleMcp"));
+  e.palmLength = o ? u : e.palmLength + (u - e.palmLength) * a, at.knuckles.copy(l("indexMcp")).add(l("middleMcp")).add(l("ringMcp")).add(l("pinkyMcp")).multiplyScalar(0.25), at.palm.copy(l("wrist")).add(at.knuckles).multiplyScalar(0.5), _t(e.palm, at.palm, e.palmLength * i.palmRadius, o, a, r);
+  for (const p of bt)
+    _t(e.tips[p], l(p), e.palmLength * i.tipRadius, o, a, r);
+  const c = e.tips.thumbTip.center, f = e.tips.indexTip.center;
+  return e.pinchDistance = c.distanceTo(f) / Math.max(e.palmLength, 1e-9), e.pinching ? e.pinching = e.pinchDistance <= i.pinchEnd : e.pinching = e.pinchDistance < i.pinchStart, e.pinch.addVectors(c, f).multiplyScalar(0.5), Oe(e, s), e.tracked = !0, e.timeMs = s, e;
+}, mn = (e, t, s, n, i) => {
+  if (!t)
+    return _e(e);
+  const o = !e.tracked || e.timeMs === null, r = o ? 0 : Math.max(0, (n - e.timeMs) / 1e3);
+  if (!o && r === 0) return e;
+  e.palmLength = i, _t(e.palm, t, i, o, 1, r);
+  for (const a of bt) _t(e.tips[a], t, 0, o, 1, r);
+  return e.pinchDistance = s ? 0 : 1 / 0, e.pinching = s, e.pinch.copy(t), Oe(e, n), e.tracked = !0, e.timeMs = n, e;
+}, Re = Object.freeze({
+  gravity: 9,
+  damping: 0.4,
+  bounce: 0.5,
+  friction: 4,
+  grabReach: 0.35,
+  hoverReach: 0.5,
+  tapMs: 350,
+  tapSpeed: 1,
+  throwScale: 1,
+  maxSpeed: 14,
+  flat: !0
+}), gn = 1 / 120, yn = 1 / 20, Mn = 0.35, wn = 0.5, xn = 1.08, vn = 1.2, At = new h.Vector3(0, 1, 0), pe = [new h.Vector3(1, 0, 0), new h.Vector3(0, 1, 0), new h.Vector3(0, 0, 1)], bn = ["x", "y", "z"], v = {
+  d: new h.Vector3(),
+  n: new h.Vector3(),
+  v: new h.Vector3(),
+  t: new h.Vector3(),
+  q: new h.Quaternion(),
+  q2: new h.Quaternion(),
+  axis: new h.Vector3()
+}, Sn = (e) => [
+  ["palm", e.palm],
+  ...bt.map((t) => [t, e.tips[t]])
+];
+class kn {
+  constructor(t = {}, s = {}) {
+    x(this, "bodies", []);
+    x(this, "bounds", new h.Box3(new h.Vector3(-2, -2, -1), new h.Vector3(2, 2, 1)));
+    x(this, "settings");
+    /** Simulated time, ms. */
+    x(this, "timeMs", 0);
+    x(this, "nextId", 1);
+    x(this, "pinched", /* @__PURE__ */ new Map());
+    /** What the pointer pressed on, and when (a quick click is a tap). */
+    x(this, "press", null);
+    x(this, "handSettings");
+    this.settings = { ...Re, ...t }, this.handSettings = s;
+  }
+  /** The hand collider settings `pinchReady` is read from. */
+  setHandSettings(t) {
+    this.handSettings = t;
+  }
+  add(t = {}) {
+    const s = Math.max(1e-4, t.size ?? 0.4), n = {
+      id: this.nextId,
+      shape: t.shape ?? "sphere",
+      size: s,
+      radius: s / 2,
+      mass: Math.max(1e-6, t.mass ?? s ** 3),
+      bounce: t.bounce,
+      grabbable: t.grabbable ?? !0,
+      pushable: t.pushable ?? !0,
+      gravity: t.gravity ?? !0,
+      position: new h.Vector3(...t.position ?? [0, 0, 0]),
+      velocity: new h.Vector3(...t.velocity ?? [0, 0, 0]),
+      quaternion: new h.Quaternion(),
+      spin: new h.Vector3(),
+      grabbedBy: null,
+      hoveredBy: null,
+      resting: !1,
+      userData: {},
+      grabOffset: new h.Vector3(),
+      contacts: /* @__PURE__ */ new Set(),
+      tapStart: {}
+    };
+    return this.nextId += 1, this.bodies.push(n), n;
+  }
+  remove(t) {
+    const s = this.bodies.indexOf(t);
+    s >= 0 && this.bodies.splice(s, 1);
+  }
+  /** The nearest grabbable (`any`: any) object whose surface is within `reach` of `point`. */
+  pick(t, s, n = !1) {
+    let i = null, o = 1 / 0;
+    for (const r of this.bodies) {
+      if (!r.grabbable && !n) continue;
+      const a = this.distance(r.position, t) - r.radius;
+      a <= s && a < o && (i = r, o = a);
+    }
+    return i;
+  }
+  /** Advances `dt` seconds with these hands; returns what happened. */
+  step(t, s) {
+    const n = [], i = h.MathUtils.clamp(t, 0, yn);
+    this.timeMs += i * 1e3;
+    const o = /* @__PURE__ */ new Map();
+    for (const l of s) l.tracked && o.set(l.hand, l);
+    this.grabAndRelease(s, o, n);
+    const r = /* @__PURE__ */ new Map(), a = Math.max(1, Math.ceil(i / gn - 1e-9));
+    for (let l = 0; l < a; l += 1) this.substep(i / a, o, r);
+    for (const l of this.bodies) {
+      const u = r.get(l);
+      for (const [c, f] of u ?? []) {
+        if (l.contacts.has(c)) continue;
+        const [p, g] = c.split(":");
+        n.push({ type: "touch", body: l, hand: p, part: g, speed: f });
+      }
+      l.contacts = new Set((u == null ? void 0 : u.keys()) ?? []);
+    }
+    return this.hoverAndTap(o, n), n;
+  }
+  /** Grab / hover reach: palm lengths for a hand; the pointer reaches as far as its sphere. */
+  reach(t, s) {
+    return t.hand === "pointer" ? t.palm.radius : t.palmLength * s;
+  }
+  distance(t, s) {
+    return this.settings.flat ? Math.hypot(t.x - s.x, t.y - s.y) : t.distanceTo(s);
+  }
+  release(t, s, n) {
+    const i = t.grabbedBy;
+    t.grabbedBy = null, s && t.velocity.copy(s.pinchVelocity).multiplyScalar(this.settings.throwScale), t.velocity.clampLength(0, this.settings.maxSpeed), n.push({ type: "release", body: t, hand: i, speed: t.velocity.length() });
+  }
+  grabAndRelease(t, s, n) {
+    for (const i of this.bodies)
+      if (i.grabbedBy && !s.has(i.grabbedBy)) {
+        const o = t.find((r) => r.hand === i.grabbedBy);
+        this.release(i, o, n);
+      }
+    for (const i of t) {
+      const o = i.tracked && i.pinching, r = this.pinched.get(i.hand) ?? !1, a = this.bodies.find((l) => l.grabbedBy === i.hand);
+      if (o && !r && !a) {
+        const l = this.pick(i.pinch, this.reach(i, this.settings.grabReach));
+        l && (l.grabbedBy && n.push({ type: "release", body: l, hand: l.grabbedBy, speed: 0 }), l.grabbedBy = i.hand, l.grabOffset.subVectors(l.position, i.pinch).clampLength(0, l.radius), n.push({ type: "grab", body: l, hand: i.hand }));
+      } else !o && a && this.release(a, i, n);
+      i.hand === "pointer" && this.clickTap(i, o, r, n), this.pinched.set(i.hand, o);
+    }
+  }
+  substep(t, s, n) {
+    const i = this.settings;
+    for (const o of this.bodies) {
+      const r = o.grabbedBy ? s.get(o.grabbedBy) : void 0;
+      r ? (v.t.addVectors(r.pinch, o.grabOffset), o.position.lerp(v.t, 1 - Math.exp(-30 * t)), o.velocity.copy(r.pinchVelocity), o.spin.multiplyScalar(Math.exp(-4 * t))) : (o.gravity && (o.velocity.y -= i.gravity * t), o.velocity.multiplyScalar(Math.exp(-i.damping * t)), o.velocity.clampLength(0, i.maxSpeed), o.spin.multiplyScalar(Math.exp(-i.damping * t)), o.position.addScaledVector(o.velocity, t)), this.turn(o, t), this.walls(o, t, !!r);
+    }
+    this.collideBodies(s), this.collideHands(s, n);
+  }
+  turn(t, s) {
+    const n = t.spin.length() * s;
+    n < 1e-9 || (v.axis.copy(t.spin).normalize(), v.q.setFromAxisAngle(v.axis, n), t.quaternion.premultiply(v.q).normalize());
+  }
+  walls(t, s, n) {
+    const i = this.settings, { min: o, max: r } = this.bounds, a = t.bounce ?? i.bounce;
+    let l = !1;
+    for (const c of bn) {
+      const f = o[c] + t.radius, p = Math.max(f, r[c] - t.radius);
+      t.position[c] < f ? (t.position[c] = f, t.velocity[c] < 0 && (t.velocity[c] = n ? 0 : -t.velocity[c] * a), c === "y" && (l = !0)) : t.position[c] > p && (t.position[c] = p, t.velocity[c] > 0 && (t.velocity[c] = n ? 0 : -t.velocity[c] * a));
+    }
+    if (n) {
+      t.resting = !1;
+      return;
+    }
+    if (!l && t.position.y - (o.y + t.radius) < 1e-4 && t.velocity.y <= 0 && (l = !0), !l) {
+      t.resting = !1;
+      return;
+    }
+    Math.abs(t.velocity.y) < Mn && (t.velocity.y = 0);
+    const u = Math.exp(-i.friction * s);
+    t.velocity.x *= u, t.velocity.z *= u, t.shape === "sphere" ? t.spin.crossVectors(At, t.velocity).divideScalar(t.radius) : (t.spin.multiplyScalar(Math.exp(-10 * s)), this.settleFlat(t, s)), t.resting = t.velocity.lengthSq() < 0.05 * 0.05;
+  }
+  /** Turns a box toward its nearest face-down orientation. */
+  settleFlat(t, s) {
+    let n = 0, i = 0;
+    pe.forEach((o, r) => {
+      const a = v.v.copy(o).applyQuaternion(t.quaternion).y;
+      Math.abs(a) > Math.abs(i) && (n = r, i = a);
+    }), v.v.copy(pe[n]).applyQuaternion(t.quaternion).multiplyScalar(Math.sign(i) || 1), v.q2.setFromUnitVectors(v.v, At).multiply(t.quaternion), t.quaternion.slerp(v.q2, 1 - Math.exp(-10 * s));
+  }
+  collideBodies(t) {
+    const { bodies: s } = this;
+    for (let n = 0; n < s.length; n += 1)
+      for (let i = n + 1; i < s.length; i += 1) {
+        const o = s[n], r = s[i];
+        v.d.subVectors(r.position, o.position);
+        const a = v.d.length(), l = o.radius + r.radius;
+        if (a >= l) continue;
+        const u = o.grabbedBy && t.has(o.grabbedBy) ? 0 : 1 / o.mass, c = r.grabbedBy && t.has(r.grabbedBy) ? 0 : 1 / r.mass;
+        if (u + c === 0) continue;
+        a > 1e-9 ? v.n.copy(v.d).divideScalar(a) : v.n.copy(At);
+        const f = (l - a) / (u + c);
+        o.position.addScaledVector(v.n, -f * u), r.position.addScaledVector(v.n, f * c);
+        const p = v.v.subVectors(r.velocity, o.velocity).dot(v.n);
+        if (p >= 0) continue;
+        const w = -(1 + Math.min(o.bounce ?? this.settings.bounce, r.bounce ?? this.settings.bounce)) * p / (u + c);
+        o.velocity.addScaledVector(v.n, -w * u), r.velocity.addScaledVector(v.n, w * c);
+      }
+  }
+  collideHands(t, s) {
+    const n = this.settings, i = this.handSettings.pinchReady ?? Ee.pinchReady;
+    for (const o of t.values()) {
+      if (o.hand === "pointer" && !o.pinching) continue;
+      const r = o.pinchDistance < i;
+      for (const [a, l] of Sn(o))
+        if (!(l.radius <= 0 || r && (a === "thumbTip" || a === "indexTip")))
+          for (const u of this.bodies) {
+            if (!u.pushable || u.grabbedBy) continue;
+            v.d.subVectors(u.position, l.center), n.flat && (v.d.z = 0);
+            const c = v.d.length(), f = u.radius + l.radius;
+            if (c >= f) continue;
+            c > 1e-9 ? v.n.copy(v.d).divideScalar(c) : v.n.copy(At), u.position.addScaledVector(v.n, f - c), v.v.subVectors(u.velocity, l.velocity);
+            const p = v.v.dot(v.n);
+            p < 0 && (u.velocity.addScaledVector(v.n, -(1 + (u.bounce ?? n.bounce)) * p), u.velocity.clampLength(0, n.maxSpeed)), v.t.copy(v.v).addScaledVector(v.n, -v.v.dot(v.n)).negate(), v.axis.crossVectors(v.n, v.t).divideScalar(-u.radius), u.spin.lerp(v.axis, wn);
+            const g = `${o.hand}:${a}`, w = s.get(u) ?? /* @__PURE__ */ new Map();
+            w.set(g, Math.max(w.get(g) ?? 0, Math.max(0, -p))), s.set(u, w);
+          }
+    }
+  }
+  /** The pointer: a press and a quick release on the same object is a tap. */
+  clickTap(t, s, n, i) {
+    const o = this.reach(t, this.settings.grabReach);
+    if (s && !n) {
+      const r = this.pick(t.pinch, o, !0);
+      this.press = r ? { body: r, timeMs: this.timeMs } : null;
+    } else if (!s && n && this.press) {
+      const { body: r, timeMs: a } = this.press;
+      this.press = null, this.distance(r.position, t.pinch) - r.radius <= o && this.timeMs - a <= this.settings.tapMs && this.bodies.includes(r) && i.push({ type: "tap", body: r, hand: t.hand });
+    }
+  }
+  hoverAndTap(t, s) {
+    const n = this.settings;
+    for (const i of this.bodies) {
+      let o = null;
+      for (const r of t.values()) {
+        const a = r.tips.indexTip, l = this.distance(i.position, a.center) - i.radius;
+        if (l <= this.reach(r, n.hoverReach) && !i.grabbedBy && (o === null || i.hoveredBy === r.hand) && (o = r.hand), r.hand === "pointer") continue;
+        const c = (i.radius + a.radius) * xn, f = (i.radius + a.radius) * vn, p = l + i.radius, g = i.tapStart[r.hand];
+        if (g === void 0 && p < c && !i.grabbedBy) {
+          v.d.subVectors(i.position, a.center), n.flat && (v.d.z = 0);
+          const w = a.velocity.dot(v.d.normalize());
+          i.tapStart[r.hand] = w >= n.tapSpeed * r.palmLength ? this.timeMs : NaN;
+        } else g !== void 0 && (p > f || i.grabbedBy) && (delete i.tapStart[r.hand], !i.grabbedBy && this.timeMs - g <= n.tapMs && s.push({ type: "tap", body: i, hand: r.hand }));
+      }
+      for (const r of Object.keys(i.tapStart))
+        t.has(r) || delete i.tapStart[r];
+      o !== i.hoveredBy && (i.hoveredBy && s.push({ type: "hoverend", body: i, hand: i.hoveredBy }), o && s.push({ type: "hoverstart", body: i, hand: o }), i.hoveredBy = o);
+    }
+  }
+}
+const An = 0.15, Tn = 0.6, Ve = Pt(null), Mi = () => Et(Ve), En = ["left", "right"], On = new h.Vector3(1, 1, 1), wi = ({
+  hands: e = "both",
+  pointer: t = !1,
+  depth: s = Tn,
+  floor: n = 0,
+  bounds: i,
+  showColliders: o = !1,
+  onEvent: r,
+  paused: a = !1,
+  active: l = !0,
+  children: u,
+  palmRadius: c,
+  tipRadius: f,
+  pinchStart: p,
+  pinchEnd: g,
+  pinchReady: w,
+  smoothing: T,
+  ...m
+}) => {
+  const { node: k } = Ot(mt.HAND_TRACKER, void 0, l), I = gt((M) => M.camera), _ = gt((M) => M.gl), J = Object.fromEntries(
+    Object.entries({ palmRadius: c, tipRadius: f, pinchStart: p, pinchEnd: g, pinchReady: w, smoothing: T }).filter(
+      ([, M]) => M !== void 0
+    )
+  ), V = j(() => new kn(), []);
+  V.settings = { ...Re, ..._n(m) }, V.setHandSettings(J);
+  const N = Y(J);
+  N.current = J;
+  const F = j(
+    () => ({
+      left: Bt("left"),
+      right: Bt("right"),
+      pointer: Bt("pointer")
+    }),
+    []
+  ), C = j(
+    () => ({
+      left: Zt.map(() => new h.Vector3()),
+      right: Zt.map(() => new h.Vector3())
+    }),
+    []
+  ), Q = j(() => /* @__PURE__ */ new Map(), []), et = Y(r);
+  et.current = r;
+  const P = Y({
+    ndc: null,
+    pressed: !1,
+    clicked: !1,
+    lifted: !1
+  }), st = !!t, ut = (typeof t == "object" ? t.radius : void 0) ?? An;
+  L(() => {
+    if (!st) return;
+    const M = _.domElement, b = P.current, D = M.style.touchAction;
+    M.style.touchAction = "none";
+    const O = (A) => {
+      const y = M.getBoundingClientRect();
+      b.ndc ?? (b.ndc = new h.Vector2()), b.ndc.set(
+        (A.clientX - y.left) / y.width * 2 - 1,
+        1 - (A.clientY - y.top) / y.height * 2
+      );
+    }, E = (A) => {
+      O(A), b.pressed = !0, b.clicked = !0, b.lifted = !1;
+    }, q = () => {
+      b.pressed = !1;
+    }, W = (A) => {
+      b.pressed = !1, A.type === "pointerup" ? A.pointerType !== "mouse" && (b.lifted = !0) : b.ndc = null;
+    };
+    return M.addEventListener("pointermove", O), M.addEventListener("pointerdown", E), window.addEventListener("pointerup", q), M.addEventListener("pointerup", W), M.addEventListener("pointerleave", W), M.addEventListener("pointercancel", W), () => {
+      M.style.touchAction = D, M.removeEventListener("pointermove", O), M.removeEventListener("pointerdown", E), window.removeEventListener("pointerup", q), M.removeEventListener("pointerup", W), M.removeEventListener("pointerleave", W), M.removeEventListener("pointercancel", W), b.ndc = null, b.pressed = !1, b.clicked = !1, b.lifted = !1;
+    };
+  }, [_, st]);
+  const H = j(
+    () => ({
+      lo: new h.Vector3(),
+      hi: new h.Vector3(),
+      point: new h.Vector3(),
+      matrix: new h.Matrix4(),
+      inverse: new h.Matrix4()
+    }),
+    []
+  );
+  Ct((M, b) => {
+    var O, E, q, W;
+    i ? (V.bounds.min.set(...i.min), V.bounds.max.set(...i.max)) : (Dt({ x: -1, y: -1 }, I, H.lo), Dt({ x: 1, y: 1 }, I, H.hi), V.bounds.min.set(
+      Math.min(H.lo.x, H.hi.x),
+      Math.min(H.lo.y, H.hi.y) + n,
+      -s
+    ), V.bounds.max.set(Math.max(H.lo.x, H.hi.x), Math.max(H.lo.y, H.hi.y), s));
+    for (const A of En) {
+      const R = e === "both" || e === A ? ((O = k == null ? void 0 : k.getHandPose) == null ? void 0 : O.call(k, A)) ?? ((E = k == null ? void 0 : k.poses) == null ? void 0 : E[A]) ?? null : null;
+      R && R.world.length >= 21 && R.image.length >= 21 ? (ns(R, I, C[A]), ue(
+        F[A],
+        C[A],
+        R.timestampMs,
+        N.current
+      )) : ue(F[A], null, 0);
+    }
+    const D = P.current;
+    if (mn(
+      F.pointer,
+      st && D.ndc ? Dt({ x: D.ndc.x, y: D.ndc.y }, I, H.point) : null,
+      D.pressed || D.clicked,
+      performance.now(),
+      ut
+    ), D.lifted && !D.clicked && (D.ndc = null, D.lifted = !1), D.clicked = !1, !a) {
+      const A = V.step(b, [F.left, F.right, F.pointer]);
+      for (const y of A)
+        (q = Q.get(y.body)) == null || q.onEvent.current(y), (W = et.current) == null || W.call(et, y);
+    }
+    for (const [A, { object: y }] of Q)
+      H.matrix.compose(A.position, A.quaternion, On), y.parent && H.matrix.premultiply(H.inverse.copy(y.parent.matrixWorld).invert()), H.matrix.decompose(y.position, y.quaternion, H.point);
+  });
+  const S = j(
+    () => ({
+      world: V,
+      hands: [F.left, F.right, F.pointer],
+      register: (M, b) => (Q.set(M, b), () => {
+        Q.delete(M);
+      })
+    }),
+    [V, F, Q]
+  );
+  return /* @__PURE__ */ Ut(Ve.Provider, { value: S, children: [
+    u,
+    o && /* @__PURE__ */ tt(Rn, { hands: S.hands })
+  ] });
+}, _n = (e) => Object.fromEntries(Object.entries(e).filter(([, t]) => t !== void 0)), Rn = ({ hands: e }) => {
+  const t = j(
+    () => e.flatMap((o) => [
+      { hand: o, sphere: o.palm },
+      ...bt.map((r) => ({ hand: o, sphere: o.tips[r] }))
+    ]),
+    [e]
+  ), s = j(() => new h.SphereGeometry(1, 20, 12), []), n = j(
+    () => ({
+      open: new h.MeshBasicMaterial({
+        color: 8246268,
+        transparent: !0,
+        opacity: 0.35,
+        depthWrite: !1
+      }),
+      pinch: new h.MeshBasicMaterial({
+        color: 16020150,
+        transparent: !0,
+        opacity: 0.5,
+        depthWrite: !1
+      })
+    }),
+    []
+  );
+  L(
+    () => () => {
+      s.dispose(), n.open.dispose(), n.pinch.dispose();
+    },
+    [s, n]
+  );
+  const i = Y([]);
+  return Ct(() => {
+    t.forEach(({ hand: o, sphere: r }, a) => {
+      const l = i.current[a];
+      l && (l.visible = o.tracked && r.radius > 0, l.position.copy(r.center), l.scale.setScalar(Math.max(r.radius, 1e-6)), l.material = o.pinching ? n.pinch : n.open);
+    });
+  }), /* @__PURE__ */ tt("group", { name: "HandTouchColliders", children: t.map((o, r) => /* @__PURE__ */ tt(
+    "mesh",
+    {
+      ref: (a) => {
+        i.current[r] = a;
+      },
+      geometry: s,
+      material: n.open,
+      renderOrder: 10,
+      frustumCulled: !1,
+      visible: !1
+    },
+    r
+  )) });
+}, rt = (e) => Number.isFinite(e) ? Math.max(0, Math.min(1, e)) : 0, yt = (e, t) => Math.hypot(e.x - t.x, e.y - t.y), U = {
+  wrist: 0,
+  thumbTip: 4,
+  indexBase: 5,
+  indexTip: 8,
+  middleBase: 9,
+  middleTip: 12,
+  ringBase: 13,
+  ringTip: 16,
+  pinkyBase: 17,
+  pinkyTip: 20
+}, Rt = [
+  [U.indexBase, U.indexTip],
+  [U.middleBase, U.middleTip],
+  [U.ringBase, U.ringTip],
+  [U.pinkyBase, U.pinkyTip]
+], ht = (e) => e !== void 0 && e.length >= 21, Gt = (e) => ht(e) ? yt(e[U.wrist], e[U.middleBase]) : 0, xi = (e) => {
+  if (!ht(e)) return 0;
+  const t = Gt(e);
+  if (t <= 0) return 0;
+  const s = yt(e[U.thumbTip], e[U.indexTip]) / t;
+  return rt(1 - (s - 0.15) / 0.85);
+}, Ie = (e, t, s) => {
+  const n = e[U.wrist], i = yt(e[t], n);
+  if (i <= 0) return 0;
+  const o = yt(e[s], n) / i;
+  return rt((1.6 - o) / 0.6);
+}, Vn = (e, t = [0, 0, 0, 0]) => {
+  for (let s = 0; s < Rt.length; s += 1) {
+    const [n, i] = Rt[s];
+    t[s] = 1 - Ie(e, n, i);
+  }
+  return t;
+}, We = (e) => {
+  const t = Gt(e);
+  if (t <= 0) return 0;
+  const s = yt(e[U.thumbTip], e[U.indexBase]) / t;
+  return rt((s - 0.45) / 0.5);
+}, de = (e) => {
+  const t = Gt(e);
+  if (t <= 0) return 0;
+  const s = (e[U.thumbTip].y - e[U.indexBase].y) / t;
+  return Math.max(-1, Math.min(1, s / 0.6));
+}, In = (e, t) => {
+  if (!ht(e)) return 0;
+  const s = Vn(e);
+  let n = 1;
+  for (let i = 0; i < 4; i += 1) {
+    const o = t.fingers[i];
+    o !== null && (n = Math.min(n, o ? s[i] : 1 - s[i]));
+  }
+  if (t.thumb !== void 0 && t.thumb !== null) {
+    const i = We(e);
+    n = Math.min(n, t.thumb ? i : 1 - i);
+  }
+  return n;
+}, vi = (e, t) => {
+  if (!ht(e)) return 0;
+  const s = In(e, { fingers: [!1, !1, !1, !1] }), n = rt(t === "up" ? de(e) : -de(e));
+  return Math.min(s, We(e), n);
+}, Wn = (e) => {
+  if (!ht(e)) return 0;
+  let t = 0;
+  for (const [s, n] of Rt) t += Ie(e, s, n);
+  return t / Rt.length;
+}, bi = (e) => ht(e) ? 1 - Wn(e) : 0, Si = (e) => ht(e) ? rt((e[U.wrist].y + 1) / 2) : 0, ot = {
+  leftShoulder: 11,
+  rightShoulder: 12,
+  leftElbow: 13,
+  rightElbow: 14,
+  leftWrist: 15,
+  rightWrist: 16,
+  leftHip: 23,
+  rightHip: 24
+}, De = (e) => e !== void 0 && e.length >= 33, Fe = (e) => yt(e[ot.leftShoulder], e[ot.rightShoulder]), ki = (e, t, s = !1) => {
+  if (!De(e)) return 0;
+  const n = Fe(e);
+  if (n <= 0) return 0;
+  const i = Ye(t, s), o = e[i === "left" ? ot.leftWrist : ot.rightWrist], r = e[i === "left" ? ot.leftShoulder : ot.rightShoulder];
+  return rt((o.y - r.y) / n);
+}, Ai = (e) => {
+  if (!De(e)) return 0;
+  const t = Fe(e);
+  if (t <= 0) return 0;
+  let s = 1;
+  for (const n of ["left", "right"]) {
+    const i = e[n === "left" ? ot.leftWrist : ot.rightWrist], o = e[n === "left" ? ot.leftShoulder : ot.rightShoulder], r = rt(1 - Math.abs(i.y - o.y) / (t * 0.5)), a = n === "left" ? i.x - o.x : o.x - i.x, l = rt(a / t);
+    s = Math.min(s, r, l);
+  }
+  return s;
+};
+class Dn {
+  constructor(t) {
+    x(this, "reversals", []);
+    /** Running extreme in the current direction (max rising, min falling). */
+    x(this, "extreme", null);
+    /** Range seen before the first swing (direction still unknown). */
+    x(this, "low", 0);
+    x(this, "high", 0);
+    x(this, "direction", 0);
+    this.options = t;
+  }
+  reset() {
+    this.reversals = [], this.extreme = null, this.direction = 0;
+  }
+  /** Feed one sample; returns the oscillation progress 0..1. */
+  push(t, s) {
+    const { minAmplitude: n } = this.options;
+    return this.extreme === null ? (this.extreme = t, this.low = t, this.high = t, this.direction = 0, this.progress(s)) : (this.direction === 0 ? t - this.low >= n ? (this.direction = 1, this.extreme = t) : this.high - t >= n ? (this.direction = -1, this.extreme = t) : (this.low = Math.min(this.low, t), this.high = Math.max(this.high, t)) : (this.direction > 0 ? t > this.extreme : t < this.extreme) ? this.extreme = t : Math.abs(this.extreme - t) >= n && (this.reversals.push(s), this.direction = -this.direction, this.extreme = t), this.progress(s));
+  }
+  progress(t) {
+    const { requiredReversals: s, windowMs: n } = this.options;
+    for (; this.reversals.length > 0 && t - this.reversals[0] > n; )
+      this.reversals.shift();
+    return rt(this.reversals.length / s);
+  }
+}
+const Ne = {
+  nose: G.nose,
+  leftShoulder: G.leftShoulder,
+  rightShoulder: G.rightShoulder,
+  leftElbow: G.leftElbow,
+  rightElbow: G.rightElbow,
+  leftWrist: G.leftWrist,
+  rightWrist: G.rightWrist,
+  leftIndex: G.leftIndex,
+  rightIndex: G.rightIndex,
+  leftHip: G.leftHip,
+  rightHip: G.rightHip,
+  leftKnee: G.leftKnee,
+  rightKnee: G.rightKnee,
+  leftAnkle: G.leftAnkle,
+  rightAnkle: G.rightAnkle
+}, Fn = Object.keys(Ne), Nn = [
+  "leftShoulder",
+  "rightShoulder",
+  "leftElbow",
+  "rightElbow",
+  "leftWrist",
+  "rightWrist"
+], Bn = [
+  "leftShoulder",
+  "rightShoulder",
+  "leftHip",
+  "rightHip",
+  "leftKnee",
+  "rightKnee",
+  "leftAnkle",
+  "rightAnkle"
+], fe = Object.freeze({
+  /** MediaPipe visibility at or above which a joint counts. */
+  visible: 0.2,
+  /**
+   * How far past the frame edge a joint may sit (frame units: each axis spans
+   * −1..1), so an ankle right at the edge, feet partly cropped, still counts.
+   */
+  edge: 0.12
+}), Ti = (e, { mirrored: t = !1, visibility: s, limits: n, aspect: i = 1, view: o } = {}) => {
+  if (e.length < se)
+    throw new Error(
+      `createBodyMoveFrame needs MediaPipe's ${se} pose landmarks (got ${e.length})`
+    );
+  const r = is(e, i), a = os(r, { mirrored: t, visibility: s, limits: n }), l = (o == null ? void 0 : o.visible) ?? fe.visible, u = 1 + ((o == null ? void 0 : o.edge) ?? fe.edge), c = {}, f = {}, p = {};
+  for (const m of Fn) {
+    const k = Ne[Qe(m, t)], I = e[k];
+    c[m] = r[k], f[m] = (s == null ? void 0 : s[k]) ?? 1, p[m] = f[m] >= l && Math.abs(I.x) <= u && Math.abs(I.y) <= u;
+  }
+  const g = (c.leftShoulder.y + c.rightShoulder.y) / 2, w = (c.leftHip.y + c.rightHip.y) / 2, T = c.leftShoulder.x - c.rightShoulder.x;
+  return {
+    shape: a,
+    landmarks: e,
+    joints: c,
+    visibility: f,
+    seen: p,
+    shoulderWidth: a.shoulderWidth,
+    torso: Math.max(0, g - w),
+    leftward: Math.abs(T) > 1e-6 ? T > 0 ? 1 : -1 : t ? -1 : 1,
+    upperInView: Nn.every((m) => p[m]),
+    fullInView: Bn.every((m) => p[m]),
+    mirrored: t,
+    aspect: i
+  };
+}, Hn = Object.fromEntries(
+  ["left", "right"].map((e) => [
+    e,
+    Object.fromEntries(
+      ["Shoulder", "Elbow", "Wrist", "Index", "Hip", "Knee", "Ankle"].map((t) => [
+        t,
+        `${e}${t}`
+      ])
+    )
+  ])
+), B = (e, t) => Hn[e][t], Mt = (e, t) => e.seen[B(t, "Shoulder")] && e.seen[B(t, "Elbow")] && e.seen[B(t, "Wrist")], qt = Object.freeze({
+  /** `jump`: shoulders, hips and both ankles rise at least this far above standing (torso lengths) … */
+  jumpRise: 0.12,
+  /** … and it lands when both ankles are back within this of the ground. */
+  jumpLand: 0.06,
+  /** Longer in the air than this is not a jump (the camera moved): the move ends and re-levels. */
+  jumpMaxAirMs: 900,
+  /** The standing level follows the body with this time constant (ms), so slow drift never jumps. */
+  jumpLevelMs: 300,
+  /**
+   * `squat`: hips down when the thigh's height falls to this × the shin's
+   * (standing ≈ 1, thighs level ≈ 0), on the straighter leg …
+   */
+  squatDown: 0.6,
+  /** … and back up (the rep ends, the next can start) above this. */
+  squatUp: 0.85,
+  /** `wave`: the forearm points up (wrist above the elbow by at least this, shoulder widths) … */
+  waveForearmUp: 0.25,
+  /** … and swings side to side by at least this between turning points … */
+  waveAmplitude: 0.3,
+  /** … this many turning points … */
+  waveReversals: 3,
+  /** … within this long (ms). */
+  waveWindowMs: 1500,
+  /** `clap`: the hands were at least this far apart (shoulder widths) … */
+  clapApart: 0.6,
+  /** … then meet within this … */
+  clapTogether: 0.3,
+  /** … in at most this long (ms). */
+  clapWithinMs: 250,
+  /** The clap ends when the hands part past this. */
+  clapRelease: 0.45,
+  /**
+   * `punch`: the arm was bent (shoulder → wrist ÷ upper arm + forearm, 1 =
+   * straight, read in 3D) below this …
+   */
+  punchBent: 0.75,
+  /** … then straightens past this … */
+  punchStraight: 0.93,
+  /** … within this long (ms) … */
+  punchWithinMs: 200,
+  /** … with the wrist within this of shoulder height (shoulder widths): not a raise or a drop. */
+  punchBand: 0.9,
+  /** `armFlap`: both wrists drop at least this far (shoulder widths) … */
+  flapStroke: 0.7,
+  /** … within this long (ms) … */
+  flapWithinMs: 500,
+  /** … from a top no lower than this relative to the shoulders (arms up like wings, not lowered from the front) … */
+  flapTop: -0.4,
+  /** … with both wrists out past their shoulders by at least this. */
+  flapOut: 0.3,
+  /** `kick`: the foot rises at least this far above the standing foot (torso lengths) … */
+  kickLift: 0.35,
+  /** … the knee at least this far above the standing knee … */
+  kickKnee: 0.15,
+  /**
+   * … and the lower leg swings up: the foot hangs below its knee by at most
+   * this × the standing shin (a march's foot hangs ≈ 1 below the knee) …
+   */
+  kickShin: 0.6,
+  /** … in at most this long from the foot leaving the ground (ms). */
+  kickWithinMs: 600,
+  /** `stepLeft` / `stepRight`: hips and feet move sideways at least this far (shoulder widths) … */
+  stepShift: 0.5,
+  /** … within this long (ms). */
+  stepWithinMs: 700,
+  /** `march`: a knee or foot rises at least this far above the other one (torso lengths) … */
+  marchLift: 0.2,
+  /** … and comes back down below this … */
+  marchDrop: 0.08,
+  /** … alternating: the other leg lifted at most this long before (ms). */
+  marchWithinMs: 1200
+}), Ei = (e) => {
+  if (typeof e.measure != "function" || typeof e.createMemory != "function")
+    throw new Error("defineBodyMove needs createMemory and measure functions");
+  return e;
+};
+class Vt {
+  constructor(t = 64) {
+    x(this, "times");
+    x(this, "values");
+    x(this, "start", 0);
+    x(this, "count", 0);
+    this.capacity = t, this.times = new Float64Array(t), this.values = new Float64Array(t);
+  }
+  clear() {
+    this.start = 0, this.count = 0;
+  }
+  push(t, s) {
+    const n = (this.start + this.count) % this.capacity;
+    this.times[n] = t, this.values[n] = s, this.count < this.capacity ? this.count += 1 : this.start = (this.start + 1) % this.capacity;
+  }
+  /** Largest value at or after `sinceMs` (−Infinity when none). */
+  max(t) {
+    let s = -1 / 0;
+    for (let n = 0; n < this.count; n += 1) {
+      const i = (this.start + n) % this.capacity;
+      this.times[i] >= t && this.values[i] > s && (s = this.values[i]);
+    }
+    return s;
+  }
+  /** Smallest value at or after `sinceMs` (Infinity when none). */
+  min(t) {
+    let s = 1 / 0;
+    for (let n = 0; n < this.count; n += 1) {
+      const i = (this.start + n) % this.capacity;
+      this.times[i] >= t && this.values[i] < s && (s = this.values[i]);
+    }
+    return s;
+  }
+}
+const It = ["left", "right"], wt = (e) => e === "left" ? "right" : "left", vt = (e, t) => t === "either" || t === e, $ = { value: 0, side: null }, jn = {
+  left: { value: 1, side: "left" },
+  right: { value: 1, side: "right" },
+  none: { value: 1, side: null }
+}, X = (e) => jn[e ?? "none"], lt = {
+  enterThreshold: 0.5,
+  exitThreshold: 0.5,
+  holdMs: 0,
+  lostGraceMs: 250
+}, Be = (e) => e.seen.leftShoulder && e.seen.rightShoulder && Mt(e, "left") && Mt(e, "right"), He = (e, { side: t }) => e.seen.leftShoulder && e.seen.rightShoulder && (vt("left", t) && Mt(e, "left") || vt("right", t) && Mt(e, "right")), St = (e) => e.fullInView && e.torso > 1e-3, qn = {
+  name: "jump",
+  label: "Jump",
+  description: "Shoulders, hips and both feet rise together above the standing level (a fast rise), then land.",
+  view: "full",
+  limitKeys: ["jumpRise", "jumpLand", "jumpMaxAirMs", "jumpLevelMs"],
+  defaults: { ...lt, cooldownMs: 150 },
+  createMemory: () => ({ level: null, lastMs: 0, airborne: !1, airSinceMs: 0 }),
+  inView: St,
+  measure: (e, t, s, { limits: n }) => {
+    const { joints: i, torso: o } = e, r = (i.leftShoulder.y + i.rightShoulder.y) / 2, a = (i.leftHip.y + i.rightHip.y) / 2, l = i.leftAnkle.y, u = i.rightAnkle.y, c = t.level;
+    if (!c)
+      return t.level = { shoulders: r, hips: a, left: l, right: u }, t.lastMs = s, $;
+    const f = Math.max(0, s - t.lastMs);
+    t.lastMs = s;
+    const p = (w, T) => (w - T) / o;
+    if (t.airborne) {
+      const w = p(l, c.left) <= n.jumpLand && p(u, c.right) <= n.jumpLand, T = s - t.airSinceMs > n.jumpMaxAirMs;
+      return !w && !T ? X(null) : (t.airborne = !1, T && Object.assign(c, { shoulders: r, hips: a, left: l, right: u }), $);
+    }
+    if (p(r, c.shoulders) >= n.jumpRise && p(a, c.hips) >= n.jumpRise && p(l, c.left) >= n.jumpRise && p(u, c.right) >= n.jumpRise)
+      return t.airborne = !0, t.airSinceMs = s, X(null);
+    const g = 1 - Math.exp(-f / Math.max(1, n.jumpLevelMs));
+    return c.shoulders += (r - c.shoulders) * g, c.hips += (a - c.hips) * g, c.left += (l - c.left) * g, c.right += (u - c.right) * g, $;
+  }
+}, me = (e, t) => {
+  const s = e.joints[B(t, "Hip")], n = e.joints[B(t, "Knee")], i = e.joints[B(t, "Ankle")], o = n.y - i.y;
+  return o > 1e-4 ? (s.y - n.y) / o : null;
+}, Pn = {
+  name: "squat",
+  label: "Squat",
+  description: "From standing, both thighs drop toward level (the hips sink to the knees), then the body stands back up.",
+  view: "full",
+  limitKeys: ["squatDown", "squatUp"],
+  defaults: { ...lt, cooldownMs: 200 },
+  createMemory: () => ({ ready: !1, down: !1 }),
+  inView: St,
+  measure: (e, t, s, { limits: n }) => {
+    const i = me(e, "left"), o = me(e, "right");
+    if (i === null || o === null) return t.down ? X(null) : $;
+    const r = Math.max(i, o), a = Math.abs(e.joints.leftAnkle.y - e.joints.rightAnkle.y) / e.torso <= 0.25;
+    return t.down ? r < n.squatUp ? X(null) : (t.down = !1, t.ready = !0, $) : (r >= n.squatUp && (t.ready = !0), t.ready && a && r <= n.squatDown ? (t.ready = !1, t.down = !0, X(null)) : $);
+  }
+}, ge = (e) => {
+  const t = () => new Dn({
+    minAmplitude: e.waveAmplitude,
+    requiredReversals: Math.max(1, Math.round(e.waveReversals)),
+    windowMs: e.waveWindowMs
+  });
+  return {
+    built: { amplitude: e.waveAmplitude, reversals: e.waveReversals, windowMs: e.waveWindowMs },
+    left: t(),
+    right: t(),
+    sample: { value: 0, side: null }
+  };
+}, Un = {
+  name: "wave",
+  label: "Wave",
+  description: "A forearm held up swings side to side about the elbow: three turning points of 0.3 shoulder widths within 1.5 s.",
+  view: "upper",
+  sided: !0,
+  limitKeys: ["waveForearmUp", "waveAmplitude", "waveReversals", "waveWindowMs"],
+  // Like the hand / face oscillations: begin at full progress, end once the swinging stops.
+  defaults: { enterThreshold: 0.99, exitThreshold: 0.3, cooldownMs: 600, lostGraceMs: 250 },
+  createMemory: () => ge(qt),
+  inView: He,
+  measure: (e, t, s, { side: n, limits: i }) => {
+    const { built: o } = t;
+    (o.amplitude !== i.waveAmplitude || o.reversals !== i.waveReversals || o.windowMs !== i.waveWindowMs) && Object.assign(t, ge(i));
+    const r = e.shoulderWidth;
+    let a = 0, l = null;
+    for (const u of It) {
+      if (!vt(u, n)) continue;
+      const c = t[u], f = e.joints[B(u, "Elbow")], p = e.joints[B(u, "Wrist")];
+      if (!Mt(e, u) || (p.y - f.y) / r < i.waveForearmUp) {
+        c.reset();
+        continue;
+      }
+      const g = c.push((p.x - f.x) / r, s);
+      g > a && (a = g, l = u);
+    }
+    return a <= 0 ? $ : (t.sample.value = a, t.sample.side = l, t.sample);
+  }
+}, Tt = (e, t, s) => {
+  const n = e.joints[B(t, "Wrist")][s];
+  return e.seen[B(t, "Index")] ? (n + e.joints[B(t, "Index")][s]) / 2 : n;
+}, Cn = {
+  name: "clap",
+  label: "Clap",
+  description: "The hands come together fast (apart to touching within 0.25 s); ends when they part. Each clap counts.",
+  view: "upper",
+  limitKeys: ["clapApart", "clapTogether", "clapWithinMs", "clapRelease"],
+  defaults: { ...lt, cooldownMs: 100 },
+  createMemory: () => ({ apartAtMs: -1 / 0, clapped: !1 }),
+  inView: Be,
+  measure: (e, t, s, { limits: n }) => {
+    const i = Math.hypot(
+      Tt(e, "left", "x") - Tt(e, "right", "x"),
+      Tt(e, "left", "y") - Tt(e, "right", "y")
+    ) / e.shoulderWidth;
+    if (t.clapped) {
+      if (i < n.clapRelease) return X(null);
+      t.clapped = !1;
+    }
+    return i >= n.clapApart && (t.apartAtMs = s), i <= n.clapTogether && s - t.apartAtMs <= n.clapWithinMs ? (t.clapped = !0, t.apartAtMs = -1 / 0, X(null)) : $;
+  }
+}, zn = (e, t) => {
+  const s = e.joints[B(t, "Shoulder")], n = e.joints[B(t, "Elbow")], i = e.joints[B(t, "Wrist")], o = (a, l) => Math.hypot(a.x - l.x, a.y - l.y, 2 * (a.z - l.z)), r = o(s, n) + o(n, i);
+  return r < 0.1 * e.shoulderWidth ? null : o(s, i) / r;
+}, Ln = {
+  name: "punch",
+  label: "Punch",
+  description: "An arm snaps from bent to straight (within 0.2 s) at shoulder height, toward the camera or to the side; ends when it bends back.",
+  view: "upper",
+  sided: !0,
+  limitKeys: ["punchBent", "punchStraight", "punchWithinMs", "punchBand"],
+  defaults: { ...lt, cooldownMs: 150 },
+  createMemory: () => ({
+    left: { bentAtMs: -1 / 0, punching: !1 },
+    right: { bentAtMs: -1 / 0, punching: !1 }
+  }),
+  inView: He,
+  measure: (e, t, s, { side: n, limits: i }) => {
+    let o = null;
+    for (const r of It) {
+      const a = t[r];
+      if (!vt(r, n) || !Mt(e, r)) {
+        a.punching = !1, a.bentAtMs = -1 / 0;
+        continue;
+      }
+      const l = zn(e, r);
+      if (l === null) {
+        a.punching && (o ?? (o = r));
+        continue;
+      }
+      const u = e.joints[B(r, "Shoulder")], c = e.joints[B(r, "Wrist")], f = Math.abs(c.y - u.y) / e.shoulderWidth <= i.punchBand;
+      if (a.punching) {
+        if (l >= i.punchStraight - 0.1 && f) {
+          o ?? (o = r);
+          continue;
+        }
+        a.punching = !1;
+      }
+      l <= i.punchBent ? a.bentAtMs = s : l >= i.punchStraight && f && s - a.bentAtMs <= i.punchWithinMs && (a.punching = !0, a.bentAtMs = -1 / 0, o ?? (o = r));
+    }
+    return o ? X(o) : $;
+  }
+}, Kn = {
+  name: "armFlap",
+  label: "Flap your arms",
+  description: "Both arms, held out to the sides, beat down together (a wing stroke of 0.7 shoulder widths within 0.5 s). Each downstroke counts.",
+  view: "upper",
+  limitKeys: ["flapStroke", "flapWithinMs", "flapTop", "flapOut"],
+  defaults: { ...lt, cooldownMs: 100 },
+  createMemory: () => ({ left: new Vt(), right: new Vt(), flapping: !1 }),
+  inView: Be,
+  measure: (e, t, s, { limits: n }) => {
+    const { left: i, right: o } = e.shape.arms;
+    t.left.push(s, i.up), t.right.push(s, o.up);
+    const r = s - n.flapWithinMs, a = t.left.max(r), l = t.right.max(r), u = Math.min(a - i.up, l - o.up);
+    return t.flapping ? u >= n.flapStroke * 0.5 ? X(null) : (t.flapping = !1, $) : u >= n.flapStroke && Math.min(a, l) >= n.flapTop && i.out >= n.flapOut && o.out >= n.flapOut ? (t.flapping = !0, X(null)) : $;
+  }
+}, Gn = {
+  name: "kick",
+  label: "Kick",
+  description: "One foot swings up fast (forward or to the side) with the knee lifted and the lower leg raised, not hanging; ends when the foot is down.",
+  view: "full",
+  sided: !0,
+  limitKeys: ["kickLift", "kickKnee", "kickShin", "kickWithinMs"],
+  defaults: { ...lt, cooldownMs: 300 },
+  createMemory: () => ({
+    left: { downAtMs: -1 / 0, kicking: !1 },
+    right: { downAtMs: -1 / 0, kicking: !1 }
+  }),
+  inView: St,
+  measure: (e, t, s, { side: n, limits: i }) => {
+    const { joints: o, torso: r } = e;
+    let a = null;
+    for (const l of It) {
+      const u = t[l], c = o[B(l, "Knee")], f = o[B(l, "Ankle")], p = o[B(wt(l), "Knee")], g = o[B(wt(l), "Ankle")], w = (f.y - g.y) / r;
+      if (u.kicking) {
+        if (w > i.kickLift * 0.4) {
+          a ?? (a = l);
+          continue;
+        }
+        u.kicking = !1;
+      }
+      if (w <= i.kickLift * 0.3 && (u.downAtMs = s), !vt(l, n)) continue;
+      const T = p.y - g.y;
+      if (T <= 1e-4) continue;
+      const m = (c.y - p.y) / r, k = (c.y - f.y) / T;
+      w >= i.kickLift && m >= i.kickKnee && k <= i.kickShin && s - u.downAtMs <= i.kickWithinMs && (u.kicking = !0, a ?? (a = l));
+    }
+    return a ? X(a) : $;
+  }
+}, Yn = 150, ye = (e) => ({
+  name: e === "left" ? "stepLeft" : "stepRight",
+  label: e === "left" ? "Step to your left" : "Step to your right",
+  description: `Hips and both feet move to the person's own ${e} by half a shoulder width within 0.7 s; ends when the body settles.`,
+  view: "full",
+  limitKeys: ["stepShift", "stepWithinMs"],
+  defaults: { ...lt, cooldownMs: 300 },
+  createMemory: () => ({
+    hips: new Vt(),
+    feet: new Vt(),
+    stepping: !1,
+    peak: 0,
+    peakAtMs: 0
+  }),
+  inView: St,
+  measure: (t, s, n, { limits: i }) => {
+    const { joints: o } = t, r = (e === "left" ? 1 : -1) * t.leftward, a = r * (o.leftHip.x + o.rightHip.x) / 2, l = r * (o.leftAnkle.x + o.rightAnkle.x) / 2, u = t.shoulderWidth;
+    if (s.stepping) {
+      if (a > s.peak && (s.peak = a, s.peakAtMs = n), !(n - s.peakAtMs >= Yn || (s.peak - a) / u > 0.15)) return X(e);
+      s.stepping = !1, s.hips.clear(), s.feet.clear();
+    }
+    s.hips.push(n, a), s.feet.push(n, l);
+    const c = n - i.stepWithinMs, f = (a - s.hips.min(c)) / u, p = (l - s.feet.min(c)) / u;
+    return f >= i.stepShift && p >= i.stepShift * 0.8 ? (s.stepping = !0, s.peak = a, s.peakAtMs = n, X(e)) : $;
+  }
+}), Qn = {
+  name: "march",
+  label: "March in place",
+  description: "Knees (or feet) lift in turn, marching or running in place. Each alternating lift counts as one step; the first lift only starts the count.",
+  view: "full",
+  limitKeys: ["marchLift", "marchDrop", "marchWithinMs"],
+  defaults: { ...lt, cooldownMs: 0 },
+  createMemory: () => ({
+    up: { left: !1, right: !1 },
+    liftedAtMs: { left: -1 / 0, right: -1 / 0 },
+    stepping: null
+  }),
+  inView: St,
+  measure: (e, t, s, { limits: n }) => {
+    const { joints: i, torso: o } = e;
+    for (const r of It) {
+      const a = i[B(r, "Knee")], l = i[B(r, "Ankle")], u = i[B(wt(r), "Knee")], c = i[B(wt(r), "Ankle")], f = Math.max(a.y - u.y, l.y - c.y) / o;
+      t.up[r] ? f <= n.marchDrop && (t.up[r] = !1) : f >= n.marchLift && (t.up[r] = !0, s - t.liftedAtMs[wt(r)] <= n.marchWithinMs && (t.stepping = r), t.liftedAtMs[r] = s);
+    }
+    return t.stepping && !t.up[t.stepping] && (t.stepping = null), t.stepping ? X(t.stepping) : $;
+  }
+}, je = {
+  jump: qn,
+  squat: Pn,
+  wave: Un,
+  clap: Cn,
+  punch: Ln,
+  armFlap: Kn,
+  kick: Gn,
+  stepLeft: ye("left"),
+  stepRight: ye("right"),
+  march: Qn
+}, Oi = Object.keys(je), Yt = (e) => typeof e == "string" ? je[e] : e, $n = (e) => e ? { ...qt, ...e } : qt, Xn = Object.freeze({
+  enterThreshold: 0.6,
+  exitThreshold: 0.25,
+  holdMs: 150,
+  lostGraceMs: 250
+}), Jn = 80, Zn = (e) => {
+  if (typeof e == "function") return "upper";
+  const t = xe(e);
+  if (t) return t.view === "full" ? "full" : "upper";
+  const s = (n) => n.legs !== void 0 || n.squat !== void 0 || n.wideStance !== void 0 || n.lean !== void 0 && n.lean !== "none" || (n.anyOf ?? []).some(s);
+  return s(e) ? "full" : "upper";
+}, ti = (e) => {
+  var s;
+  if (e.move !== void 0) return Yt(e.move).name;
+  const t = e.pose;
+  return typeof t == "string" ? t : ((s = xe(t)) == null ? void 0 : s.label) ?? "pose";
+}, qe = (e, t = {}) => ie(
+  t,
+  ie(
+    e.move !== void 0 ? Yt(e.move).defaults : Xn
+  )
+), Pe = ({ side: e = "either", limits: t, ...s }) => ({
+  engine: s,
+  context: { side: e, limits: $n(t) }
+}), _i = (e, t = {}) => {
+  const s = ti(e), n = e.move !== void 0 ? Yt(e.move) : null, i = e.move !== void 0 ? null : e.pose, { engine: o, context: r } = Pe(t), a = cs(s);
+  return {
+    ...ve(a),
+    kind: n ? "move" : "pose",
+    view: n ? n.view : Zn(i),
+    inView: !1,
+    side: null,
+    pose: i,
+    move: n,
+    memory: n ? n.createMemory() : null,
+    memoryUsed: !1,
+    detector: a,
+    options: qe(e, o),
+    context: r,
+    sample: null,
+    sampleSide: null,
+    lastSampleMs: null
+  };
+}, Ri = (e, t, s = {}) => {
+  const { engine: n, context: i } = Pe(s);
+  e.options = qe(t, n), e.context = i;
+}, Ht = (e) => {
+  e.move && e.memoryUsed && (e.memory = e.move.createMemory(), e.memoryUsed = !1), e.lastSampleMs = null;
+}, ei = (e, t, s) => {
+  if (e.sampleSide = null, !t) {
+    e.inView = !1, e.sample = null, Ht(e);
+    return;
+  }
+  const n = e.sample ?? { value: 0, confidence: 0 };
+  if (e.sample = n, e.pose !== null) {
+    const a = t.shape.upperBodyVisible;
+    if (e.inView = a && (e.view !== "full" || t.shape.lowerBodyVisible), !a) {
+      Ht(e), n.value = 0, n.confidence = 0;
+      return;
+    }
+    const l = rs(t.shape, e.pose) ? 1 : 0;
+    n.value = e.lastSampleMs === null ? l : n.value + (l - n.value) * (1 - Math.exp(-(s - e.lastSampleMs) / Jn)), n.confidence = 1, e.lastSampleMs = s;
+    return;
+  }
+  const i = e.move, o = e.context;
+  if (e.inView = i.inView ? i.inView(t, o) : i.view === "full" ? t.fullInView && t.torso > 0 : t.upperInView, !e.inView) {
+    Ht(e), n.value = 0, n.confidence = 0;
+    return;
+  }
+  const r = i.measure(t, e.memory, s, o);
+  e.memoryUsed = !0, e.lastSampleMs = s, n.value = Number.isFinite(r.value) ? r.value : 0, n.confidence = 1, e.sampleSide = r.side ?? null;
+}, Vi = (e, t, s, n = !0) => {
+  (n || !t) && ei(e, t, s);
+  const i = hs(e.detector, e.sample, s, e.options);
+  return i.justBegan && (e.side = e.sampleSide), ve(i, e), e;
+}, Ii = (e, t) => {
+  const s = t ?? {};
+  return s.name = e.name, s.active = e.active, s.value = e.value, s.confidence = e.confidence, s.tracked = e.tracked, s.phase = e.phase, s.justBegan = e.justBegan, s.justEnded = e.justEnded, s.endReason = e.endReason, s.startedAtMs = e.startedAtMs, s.durationMs = e.durationMs, s.count = e.count, s.kind = e.kind, s.view = e.view, s.inView = e.inView, s.side = e.side, s;
+}, Wi = (e, t) => ls(e, t) && e.kind === t.kind && e.view === t.view && e.inView === t.inView && e.side === t.side;
+export {
+  $n as $,
+  yi as A,
+  Js as B,
+  Zs as C,
+  Tn as D,
+  An as E,
+  Ks as F,
+  wi as G,
+  Kt as H,
+  Mi as I,
+  Ee as J,
+  bt as K,
+  je as L,
+  qt as M,
+  Oi as N,
+  Dn as O,
+  fe as P,
+  Ei as Q,
+  fi as R,
+  U as S,
+  Re as T,
+  ot as U,
+  Vn as V,
+  Cs as W,
+  de as X,
+  We as Y,
+  Xn as Z,
+  Vt as _,
+  Ve as a,
+  qe as a0,
+  B as a1,
+  Lt as a2,
+  Xs as a3,
+  $s as a4,
+  tn as a5,
+  rn as a6,
+  en as a7,
+  nn as a8,
+  gi as a9,
+  cn as aa,
+  Te as ab,
+  Os as ac,
+  ps as ad,
+  ds as ae,
+  fs as af,
+  xs as ag,
+  be as ah,
+  Ms as ai,
+  ks as aj,
+  As as ak,
+  Se as al,
+  vs as am,
+  xt as an,
+  re as ao,
+  Bs as ap,
+  Ae as aq,
+  Hs as ar,
+  Is as as,
+  Ws as at,
+  kn as au,
+  Bt as av,
+  mn as aw,
+  ue as ax,
+  ki as b,
+  vi as c,
+  In as d,
+  Si as e,
+  bi as f,
+  Wn as g,
+  xi as h,
+  _i as i,
+  Ri as j,
+  Vi as k,
+  Wi as l,
+  Ai as m,
+  Ti as n,
+  qs as o,
+  Ls as p,
+  Rs as q,
+  Yt as r,
+  Ii as s,
+  _s as t,
+  Vs as u,
+  Es as v,
+  Ts as w,
+  ke as x,
+  Ys as y,
+  mi as z
+};