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

package/dist/FaceMeshRenderer-UuH5sTXG.js

@@ -0,0 +1,1322 @@
+import { jsx as M, jsxs as Ie, Fragment as et } from "react/jsx-runtime";
+import { useLoader as fe, useThree as Zt, useFrame as en } from "@react-three/fiber";
+import { useRef as m, useMemo as J, useState as tt, useCallback as Ye, useEffect as Fe } from "react";
+import * as k from "three";
+import { MathUtils as nt, Color as tn, Vector2 as qe } from "three";
+import { l as se, p as nn, X as rn, F as an } from "./index-CnGox6Xr.js";
+import { a as on, u as sn } from "./selectors-C5G1PMYL.js";
+import { s as cn, t as ln, p as dn, b as fn } from "./index-CsUdQ-pn.js";
+import { T as Me, c as un, a as hn } from "./index-Dw6tj2Mi.js";
+import { TransformControls as mn } from "@react-three/drei";
+const pn = (e) => {
+  const n = m(null);
+  if (n.current) {
+    const t = n.current;
+    Object.keys(e).forEach((r) => {
+      t[r].value = e[r];
+    });
+  } else {
+    const t = {};
+    Object.keys(e).forEach((r) => {
+      t[r] = { value: e[r] };
+    }), n.current = t;
+  }
+  return n.current;
+}, we = 8, Q = {
+  type: "linear",
+  stops: [
+    { offset: 0, color: "#38bdf8" },
+    { offset: 1, color: "#a78bfa" }
+  ],
+  angle: 0,
+  center: { x: 0.5, y: 0.5 },
+  radius: 0.5
+}, yn = (e) => {
+  const n = e.slice(0, we).map((t) => ({ ...t, offset: nt.clamp(t.offset, 0, 1) })).sort((t, r) => t.offset - r.offset);
+  return n.length >= 2 ? n : Q.stops.map((t) => ({ ...t }));
+}, gn = (e) => ({
+  ...Q,
+  ...e,
+  center: { ...Q.center, ...e == null ? void 0 : e.center },
+  radius: Math.max(0.01, (e == null ? void 0 : e.radius) ?? Q.radius),
+  stops: yn((e == null ? void 0 : e.stops) ?? Q.stops)
+}), bn = `
+  varying vec2 vPosition;
+  void main() {
+    vPosition = position.xy;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`, En = `
+  #define MAX_STOPS 8
+  uniform vec3 stopColors[MAX_STOPS];
+  uniform float stopOffsets[MAX_STOPS];
+  uniform int stopCount;
+  uniform int gradientType;
+  uniform vec2 direction;
+  uniform vec2 center;
+  uniform float radius;
+  uniform float angleOffset;
+  uniform float opacity;
+  varying vec2 vPosition;
+
+  vec3 sampleGradient(float amount) {
+    vec3 color = stopColors[0];
+    for (int index = 1; index < MAX_STOPS; index++) {
+      if (index >= stopCount) break;
+      if (amount <= stopOffsets[index]) {
+        float width = max(0.0001, stopOffsets[index] - stopOffsets[index - 1]);
+        return mix(stopColors[index - 1], stopColors[index], clamp((amount - stopOffsets[index - 1]) / width, 0.0, 1.0));
+      }
+      color = stopColors[index];
+    }
+    return color;
+  }
+
+  void main() {
+    vec2 delta = vPosition - center;
+    float amount;
+    if (gradientType == 1) {
+      amount = clamp(length(delta) / radius, 0.0, 1.0);
+    } else if (gradientType == 2) {
+      amount = fract(atan(delta.y, delta.x) / 6.28318530718 + 0.5 + angleOffset);
+    } else {
+      amount = clamp(dot(delta, direction) + 0.5, 0.0, 1.0);
+    }
+    gl_FragColor = vec4(sampleGradient(amount), opacity);
+  }
+`, Mn = { linear: 0, radial: 1, angular: 2 }, xn = ({ opacity: e = 1, value: n }) => {
+  const t = J(() => {
+    const a = gn(n), o = nt.degToRad(a.angle), s = a.stops.map((f) => new tn(f.color)), l = a.stops.map((f) => f.offset);
+    for (; s.length < we; ) s.push(s[s.length - 1]);
+    for (; l.length < we; ) l.push(1);
+    return {
+      stopColors: s,
+      stopOffsets: l,
+      stopCount: a.stops.length,
+      gradientType: Mn[a.type],
+      direction: new qe(Math.cos(o), Math.sin(o)),
+      center: new qe(a.center.x - 0.5, 0.5 - a.center.y),
+      radius: a.radius,
+      angleOffset: a.angle / 360,
+      opacity: e
+    };
+  }, [e, n]), r = pn(t);
+  return /* @__PURE__ */ M(
+    "shaderMaterial",
+    {
+      uniforms: r,
+      vertexShader: bn,
+      fragmentShader: En,
+      transparent: e < 1,
+      depthTest: !1,
+      depthWrite: !1,
+      toneMapped: !1
+    }
+  );
+}, vn = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO2YpZcAAAAASUVORK5CYII=", fr = {
+  source: "solid",
+  color: "#ffffff",
+  opacity: 1,
+  textureUrl: "",
+  gradient: Q
+}, rt = (e) => ({
+  ...Q,
+  stops: [
+    { offset: 0, color: "#ffffff" },
+    { offset: 1, color: e }
+  ]
+}), An = ({
+  depthTest: e,
+  depthWrite: n,
+  settings: t,
+  side: r,
+  toneMapped: a
+}) => {
+  const o = fe(
+    k.TextureLoader,
+    t.textureUrl || vn
+  );
+  return /* @__PURE__ */ M(
+    "meshBasicMaterial",
+    {
+      color: t.color,
+      map: o,
+      transparent: !0,
+      opacity: t.opacity,
+      side: r,
+      depthWrite: n,
+      depthTest: e,
+      toneMapped: a
+    }
+  );
+}, Sn = ({
+  depthTest: e = !1,
+  depthWrite: n = !1,
+  settings: t,
+  side: r,
+  toneMapped: a = !1
+}) => {
+  const o = J(
+    () => t.gradient ?? rt(t.color),
+    [t.color, t.gradient]
+  );
+  return t.source === "gradient" ? /* @__PURE__ */ M(xn, { value: o, opacity: t.opacity }) : t.source === "texture" ? /* @__PURE__ */ M(
+    An,
+    {
+      settings: t,
+      side: r,
+      depthTest: e,
+      depthWrite: n,
+      toneMapped: a
+    }
+  ) : /* @__PURE__ */ M(
+    "meshBasicMaterial",
+    {
+      color: t.color,
+      transparent: !0,
+      opacity: t.opacity,
+      side: r,
+      depthWrite: n,
+      depthTest: e,
+      toneMapped: a
+    }
+  );
+}, xe = Math.PI / 180, ve = 180 / Math.PI, W = (e) => Number(e.toFixed(6)), Je = {
+  enabled: !0,
+  linked: {
+    position: !1,
+    rotation: !1,
+    scale: !1
+  },
+  showTransformControls: !1,
+  transformControlMode: "translate",
+  transformControlSpace: "local",
+  position: { x: 0, y: 0, z: 0 },
+  rotation: { x: 0, y: 0, z: 0 },
+  scale: { x: 1, y: 1, z: 1 },
+  visible: !0
+}, ur = ({ children: e, objectRef: n, onChange: t, value: r }) => {
+  const a = m(null), o = m(n);
+  o.current = n;
+  const [s, l] = tt(null), f = Ye((i) => {
+    var u;
+    a.current = i, l(i), (u = o.current) == null || u.call(o, i);
+  }, []), d = Ye(() => {
+    const i = a.current;
+    !i || !t || t({
+      ...r,
+      position: {
+        x: W(i.position.x),
+        y: W(i.position.y),
+        z: W(i.position.z)
+      },
+      rotation: {
+        x: W(i.rotation.x * ve),
+        y: W(i.rotation.y * ve),
+        z: W(i.rotation.z * ve)
+      },
+      scale: {
+        x: W(i.scale.x),
+        y: W(i.scale.y),
+        z: W(i.scale.z)
+      }
+    });
+  }, [t, r]);
+  return r.enabled ? /* @__PURE__ */ Ie(et, { children: [
+    /* @__PURE__ */ M(
+      "group",
+      {
+        ref: f,
+        position: [r.position.x, r.position.y, r.position.z],
+        rotation: [
+          r.rotation.x * xe,
+          r.rotation.y * xe,
+          r.rotation.z * xe
+        ],
+        scale: [r.scale.x, r.scale.y, r.scale.z],
+        visible: r.visible,
+        children: e
+      }
+    ),
+    s && r.showTransformControls && /* @__PURE__ */ M(
+      mn,
+      {
+        object: s,
+        mode: r.transformControlMode,
+        space: r.transformControlSpace,
+        size: 0.85,
+        onMouseUp: d,
+        onObjectChange: d
+      }
+    )
+  ] }) : null;
+}, ae = (e) => Math.min(1, Math.max(0, e)), O = (e, n, t) => ae(1 - Math.abs(e - n) / t), Tn = (e) => {
+  let n = 1 / 0, t = -1 / 0, r = 1 / 0, a = -1 / 0;
+  for (const l of e)
+    n = Math.min(n, l.x), t = Math.max(t, l.x), r = Math.min(r, l.y), a = Math.max(a, l.y);
+  const o = Math.max(t - n, 1e-3), s = Math.max(a - r, 1e-3);
+  return {
+    centerX: n + o * 0.5,
+    centerY: r + s * 0.5,
+    width: o,
+    height: s
+  };
+}, Rn = (e) => e != null && e.enabled ? (e.strength ?? 1) !== 0 && Object.entries(e).some(
+  ([n, t]) => n !== "enabled" && n !== "strength" && typeof t == "number" && t !== 0
+) : !1, _n = (e, n, t, r) => {
+  const a = t.enabled ? t.strength ?? 1 : 0;
+  if (a === 0)
+    return r.x = e.x, r.y = e.y, r.z = e.z, r;
+  const o = (e.x - n.centerX) / n.width, s = (e.y - n.centerY) / n.height, l = Math.abs(o), f = ae((-s + 0.42) / 0.55), d = O(s, -0.02, 0.34), i = O(s, -0.24, 0.16) * ae((l - 0.05) / 0.28), u = O(s, 0.02, 0.26) * O(l, 0, 0.18), c = O(s, 0.29, 0.18) * O(l, 0, 0.36), p = ae((s - 0.16) / 0.36), h = d * O(l, 0.34, 0.22), A = f * O(l, 0, 0.48), x = O(s, -0.19, 0.1) * ae((l - 0.05) / 0.3), U = O(s, 0.48, 0.2) * O(l, 0, 0.26);
+  let g = e.x, b = e.y, R = e.z;
+  const S = (K, L = 1) => {
+    g += o * n.width * K * a * L;
+  }, E = (K, L = 1) => {
+    b += s * n.height * K * a * L;
+  };
+  S(t.faceWidth ?? 0), E(t.faceHeight ?? 0), S(t.faceRoundness ?? 0, d * (1 - l)), b -= n.height * (t.midfaceHeight ?? 0) * a * d * 0.25, E(-(t.foreheadHeight ?? 0), A), S(t.foreheadWidth ?? 0, A), S(
+    t.cheekboneWidth ?? 0,
+    O(s, -0.06, 0.16) * O(l, 0.34, 0.2)
+  ), S(t.cheekWidth ?? 0, h), S(t.jawWidth ?? 0, p), E(t.chinHeight ?? 0, U), b -= n.height * (t.scalpHeight ?? 0) * a * f * 0.3, R -= (t.midfaceDepth ?? 0) * a * d * 0.08, R += (t.cheekHollowness ?? 0) * a * h * 0.06, R -= (t.browDepth ?? 0) * a * x * 0.05, b -= n.height * (t.browHeight ?? 0) * a * x * 0.2, g += Math.sign(o || 1) * n.width * (t.browDistance ?? 0) * a * x * 0.16;
+  const _ = (t.headCurve ?? 0) * a * (s + 0.1);
+  R -= _ * _ * 0.04 * Math.sign(t.headCurve ?? 0), g += n.width * (t.faceTwist ?? 0) * a * s * 0.18;
+  const v = (t.faceSwirl ?? 0) * a * 0.22;
+  g += -s * n.width * v, b += o * n.height * v;
+  const F = o < 0 ? t.leftEyeSize ?? 0 : t.rightEyeSize ?? 0, N = ((t.eyeSize ?? 0) + F) * a * i;
+  g += o * n.width * N * 0.45, b += (s + 0.24) * n.height * N * 0.7, g += Math.sign(o || 1) * n.width * (t.eyeDistance ?? 0) * a * i * 0.2, g += n.width * (o < 0 ? t.leftEyeX ?? 0 : t.rightEyeX ?? 0) * a * i * 0.15, b += n.height * (o < 0 ? t.leftEyeY ?? 0 : t.rightEyeY ?? 0) * a * i * 0.15;
+  const $ = (t.noseSize ?? 0) * a * u;
+  return g += o * n.width * $ * 0.7, b += (s - 0.02) * n.height * $ * 0.5, b += n.height * (t.noseLength ?? 0) * a * u * Math.max(s + 0.08, 0) * 0.4, R -= (t.noseSize ?? 0) * a * u * 0.08, g += o * n.width * (t.mouthWidth ?? 0) * a * c, b += (s - 0.29) * n.height * (t.mouthHeight ?? 0) * a * c, r.x = g, r.y = b, r.z = R, r;
+}, Ae = /* @__PURE__ */ new Set([
+  61,
+  146,
+  91,
+  181,
+  84,
+  17,
+  314,
+  405,
+  321,
+  375,
+  291,
+  78,
+  95,
+  88,
+  178,
+  87,
+  14,
+  317,
+  402,
+  318,
+  324,
+  308,
+  191,
+  80,
+  81,
+  82,
+  13,
+  312,
+  311,
+  310,
+  415
+]), at = [
+  61,
+  146,
+  91,
+  181,
+  84,
+  17,
+  314,
+  405,
+  321,
+  375,
+  291,
+  409,
+  270,
+  269,
+  267,
+  0,
+  37,
+  39,
+  40,
+  185
+], Oe = [
+  78,
+  95,
+  88,
+  178,
+  87,
+  14,
+  317,
+  402,
+  318,
+  324,
+  308,
+  415,
+  310,
+  311,
+  312,
+  13,
+  82,
+  81,
+  80,
+  191
+], Se = new Set(Oe), Te = /* @__PURE__ */ new Set([
+  33,
+  7,
+  163,
+  144,
+  145,
+  153,
+  154,
+  155,
+  133,
+  173,
+  157,
+  158,
+  159,
+  160,
+  161,
+  246
+]), Re = /* @__PURE__ */ new Set([
+  362,
+  382,
+  381,
+  380,
+  374,
+  373,
+  390,
+  249,
+  263,
+  466,
+  388,
+  387,
+  386,
+  385,
+  384,
+  398
+]), Cn = /* @__PURE__ */ new Set([814, 815, 816, 817, 818, 819, 830, 831, 832, 833]), kn = (e, n, t) => {
+  const r = Ae.has(e) && Ae.has(n) && Ae.has(t), a = Te.has(e) && Te.has(n) && Te.has(t), o = Re.has(e) && Re.has(n) && Re.has(t);
+  return r ? "mouth" : a ? "leftEye" : o ? "rightEye" : "base";
+}, ue = (e, n) => e < n ? `${e}:${n}` : `${n}:${e}`, ot = (e) => e.map((n, t) => ue(n, e[(t + 1) % e.length])), st = ot(Oe), _e = /* @__PURE__ */ new Set([...ot(at), ...st]), Fn = (e) => {
+  const n = e.length / 3, t = /* @__PURE__ */ new Map(), r = (c, p) => e[c * 3 + p], a = (c) => {
+    const p = r(c, 0), h = r(c, 1), A = r(c, 2);
+    return [ue(p, h), ue(h, A), ue(A, p)];
+  }, o = (c) => Se.has(r(c, 0)) && Se.has(r(c, 1)) && Se.has(r(c, 2));
+  for (let c = 0; c < n; c += 1)
+    a(c).forEach((p) => {
+      const h = t.get(p);
+      h ? h.push(c) : t.set(p, [c]);
+    });
+  let s = -1;
+  for (const c of st) {
+    const p = (t.get(c) ?? []).find((h) => !o(h));
+    if (p !== void 0) {
+      s = p;
+      break;
+    }
+  }
+  if (s < 0) return [];
+  const l = /* @__PURE__ */ new Set([s]), f = [s], d = /* @__PURE__ */ new Map();
+  for (; f.length > 0; ) {
+    const c = f.pop();
+    a(c).forEach((p) => {
+      d.set(p, (d.get(p) ?? 0) + 1), !_e.has(p) && (t.get(p) ?? []).forEach((h) => {
+        l.has(h) || (l.add(h), f.push(h));
+      });
+    });
+  }
+  const i = [...d].filter(([, c]) => c === 1).map(([c]) => c);
+  return i.length === _e.size && i.every((c) => _e.has(c)) ? [...l].sort((c, p) => c - p).flatMap((c) => [r(c, 0), r(c, 1), r(c, 2)]) : [];
+}, wn = (e, n) => {
+  const t = new Float32Array(n).fill(1), r = /* @__PURE__ */ new Map(), a = (f, d) => {
+    r.has(f) || r.set(f, /* @__PURE__ */ new Set()), r.get(f).add(d);
+  };
+  for (let f = 0; f < e.length; f += 3) {
+    const [d, i, u] = [e[f], e[f + 1], e[f + 2]];
+    a(d, i), a(i, d), a(i, u), a(u, i), a(u, d), a(d, u);
+  }
+  const o = (f) => {
+    const d = /* @__PURE__ */ new Map(), i = f.filter((u) => r.has(u));
+    i.forEach((u) => d.set(u, 0));
+    for (let u = 0; u < i.length; u += 1) {
+      const c = i[u], p = d.get(c) + 1;
+      r.get(c).forEach((h) => {
+        d.has(h) || (d.set(h, p), i.push(h));
+      });
+    }
+    return d;
+  }, s = o(at), l = o(Oe);
+  return r.forEach((f, d) => {
+    const i = s.get(d) ?? 0, u = l.get(d) ?? 0;
+    t[d] = i + u === 0 ? 1 : i / (i + u);
+  }), t;
+}, Un = (e) => {
+  const n = [], t = [], r = [], a = [], o = [], s = [], l = [], f = [];
+  let d = 0, i = 0;
+  e.split(`
+`).forEach((x) => {
+    const U = x.trim();
+    if (!U) return;
+    if (U.startsWith("v ")) {
+      d += 1;
+      return;
+    }
+    if (U.startsWith("vt ")) {
+      const [, S, E] = U.split(/\s+/);
+      l.push([Number(S), Number(E)]);
+      return;
+    }
+    if (!U.startsWith("f ")) return;
+    const g = i;
+    i += 1;
+    const [, ...b] = U.split(/\s+/), R = b.map((S) => {
+      const [E, _] = S.split("/"), v = Number(E) - 1, F = Number(_) - 1;
+      return F >= 0 && l[F] && !f[v] && (f[v] = l[F]), v;
+    });
+    if (!(R.length < 3))
+      for (let S = 1; S < R.length - 1; S += 1) {
+        const E = R[0], _ = R[S], v = R[S + 1];
+        n.push(E, _, v);
+        const F = kn(E, _, v);
+        Cn.has(g) ? s.push(E, _, v) : F === "mouth" ? r.push(E, _, v) : F === "leftEye" ? a.push(E, _, v) : F === "rightEye" ? o.push(E, _, v) : t.push(E, _, v);
+      }
+  });
+  const u = [];
+  for (let x = 0; x < d; x += 1) {
+    const [U, g] = f[x] ?? [0, 0];
+    u.push(U, g);
+  }
+  const c = new Uint16Array(a), p = new Uint16Array(o), h = new Uint16Array(a.length + o.length);
+  h.set(c), h.set(p, c.length);
+  const A = Fn(n);
+  return {
+    baseIndices: new Uint16Array(t),
+    mouthIndices: new Uint16Array(r),
+    lipIndices: new Uint16Array(A),
+    lipEdgeDistance: wn(A, d),
+    leftEyeIndices: c,
+    rightEyeIndices: p,
+    eyeIndices: h,
+    noseIndices: new Uint16Array(s),
+    uvs: new Float32Array(u),
+    vertexCount: d
+  };
+}, In = "canonical_face_model.obj", On = new TextDecoder("utf-8"), Ce = /* @__PURE__ */ new Map(), Ln = (e) => {
+  const n = Ce.get(e);
+  if (n) return n;
+  const t = nn(e).then((r) => Un(On.decode(r))).catch((r) => {
+    throw Ce.delete(e), r;
+  });
+  return Ce.set(e, t), t;
+}, Dn = (e) => {
+  const { mesh: n, url: t } = e ?? {}, r = t ?? `${se.sdkAssetsBaseUrl}/${In}`, [a, o] = tt(n ?? null);
+  return Fe(() => {
+    if (n) {
+      o(n);
+      return;
+    }
+    let s = !1;
+    return Ln(r).then((l) => {
+      s || o(l);
+    }).catch((l) => {
+      s || console.error(`${se.loggerPrefix} canonical face mesh load failed`, l);
+    }), () => {
+      s = !0;
+    };
+  }, [n, r]), a;
+}, C = {
+  basic: "basic",
+  standard: "standard",
+  physical: "physical",
+  toon: "toon",
+  normal: "normal",
+  matcap: "matcap",
+  wireframe: "wireframe",
+  shader: "shader"
+}, V = {
+  originalFace: "originalFace",
+  composite: "composite"
+}, j = {
+  none: "none",
+  canonical: "canonical",
+  style2: "style2"
+}, ee = {
+  none: "none",
+  canonical: "canonical"
+}, ce = {
+  solid: "solid",
+  gradient: "gradient",
+  imageUrl: "imageUrl",
+  mediaUrl: "mediaUrl"
+}, oe = {
+  front: "front",
+  back: "back",
+  double: "double"
+}, ct = {
+  normal: "normal",
+  add: "add",
+  subtract: "subtract",
+  multiply: "multiply",
+  screen: "screen",
+  overlay: "overlay",
+  softLight: "softLight",
+  hardLight: "hardLight",
+  lighten: "lighten",
+  darken: "darken",
+  difference: "difference",
+  exclusion: "exclusion"
+}, Pn = {
+  textureMap: j.canonical,
+  alphaMap: ee.canonical,
+  alphaOpacity: 1
+}, Qe = {
+  ...Pn,
+  blendMode: ct.hardLight,
+  blendOpacity: 0.85,
+  baseColor: "#ffffff",
+  opacity: 1,
+  compositeShading: !0
+}, P = {
+  materialType: C.basic,
+  shaderPreset: V.originalFace,
+  textureMap: j.none,
+  alphaMap: ee.none,
+  alphaOpacity: 1,
+  side: oe.front,
+  blendMode: ct.normal,
+  blendOpacity: 1,
+  baseColor: "#38bdf8",
+  opacity: 0.45,
+  compositeShading: !1
+};
+C.shader, V.composite, oe.front;
+const ke = {
+  mouth: !0,
+  eyes: !0,
+  nose: !0
+}, te = {
+  textureSource: ce.solid,
+  color: "#111111",
+  opacity: 0.5
+}, Nn = 24, it = 10, Le = (e, n, t) => e !== C.shader ? "none" : n === V.originalFace ? "originalFace" : n === V.composite ? t === j.none ? "originalFace" : "composite" : "none", hr = (e, n) => e === C.basic || e === C.standard || e === C.physical || e === C.toon || e === C.shader && n === V.composite, mr = (e, n, t = j.canonical) => Le(e, n, t) === "composite", Gn = (e, n, t) => Le(e, n, t) === "originalFace", Ue = (e) => e === ce.imageUrl || e === ce.mediaUrl, zn = (e) => e === ce.solid || e === ce.gradient, Ze = {
+  normal: 0,
+  add: 1,
+  subtract: 2,
+  multiply: 3,
+  screen: 4,
+  overlay: 5,
+  softLight: 6,
+  hardLight: 7,
+  lighten: 8,
+  darken: 9,
+  difference: 10,
+  exclusion: 11
+}, Hn = `
+  attribute vec2 faceUv;
+  varying vec2 vUv;
+  varying vec2 vFaceUv;
+  varying vec3 vNormal;
+
+  void main() {
+    vUv = uv;
+    vFaceUv = faceUv;
+    vNormal = normalize(normalMatrix * normal);
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`, Bn = `
+  uniform sampler2D cameraTexture;
+  uniform sampler2D canonicalTexture;
+  uniform sampler2D alphaMask;
+  uniform vec3 textureTint;
+  uniform float opacity;
+  uniform int blendMode;
+  uniform float blendOpacity;
+  uniform float useCanonicalTexture;
+  uniform float useAlphaMask;
+  uniform float alphaOpacity;
+  uniform float compositeShading;
+  uniform vec3 lightDirection;
+  uniform float ambientStrength;
+  uniform float directionalStrength;
+  varying vec2 vUv;
+  varying vec2 vFaceUv;
+  varying vec3 vNormal;
+
+  vec3 linearToSrgb(vec3 value) {
+    vec3 low = value * 12.92;
+    vec3 high = 1.055 * pow(max(value, vec3(0.0)), vec3(1.0 / 2.4)) - 0.055;
+    return mix(high, low, step(value, vec3(0.0031308)));
+  }
+
+  vec3 srgbToLinear(vec3 value) {
+    vec3 low = value / 12.92;
+    vec3 high = pow(max((value + 0.055) / 1.055, vec3(0.0)), vec3(2.4));
+    return mix(high, low, step(value, vec3(0.04045)));
+  }
+
+  float overlayChannel(float base, float blend) {
+    return base < 0.5 ? 2.0 * base * blend : 1.0 - 2.0 * (1.0 - base) * (1.0 - blend);
+  }
+
+  float hardLightChannel(float base, float blend) {
+    return blend < 0.5 ? 2.0 * base * blend : 1.0 - 2.0 * (1.0 - base) * (1.0 - blend);
+  }
+
+  float softLightChannel(float base, float blend) {
+    if (blend <= 0.5) {
+      return base - (1.0 - 2.0 * blend) * base * (1.0 - base);
+    }
+
+    float d = base <= 0.25
+      ? ((16.0 * base - 12.0) * base + 4.0) * base
+      : sqrt(base);
+
+    return base + (2.0 * blend - 1.0) * (d - base);
+  }
+
+  vec3 applyBlendMode(vec3 base, vec3 blend, int mode) {
+    if (mode == 0) return blend;
+    if (mode == 1) return min(base + blend, 1.0);
+    if (mode == 2) return max(base - blend, 0.0);
+    if (mode == 3) return base * blend;
+    if (mode == 4) return 1.0 - (1.0 - base) * (1.0 - blend);
+    if (mode == 5) {
+      return vec3(
+        overlayChannel(base.r, blend.r),
+        overlayChannel(base.g, blend.g),
+        overlayChannel(base.b, blend.b)
+      );
+    }
+    if (mode == 6) {
+      return vec3(
+        softLightChannel(base.r, blend.r),
+        softLightChannel(base.g, blend.g),
+        softLightChannel(base.b, blend.b)
+      );
+    }
+    if (mode == 7) {
+      return vec3(
+        hardLightChannel(base.r, blend.r),
+        hardLightChannel(base.g, blend.g),
+        hardLightChannel(base.b, blend.b)
+      );
+    }
+    if (mode == 8) return max(base, blend);
+    if (mode == 9) return min(base, blend);
+    if (mode == 10) return abs(base - blend);
+    return base + blend - 2.0 * base * blend;
+  }
+
+  void main() {
+    vec3 base = linearToSrgb(texture2D(cameraTexture, vFaceUv).rgb);
+    vec4 textureSample = texture2D(canonicalTexture, vUv);
+    vec3 blend = linearToSrgb(textureSample.rgb) * textureTint;
+    float light = ambientStrength + max(dot(normalize(vNormal), normalize(lightDirection)), 0.0) * directionalStrength;
+    blend *= mix(1.0, clamp(light, 0.35, 1.35), compositeShading);
+    float maskSample = texture2D(alphaMask, vUv).r;
+    float mask = useAlphaMask > 0.5 ? mix(1.0, maskSample, alphaOpacity) : 1.0;
+    float textureAlpha = useCanonicalTexture > 0.5 ? textureSample.a : 1.0;
+    vec3 blended = applyBlendMode(base, blend, blendMode);
+    vec3 color = useCanonicalTexture > 0.5 ? mix(base, blended, blendOpacity) : base;
+    gl_FragColor = vec4(srgbToLinear(color), opacity * mask * textureAlpha);
+    // Blending above runs in sRGB; the result is linear here and three only
+    // encodes built-in materials, so encode for the output colour space.
+    #include <colorspace_fragment>
+  }
+`, Wn = ({
+  alphaMap: e,
+  alphaOpacity: n,
+  blendMode: t,
+  blendOpacity: r,
+  cameraTexture: a,
+  color: o,
+  compositeShading: s,
+  faceAlphaMaskUrl: l,
+  faceTextureStyle2Url: f,
+  faceTextureUrl: d,
+  masked: i = !1,
+  maskColor: u,
+  maskOpacity: c,
+  maskSourceUrl: p,
+  maskTextureSource: h,
+  materialType: A,
+  opacity: x,
+  shaderPreset: U,
+  side: g,
+  textureMap: b
+}) => {
+  const R = fe(
+    k.TextureLoader,
+    d || Me
+  ), S = fe(
+    k.TextureLoader,
+    f || d || Me
+  ), E = fe(
+    k.TextureLoader,
+    l || Me
+  ), _ = J(() => un(), []), v = J(() => hn(), []);
+  Fe(
+    () => () => {
+      _.dispose(), v.dispose();
+    },
+    [v, _]
+  );
+  const F = b === j.style2 ? S : R, N = b !== j.none, $ = Le(A, U, b), K = [
+    "composite-material",
+    b,
+    e,
+    n,
+    t,
+    r,
+    s ? "lit" : "flat",
+    o,
+    x,
+    d,
+    f,
+    l
+  ].join("|"), L = {
+    side: g,
+    transparent: !0,
+    opacity: x,
+    wireframe: !1
+  }, he = J(
+    () => ({
+      source: Ue(h) ? "texture" : h,
+      color: zn(h) ? u : "#ffffff",
+      opacity: c,
+      textureUrl: Ue(h) ? p : "",
+      gradient: rt(u)
+    }),
+    [u, c, p, h]
+  ), w = J(
+    () => ({
+      cameraTexture: { value: null },
+      canonicalTexture: { value: null },
+      alphaMask: { value: null },
+      textureTint: { value: new k.Color(o) },
+      opacity: { value: x },
+      blendMode: { value: Ze[t] },
+      blendOpacity: { value: r },
+      useCanonicalTexture: { value: N ? 1 : 0 },
+      useAlphaMask: { value: e === ee.canonical ? 1 : 0 },
+      alphaOpacity: { value: n },
+      compositeShading: { value: s ? 1 : 0 },
+      lightDirection: { value: new k.Vector3(0.3, 0.65, 0.7).normalize() },
+      ambientStrength: { value: 0.78 },
+      directionalStrength: { value: 0.38 }
+    }),
+    [
+      e,
+      n,
+      t,
+      r,
+      o,
+      s,
+      N,
+      x
+    ]
+  );
+  if (Fe(() => {
+    w.cameraTexture.value = a ?? R, w.canonicalTexture.value = F, w.alphaMask.value = E, w.textureTint.value.set(o), w.opacity.value = x, w.blendMode.value = Ze[t], w.blendOpacity.value = r, w.useCanonicalTexture.value = N ? 1 : 0, w.useAlphaMask.value = e === ee.canonical ? 1 : 0, w.alphaOpacity.value = n, w.compositeShading.value = s ? 1 : 0;
+  }, [
+    e,
+    E,
+    n,
+    t,
+    r,
+    a,
+    o,
+    s,
+    w,
+    R,
+    N,
+    x,
+    F
+  ]), i)
+    return /* @__PURE__ */ M(
+      Sn,
+      {
+        settings: he,
+        side: g
+      },
+      `masked-${h}-material`
+    );
+  if (A === C.wireframe)
+    return /* @__PURE__ */ M(
+      "meshBasicMaterial",
+      {
+        color: o,
+        transparent: !0,
+        opacity: x,
+        side: g,
+        depthWrite: !1,
+        depthTest: !1,
+        wireframe: !0,
+        toneMapped: !1
+      },
+      "wireframe-material"
+    );
+  if ($ === "originalFace" && a)
+    return /* @__PURE__ */ M(
+      "meshBasicMaterial",
+      {
+        map: a,
+        alphaMap: E,
+        transparent: !0,
+        opacity: x,
+        side: g,
+        depthWrite: !1,
+        depthTest: !0,
+        toneMapped: !1
+      },
+      "use-original-face-material"
+    );
+  if ($ === "composite" && a)
+    return /* @__PURE__ */ M(
+      "shaderMaterial",
+      {
+        uniforms: w,
+        vertexShader: Hn,
+        fragmentShader: Bn,
+        transparent: !0,
+        side: g,
+        depthWrite: !1,
+        depthTest: !0,
+        toneMapped: !1
+      },
+      K
+    );
+  const Z = N ? F : null, Y = e === ee.canonical && n > 0 ? E : null, X = `${A}-${b}-${e}-${n > 0 ? "alpha-on" : "alpha-off"}`;
+  return A === C.standard ? /* @__PURE__ */ M(
+    "meshStandardMaterial",
+    {
+      ...L,
+      color: o,
+      map: Z ?? void 0,
+      alphaMap: Y ?? void 0,
+      depthWrite: !0,
+      depthTest: !0,
+      metalness: 0.05,
+      roughness: 0.72
+    },
+    X
+  ) : A === C.physical ? /* @__PURE__ */ M(
+    "meshPhysicalMaterial",
+    {
+      ...L,
+      color: o,
+      map: Z ?? void 0,
+      alphaMap: Y ?? void 0,
+      depthWrite: !0,
+      depthTest: !0,
+      roughness: 0.58,
+      metalness: 0.08,
+      clearcoat: 0.35,
+      clearcoatRoughness: 0.4
+    },
+    X
+  ) : A === C.toon ? /* @__PURE__ */ M(
+    "meshToonMaterial",
+    {
+      ...L,
+      color: o,
+      map: Z ?? void 0,
+      alphaMap: Y ?? void 0,
+      gradientMap: _,
+      depthWrite: !0,
+      depthTest: !0
+    },
+    X
+  ) : A === C.normal ? /* @__PURE__ */ M(
+    "meshNormalMaterial",
+    {
+      ...L,
+      depthWrite: !0,
+      depthTest: !0,
+      flatShading: !1
+    },
+    "normal-material"
+  ) : A === C.matcap ? /* @__PURE__ */ M(
+    "meshMatcapMaterial",
+    {
+      ...L,
+      color: o,
+      matcap: v,
+      depthWrite: !0,
+      depthTest: !0
+    },
+    "matcap-material"
+  ) : /* @__PURE__ */ M(
+    "meshBasicMaterial",
+    {
+      ...L,
+      color: o,
+      map: Z ?? void 0,
+      alphaMap: Y ?? void 0,
+      depthWrite: !1,
+      depthTest: b !== j.none || e !== ee.none,
+      toneMapped: !1
+    },
+    X
+  );
+}, Xn = [
+  {
+    key: "base",
+    getIndices: (e) => e.baseIndices,
+    masked: !1,
+    renderOrderOffset: 0
+  },
+  {
+    key: "mouth",
+    getIndices: (e) => e.mouthIndices,
+    masked: !1,
+    renderOrderOffset: 2
+  },
+  {
+    key: "lips",
+    getIndices: (e) => e.lipIndices,
+    masked: !1,
+    renderOrderOffset: 3
+  },
+  {
+    key: "left-eye",
+    getIndices: (e) => e.leftEyeIndices,
+    masked: !1,
+    renderOrderOffset: 2
+  },
+  {
+    key: "right-eye",
+    getIndices: (e) => e.rightEyeIndices,
+    masked: !1,
+    renderOrderOffset: 2
+  },
+  {
+    key: "nose",
+    getIndices: (e) => e.noseIndices,
+    masked: !1,
+    renderOrderOffset: 2
+  },
+  {
+    key: "mouth-mask",
+    getIndices: (e) => e.mouthIndices,
+    masked: !0,
+    renderOrderOffset: 3
+  },
+  {
+    key: "left-eye-mask",
+    getIndices: (e) => e.leftEyeIndices,
+    masked: !0,
+    renderOrderOffset: 3
+  },
+  {
+    key: "right-eye-mask",
+    getIndices: (e) => e.rightEyeIndices,
+    masked: !0,
+    renderOrderOffset: 3
+  },
+  {
+    key: "nose-mask",
+    getIndices: (e) => e.noseIndices,
+    masked: !0,
+    renderOrderOffset: 3
+  }
+], Vn = {
+  [oe.front]: k.FrontSide,
+  [oe.back]: k.BackSide,
+  [oe.double]: k.DoubleSide
+}, jn = (e) => ({
+  position: new k.BufferAttribute(new Float32Array(e.vertexCount * 3), 3),
+  uv: new k.BufferAttribute(new Float32Array(e.uvs), 2),
+  faceUv: new k.BufferAttribute(new Float32Array(e.vertexCount * 2), 2),
+  lipEdge: new k.BufferAttribute(new Float32Array(e.lipEdgeDistance), 1)
+}), $n = (e, n, t) => {
+  e.setAttribute("position", n.position), e.setAttribute("uv", n.uv), e.setAttribute("faceUv", n.faceUv), e.setAttribute("lipEdge", n.lipEdge), e.setIndex(new k.BufferAttribute(t, 1));
+}, Kn = ({
+  faceIndex: e = 0,
+  baseColor: n,
+  color: t = P.baseColor,
+  opacity: r = P.opacity,
+  materialType: a = P.materialType,
+  shaderPreset: o = P.shaderPreset,
+  textureMap: s = P.textureMap,
+  alphaMap: l = P.alphaMap,
+  alphaOpacity: f = P.alphaOpacity,
+  side: d = P.side,
+  blendMode: i = P.blendMode,
+  blendOpacity: u = P.blendOpacity,
+  showOverlayMask: c = !1,
+  showMouthMask: p = ke.mouth,
+  showEyeMask: h = ke.eyes,
+  showLeftEyeMask: A,
+  showRightEyeMask: x,
+  showNoseMask: U = ke.nose,
+  showEyeGeometry: g = !0,
+  showLeftEyeGeometry: b,
+  showRightEyeGeometry: R,
+  showMouthGeometry: S = !0,
+  // The lips mesh is an effect-only overlay. Rendering it with the base face
+  // mesh duplicates an incomplete triangulation over the mouth.
+  showLipsGeometry: E = !1,
+  showBaseGeometry: _ = !0,
+  showNoseGeometry: v = !0,
+  maskTextureSource: F = te.textureSource,
+  maskSourceUrl: N = "",
+  maskColor: $ = te.color,
+  maskOpacity: K = te.opacity,
+  faceTextureUrl: L = "",
+  faceTextureStyle2Url: he = "",
+  faceAlphaMaskUrl: w = "",
+  compositeShading: Z = !1,
+  faceWarp3D: Y,
+  transform: X,
+  renderOrder: lt = it,
+  externalScale: me = 1,
+  mesh: dt,
+  meshUrl: ft,
+  materialOverride: ne,
+  maxUpdateFps: ut,
+  holdMs: De = 250,
+  predictMs: Pe = 0
+}) => {
+  const pe = on(rn.FACE_TRACKER), Ne = sn(), { camera: ht } = Zt(), G = Dn({ mesh: dt, url: ft }), Ge = m(null), mt = m(null), pt = m(null), yt = m(null), gt = m(null), bt = m(null), Et = m(null), Mt = m(null), xt = m(null), vt = m(null), At = m(null), St = m(null), Tt = m(null), Rt = m(null), _t = m(null), Ct = m(null), kt = m(null), Ft = m(null), wt = m(null), Ut = m(null), I = J(
+    () => G ? jn(G) : null,
+    [G]
+  ), ze = m(null), He = m(-1 / 0), ie = m(null);
+  ie.current || (ie.current = new an({ holdMs: De, predictMs: Pe })), ie.current.setOptions({ holdMs: De, predictMs: Pe });
+  const It = m(new k.Vector3()), Ot = m({ x: 0, y: 0, z: 0 }), Lt = m({ x: 0, y: 0, z: 0 }), Dt = m({ x: 0, y: 0, z: 0 }), le = m(!1), Pt = Vn[d], Nt = n ?? t, Gt = b ?? g, zt = R ?? g, Ht = c || (A ?? h), Bt = c || (x ?? h), Wt = c || p, Xt = c || U, Vt = {
+    base: Ge,
+    mouth: mt,
+    lips: pt,
+    "left-eye": yt,
+    "right-eye": gt,
+    nose: bt,
+    "mouth-mask": Et,
+    "left-eye-mask": Mt,
+    "right-eye-mask": xt,
+    "nose-mask": vt
+  }, jt = {
+    base: At,
+    mouth: St,
+    lips: Tt,
+    "left-eye": Rt,
+    "right-eye": _t,
+    nose: Ct,
+    "mouth-mask": kt,
+    "left-eye-mask": Ft,
+    "right-eye-mask": wt,
+    "nose-mask": Ut
+  }, $t = {
+    base: _,
+    mouth: S,
+    lips: E,
+    "left-eye": Gt,
+    "right-eye": zt,
+    nose: v,
+    "mouth-mask": Wt,
+    "left-eye-mask": Ht,
+    "right-eye-mask": Bt,
+    "nose-mask": Xt
+  }, Kt = (T) => /* @__PURE__ */ M(
+    Wn,
+    {
+      alphaMap: l,
+      alphaOpacity: f,
+      blendMode: i,
+      blendOpacity: u,
+      cameraTexture: Ne,
+      color: Nt,
+      compositeShading: Z,
+      faceAlphaMaskUrl: w,
+      faceTextureStyle2Url: he,
+      faceTextureUrl: L,
+      masked: T,
+      maskColor: $,
+      maskOpacity: K,
+      maskSourceUrl: N,
+      maskTextureSource: F,
+      materialType: a,
+      opacity: r,
+      shaderPreset: o,
+      side: Pt,
+      textureMap: s
+    }
+  ), q = Xn.map(
+    (T) => ({
+      ...T,
+      geometryRef: Vt[T.key],
+      meshRef: jt[T.key],
+      visible: $t[T.key]
+    })
+  ), Yt = (T) => dn(T, ht, It.current);
+  return en((T) => {
+    var je, $e;
+    const B = Ge.current, re = ($e = (je = pe == null ? void 0 : pe.detectionResults) == null ? void 0 : je.faceLandmarks) == null ? void 0 : $e[e], qt = q.every(
+      (y) => y.geometryRef.current && y.meshRef.current
+    );
+    if (!G || !I || !B || !qt) return;
+    const z = ie.current.update(
+      [re ?? []],
+      T.clock.elapsedTime * 1e3
+    )[0];
+    if (!z || z.length < G.vertexCount) {
+      q.forEach((y) => {
+        y.meshRef.current.visible = !1;
+      });
+      return;
+    }
+    if ((ze.current !== G || q.some((y) => !y.geometryRef.current.index)) && (q.forEach((y) => {
+      $n(y.geometryRef.current, I, y.getIndices(G));
+    }), I.uv.needsUpdate = !0, I.lipEdge.needsUpdate = !0, ze.current = G, le.current = !1), cn(T.clock.elapsedTime, He.current, ut)) return;
+    He.current = T.clock.elapsedTime;
+    const ye = I.position.array, Be = I.faceUv.array, ge = I.uv.array, We = Gn(a, o, s), Xe = Rn(Y), Ve = Xe ? Tn(z) : null, D = X ? Dt.current : null;
+    if (D) {
+      D.x = 0, D.y = 0, D.z = 0;
+      for (let y = 0; y < z.length; y++) {
+        const H = z[y];
+        D.x += H.x, D.y += H.y, D.z += H.z;
+      }
+      D.x /= z.length, D.y /= z.length, D.z /= z.length;
+    }
+    const Jt = Math.min(z.length, G.vertexCount);
+    for (let y = 0; y < Jt; y++) {
+      const H = z[y], Ke = Xe && Ve ? _n(H, Ve, Y, Ot.current) : H, Qt = X && D ? ln(
+        Ke,
+        D,
+        X,
+        Lt.current
+      ) : Ke, be = y * 3, de = y * 2, Ee = Yt(Qt);
+      ye[be] = Ee.x, ye[be + 1] = Ee.y, ye[be + 2] = Ee.z, Be[de] = H.x, Be[de + 1] = 1 - H.y, We && (ge[de] = H.x, ge[de + 1] = 1 - H.y);
+    }
+    We ? (B.attributes.uv.needsUpdate = !0, le.current = !0) : le.current && (ge.set(G.uvs), B.attributes.uv.needsUpdate = !0, le.current = !1), q.forEach((y) => {
+      y.meshRef.current.visible = y.visible;
+    }), B.attributes.position.needsUpdate = !0, B.attributes.faceUv.needsUpdate = !0, q.forEach((y) => {
+      y.geometryRef.current.computeVertexNormals();
+    });
+  }), /* @__PURE__ */ M("group", { scale: [me, me, me], children: q.map((T) => {
+    const B = ne ? typeof ne == "function" ? ne({
+      cameraTexture: Ne ?? null,
+      geometryKey: T.key,
+      faceUv: (I == null ? void 0 : I.faceUv) ?? null,
+      lipEdge: (I == null ? void 0 : I.lipEdge) ?? null
+    }) : ne : void 0, re = B instanceof k.Material ? B : void 0;
+    return /* @__PURE__ */ Ie(
+      "mesh",
+      {
+        ref: T.meshRef,
+        renderOrder: lt + T.renderOrderOffset,
+        frustumCulled: !1,
+        material: re,
+        children: [
+          /* @__PURE__ */ M("bufferGeometry", { ref: T.geometryRef }),
+          re ? null : ne ? B : Kt(T.masked)
+        ]
+      },
+      `${T.key}:${re ? "instance" : "node"}`
+    );
+  }) });
+}, Yn = `${se.sdkAssetsBaseUrl}/Canonical_Face_Color.png`, qn = `${se.sdkAssetsBaseUrl}/Canonical_Face_Color_style_2.png`, Jn = `${se.sdkAssetsBaseUrl}/Canonical_Face_Color_Mask.png`, Qn = {
+  ...Je,
+  position: { ...Je.position, y: 1e-3 }
+}, pr = {
+  enabled: !0,
+  faceIndex: 0,
+  targetFps: Nn,
+  ...P,
+  showLeftEyeGeometry: !0,
+  showRightEyeGeometry: !0,
+  showMouthGeometry: !0,
+  showNoseGeometry: !0,
+  externalScale: 1,
+  showOverlayMask: !1,
+  showMouthMask: !1,
+  showLeftEyeMask: !1,
+  showRightEyeMask: !1,
+  showNoseMask: !1,
+  maskTextureSource: te.textureSource,
+  maskSourceUrl: "",
+  maskColor: te.color,
+  maskOpacity: te.opacity,
+  faceTextureUrl: Yn,
+  faceTextureStyle2Url: qn,
+  faceAlphaMaskUrl: Jn,
+  renderOrder: it
+}, Zn = (e) => {
+  const { externalMeshUrl: n, ...t } = e;
+  return { ...t, color: t.baseColor, meshUrl: n };
+}, er = ({
+  materialOverride: e,
+  value: n
+}) => ({
+  ...Zn(n),
+  materialOverride: e
+}), yr = (e, n) => {
+  const t = { ...e, ...n };
+  return n.maskTextureSource && !Ue(n.maskTextureSource) && (t.maskSourceUrl = ""), t.materialType === C.shader && n.shaderPreset === V.composite ? {
+    ...t,
+    ...Qe,
+    materialType: C.shader,
+    shaderPreset: V.composite
+  } : t.materialType === C.shader && t.shaderPreset === V.composite && t.textureMap === j.none ? {
+    ...t,
+    textureMap: Qe.textureMap
+  } : t;
+}, gr = ({ transform: e, value: n, materialOverride: t }) => n.enabled ? /* @__PURE__ */ Ie(et, { children: [
+  /* @__PURE__ */ M(
+    fn,
+    {
+      active: n.enabled,
+      faceIndex: n.faceIndex,
+      numFaces: n.faceIndex + 1,
+      targetFps: n.targetFps
+    }
+  ),
+  /* @__PURE__ */ M(
+    Kn,
+    {
+      ...er({ value: n, materialOverride: t }),
+      transform: e ?? Qn
+    }
+  )
+] }) : null;
+export {
+  Q as A,
+  gn as B,
+  at as C,
+  P as D,
+  Je as E,
+  C as F,
+  fr as G,
+  rt as H,
+  we as I,
+  zn as J,
+  Ue as K,
+  Sn as M,
+  xn as S,
+  ur as T,
+  V as a,
+  oe as b,
+  j as c,
+  ee as d,
+  ct as e,
+  ce as f,
+  Oe as g,
+  Kn as h,
+  Ze as i,
+  pr as j,
+  Qn as k,
+  ke as l,
+  mr as m,
+  Wn as n,
+  gr as o,
+  Jn as p,
+  qn as q,
+  Yn as r,
+  hr as s,
+  Xn as t,
+  Dn as u,
+  er as v,
+  Zn as w,
+  yr as x,
+  Un as y,
+  pn as z
+};