@vincentt-xr/sdk 2.0.0-alpha.0

package/dist/face-effects.js

@@ -0,0 +1,3542 @@
+import * as R from "three";
+import { TrianglesDrawMode as $t, TriangleFanDrawMode as tt, TriangleStripDrawMode as _t, Loader as Jt, LoaderUtils as xe, FileLoader as Lt, MeshPhysicalMaterial as X, Vector2 as It, Color as se, LinearSRGBColorSpace as V, SRGBColorSpace as ve, SpotLight as en, PointLight as tn, DirectionalLight as nn, Matrix4 as Ne, Vector3 as te, Quaternion as Ct, InstancedMesh as sn, InstancedBufferAttribute as rn, Object3D as Nt, TextureLoader as on, ImageBitmapLoader as an, BufferAttribute as He, InterleavedBuffer as cn, InterleavedBufferAttribute as ln, LinearMipmapLinearFilter as Pt, NearestMipmapLinearFilter as un, LinearMipmapNearestFilter as hn, NearestMipmapNearestFilter as dn, LinearFilter as nt, NearestFilter as Ft, RepeatWrapping as st, MirroredRepeatWrapping as fn, ClampToEdgeWrapping as pn, PointsMaterial as mn, Material as je, LineBasicMaterial as gn, MeshStandardMaterial as Ot, DoubleSide as Ie, MeshBasicMaterial as Te, PropertyBinding as An, BufferGeometry as Tn, SkinnedMesh as xn, Mesh as vn, LineSegments as bn, Line as En, LineLoop as Rn, Points as Mn, Group as Xe, PerspectiveCamera as wn, MathUtils as Sn, OrthographicCamera as yn, Skeleton as _n, AnimationClip as Ln, Bone as In, InterpolateDiscrete as Cn, InterpolateLinear as Dt, Texture as ft, VectorKeyframeTrack as pt, NumberKeyframeTrack as mt, QuaternionKeyframeTrack as gt, ColorManagement as At, FrontSide as Nn, Interpolant as Pn, Box3 as Fn, Sphere as On, Euler as Dn } from "three";
+import { jsxs as w, Fragment as rt, jsx as T } from "react/jsx-runtime";
+import { useThree as kt, useLoader as Ke, useFrame as kn } from "@react-three/fiber";
+import { useState as at, useEffect as $, useMemo as j, useRef as N } from "react";
+import { l as Pe, f as Bt, X as Bn } from "./index-CYMj26Ej.js";
+import { a as Un, u as Ut } from "./selectors-BHO6TnoC.js";
+import { p as Gn, F as Hn, b as jn } from "./index-BD-JWMjE.js";
+import { Text as Ye } from "@react-three/drei";
+const Tt = {
+  normal: 0,
+  add: 1,
+  subtract: 2,
+  multiply: 3,
+  screen: 4,
+  overlay: 5,
+  softLight: 6,
+  hardLight: 7,
+  lighten: 8,
+  darken: 9,
+  difference: 10,
+  exclusion: 11
+}, Ve = /* @__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
+]), We = /* @__PURE__ */ new Set([
+  33,
+  7,
+  163,
+  144,
+  145,
+  153,
+  154,
+  155,
+  133,
+  173,
+  157,
+  158,
+  159,
+  160,
+  161,
+  246
+]), ze = /* @__PURE__ */ new Set([
+  362,
+  382,
+  381,
+  380,
+  374,
+  373,
+  390,
+  249,
+  263,
+  466,
+  388,
+  387,
+  386,
+  385,
+  384,
+  398
+]), Xn = /* @__PURE__ */ new Set([814, 815, 816, 817, 818, 819, 830, 831, 832, 833]), Kn = (i, e, t) => {
+  const s = Ve.has(i) && Ve.has(e) && Ve.has(t), n = We.has(i) && We.has(e) && We.has(t), r = ze.has(i) && ze.has(e) && ze.has(t);
+  return s ? "mouth" : n || r ? "eye" : "base";
+}, Yn = (i) => {
+  const e = [], t = [], s = [], n = [], r = [], o = [];
+  let c = 0, a = 0;
+  i.split(`
+`).forEach((u) => {
+    const h = u.trim();
+    if (!h) return;
+    if (h.startsWith("v ")) {
+      c += 1;
+      return;
+    }
+    if (h.startsWith("vt ")) {
+      const [, A, m] = h.split(/\s+/);
+      r.push([Number(A), Number(m)]);
+      return;
+    }
+    if (!h.startsWith("f ")) return;
+    const d = a;
+    a += 1;
+    const [, ...p] = h.split(/\s+/), g = p.map((A) => {
+      const [m, f] = A.split("/"), x = Number(m) - 1, v = Number(f) - 1;
+      return v >= 0 && r[v] && !o[x] && (o[x] = r[v]), x;
+    });
+    if (!(g.length < 3))
+      for (let A = 1; A < g.length - 1; A += 1) {
+        const m = g[0], f = g[A], x = g[A + 1], v = Kn(m, f, x);
+        Xn.has(d) ? n.push(m, f, x) : v === "mouth" ? t.push(m, f, x) : v === "eye" ? s.push(m, f, x) : e.push(m, f, x);
+      }
+  });
+  const l = [];
+  for (let u = 0; u < c; u += 1) {
+    const [h, d] = o[u] ?? [0, 0];
+    l.push(h, d);
+  }
+  return {
+    baseIndices: new Uint16Array(e),
+    mouthIndices: new Uint16Array(t),
+    eyeIndices: new Uint16Array(s),
+    noseIndices: new Uint16Array(n),
+    uvs: new Float32Array(l),
+    vertexCount: c
+  };
+}, Vn = "canonical_face_model.obj", Wn = new TextDecoder("utf-8"), qe = /* @__PURE__ */ new Map(), zn = (i) => {
+  const e = qe.get(i);
+  if (e) return e;
+  const t = Bt(i).then((s) => Yn(Wn.decode(s))).catch((s) => {
+    throw qe.delete(i), s;
+  });
+  return qe.set(i, t), t;
+}, qn = (i) => {
+  const { mesh: e, url: t } = i ?? {}, s = t ?? `${Pe.sdkAssetsBaseUrl}/${Vn}`, [n, r] = at(e ?? null);
+  return $(() => {
+    if (e) {
+      r(e);
+      return;
+    }
+    let o = !1;
+    return zn(s).then((c) => {
+      o || r(c);
+    }).catch((c) => {
+      o || console.error(`${Pe.loggerPrefix} canonical face mesh load failed`, c);
+    }), () => {
+      o = !0;
+    };
+  }, [e, s]), n;
+}, Zn = {
+  front: R.FrontSide,
+  back: R.BackSide,
+  double: R.DoubleSide
+}, Qn = `
+  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);
+  }
+`, $n = `
+  uniform sampler2D cameraTexture;
+  uniform sampler2D canonicalTexture;
+  uniform sampler2D alphaMask;
+  uniform vec3 textureTint;
+  uniform float opacity;
+  uniform float blendMode;
+  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, float mode) {
+    if (mode < 0.5) return blend;
+    if (mode < 1.5) return min(base + blend, 1.0);
+    if (mode < 2.5) return max(base - blend, 0.0);
+    if (mode < 3.5) return base * blend;
+    if (mode < 4.5) return 1.0 - (1.0 - base) * (1.0 - blend);
+    if (mode < 5.5) {
+      return vec3(
+        overlayChannel(base.r, blend.r),
+        overlayChannel(base.g, blend.g),
+        overlayChannel(base.b, blend.b)
+      );
+    }
+    if (mode < 6.5) {
+      return vec3(
+        softLightChannel(base.r, blend.r),
+        softLightChannel(base.g, blend.g),
+        softLightChannel(base.b, blend.b)
+      );
+    }
+    if (mode < 7.5) {
+      return vec3(
+        hardLightChannel(base.r, blend.r),
+        hardLightChannel(base.g, blend.g),
+        hardLightChannel(base.b, blend.b)
+      );
+    }
+    if (mode < 8.5) return max(base, blend);
+    if (mode < 9.5) return min(base, blend);
+    if (mode < 10.5) 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 color = useCanonicalTexture > 0.5 ? applyBlendMode(base, blend, blendMode) : base;
+    gl_FragColor = vec4(srgbToLinear(color), opacity * mask * textureAlpha);
+  }
+`, Jn = `
+  varying vec2 vUv;
+  varying vec3 vNormal;
+
+  void main() {
+    vUv = uv;
+    vNormal = normalize(normalMatrix * normal);
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`, es = `
+  uniform vec3 color;
+  uniform float opacity;
+  varying vec3 vNormal;
+
+  void main() {
+    vec3 normalTint = 0.5 + 0.5 * normalize(vNormal);
+    vec3 base = color * mix(vec3(1.0), normalTint, 0.35);
+
+    gl_FragColor = vec4(base, opacity);
+  }
+`, ts = () => {
+  const i = new Uint8Array([
+    32,
+    32,
+    32,
+    255,
+    96,
+    96,
+    96,
+    255,
+    176,
+    176,
+    176,
+    255,
+    255,
+    255,
+    255,
+    255
+  ]), e = new R.DataTexture(i, 4, 1, R.RGBAFormat);
+  return e.minFilter = R.NearestFilter, e.magFilter = R.NearestFilter, e.generateMipmaps = !1, e.needsUpdate = !0, e;
+}, ns = () => {
+  const i = document.createElement("canvas");
+  i.width = 256, i.height = 256;
+  const e = i.getContext("2d");
+  if (!e)
+    return new R.CanvasTexture(i);
+  const t = e.createRadialGradient(96, 80, 10, 128, 128, 128);
+  t.addColorStop(0, "#ffffff"), t.addColorStop(0.18, "#f7d794"), t.addColorStop(0.45, "#d97706"), t.addColorStop(0.72, "#78350f"), t.addColorStop(1, "#120701"), e.fillStyle = t, e.fillRect(0, 0, i.width, i.height);
+  const s = new R.CanvasTexture(i);
+  return s.needsUpdate = !0, s;
+}, Cr = ({
+  faceIndex: i = 0,
+  color: e = "#38bdf8",
+  opacity: t = 0.45,
+  materialType: s = "basic",
+  shaderPreset: n = "basicShader",
+  textureMap: r = "none",
+  alphaMap: o = "none",
+  alphaOpacity: c = 0,
+  side: a = "front",
+  blendMode: l = "normal",
+  showMouthMask: u = !0,
+  showEyeMask: h = !0,
+  showNoseMask: d = !0,
+  maskTextureSource: p = "none",
+  maskColor: g = "#111111",
+  maskOpacity: A = 0,
+  faceTextureUrl: m = "",
+  faceTextureStyle2Url: f = "",
+  faceAlphaMaskUrl: x = "",
+  compositeShading: v = !1,
+  mesh: b,
+  meshUrl: y
+}) => {
+  const L = Un(Bn.FACE_TRACKER), _ = Ut(), { camera: D } = kt(), M = qn({ mesh: b, url: y }), P = Ke(R.TextureLoader, m || "/placeholder.png"), re = Ke(
+    R.TextureLoader,
+    f || m || "/placeholder.png"
+  ), I = Ke(R.TextureLoader, x || "/placeholder.png"), W = j(() => ts(), []), S = j(() => ns(), []), oe = N(null), z = N(null), q = N(null), ue = N(null), he = N(null), de = N(null), fe = N(null), ie = N(null), ae = N(null), pe = N(null), me = N(null), be = N(null), qt = N(new R.Vector3()), Ee = N(!1), J = Zn[a], ce = {
+    side: J,
+    transparent: !0,
+    opacity: t,
+    wireframe: !1
+  }, Fe = r === "style2" ? re : P, ge = r !== "none", Re = j(
+    () => ({
+      color: { value: new R.Color(e) },
+      opacity: { value: t }
+    }),
+    []
+  ), F = j(
+    () => ({
+      cameraTexture: { value: null },
+      canonicalTexture: { value: null },
+      alphaMask: { value: null },
+      textureTint: { value: new R.Color(e) },
+      opacity: { value: t },
+      blendMode: { value: Tt[l] },
+      useCanonicalTexture: { value: ge ? 1 : 0 },
+      useAlphaMask: { value: o === "canonical" ? 1 : 0 },
+      alphaOpacity: { value: c },
+      compositeShading: { value: v ? 1 : 0 },
+      lightDirection: { value: new R.Vector3(0.3, 0.65, 0.7).normalize() },
+      ambientStrength: { value: 0.78 },
+      directionalStrength: { value: 0.38 }
+    }),
+    []
+  );
+  $(() => {
+    Re.color.value.set(e), Re.opacity.value = t;
+  }, [e, t, Re]), $(() => {
+    F.cameraTexture.value = _ ?? P, F.canonicalTexture.value = Fe, F.alphaMask.value = I, F.textureTint.value.set(e), F.opacity.value = t, F.blendMode.value = Tt[l], F.useCanonicalTexture.value = ge ? 1 : 0, F.useAlphaMask.value = o === "canonical" ? 1 : 0, F.alphaOpacity.value = c, F.compositeShading.value = v ? 1 : 0;
+  }, [
+    o,
+    I,
+    c,
+    l,
+    _,
+    e,
+    v,
+    F,
+    P,
+    ge,
+    t,
+    Fe,
+    r
+  ]);
+  const Me = (C) => {
+    if (C)
+      return p === "canonical" ? /* @__PURE__ */ T(
+        "meshBasicMaterial",
+        {
+          color: g,
+          alphaMap: I,
+          transparent: !0,
+          opacity: A,
+          side: J,
+          depthWrite: !1,
+          depthTest: !1,
+          toneMapped: !1
+        },
+        "masked-canonical-material"
+      ) : /* @__PURE__ */ T(
+        "meshBasicMaterial",
+        {
+          color: g,
+          transparent: !0,
+          opacity: A,
+          side: J,
+          depthWrite: !1,
+          depthTest: !1,
+          toneMapped: !1
+        },
+        "masked-solid-material"
+      );
+    if (s === "wireframe")
+      return /* @__PURE__ */ T(
+        "meshBasicMaterial",
+        {
+          color: e,
+          transparent: !0,
+          opacity: t,
+          side: J,
+          depthWrite: !1,
+          depthTest: !1,
+          wireframe: !0,
+          toneMapped: !1
+        },
+        "wireframe-material"
+      );
+    if (s === "shader" && _ && (n === "originalFace" || n === "composite" && r === "none"))
+      return /* @__PURE__ */ T(
+        "meshBasicMaterial",
+        {
+          map: _,
+          alphaMap: I,
+          transparent: !0,
+          opacity: t,
+          side: J,
+          depthWrite: !1,
+          depthTest: !0,
+          toneMapped: !1
+        },
+        "use-original-face-material"
+      );
+    if (s === "shader" && n === "composite" && ge && _)
+      return /* @__PURE__ */ T(
+        "shaderMaterial",
+        {
+          uniforms: F,
+          vertexShader: Qn,
+          fragmentShader: $n,
+          transparent: !0,
+          side: J,
+          depthWrite: !1,
+          depthTest: !0,
+          toneMapped: !1
+        },
+        "composite-material"
+      );
+    const k = ge ? Fe : null, B = o === "canonical" && c > 0 ? I : null, U = `${s}-${r}-${o}-${c > 0 ? "alpha-on" : "alpha-off"}`;
+    return s === "standard" ? /* @__PURE__ */ T(
+      "meshStandardMaterial",
+      {
+        ...ce,
+        color: e,
+        map: k ?? void 0,
+        alphaMap: B ?? void 0,
+        depthWrite: !0,
+        depthTest: !0,
+        metalness: 0.05,
+        roughness: 0.72
+      },
+      U
+    ) : s === "physical" ? /* @__PURE__ */ T(
+      "meshPhysicalMaterial",
+      {
+        ...ce,
+        color: e,
+        map: k ?? void 0,
+        alphaMap: B ?? void 0,
+        depthWrite: !0,
+        depthTest: !0,
+        roughness: 0.58,
+        metalness: 0.08,
+        clearcoat: 0.35,
+        clearcoatRoughness: 0.4
+      },
+      U
+    ) : s === "toon" ? /* @__PURE__ */ T(
+      "meshToonMaterial",
+      {
+        ...ce,
+        color: e,
+        map: k ?? void 0,
+        alphaMap: B ?? void 0,
+        gradientMap: W,
+        depthWrite: !0,
+        depthTest: !0
+      },
+      U
+    ) : s === "normal" ? /* @__PURE__ */ T(
+      "meshNormalMaterial",
+      {
+        ...ce,
+        depthWrite: !0,
+        depthTest: !0,
+        flatShading: !1
+      },
+      "normal-material"
+    ) : s === "matcap" ? /* @__PURE__ */ T(
+      "meshMatcapMaterial",
+      {
+        ...ce,
+        color: e,
+        matcap: S,
+        depthWrite: !0,
+        depthTest: !0
+      },
+      "matcap-material"
+    ) : s === "shader" ? /* @__PURE__ */ T(
+      "shaderMaterial",
+      {
+        uniforms: Re,
+        vertexShader: Jn,
+        fragmentShader: es,
+        transparent: !0,
+        side: J,
+        depthWrite: !1,
+        depthTest: !0,
+        toneMapped: !1
+      },
+      "generic-shader-material"
+    ) : /* @__PURE__ */ T(
+      "meshBasicMaterial",
+      {
+        ...ce,
+        color: e,
+        map: k ?? void 0,
+        alphaMap: B ?? void 0,
+        depthWrite: !1,
+        depthTest: r !== "none" || o !== "none",
+        toneMapped: !1
+      },
+      U
+    );
+  }, Zt = (C) => Gn(C, D, qt.current);
+  return kn(() => {
+    var ht, dt;
+    const C = oe.current, k = z.current, B = q.current, U = ue.current, Oe = he.current, De = de.current, ke = fe.current, Be = ie.current, we = (dt = (ht = L == null ? void 0 : L.detectionResults) == null ? void 0 : ht.faceLandmarks) == null ? void 0 : dt[i];
+    if (!M || !C || !k || !B || !U || !Oe || !De || !ke || !Be)
+      return;
+    if (!we || we.length < M.vertexCount) {
+      Oe.visible = !1, De.visible = !1, ke.visible = !1, Be.visible = !1;
+      return;
+    }
+    if (be.current !== M) {
+      ae.current = new Float32Array(M.vertexCount * 3), pe.current = new Float32Array(M.uvs), me.current = new Float32Array(M.vertexCount * 2);
+      const H = new R.BufferAttribute(ae.current, 3), G = new R.BufferAttribute(pe.current, 2), Z = new R.BufferAttribute(me.current, 2);
+      C.setAttribute("position", H), C.setAttribute("uv", G), C.setAttribute("faceUv", Z), C.setIndex(new R.BufferAttribute(M.baseIndices, 1)), k.setAttribute("position", H), k.setAttribute("uv", G), k.setAttribute("faceUv", Z), k.setIndex(new R.BufferAttribute(M.mouthIndices, 1)), B.setAttribute("position", H), B.setAttribute("uv", G), B.setAttribute("faceUv", Z), B.setIndex(new R.BufferAttribute(M.eyeIndices, 1)), U.setAttribute("position", H), U.setAttribute("uv", G), U.setAttribute("faceUv", Z), U.setIndex(new R.BufferAttribute(M.noseIndices, 1)), G.needsUpdate = !0, be.current = M, Ee.current = !1;
+    }
+    const Se = ae.current, Ue = me.current, ye = pe.current;
+    if (!Se || !Ue || !ye) return;
+    const ut = s === "shader" && (n === "originalFace" || n === "composite" && r === "none"), Qt = Math.min(we.length, M.vertexCount);
+    for (let H = 0; H < Qt; H++) {
+      const G = we[H], Z = H * 3, _e = H * 2, Ge = Zt(G);
+      Se[Z] = Ge.x, Se[Z + 1] = Ge.y, Se[Z + 2] = Ge.z, Ue[_e] = G.x, Ue[_e + 1] = 1 - G.y, ut && (ye[_e] = G.x, ye[_e + 1] = 1 - G.y);
+    }
+    ut ? (C.attributes.uv.needsUpdate = !0, Ee.current = !0) : Ee.current && (ye.set(M.uvs), C.attributes.uv.needsUpdate = !0, Ee.current = !1), Oe.visible = !0, De.visible = !0, ke.visible = !0, Be.visible = !0, C.attributes.position.needsUpdate = !0, C.attributes.faceUv.needsUpdate = !0, C.computeVertexNormals(), k.computeVertexNormals(), B.computeVertexNormals(), U.computeVertexNormals();
+  }), /* @__PURE__ */ w(rt, { children: [
+    /* @__PURE__ */ w("mesh", { ref: he, renderOrder: 10, frustumCulled: !1, children: [
+      /* @__PURE__ */ T("bufferGeometry", { ref: oe }),
+      Me(!1)
+    ] }),
+    /* @__PURE__ */ w("mesh", { ref: de, renderOrder: 12, frustumCulled: !1, children: [
+      /* @__PURE__ */ T("bufferGeometry", { ref: z }),
+      Me(u)
+    ] }),
+    /* @__PURE__ */ w("mesh", { ref: fe, renderOrder: 12, frustumCulled: !1, children: [
+      /* @__PURE__ */ T("bufferGeometry", { ref: q }),
+      Me(h)
+    ] }),
+    /* @__PURE__ */ w("mesh", { ref: ie, renderOrder: 12, frustumCulled: !1, children: [
+      /* @__PURE__ */ T("bufferGeometry", { ref: ue }),
+      Me(d)
+    ] })
+  ] });
+}, Nr = {
+  materialType: "basic",
+  shaderPreset: "basicShader",
+  textureMap: "none",
+  alphaMap: "none",
+  alphaOpacity: 1,
+  side: "front",
+  blendMode: "normal",
+  baseColor: "#38bdf8",
+  opacity: 0.45
+}, Pr = {
+  mouth: !0,
+  eyes: !0,
+  nose: !0
+}, Fr = [
+  { label: "Wireframe", value: "wireframe" },
+  { label: "Basic", value: "basic" },
+  { label: "Standard", value: "standard" },
+  { label: "Physical", value: "physical" },
+  { label: "Toon", value: "toon" },
+  { label: "Normal", value: "normal" },
+  { label: "Matcap", value: "matcap" },
+  { label: "Shader", value: "shader" }
+], Or = [
+  { label: "Basic Shader", value: "basicShader" },
+  { label: "Original Face", value: "originalFace" },
+  { label: "Composite", value: "composite" }
+], Dr = [
+  { label: "Front", value: "front" },
+  { label: "Back", value: "back" },
+  { label: "Double", value: "double" }
+], kr = [
+  { label: "None", value: "none" },
+  { label: "UV Map 1", value: "canonical" },
+  { label: "UV Map 2", value: "style2" }
+], Br = [
+  { label: "None", value: "none" },
+  { label: "Default Mask", value: "canonical" }
+], Ur = [
+  { label: "Normal", value: "normal" },
+  { label: "Add", value: "add" },
+  { label: "Subtract", value: "subtract" },
+  { label: "Multiply", value: "multiply" },
+  { label: "Screen", value: "screen" },
+  { label: "Overlay", value: "overlay" },
+  { label: "Soft Light", value: "softLight" },
+  { label: "Hard Light", value: "hardLight" },
+  { label: "Lighten", value: "lighten" },
+  { label: "Darken", value: "darken" },
+  { label: "Difference", value: "difference" },
+  { label: "Exclusion", value: "exclusion" }
+], Gr = (i, e) => i === "basic" || i === "standard" || i === "physical" || i === "toon" || i === "shader" && e === "composite", Hr = (i, e) => i === "shader" && e === "composite", ss = `
+  varying vec2 vUv;
+
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`, rs = `
+  uniform sampler2D cameraTexture;
+  uniform sampler2D retouchMaskTexture;
+  uniform sampler2D mouthMaskTexture;
+  uniform vec2 texelSize;
+  uniform float retouchAmount;
+  uniform float blurRadius;
+  uniform float teethWhitening;
+  uniform float previewMask;
+  uniform float protectLandmarks;
+  varying vec2 vUv;
+
+  vec3 sampleCamera(vec2 uv) {
+    return texture2D(cameraTexture, clamp(uv, vec2(0.0), vec2(1.0))).rgb;
+  }
+
+  vec3 readRetouchMask(vec2 uv) {
+    vec4 mask = texture2D(retouchMaskTexture, uv);
+    float faceRegion = clamp(mask.b, 0.0, 1.0);
+    float softFaceRegion = min(mask.r, faceRegion);
+    float protectedRegion = min(mask.g, faceRegion) * protectLandmarks;
+    float hardProtectedRegion = step(0.08, protectedRegion);
+    float softRetouchRegion = softFaceRegion * (1.0 - protectedRegion);
+    float hardRetouchRegion = step(0.5, faceRegion) * (1.0 - hardProtectedRegion);
+
+    return vec3(
+      clamp(softRetouchRegion, 0.0, 1.0),
+      clamp(protectedRegion, 0.0, 1.0),
+      clamp(hardRetouchRegion, 0.0, 1.0)
+    );
+  }
+
+  float readMouthMask(vec2 uv) {
+    return clamp(texture2D(mouthMaskTexture, uv).r, 0.0, 1.0);
+  }
+
+  float retouchCoverage(vec2 uv) {
+    return step(0.001, readRetouchMask(uv).x);
+  }
+
+  void addMaskedBlurSample(inout vec3 color, inout float weightSum, vec2 centerUv, vec2 sampleUv, float weight) {
+    float coverage = retouchCoverage(sampleUv);
+    vec3 sampleColor = mix(sampleCamera(centerUv), sampleCamera(sampleUv), coverage);
+    color += sampleColor * weight;
+    weightSum += weight;
+  }
+
+  vec3 maskedBlurCamera(vec2 uv, float radius) {
+    vec2 r = texelSize * radius;
+    vec3 color = sampleCamera(uv) * 0.2;
+    float weightSum = 0.2;
+
+    addMaskedBlurSample(color, weightSum, uv, uv + vec2(r.x, 0.0), 0.1);
+    addMaskedBlurSample(color, weightSum, uv, uv - vec2(r.x, 0.0), 0.1);
+    addMaskedBlurSample(color, weightSum, uv, uv + vec2(0.0, r.y), 0.1);
+    addMaskedBlurSample(color, weightSum, uv, uv - vec2(0.0, r.y), 0.1);
+    addMaskedBlurSample(color, weightSum, uv, uv + r, 0.075);
+    addMaskedBlurSample(color, weightSum, uv, uv - r, 0.075);
+    addMaskedBlurSample(color, weightSum, uv, uv + vec2(r.x, -r.y), 0.075);
+    addMaskedBlurSample(color, weightSum, uv, uv + vec2(-r.x, r.y), 0.075);
+    addMaskedBlurSample(color, weightSum, uv, uv + r * 2.0, 0.05);
+    addMaskedBlurSample(color, weightSum, uv, uv - r * 2.0, 0.05);
+
+    return color / max(weightSum, 0.001);
+  }
+
+  vec3 whitenTeeth(vec3 color, float amount, float mouthRegion) {
+    float maxChannel = max(max(color.r, color.g), color.b);
+    float minChannel = min(min(color.r, color.g), color.b);
+    float saturation = maxChannel - minChannel;
+    float brightness = dot(color, vec3(0.299, 0.587, 0.114));
+    float redness = max(color.r - max(color.g, color.b), 0.0);
+    float greenBlueBalance = 1.0 - smoothstep(0.08, 0.24, abs(color.g - color.b));
+    float candidate =
+      smoothstep(0.34, 0.62, brightness) *
+      (1.0 - smoothstep(0.14, 0.32, redness)) *
+      (1.0 - smoothstep(0.18, 0.42, saturation)) *
+      greenBlueBalance;
+    float whiteningMask = clamp(mouthRegion * candidate, 0.0, 1.0);
+    vec3 desaturated = mix(color, vec3(brightness), 0.42);
+    vec3 brightened = min(desaturated + vec3(0.16), vec3(1.0));
+
+    return mix(color, brightened, clamp(amount * whiteningMask * 0.38, 0.0, 1.0));
+  }
+
+  void main() {
+    vec3 original = sampleCamera(vUv);
+    vec3 masks = readRetouchMask(vUv);
+    float mouthMask = readMouthMask(vUv);
+
+    if (previewMask > 0.5) {
+      float sharpPreview = 1.0 - step(0.001, retouchAmount + blurRadius);
+      float retouchPreview = mix(masks.x, masks.z, sharpPreview);
+      float protectedPreview = mix(masks.y, step(0.08, masks.y), sharpPreview);
+      float whiteningPreview = mouthMask * teethWhitening;
+      vec3 facePreview = vec3(retouchPreview, 0.08, 0.08);
+      vec3 featurePreview = vec3(0.05, protectedPreview, 0.1);
+      vec3 whiteningMaskPreview = vec3(whiteningPreview, whiteningPreview, 0.05);
+      vec3 maskPreview = max(max(facePreview, featurePreview), whiteningMaskPreview);
+      vec3 debugColor = mix(original * 0.18, maskPreview, max(max(retouchPreview, protectedPreview), whiteningPreview));
+      gl_FragColor = vec4(debugColor, 1.0);
+      #include <colorspace_fragment>
+      return;
+    }
+
+    float effectiveBlurRadius = min(blurRadius, 7.0);
+    vec3 smallBlur = maskedBlurCamera(vUv, max(0.0, effectiveBlurRadius * 0.45));
+    vec3 largeBlur = maskedBlurCamera(vUv, max(0.0, effectiveBlurRadius));
+    vec3 detail = original - smallBlur;
+    float detailAmount = mix(0.5, 0.9, masks.y);
+    vec3 smoothed = clamp(largeBlur + detail * detailAmount, 0.0, 1.0);
+    vec3 color = mix(original, smoothed, min(retouchAmount, 0.72) * masks.x);
+    color = whitenTeeth(color, teethWhitening, mouthMask);
+    gl_FragColor = vec4(color, 1.0);
+    #include <colorspace_fragment>
+  }
+`, jr = ({
+  retouchMask: i,
+  mouthMask: e,
+  retouchAmount: t,
+  blurRadius: s,
+  teethWhitening: n,
+  previewMask: r,
+  protectLandmarks: o
+}) => {
+  const { camera: c, size: a } = kt(), l = Ut(), u = j(
+    () => ({
+      cameraTexture: { value: null },
+      retouchMaskTexture: { value: i },
+      mouthMaskTexture: { value: e },
+      texelSize: { value: new R.Vector2(1 / 1280, 1 / 720) },
+      retouchAmount: { value: t },
+      blurRadius: { value: s },
+      teethWhitening: { value: n },
+      previewMask: { value: 0 },
+      protectLandmarks: { value: 1 }
+    }),
+    [e, i]
+  ), h = j(() => {
+    if (!(c instanceof R.PerspectiveCamera))
+      return [10, 10];
+    const g = (c.position.z || 5) - -1, A = R.MathUtils.degToRad(c.fov), m = 2 * Math.tan(A / 2) * g;
+    return [m * (a.width / a.height), m];
+  }, [c, a]);
+  return $(() => {
+    u.cameraTexture.value = l ?? null, u.retouchMaskTexture.value = i, u.mouthMaskTexture.value = e, u.texelSize.value.set(1 / Math.max(a.width, 1), 1 / Math.max(a.height, 1)), u.retouchAmount.value = t, u.blurRadius.value = s, u.teethWhitening.value = n, u.previewMask.value = r ? 1 : 0, u.protectLandmarks.value = o ? 1 : 0;
+  }, [
+    s,
+    l,
+    r,
+    o,
+    t,
+    e,
+    i,
+    n,
+    a.height,
+    a.width,
+    u
+  ]), l ? /* @__PURE__ */ T("group", { position: [0, 0, -1], children: /* @__PURE__ */ w("mesh", { renderOrder: -1e3, children: [
+    /* @__PURE__ */ T("planeGeometry", { args: h }),
+    /* @__PURE__ */ T(
+      "shaderMaterial",
+      {
+        uniforms: u,
+        vertexShader: ss,
+        fragmentShader: rs,
+        depthTest: !1,
+        depthWrite: !1,
+        toneMapped: !1
+      }
+    )
+  ] }) }) : null;
+}, ct = 512, Gt = [
+  10,
+  338,
+  297,
+  332,
+  284,
+  251,
+  389,
+  356,
+  454,
+  323,
+  361,
+  288,
+  397,
+  365,
+  379,
+  378,
+  400,
+  377,
+  152,
+  148,
+  176,
+  149,
+  150,
+  136,
+  172,
+  58,
+  132,
+  93,
+  234,
+  127,
+  162,
+  21,
+  54,
+  103,
+  67,
+  109
+], os = [
+  33,
+  246,
+  161,
+  160,
+  159,
+  158,
+  157,
+  173,
+  133,
+  155,
+  154,
+  153,
+  145,
+  144,
+  163,
+  7
+], is = [
+  362,
+  398,
+  384,
+  385,
+  386,
+  387,
+  388,
+  466,
+  263,
+  249,
+  390,
+  373,
+  374,
+  380,
+  381,
+  382
+], as = [
+  61,
+  146,
+  91,
+  181,
+  84,
+  17,
+  314,
+  405,
+  321,
+  375,
+  291,
+  409,
+  270,
+  269,
+  267,
+  0,
+  37,
+  39,
+  40,
+  185
+], Ht = [
+  78,
+  95,
+  88,
+  178,
+  87,
+  14,
+  317,
+  402,
+  318,
+  324,
+  308,
+  415,
+  310,
+  311,
+  312,
+  13,
+  82,
+  81,
+  80,
+  191
+], cs = [70, 63, 105, 66, 107, 55, 65, 52, 53, 46], ls = [336, 296, 334, 293, 300, 276, 283, 282, 295, 285], us = [
+  os,
+  is,
+  as,
+  Ht,
+  cs,
+  ls
+], xt = (i, e, t) => {
+  lt(i, e, Gt, t);
+}, hs = (i, e, t) => {
+  us.forEach((s) => lt(i, e, s, t));
+}, vt = (i, e, t) => {
+  const s = i[e];
+  return s ? {
+    x: s.x * t,
+    y: s.y * t
+  } : null;
+}, lt = (i, e, t, s) => {
+  const n = vt(e, t[0], s);
+  if (n) {
+    i.beginPath(), i.moveTo(n.x, n.y);
+    for (let r = 1; r < t.length; r += 1) {
+      const o = vt(e, t[r], s);
+      o && i.lineTo(o.x, o.y);
+    }
+    i.closePath(), i.fill();
+  }
+}, ds = (i, e, t = ct) => {
+  i.clearRect(0, 0, t, t), e != null && e.length && (i.save(), i.globalCompositeOperation = "lighter", i.fillStyle = "rgb(0, 0, 255)", xt(i, e, t), i.restore(), i.save(), i.globalCompositeOperation = "lighter", i.filter = "blur(8px)", i.fillStyle = "rgb(255, 0, 0)", xt(i, e, t), i.restore(), i.save(), i.globalCompositeOperation = "lighter", i.filter = "blur(3px)", i.fillStyle = "rgb(0, 255, 0)", hs(i, e, t), i.restore());
+}, fs = (i, e, t = ct) => {
+  i.clearRect(0, 0, t, t), e != null && e.length && (i.save(), i.filter = "blur(2px)", i.fillStyle = "rgb(255, 255, 255)", lt(i, e, Ht, t), i.restore());
+}, ps = 0.1, ms = 0.48, gs = 0.012, As = 1, Ts = 1.1, xs = 1.15, vs = 0.04, bs = [
+  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
+], Es = [
+  33,
+  7,
+  163,
+  144,
+  145,
+  153,
+  154,
+  155,
+  133,
+  173,
+  157,
+  158,
+  159,
+  160,
+  161,
+  246
+], Rs = [
+  362,
+  382,
+  381,
+  380,
+  374,
+  373,
+  390,
+  249,
+  263,
+  466,
+  388,
+  387,
+  386,
+  385,
+  384,
+  398
+], Ms = [70, 63, 105, 66, 107, 55, 65, 52, 53, 46], ws = [336, 296, 334, 293, 300, 285, 295, 282, 283, 276], Ss = [
+  1,
+  2,
+  4,
+  5,
+  6,
+  19,
+  94,
+  97,
+  98,
+  99,
+  102,
+  129,
+  168,
+  195,
+  197,
+  240,
+  279,
+  326,
+  327,
+  328,
+  331,
+  344,
+  358,
+  440
+], ys = [
+  bs,
+  Es,
+  Rs,
+  Ms,
+  ws,
+  Ss
+], _s = [
+  61,
+  91,
+  84,
+  17,
+  314,
+  321,
+  291,
+  78,
+  178,
+  14,
+  402,
+  308,
+  80,
+  13,
+  312,
+  0,
+  33,
+  144,
+  145,
+  153,
+  155,
+  133,
+  157,
+  159,
+  161,
+  246,
+  362,
+  382,
+  374,
+  373,
+  263,
+  466,
+  388,
+  386,
+  384,
+  398,
+  70,
+  105,
+  107,
+  55,
+  52,
+  46,
+  336,
+  334,
+  300,
+  285,
+  282,
+  276,
+  1,
+  4,
+  5,
+  94,
+  97,
+  98,
+  327,
+  326,
+  2,
+  195
+], Le = (i) => Math.min(Math.max(i, 0), 1), bt = (i, e, t, s, n, r) => {
+  let o = 1, c = 1, a = 0, l = 0, u = 0;
+  if (e.forEach((v) => {
+    const b = i[v];
+    b && (o = Math.min(o, b.x), c = Math.min(c, b.y), a = Math.max(a, b.x), l = Math.max(l, b.y), u += 1);
+  }), u === 0) return null;
+  const h = a - o, d = l - c, p = Math.max(h * t, r), g = Math.max(d * t, r), A = Le(o - p), m = Le(c - g), f = Le(a + p), x = Le(l + g);
+  return {
+    centerX: (A + f) * 0.5,
+    centerY: (m + x) * 0.5,
+    radiusX: Math.max((f - A) * 0.5, r),
+    radiusY: Math.max((x - m) * 0.5, r),
+    strength: s,
+    kind: n
+  };
+}, Ls = (i, e, t) => i ? {
+  centerX: i.x,
+  centerY: i.y,
+  radiusX: e,
+  radiusY: e,
+  strength: t,
+  kind: "feature"
+} : null, Is = (i, e) => {
+  if (!(i != null && i.length)) return [];
+  const t = (e == null ? void 0 : e.faceOvalIndices) ?? Gt, s = (e == null ? void 0 : e.featureGroups) ?? ys, n = (e == null ? void 0 : e.featurePointIndices) ?? _s, r = (e == null ? void 0 : e.faceBoundsExpansion) ?? ps, o = (e == null ? void 0 : e.featureBoundsExpansion) ?? ms, c = (e == null ? void 0 : e.minRegionRadius) ?? gs, a = (e == null ? void 0 : e.faceRegionStrength) ?? As, l = (e == null ? void 0 : e.featureRegionStrength) ?? Ts, u = (e == null ? void 0 : e.featurePointRegionStrength) ?? xs, h = (e == null ? void 0 : e.featurePointRadiusRatio) ?? vs, d = [], p = bt(
+    i,
+    t,
+    r,
+    a,
+    "face",
+    c
+  );
+  p && d.push(p);
+  const g = Math.max(
+    Math.max((p == null ? void 0 : p.radiusX) ?? 0, (p == null ? void 0 : p.radiusY) ?? 0) * h,
+    c * 1.35
+  );
+  return s.forEach((A) => {
+    const m = bt(
+      i,
+      A,
+      o,
+      l,
+      "feature",
+      c
+    );
+    m && d.push(m);
+  }), n.forEach((A) => {
+    const m = Ls(
+      i[A],
+      g,
+      u
+    );
+    m && d.push(m);
+  }), d;
+}, Et = (i) => {
+  const e = document.createElement("canvas");
+  e.width = i, e.height = i;
+  const t = e.getContext("2d", { willReadFrequently: !1 });
+  if (!t) throw new Error("Unable to create face retouch mask context");
+  const s = new R.CanvasTexture(e);
+  return s.colorSpace = R.NoColorSpace, s.minFilter = R.LinearFilter, s.magFilter = R.LinearFilter, s.generateMipmaps = !1, s.needsUpdate = !0, { canvas: e, context: t, texture: s };
+}, Xr = (i, e = ct) => {
+  const { mask: t, mouthMask: s } = j(() => ({
+    mask: Et(e),
+    mouthMask: Et(e)
+  }), [e]);
+  return $(() => {
+    let n = 0;
+    const r = () => {
+      var c, a;
+      n = requestAnimationFrame(r);
+      const o = (a = (c = i == null ? void 0 : i.detectionResults) == null ? void 0 : c.faceLandmarks) == null ? void 0 : a[0];
+      ds(t.context, o, e), fs(s.context, o, e), t.texture.needsUpdate = !0, s.texture.needsUpdate = !0;
+    };
+    return r(), () => {
+      cancelAnimationFrame(n);
+    };
+  }, [i, t.context, t.texture, s.context, s.texture, e]), { canvas: t.canvas, texture: t.texture, mouthTexture: s.texture };
+}, Cs = (i) => i.map(
+  (e) => [
+    e.centerX.toFixed(4),
+    e.centerY.toFixed(4),
+    e.radiusX.toFixed(4),
+    e.radiusY.toFixed(4),
+    e.strength.toFixed(2),
+    e.kind
+  ].join(",")
+).join("|"), Kr = (i, e) => {
+  const [t, s] = at([]);
+  return $(() => {
+    let n = 0, r = "";
+    const o = () => {
+      var u, h;
+      n = requestAnimationFrame(o);
+      const c = (h = (u = i == null ? void 0 : i.detectionResults) == null ? void 0 : u.faceLandmarks) == null ? void 0 : h[0], a = Is(c, e), l = Cs(a);
+      l !== r && (r = l, s(a));
+    };
+    return o(), () => {
+      cancelAnimationFrame(n);
+    };
+  }, [i]), t;
+};
+function Rt(i, e) {
+  if (e === $t)
+    return console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles."), i;
+  if (e === tt || e === _t) {
+    let t = i.getIndex();
+    if (t === null) {
+      const o = [], c = i.getAttribute("position");
+      if (c !== void 0) {
+        for (let a = 0; a < c.count; a++)
+          o.push(a);
+        i.setIndex(o), t = i.getIndex();
+      } else
+        return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible."), i;
+    }
+    const s = t.count - 2, n = [];
+    if (e === tt)
+      for (let o = 1; o <= s; o++)
+        n.push(t.getX(0)), n.push(t.getX(o)), n.push(t.getX(o + 1));
+    else
+      for (let o = 0; o < s; o++)
+        o % 2 === 0 ? (n.push(t.getX(o)), n.push(t.getX(o + 1)), n.push(t.getX(o + 2))) : (n.push(t.getX(o + 2)), n.push(t.getX(o + 1)), n.push(t.getX(o)));
+    n.length / 3 !== s && console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unable to generate correct amount of triangles.");
+    const r = i.clone();
+    return r.setIndex(n), r.clearGroups(), r;
+  } else
+    return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unknown draw mode:", e), i;
+}
+class Ns extends Jt {
+  constructor(e) {
+    super(e), this.dracoLoader = null, this.ktx2Loader = null, this.meshoptDecoder = null, this.pluginCallbacks = [], this.register(function(t) {
+      return new ks(t);
+    }), this.register(function(t) {
+      return new Bs(t);
+    }), this.register(function(t) {
+      return new Ws(t);
+    }), this.register(function(t) {
+      return new zs(t);
+    }), this.register(function(t) {
+      return new qs(t);
+    }), this.register(function(t) {
+      return new Gs(t);
+    }), this.register(function(t) {
+      return new Hs(t);
+    }), this.register(function(t) {
+      return new js(t);
+    }), this.register(function(t) {
+      return new Xs(t);
+    }), this.register(function(t) {
+      return new Ds(t);
+    }), this.register(function(t) {
+      return new Ks(t);
+    }), this.register(function(t) {
+      return new Us(t);
+    }), this.register(function(t) {
+      return new Vs(t);
+    }), this.register(function(t) {
+      return new Ys(t);
+    }), this.register(function(t) {
+      return new Fs(t);
+    }), this.register(function(t) {
+      return new Zs(t);
+    }), this.register(function(t) {
+      return new Qs(t);
+    });
+  }
+  load(e, t, s, n) {
+    const r = this;
+    let o;
+    if (this.resourcePath !== "")
+      o = this.resourcePath;
+    else if (this.path !== "") {
+      const l = xe.extractUrlBase(e);
+      o = xe.resolveURL(l, this.path);
+    } else
+      o = xe.extractUrlBase(e);
+    this.manager.itemStart(e);
+    const c = function(l) {
+      n ? n(l) : console.error(l), r.manager.itemError(e), r.manager.itemEnd(e);
+    }, a = new Lt(this.manager);
+    a.setPath(this.path), a.setResponseType("arraybuffer"), a.setRequestHeader(this.requestHeader), a.setWithCredentials(this.withCredentials), a.load(e, function(l) {
+      try {
+        r.parse(l, o, function(u) {
+          t(u), r.manager.itemEnd(e);
+        }, c);
+      } catch (u) {
+        c(u);
+      }
+    }, s, c);
+  }
+  setDRACOLoader(e) {
+    return this.dracoLoader = e, this;
+  }
+  setKTX2Loader(e) {
+    return this.ktx2Loader = e, this;
+  }
+  setMeshoptDecoder(e) {
+    return this.meshoptDecoder = e, this;
+  }
+  register(e) {
+    return this.pluginCallbacks.indexOf(e) === -1 && this.pluginCallbacks.push(e), this;
+  }
+  unregister(e) {
+    return this.pluginCallbacks.indexOf(e) !== -1 && this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(e), 1), this;
+  }
+  parse(e, t, s, n) {
+    let r;
+    const o = {}, c = {}, a = new TextDecoder();
+    if (typeof e == "string")
+      r = JSON.parse(e);
+    else if (e instanceof ArrayBuffer)
+      if (a.decode(new Uint8Array(e, 0, 4)) === jt) {
+        try {
+          o[E.KHR_BINARY_GLTF] = new $s(e);
+        } catch (h) {
+          n && n(h);
+          return;
+        }
+        r = JSON.parse(o[E.KHR_BINARY_GLTF].content);
+      } else
+        r = JSON.parse(a.decode(e));
+    else
+      r = e;
+    if (r.asset === void 0 || r.asset.version[0] < 2) {
+      n && n(new Error("THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported."));
+      return;
+    }
+    const l = new hr(r, {
+      path: t || this.resourcePath || "",
+      crossOrigin: this.crossOrigin,
+      requestHeader: this.requestHeader,
+      manager: this.manager,
+      ktx2Loader: this.ktx2Loader,
+      meshoptDecoder: this.meshoptDecoder
+    });
+    l.fileLoader.setRequestHeader(this.requestHeader);
+    for (let u = 0; u < this.pluginCallbacks.length; u++) {
+      const h = this.pluginCallbacks[u](l);
+      h.name || console.error("THREE.GLTFLoader: Invalid plugin found: missing name"), c[h.name] = h, o[h.name] = !0;
+    }
+    if (r.extensionsUsed)
+      for (let u = 0; u < r.extensionsUsed.length; ++u) {
+        const h = r.extensionsUsed[u], d = r.extensionsRequired || [];
+        switch (h) {
+          case E.KHR_MATERIALS_UNLIT:
+            o[h] = new Os();
+            break;
+          case E.KHR_DRACO_MESH_COMPRESSION:
+            o[h] = new Js(r, this.dracoLoader);
+            break;
+          case E.KHR_TEXTURE_TRANSFORM:
+            o[h] = new er();
+            break;
+          case E.KHR_MESH_QUANTIZATION:
+            o[h] = new tr();
+            break;
+          default:
+            d.indexOf(h) >= 0 && c[h] === void 0 && console.warn('THREE.GLTFLoader: Unknown extension "' + h + '".');
+        }
+      }
+    l.setExtensions(o), l.setPlugins(c), l.parse(s, n);
+  }
+  parseAsync(e, t) {
+    const s = this;
+    return new Promise(function(n, r) {
+      s.parse(e, t, n, r);
+    });
+  }
+}
+function Ps() {
+  let i = {};
+  return {
+    get: function(e) {
+      return i[e];
+    },
+    add: function(e, t) {
+      i[e] = t;
+    },
+    remove: function(e) {
+      delete i[e];
+    },
+    removeAll: function() {
+      i = {};
+    }
+  };
+}
+const E = {
+  KHR_BINARY_GLTF: "KHR_binary_glTF",
+  KHR_DRACO_MESH_COMPRESSION: "KHR_draco_mesh_compression",
+  KHR_LIGHTS_PUNCTUAL: "KHR_lights_punctual",
+  KHR_MATERIALS_CLEARCOAT: "KHR_materials_clearcoat",
+  KHR_MATERIALS_DISPERSION: "KHR_materials_dispersion",
+  KHR_MATERIALS_IOR: "KHR_materials_ior",
+  KHR_MATERIALS_SHEEN: "KHR_materials_sheen",
+  KHR_MATERIALS_SPECULAR: "KHR_materials_specular",
+  KHR_MATERIALS_TRANSMISSION: "KHR_materials_transmission",
+  KHR_MATERIALS_IRIDESCENCE: "KHR_materials_iridescence",
+  KHR_MATERIALS_ANISOTROPY: "KHR_materials_anisotropy",
+  KHR_MATERIALS_UNLIT: "KHR_materials_unlit",
+  KHR_MATERIALS_VOLUME: "KHR_materials_volume",
+  KHR_TEXTURE_BASISU: "KHR_texture_basisu",
+  KHR_TEXTURE_TRANSFORM: "KHR_texture_transform",
+  KHR_MESH_QUANTIZATION: "KHR_mesh_quantization",
+  KHR_MATERIALS_EMISSIVE_STRENGTH: "KHR_materials_emissive_strength",
+  EXT_MATERIALS_BUMP: "EXT_materials_bump",
+  EXT_TEXTURE_WEBP: "EXT_texture_webp",
+  EXT_TEXTURE_AVIF: "EXT_texture_avif",
+  EXT_MESHOPT_COMPRESSION: "EXT_meshopt_compression",
+  EXT_MESH_GPU_INSTANCING: "EXT_mesh_gpu_instancing"
+};
+class Fs {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_LIGHTS_PUNCTUAL, this.cache = { refs: {}, uses: {} };
+  }
+  _markDefs() {
+    const e = this.parser, t = this.parser.json.nodes || [];
+    for (let s = 0, n = t.length; s < n; s++) {
+      const r = t[s];
+      r.extensions && r.extensions[this.name] && r.extensions[this.name].light !== void 0 && e._addNodeRef(this.cache, r.extensions[this.name].light);
+    }
+  }
+  _loadLight(e) {
+    const t = this.parser, s = "light:" + e;
+    let n = t.cache.get(s);
+    if (n) return n;
+    const r = t.json, a = ((r.extensions && r.extensions[this.name] || {}).lights || [])[e];
+    let l;
+    const u = new se(16777215);
+    a.color !== void 0 && u.setRGB(a.color[0], a.color[1], a.color[2], V);
+    const h = a.range !== void 0 ? a.range : 0;
+    switch (a.type) {
+      case "directional":
+        l = new nn(u), l.target.position.set(0, 0, -1), l.add(l.target);
+        break;
+      case "point":
+        l = new tn(u), l.distance = h;
+        break;
+      case "spot":
+        l = new en(u), l.distance = h, a.spot = a.spot || {}, a.spot.innerConeAngle = a.spot.innerConeAngle !== void 0 ? a.spot.innerConeAngle : 0, a.spot.outerConeAngle = a.spot.outerConeAngle !== void 0 ? a.spot.outerConeAngle : Math.PI / 4, l.angle = a.spot.outerConeAngle, l.penumbra = 1 - a.spot.innerConeAngle / a.spot.outerConeAngle, l.target.position.set(0, 0, -1), l.add(l.target);
+        break;
+      default:
+        throw new Error("THREE.GLTFLoader: Unexpected light type: " + a.type);
+    }
+    return l.position.set(0, 0, 0), K(l, a), a.intensity !== void 0 && (l.intensity = a.intensity), l.name = t.createUniqueName(a.name || "light_" + e), n = Promise.resolve(l), t.cache.add(s, n), n;
+  }
+  getDependency(e, t) {
+    if (e === "light")
+      return this._loadLight(t);
+  }
+  createNodeAttachment(e) {
+    const t = this, s = this.parser, r = s.json.nodes[e], c = (r.extensions && r.extensions[this.name] || {}).light;
+    return c === void 0 ? null : this._loadLight(c).then(function(a) {
+      return s._getNodeRef(t.cache, c, a);
+    });
+  }
+}
+class Os {
+  constructor() {
+    this.name = E.KHR_MATERIALS_UNLIT;
+  }
+  getMaterialType() {
+    return Te;
+  }
+  extendParams(e, t, s) {
+    const n = [];
+    e.color = new se(1, 1, 1), e.opacity = 1;
+    const r = t.pbrMetallicRoughness;
+    if (r) {
+      if (Array.isArray(r.baseColorFactor)) {
+        const o = r.baseColorFactor;
+        e.color.setRGB(o[0], o[1], o[2], V), e.opacity = o[3];
+      }
+      r.baseColorTexture !== void 0 && n.push(s.assignTexture(e, "map", r.baseColorTexture, ve));
+    }
+    return Promise.all(n);
+  }
+}
+class Ds {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_EMISSIVE_STRENGTH;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = n.extensions[this.name].emissiveStrength;
+    return r !== void 0 && (t.emissiveIntensity = r), Promise.resolve();
+  }
+}
+class ks {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_CLEARCOAT;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser, n = s.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = [], o = n.extensions[this.name];
+    if (o.clearcoatFactor !== void 0 && (t.clearcoat = o.clearcoatFactor), o.clearcoatTexture !== void 0 && r.push(s.assignTexture(t, "clearcoatMap", o.clearcoatTexture)), o.clearcoatRoughnessFactor !== void 0 && (t.clearcoatRoughness = o.clearcoatRoughnessFactor), o.clearcoatRoughnessTexture !== void 0 && r.push(s.assignTexture(t, "clearcoatRoughnessMap", o.clearcoatRoughnessTexture)), o.clearcoatNormalTexture !== void 0 && (r.push(s.assignTexture(t, "clearcoatNormalMap", o.clearcoatNormalTexture)), o.clearcoatNormalTexture.scale !== void 0)) {
+      const c = o.clearcoatNormalTexture.scale;
+      t.clearcoatNormalScale = new It(c, c);
+    }
+    return Promise.all(r);
+  }
+}
+class Bs {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_DISPERSION;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = n.extensions[this.name];
+    return t.dispersion = r.dispersion !== void 0 ? r.dispersion : 0, Promise.resolve();
+  }
+}
+class Us {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_IRIDESCENCE;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser, n = s.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = [], o = n.extensions[this.name];
+    return o.iridescenceFactor !== void 0 && (t.iridescence = o.iridescenceFactor), o.iridescenceTexture !== void 0 && r.push(s.assignTexture(t, "iridescenceMap", o.iridescenceTexture)), o.iridescenceIor !== void 0 && (t.iridescenceIOR = o.iridescenceIor), t.iridescenceThicknessRange === void 0 && (t.iridescenceThicknessRange = [100, 400]), o.iridescenceThicknessMinimum !== void 0 && (t.iridescenceThicknessRange[0] = o.iridescenceThicknessMinimum), o.iridescenceThicknessMaximum !== void 0 && (t.iridescenceThicknessRange[1] = o.iridescenceThicknessMaximum), o.iridescenceThicknessTexture !== void 0 && r.push(s.assignTexture(t, "iridescenceThicknessMap", o.iridescenceThicknessTexture)), Promise.all(r);
+  }
+}
+class Gs {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_SHEEN;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser, n = s.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = [];
+    t.sheenColor = new se(0, 0, 0), t.sheenRoughness = 0, t.sheen = 1;
+    const o = n.extensions[this.name];
+    if (o.sheenColorFactor !== void 0) {
+      const c = o.sheenColorFactor;
+      t.sheenColor.setRGB(c[0], c[1], c[2], V);
+    }
+    return o.sheenRoughnessFactor !== void 0 && (t.sheenRoughness = o.sheenRoughnessFactor), o.sheenColorTexture !== void 0 && r.push(s.assignTexture(t, "sheenColorMap", o.sheenColorTexture, ve)), o.sheenRoughnessTexture !== void 0 && r.push(s.assignTexture(t, "sheenRoughnessMap", o.sheenRoughnessTexture)), Promise.all(r);
+  }
+}
+class Hs {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_TRANSMISSION;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser, n = s.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = [], o = n.extensions[this.name];
+    return o.transmissionFactor !== void 0 && (t.transmission = o.transmissionFactor), o.transmissionTexture !== void 0 && r.push(s.assignTexture(t, "transmissionMap", o.transmissionTexture)), Promise.all(r);
+  }
+}
+class js {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_VOLUME;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser, n = s.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = [], o = n.extensions[this.name];
+    t.thickness = o.thicknessFactor !== void 0 ? o.thicknessFactor : 0, o.thicknessTexture !== void 0 && r.push(s.assignTexture(t, "thicknessMap", o.thicknessTexture)), t.attenuationDistance = o.attenuationDistance || 1 / 0;
+    const c = o.attenuationColor || [1, 1, 1];
+    return t.attenuationColor = new se().setRGB(c[0], c[1], c[2], V), Promise.all(r);
+  }
+}
+class Xs {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_IOR;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = n.extensions[this.name];
+    return t.ior = r.ior !== void 0 ? r.ior : 1.5, Promise.resolve();
+  }
+}
+class Ks {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_SPECULAR;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser, n = s.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = [], o = n.extensions[this.name];
+    t.specularIntensity = o.specularFactor !== void 0 ? o.specularFactor : 1, o.specularTexture !== void 0 && r.push(s.assignTexture(t, "specularIntensityMap", o.specularTexture));
+    const c = o.specularColorFactor || [1, 1, 1];
+    return t.specularColor = new se().setRGB(c[0], c[1], c[2], V), o.specularColorTexture !== void 0 && r.push(s.assignTexture(t, "specularColorMap", o.specularColorTexture, ve)), Promise.all(r);
+  }
+}
+class Ys {
+  constructor(e) {
+    this.parser = e, this.name = E.EXT_MATERIALS_BUMP;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser, n = s.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = [], o = n.extensions[this.name];
+    return t.bumpScale = o.bumpFactor !== void 0 ? o.bumpFactor : 1, o.bumpTexture !== void 0 && r.push(s.assignTexture(t, "bumpMap", o.bumpTexture)), Promise.all(r);
+  }
+}
+class Vs {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_ANISOTROPY;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser, n = s.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = [], o = n.extensions[this.name];
+    return o.anisotropyStrength !== void 0 && (t.anisotropy = o.anisotropyStrength), o.anisotropyRotation !== void 0 && (t.anisotropyRotation = o.anisotropyRotation), o.anisotropyTexture !== void 0 && r.push(s.assignTexture(t, "anisotropyMap", o.anisotropyTexture)), Promise.all(r);
+  }
+}
+class Ws {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_TEXTURE_BASISU;
+  }
+  loadTexture(e) {
+    const t = this.parser, s = t.json, n = s.textures[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return null;
+    const r = n.extensions[this.name], o = t.options.ktx2Loader;
+    if (!o) {
+      if (s.extensionsRequired && s.extensionsRequired.indexOf(this.name) >= 0)
+        throw new Error("THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures");
+      return null;
+    }
+    return t.loadTextureImage(e, r.source, o);
+  }
+}
+class zs {
+  constructor(e) {
+    this.parser = e, this.name = E.EXT_TEXTURE_WEBP, this.isSupported = null;
+  }
+  loadTexture(e) {
+    const t = this.name, s = this.parser, n = s.json, r = n.textures[e];
+    if (!r.extensions || !r.extensions[t])
+      return null;
+    const o = r.extensions[t], c = n.images[o.source];
+    let a = s.textureLoader;
+    if (c.uri) {
+      const l = s.options.manager.getHandler(c.uri);
+      l !== null && (a = l);
+    }
+    return this.detectSupport().then(function(l) {
+      if (l) return s.loadTextureImage(e, o.source, a);
+      if (n.extensionsRequired && n.extensionsRequired.indexOf(t) >= 0)
+        throw new Error("THREE.GLTFLoader: WebP required by asset but unsupported.");
+      return s.loadTexture(e);
+    });
+  }
+  detectSupport() {
+    return this.isSupported || (this.isSupported = new Promise(function(e) {
+      const t = new Image();
+      t.src = "data:image/webp;base64,UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA", t.onload = t.onerror = function() {
+        e(t.height === 1);
+      };
+    })), this.isSupported;
+  }
+}
+class qs {
+  constructor(e) {
+    this.parser = e, this.name = E.EXT_TEXTURE_AVIF, this.isSupported = null;
+  }
+  loadTexture(e) {
+    const t = this.name, s = this.parser, n = s.json, r = n.textures[e];
+    if (!r.extensions || !r.extensions[t])
+      return null;
+    const o = r.extensions[t], c = n.images[o.source];
+    let a = s.textureLoader;
+    if (c.uri) {
+      const l = s.options.manager.getHandler(c.uri);
+      l !== null && (a = l);
+    }
+    return this.detectSupport().then(function(l) {
+      if (l) return s.loadTextureImage(e, o.source, a);
+      if (n.extensionsRequired && n.extensionsRequired.indexOf(t) >= 0)
+        throw new Error("THREE.GLTFLoader: AVIF required by asset but unsupported.");
+      return s.loadTexture(e);
+    });
+  }
+  detectSupport() {
+    return this.isSupported || (this.isSupported = new Promise(function(e) {
+      const t = new Image();
+      t.src = "data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAABcAAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAEAAAABAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQAMAAAAABNjb2xybmNseAACAAIABoAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAAB9tZGF0EgAKCBgABogQEDQgMgkQAAAAB8dSLfI=", t.onload = t.onerror = function() {
+        e(t.height === 1);
+      };
+    })), this.isSupported;
+  }
+}
+class Zs {
+  constructor(e) {
+    this.name = E.EXT_MESHOPT_COMPRESSION, this.parser = e;
+  }
+  loadBufferView(e) {
+    const t = this.parser.json, s = t.bufferViews[e];
+    if (s.extensions && s.extensions[this.name]) {
+      const n = s.extensions[this.name], r = this.parser.getDependency("buffer", n.buffer), o = this.parser.options.meshoptDecoder;
+      if (!o || !o.supported) {
+        if (t.extensionsRequired && t.extensionsRequired.indexOf(this.name) >= 0)
+          throw new Error("THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files");
+        return null;
+      }
+      return r.then(function(c) {
+        const a = n.byteOffset || 0, l = n.byteLength || 0, u = n.count, h = n.byteStride, d = new Uint8Array(c, a, l);
+        return o.decodeGltfBufferAsync ? o.decodeGltfBufferAsync(u, h, d, n.mode, n.filter).then(function(p) {
+          return p.buffer;
+        }) : o.ready.then(function() {
+          const p = new ArrayBuffer(u * h);
+          return o.decodeGltfBuffer(new Uint8Array(p), u, h, d, n.mode, n.filter), p;
+        });
+      });
+    } else
+      return null;
+  }
+}
+class Qs {
+  constructor(e) {
+    this.name = E.EXT_MESH_GPU_INSTANCING, this.parser = e;
+  }
+  createNodeMesh(e) {
+    const t = this.parser.json, s = t.nodes[e];
+    if (!s.extensions || !s.extensions[this.name] || s.mesh === void 0)
+      return null;
+    const n = t.meshes[s.mesh];
+    for (const l of n.primitives)
+      if (l.mode !== O.TRIANGLES && l.mode !== O.TRIANGLE_STRIP && l.mode !== O.TRIANGLE_FAN && l.mode !== void 0)
+        return null;
+    const o = s.extensions[this.name].attributes, c = [], a = {};
+    for (const l in o)
+      c.push(this.parser.getDependency("accessor", o[l]).then((u) => (a[l] = u, a[l])));
+    return c.length < 1 ? null : (c.push(this.parser.createNodeMesh(e)), Promise.all(c).then((l) => {
+      const u = l.pop(), h = u.isGroup ? u.children : [u], d = l[0].count, p = [];
+      for (const g of h) {
+        const A = new Ne(), m = new te(), f = new Ct(), x = new te(1, 1, 1), v = new sn(g.geometry, g.material, d);
+        for (let b = 0; b < d; b++)
+          a.TRANSLATION && m.fromBufferAttribute(a.TRANSLATION, b), a.ROTATION && f.fromBufferAttribute(a.ROTATION, b), a.SCALE && x.fromBufferAttribute(a.SCALE, b), v.setMatrixAt(b, A.compose(m, f, x));
+        for (const b in a)
+          if (b === "_COLOR_0") {
+            const y = a[b];
+            v.instanceColor = new rn(y.array, y.itemSize, y.normalized);
+          } else b !== "TRANSLATION" && b !== "ROTATION" && b !== "SCALE" && g.geometry.setAttribute(b, a[b]);
+        Nt.prototype.copy.call(v, g), this.parser.assignFinalMaterial(v), p.push(v);
+      }
+      return u.isGroup ? (u.clear(), u.add(...p), u) : p[0];
+    }));
+  }
+}
+const jt = "glTF", Ae = 12, Mt = { JSON: 1313821514, BIN: 5130562 };
+class $s {
+  constructor(e) {
+    this.name = E.KHR_BINARY_GLTF, this.content = null, this.body = null;
+    const t = new DataView(e, 0, Ae), s = new TextDecoder();
+    if (this.header = {
+      magic: s.decode(new Uint8Array(e.slice(0, 4))),
+      version: t.getUint32(4, !0),
+      length: t.getUint32(8, !0)
+    }, this.header.magic !== jt)
+      throw new Error("THREE.GLTFLoader: Unsupported glTF-Binary header.");
+    if (this.header.version < 2)
+      throw new Error("THREE.GLTFLoader: Legacy binary file detected.");
+    const n = this.header.length - Ae, r = new DataView(e, Ae);
+    let o = 0;
+    for (; o < n; ) {
+      const c = r.getUint32(o, !0);
+      o += 4;
+      const a = r.getUint32(o, !0);
+      if (o += 4, a === Mt.JSON) {
+        const l = new Uint8Array(e, Ae + o, c);
+        this.content = s.decode(l);
+      } else if (a === Mt.BIN) {
+        const l = Ae + o;
+        this.body = e.slice(l, l + c);
+      }
+      o += c;
+    }
+    if (this.content === null)
+      throw new Error("THREE.GLTFLoader: JSON content not found.");
+  }
+}
+class Js {
+  constructor(e, t) {
+    if (!t)
+      throw new Error("THREE.GLTFLoader: No DRACOLoader instance provided.");
+    this.name = E.KHR_DRACO_MESH_COMPRESSION, this.json = e, this.dracoLoader = t, this.dracoLoader.preload();
+  }
+  decodePrimitive(e, t) {
+    const s = this.json, n = this.dracoLoader, r = e.extensions[this.name].bufferView, o = e.extensions[this.name].attributes, c = {}, a = {}, l = {};
+    for (const u in o) {
+      const h = ot[u] || u.toLowerCase();
+      c[h] = o[u];
+    }
+    for (const u in e.attributes) {
+      const h = ot[u] || u.toLowerCase();
+      if (o[u] !== void 0) {
+        const d = s.accessors[e.attributes[u]], p = le[d.componentType];
+        l[h] = p.name, a[h] = d.normalized === !0;
+      }
+    }
+    return t.getDependency("bufferView", r).then(function(u) {
+      return new Promise(function(h, d) {
+        n.decodeDracoFile(u, function(p) {
+          for (const g in p.attributes) {
+            const A = p.attributes[g], m = a[g];
+            m !== void 0 && (A.normalized = m);
+          }
+          h(p);
+        }, c, l, V, d);
+      });
+    });
+  }
+}
+class er {
+  constructor() {
+    this.name = E.KHR_TEXTURE_TRANSFORM;
+  }
+  extendTexture(e, t) {
+    return (t.texCoord === void 0 || t.texCoord === e.channel) && t.offset === void 0 && t.rotation === void 0 && t.scale === void 0 || (e = e.clone(), t.texCoord !== void 0 && (e.channel = t.texCoord), t.offset !== void 0 && e.offset.fromArray(t.offset), t.rotation !== void 0 && (e.rotation = t.rotation), t.scale !== void 0 && e.repeat.fromArray(t.scale), e.needsUpdate = !0), e;
+  }
+}
+class tr {
+  constructor() {
+    this.name = E.KHR_MESH_QUANTIZATION;
+  }
+}
+class Xt extends Pn {
+  constructor(e, t, s, n) {
+    super(e, t, s, n);
+  }
+  copySampleValue_(e) {
+    const t = this.resultBuffer, s = this.sampleValues, n = this.valueSize, r = e * n * 3 + n;
+    for (let o = 0; o !== n; o++)
+      t[o] = s[r + o];
+    return t;
+  }
+  interpolate_(e, t, s, n) {
+    const r = this.resultBuffer, o = this.sampleValues, c = this.valueSize, a = c * 2, l = c * 3, u = n - t, h = (s - t) / u, d = h * h, p = d * h, g = e * l, A = g - l, m = -2 * p + 3 * d, f = p - d, x = 1 - m, v = f - d + h;
+    for (let b = 0; b !== c; b++) {
+      const y = o[A + b + c], L = o[A + b + a] * u, _ = o[g + b + c], D = o[g + b] * u;
+      r[b] = x * y + v * L + m * _ + f * D;
+    }
+    return r;
+  }
+}
+const nr = new Ct();
+class sr extends Xt {
+  interpolate_(e, t, s, n) {
+    const r = super.interpolate_(e, t, s, n);
+    return nr.fromArray(r).normalize().toArray(r), r;
+  }
+}
+const O = {
+  POINTS: 0,
+  LINES: 1,
+  LINE_LOOP: 2,
+  LINE_STRIP: 3,
+  TRIANGLES: 4,
+  TRIANGLE_STRIP: 5,
+  TRIANGLE_FAN: 6
+}, le = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5125: Uint32Array,
+  5126: Float32Array
+}, wt = {
+  9728: Ft,
+  9729: nt,
+  9984: dn,
+  9985: hn,
+  9986: un,
+  9987: Pt
+}, St = {
+  33071: pn,
+  33648: fn,
+  10497: st
+}, Ze = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+}, ot = {
+  POSITION: "position",
+  NORMAL: "normal",
+  TANGENT: "tangent",
+  TEXCOORD_0: "uv",
+  TEXCOORD_1: "uv1",
+  TEXCOORD_2: "uv2",
+  TEXCOORD_3: "uv3",
+  COLOR_0: "color",
+  WEIGHTS_0: "skinWeight",
+  JOINTS_0: "skinIndex"
+}, Q = {
+  scale: "scale",
+  translation: "position",
+  rotation: "quaternion",
+  weights: "morphTargetInfluences"
+}, rr = {
+  CUBICSPLINE: void 0,
+  // We use a custom interpolant (GLTFCubicSplineInterpolation) for CUBICSPLINE tracks. Each
+  // keyframe track will be initialized with a default interpolation type, then modified.
+  LINEAR: Dt,
+  STEP: Cn
+}, Qe = {
+  OPAQUE: "OPAQUE",
+  MASK: "MASK",
+  BLEND: "BLEND"
+};
+function or(i) {
+  return i.DefaultMaterial === void 0 && (i.DefaultMaterial = new Ot({
+    color: 16777215,
+    emissive: 0,
+    metalness: 1,
+    roughness: 1,
+    transparent: !1,
+    depthTest: !0,
+    side: Nn
+  })), i.DefaultMaterial;
+}
+function ee(i, e, t) {
+  for (const s in t.extensions)
+    i[s] === void 0 && (e.userData.gltfExtensions = e.userData.gltfExtensions || {}, e.userData.gltfExtensions[s] = t.extensions[s]);
+}
+function K(i, e) {
+  e.extras !== void 0 && (typeof e.extras == "object" ? Object.assign(i.userData, e.extras) : console.warn("THREE.GLTFLoader: Ignoring primitive type .extras, " + e.extras));
+}
+function ir(i, e, t) {
+  let s = !1, n = !1, r = !1;
+  for (let l = 0, u = e.length; l < u; l++) {
+    const h = e[l];
+    if (h.POSITION !== void 0 && (s = !0), h.NORMAL !== void 0 && (n = !0), h.COLOR_0 !== void 0 && (r = !0), s && n && r) break;
+  }
+  if (!s && !n && !r) return Promise.resolve(i);
+  const o = [], c = [], a = [];
+  for (let l = 0, u = e.length; l < u; l++) {
+    const h = e[l];
+    if (s) {
+      const d = h.POSITION !== void 0 ? t.getDependency("accessor", h.POSITION) : i.attributes.position;
+      o.push(d);
+    }
+    if (n) {
+      const d = h.NORMAL !== void 0 ? t.getDependency("accessor", h.NORMAL) : i.attributes.normal;
+      c.push(d);
+    }
+    if (r) {
+      const d = h.COLOR_0 !== void 0 ? t.getDependency("accessor", h.COLOR_0) : i.attributes.color;
+      a.push(d);
+    }
+  }
+  return Promise.all([
+    Promise.all(o),
+    Promise.all(c),
+    Promise.all(a)
+  ]).then(function(l) {
+    const u = l[0], h = l[1], d = l[2];
+    return s && (i.morphAttributes.position = u), n && (i.morphAttributes.normal = h), r && (i.morphAttributes.color = d), i.morphTargetsRelative = !0, i;
+  });
+}
+function ar(i, e) {
+  if (i.updateMorphTargets(), e.weights !== void 0)
+    for (let t = 0, s = e.weights.length; t < s; t++)
+      i.morphTargetInfluences[t] = e.weights[t];
+  if (e.extras && Array.isArray(e.extras.targetNames)) {
+    const t = e.extras.targetNames;
+    if (i.morphTargetInfluences.length === t.length) {
+      i.morphTargetDictionary = {};
+      for (let s = 0, n = t.length; s < n; s++)
+        i.morphTargetDictionary[t[s]] = s;
+    } else
+      console.warn("THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.");
+  }
+}
+function cr(i) {
+  let e;
+  const t = i.extensions && i.extensions[E.KHR_DRACO_MESH_COMPRESSION];
+  if (t ? e = "draco:" + t.bufferView + ":" + t.indices + ":" + $e(t.attributes) : e = i.indices + ":" + $e(i.attributes) + ":" + i.mode, i.targets !== void 0)
+    for (let s = 0, n = i.targets.length; s < n; s++)
+      e += ":" + $e(i.targets[s]);
+  return e;
+}
+function $e(i) {
+  let e = "";
+  const t = Object.keys(i).sort();
+  for (let s = 0, n = t.length; s < n; s++)
+    e += t[s] + ":" + i[t[s]] + ";";
+  return e;
+}
+function it(i) {
+  switch (i) {
+    case Int8Array:
+      return 1 / 127;
+    case Uint8Array:
+      return 1 / 255;
+    case Int16Array:
+      return 1 / 32767;
+    case Uint16Array:
+      return 1 / 65535;
+    default:
+      throw new Error("THREE.GLTFLoader: Unsupported normalized accessor component type.");
+  }
+}
+function lr(i) {
+  return i.search(/\.jpe?g($|\?)/i) > 0 || i.search(/^data\:image\/jpeg/) === 0 ? "image/jpeg" : i.search(/\.webp($|\?)/i) > 0 || i.search(/^data\:image\/webp/) === 0 ? "image/webp" : i.search(/\.ktx2($|\?)/i) > 0 || i.search(/^data\:image\/ktx2/) === 0 ? "image/ktx2" : "image/png";
+}
+const ur = new Ne();
+class hr {
+  constructor(e = {}, t = {}) {
+    this.json = e, this.extensions = {}, this.plugins = {}, this.options = t, this.cache = new Ps(), this.associations = /* @__PURE__ */ new Map(), this.primitiveCache = {}, this.nodeCache = {}, this.meshCache = { refs: {}, uses: {} }, this.cameraCache = { refs: {}, uses: {} }, this.lightCache = { refs: {}, uses: {} }, this.sourceCache = {}, this.textureCache = {}, this.nodeNamesUsed = {};
+    let s = !1, n = -1, r = !1, o = -1;
+    if (typeof navigator < "u") {
+      const c = navigator.userAgent;
+      s = /^((?!chrome|android).)*safari/i.test(c) === !0;
+      const a = c.match(/Version\/(\d+)/);
+      n = s && a ? parseInt(a[1], 10) : -1, r = c.indexOf("Firefox") > -1, o = r ? c.match(/Firefox\/([0-9]+)\./)[1] : -1;
+    }
+    typeof createImageBitmap > "u" || s && n < 17 || r && o < 98 ? this.textureLoader = new on(this.options.manager) : this.textureLoader = new an(this.options.manager), this.textureLoader.setCrossOrigin(this.options.crossOrigin), this.textureLoader.setRequestHeader(this.options.requestHeader), this.fileLoader = new Lt(this.options.manager), this.fileLoader.setResponseType("arraybuffer"), this.options.crossOrigin === "use-credentials" && this.fileLoader.setWithCredentials(!0);
+  }
+  setExtensions(e) {
+    this.extensions = e;
+  }
+  setPlugins(e) {
+    this.plugins = e;
+  }
+  parse(e, t) {
+    const s = this, n = this.json, r = this.extensions;
+    this.cache.removeAll(), this.nodeCache = {}, this._invokeAll(function(o) {
+      return o._markDefs && o._markDefs();
+    }), Promise.all(this._invokeAll(function(o) {
+      return o.beforeRoot && o.beforeRoot();
+    })).then(function() {
+      return Promise.all([
+        s.getDependencies("scene"),
+        s.getDependencies("animation"),
+        s.getDependencies("camera")
+      ]);
+    }).then(function(o) {
+      const c = {
+        scene: o[0][n.scene || 0],
+        scenes: o[0],
+        animations: o[1],
+        cameras: o[2],
+        asset: n.asset,
+        parser: s,
+        userData: {}
+      };
+      return ee(r, c, n), K(c, n), Promise.all(s._invokeAll(function(a) {
+        return a.afterRoot && a.afterRoot(c);
+      })).then(function() {
+        for (const a of c.scenes)
+          a.updateMatrixWorld();
+        e(c);
+      });
+    }).catch(t);
+  }
+  /**
+   * Marks the special nodes/meshes in json for efficient parse.
+   */
+  _markDefs() {
+    const e = this.json.nodes || [], t = this.json.skins || [], s = this.json.meshes || [];
+    for (let n = 0, r = t.length; n < r; n++) {
+      const o = t[n].joints;
+      for (let c = 0, a = o.length; c < a; c++)
+        e[o[c]].isBone = !0;
+    }
+    for (let n = 0, r = e.length; n < r; n++) {
+      const o = e[n];
+      o.mesh !== void 0 && (this._addNodeRef(this.meshCache, o.mesh), o.skin !== void 0 && (s[o.mesh].isSkinnedMesh = !0)), o.camera !== void 0 && this._addNodeRef(this.cameraCache, o.camera);
+    }
+  }
+  /**
+   * Counts references to shared node / Object3D resources. These resources
+   * can be reused, or "instantiated", at multiple nodes in the scene
+   * hierarchy. Mesh, Camera, and Light instances are instantiated and must
+   * be marked. Non-scenegraph resources (like Materials, Geometries, and
+   * Textures) can be reused directly and are not marked here.
+   *
+   * Example: CesiumMilkTruck sample model reuses "Wheel" meshes.
+   *
+   * @param {Object} cache
+   * @param {Object3D} index
+   */
+  _addNodeRef(e, t) {
+    t !== void 0 && (e.refs[t] === void 0 && (e.refs[t] = e.uses[t] = 0), e.refs[t]++);
+  }
+  /**
+   * Returns a reference to a shared resource, cloning it if necessary.
+   *
+   * @param {Object} cache
+   * @param {Number} index
+   * @param {Object} object
+   * @return {Object}
+   */
+  _getNodeRef(e, t, s) {
+    if (e.refs[t] <= 1) return s;
+    const n = s.clone(), r = (o, c) => {
+      const a = this.associations.get(o);
+      a != null && this.associations.set(c, a);
+      for (const [l, u] of o.children.entries())
+        r(u, c.children[l]);
+    };
+    return r(s, n), n.name += "_instance_" + e.uses[t]++, n;
+  }
+  _invokeOne(e) {
+    const t = Object.values(this.plugins);
+    t.push(this);
+    for (let s = 0; s < t.length; s++) {
+      const n = e(t[s]);
+      if (n) return n;
+    }
+    return null;
+  }
+  _invokeAll(e) {
+    const t = Object.values(this.plugins);
+    t.unshift(this);
+    const s = [];
+    for (let n = 0; n < t.length; n++) {
+      const r = e(t[n]);
+      r && s.push(r);
+    }
+    return s;
+  }
+  /**
+   * Requests the specified dependency asynchronously, with caching.
+   * @param {string} type
+   * @param {number} index
+   * @return {Promise<Object3D|Material|THREE.Texture|AnimationClip|ArrayBuffer|Object>}
+   */
+  getDependency(e, t) {
+    const s = e + ":" + t;
+    let n = this.cache.get(s);
+    if (!n) {
+      switch (e) {
+        case "scene":
+          n = this.loadScene(t);
+          break;
+        case "node":
+          n = this._invokeOne(function(r) {
+            return r.loadNode && r.loadNode(t);
+          });
+          break;
+        case "mesh":
+          n = this._invokeOne(function(r) {
+            return r.loadMesh && r.loadMesh(t);
+          });
+          break;
+        case "accessor":
+          n = this.loadAccessor(t);
+          break;
+        case "bufferView":
+          n = this._invokeOne(function(r) {
+            return r.loadBufferView && r.loadBufferView(t);
+          });
+          break;
+        case "buffer":
+          n = this.loadBuffer(t);
+          break;
+        case "material":
+          n = this._invokeOne(function(r) {
+            return r.loadMaterial && r.loadMaterial(t);
+          });
+          break;
+        case "texture":
+          n = this._invokeOne(function(r) {
+            return r.loadTexture && r.loadTexture(t);
+          });
+          break;
+        case "skin":
+          n = this.loadSkin(t);
+          break;
+        case "animation":
+          n = this._invokeOne(function(r) {
+            return r.loadAnimation && r.loadAnimation(t);
+          });
+          break;
+        case "camera":
+          n = this.loadCamera(t);
+          break;
+        default:
+          if (n = this._invokeOne(function(r) {
+            return r != this && r.getDependency && r.getDependency(e, t);
+          }), !n)
+            throw new Error("Unknown type: " + e);
+          break;
+      }
+      this.cache.add(s, n);
+    }
+    return n;
+  }
+  /**
+   * Requests all dependencies of the specified type asynchronously, with caching.
+   * @param {string} type
+   * @return {Promise<Array<Object>>}
+   */
+  getDependencies(e) {
+    let t = this.cache.get(e);
+    if (!t) {
+      const s = this, n = this.json[e + (e === "mesh" ? "es" : "s")] || [];
+      t = Promise.all(n.map(function(r, o) {
+        return s.getDependency(e, o);
+      })), this.cache.add(e, t);
+    }
+    return t;
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
+   * @param {number} bufferIndex
+   * @return {Promise<ArrayBuffer>}
+   */
+  loadBuffer(e) {
+    const t = this.json.buffers[e], s = this.fileLoader;
+    if (t.type && t.type !== "arraybuffer")
+      throw new Error("THREE.GLTFLoader: " + t.type + " buffer type is not supported.");
+    if (t.uri === void 0 && e === 0)
+      return Promise.resolve(this.extensions[E.KHR_BINARY_GLTF].body);
+    const n = this.options;
+    return new Promise(function(r, o) {
+      s.load(xe.resolveURL(t.uri, n.path), r, void 0, function() {
+        o(new Error('THREE.GLTFLoader: Failed to load buffer "' + t.uri + '".'));
+      });
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
+   * @param {number} bufferViewIndex
+   * @return {Promise<ArrayBuffer>}
+   */
+  loadBufferView(e) {
+    const t = this.json.bufferViews[e];
+    return this.getDependency("buffer", t.buffer).then(function(s) {
+      const n = t.byteLength || 0, r = t.byteOffset || 0;
+      return s.slice(r, r + n);
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
+   * @param {number} accessorIndex
+   * @return {Promise<BufferAttribute|InterleavedBufferAttribute>}
+   */
+  loadAccessor(e) {
+    const t = this, s = this.json, n = this.json.accessors[e];
+    if (n.bufferView === void 0 && n.sparse === void 0) {
+      const o = Ze[n.type], c = le[n.componentType], a = n.normalized === !0, l = new c(n.count * o);
+      return Promise.resolve(new He(l, o, a));
+    }
+    const r = [];
+    return n.bufferView !== void 0 ? r.push(this.getDependency("bufferView", n.bufferView)) : r.push(null), n.sparse !== void 0 && (r.push(this.getDependency("bufferView", n.sparse.indices.bufferView)), r.push(this.getDependency("bufferView", n.sparse.values.bufferView))), Promise.all(r).then(function(o) {
+      const c = o[0], a = Ze[n.type], l = le[n.componentType], u = l.BYTES_PER_ELEMENT, h = u * a, d = n.byteOffset || 0, p = n.bufferView !== void 0 ? s.bufferViews[n.bufferView].byteStride : void 0, g = n.normalized === !0;
+      let A, m;
+      if (p && p !== h) {
+        const f = Math.floor(d / p), x = "InterleavedBuffer:" + n.bufferView + ":" + n.componentType + ":" + f + ":" + n.count;
+        let v = t.cache.get(x);
+        v || (A = new l(c, f * p, n.count * p / u), v = new cn(A, p / u), t.cache.add(x, v)), m = new ln(v, a, d % p / u, g);
+      } else
+        c === null ? A = new l(n.count * a) : A = new l(c, d, n.count * a), m = new He(A, a, g);
+      if (n.sparse !== void 0) {
+        const f = Ze.SCALAR, x = le[n.sparse.indices.componentType], v = n.sparse.indices.byteOffset || 0, b = n.sparse.values.byteOffset || 0, y = new x(o[1], v, n.sparse.count * f), L = new l(o[2], b, n.sparse.count * a);
+        c !== null && (m = new He(m.array.slice(), m.itemSize, m.normalized)), m.normalized = !1;
+        for (let _ = 0, D = y.length; _ < D; _++) {
+          const M = y[_];
+          if (m.setX(M, L[_ * a]), a >= 2 && m.setY(M, L[_ * a + 1]), a >= 3 && m.setZ(M, L[_ * a + 2]), a >= 4 && m.setW(M, L[_ * a + 3]), a >= 5) throw new Error("THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.");
+        }
+        m.normalized = g;
+      }
+      return m;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures
+   * @param {number} textureIndex
+   * @return {Promise<THREE.Texture|null>}
+   */
+  loadTexture(e) {
+    const t = this.json, s = this.options, r = t.textures[e].source, o = t.images[r];
+    let c = this.textureLoader;
+    if (o.uri) {
+      const a = s.manager.getHandler(o.uri);
+      a !== null && (c = a);
+    }
+    return this.loadTextureImage(e, r, c);
+  }
+  loadTextureImage(e, t, s) {
+    const n = this, r = this.json, o = r.textures[e], c = r.images[t], a = (c.uri || c.bufferView) + ":" + o.sampler;
+    if (this.textureCache[a])
+      return this.textureCache[a];
+    const l = this.loadImageSource(t, s).then(function(u) {
+      u.flipY = !1, u.name = o.name || c.name || "", u.name === "" && typeof c.uri == "string" && c.uri.startsWith("data:image/") === !1 && (u.name = c.uri);
+      const d = (r.samplers || {})[o.sampler] || {};
+      return u.magFilter = wt[d.magFilter] || nt, u.minFilter = wt[d.minFilter] || Pt, u.wrapS = St[d.wrapS] || st, u.wrapT = St[d.wrapT] || st, u.generateMipmaps = !u.isCompressedTexture && u.minFilter !== Ft && u.minFilter !== nt, n.associations.set(u, { textures: e }), u;
+    }).catch(function() {
+      return null;
+    });
+    return this.textureCache[a] = l, l;
+  }
+  loadImageSource(e, t) {
+    const s = this, n = this.json, r = this.options;
+    if (this.sourceCache[e] !== void 0)
+      return this.sourceCache[e].then((h) => h.clone());
+    const o = n.images[e], c = self.URL || self.webkitURL;
+    let a = o.uri || "", l = !1;
+    if (o.bufferView !== void 0)
+      a = s.getDependency("bufferView", o.bufferView).then(function(h) {
+        l = !0;
+        const d = new Blob([h], { type: o.mimeType });
+        return a = c.createObjectURL(d), a;
+      });
+    else if (o.uri === void 0)
+      throw new Error("THREE.GLTFLoader: Image " + e + " is missing URI and bufferView");
+    const u = Promise.resolve(a).then(function(h) {
+      return new Promise(function(d, p) {
+        let g = d;
+        t.isImageBitmapLoader === !0 && (g = function(A) {
+          const m = new ft(A);
+          m.needsUpdate = !0, d(m);
+        }), t.load(xe.resolveURL(h, r.path), g, void 0, p);
+      });
+    }).then(function(h) {
+      return l === !0 && c.revokeObjectURL(a), K(h, o), h.userData.mimeType = o.mimeType || lr(o.uri), h;
+    }).catch(function(h) {
+      throw console.error("THREE.GLTFLoader: Couldn't load texture", a), h;
+    });
+    return this.sourceCache[e] = u, u;
+  }
+  /**
+   * Asynchronously assigns a texture to the given material parameters.
+   *
+   * @param {Object} materialParams
+   * @param {string} mapName
+   * @param {Object} mapDef
+   * @param {string} colorSpace
+   * @return {Promise<Texture>}
+   */
+  assignTexture(e, t, s, n) {
+    const r = this;
+    return this.getDependency("texture", s.index).then(function(o) {
+      if (!o) return null;
+      if (s.texCoord !== void 0 && s.texCoord > 0 && (o = o.clone(), o.channel = s.texCoord), r.extensions[E.KHR_TEXTURE_TRANSFORM]) {
+        const c = s.extensions !== void 0 ? s.extensions[E.KHR_TEXTURE_TRANSFORM] : void 0;
+        if (c) {
+          const a = r.associations.get(o);
+          o = r.extensions[E.KHR_TEXTURE_TRANSFORM].extendTexture(o, c), r.associations.set(o, a);
+        }
+      }
+      return n !== void 0 && (o.colorSpace = n), e[t] = o, o;
+    });
+  }
+  /**
+   * Assigns final material to a Mesh, Line, or Points instance. The instance
+   * already has a material (generated from the glTF material options alone)
+   * but reuse of the same glTF material may require multiple threejs materials
+   * to accommodate different primitive types, defines, etc. New materials will
+   * be created if necessary, and reused from a cache.
+   * @param  {Object3D} mesh Mesh, Line, or Points instance.
+   */
+  assignFinalMaterial(e) {
+    const t = e.geometry;
+    let s = e.material;
+    const n = t.attributes.tangent === void 0, r = t.attributes.color !== void 0, o = t.attributes.normal === void 0;
+    if (e.isPoints) {
+      const c = "PointsMaterial:" + s.uuid;
+      let a = this.cache.get(c);
+      a || (a = new mn(), je.prototype.copy.call(a, s), a.color.copy(s.color), a.map = s.map, a.sizeAttenuation = !1, this.cache.add(c, a)), s = a;
+    } else if (e.isLine) {
+      const c = "LineBasicMaterial:" + s.uuid;
+      let a = this.cache.get(c);
+      a || (a = new gn(), je.prototype.copy.call(a, s), a.color.copy(s.color), a.map = s.map, this.cache.add(c, a)), s = a;
+    }
+    if (n || r || o) {
+      let c = "ClonedMaterial:" + s.uuid + ":";
+      n && (c += "derivative-tangents:"), r && (c += "vertex-colors:"), o && (c += "flat-shading:");
+      let a = this.cache.get(c);
+      a || (a = s.clone(), r && (a.vertexColors = !0), o && (a.flatShading = !0), n && (a.normalScale && (a.normalScale.y *= -1), a.clearcoatNormalScale && (a.clearcoatNormalScale.y *= -1)), this.cache.add(c, a), this.associations.set(a, this.associations.get(s))), s = a;
+    }
+    e.material = s;
+  }
+  getMaterialType() {
+    return Ot;
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
+   * @param {number} materialIndex
+   * @return {Promise<Material>}
+   */
+  loadMaterial(e) {
+    const t = this, s = this.json, n = this.extensions, r = s.materials[e];
+    let o;
+    const c = {}, a = r.extensions || {}, l = [];
+    if (a[E.KHR_MATERIALS_UNLIT]) {
+      const h = n[E.KHR_MATERIALS_UNLIT];
+      o = h.getMaterialType(), l.push(h.extendParams(c, r, t));
+    } else {
+      const h = r.pbrMetallicRoughness || {};
+      if (c.color = new se(1, 1, 1), c.opacity = 1, Array.isArray(h.baseColorFactor)) {
+        const d = h.baseColorFactor;
+        c.color.setRGB(d[0], d[1], d[2], V), c.opacity = d[3];
+      }
+      h.baseColorTexture !== void 0 && l.push(t.assignTexture(c, "map", h.baseColorTexture, ve)), c.metalness = h.metallicFactor !== void 0 ? h.metallicFactor : 1, c.roughness = h.roughnessFactor !== void 0 ? h.roughnessFactor : 1, h.metallicRoughnessTexture !== void 0 && (l.push(t.assignTexture(c, "metalnessMap", h.metallicRoughnessTexture)), l.push(t.assignTexture(c, "roughnessMap", h.metallicRoughnessTexture))), o = this._invokeOne(function(d) {
+        return d.getMaterialType && d.getMaterialType(e);
+      }), l.push(Promise.all(this._invokeAll(function(d) {
+        return d.extendMaterialParams && d.extendMaterialParams(e, c);
+      })));
+    }
+    r.doubleSided === !0 && (c.side = Ie);
+    const u = r.alphaMode || Qe.OPAQUE;
+    if (u === Qe.BLEND ? (c.transparent = !0, c.depthWrite = !1) : (c.transparent = !1, u === Qe.MASK && (c.alphaTest = r.alphaCutoff !== void 0 ? r.alphaCutoff : 0.5)), r.normalTexture !== void 0 && o !== Te && (l.push(t.assignTexture(c, "normalMap", r.normalTexture)), c.normalScale = new It(1, 1), r.normalTexture.scale !== void 0)) {
+      const h = r.normalTexture.scale;
+      c.normalScale.set(h, h);
+    }
+    if (r.occlusionTexture !== void 0 && o !== Te && (l.push(t.assignTexture(c, "aoMap", r.occlusionTexture)), r.occlusionTexture.strength !== void 0 && (c.aoMapIntensity = r.occlusionTexture.strength)), r.emissiveFactor !== void 0 && o !== Te) {
+      const h = r.emissiveFactor;
+      c.emissive = new se().setRGB(h[0], h[1], h[2], V);
+    }
+    return r.emissiveTexture !== void 0 && o !== Te && l.push(t.assignTexture(c, "emissiveMap", r.emissiveTexture, ve)), Promise.all(l).then(function() {
+      const h = new o(c);
+      return r.name && (h.name = r.name), K(h, r), t.associations.set(h, { materials: e }), r.extensions && ee(n, h, r), h;
+    });
+  }
+  /**
+   * When Object3D instances are targeted by animation, they need unique names.
+   *
+   * @param {String} originalName
+   * @return {String}
+   */
+  createUniqueName(e) {
+    const t = An.sanitizeNodeName(e || "");
+    return t in this.nodeNamesUsed ? t + "_" + ++this.nodeNamesUsed[t] : (this.nodeNamesUsed[t] = 0, t);
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#geometry
+   *
+   * Creates BufferGeometries from primitives.
+   *
+   * @param {Array<GLTF.Primitive>} primitives
+   * @return {Promise<Array<BufferGeometry>>}
+   */
+  loadGeometries(e) {
+    const t = this, s = this.extensions, n = this.primitiveCache;
+    function r(c) {
+      return s[E.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(c, t).then(function(a) {
+        return yt(a, c, t);
+      });
+    }
+    const o = [];
+    for (let c = 0, a = e.length; c < a; c++) {
+      const l = e[c], u = cr(l), h = n[u];
+      if (h)
+        o.push(h.promise);
+      else {
+        let d;
+        l.extensions && l.extensions[E.KHR_DRACO_MESH_COMPRESSION] ? d = r(l) : d = yt(new Tn(), l, t), n[u] = { primitive: l, promise: d }, o.push(d);
+      }
+    }
+    return Promise.all(o);
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes
+   * @param {number} meshIndex
+   * @return {Promise<Group|Mesh|SkinnedMesh>}
+   */
+  loadMesh(e) {
+    const t = this, s = this.json, n = this.extensions, r = s.meshes[e], o = r.primitives, c = [];
+    for (let a = 0, l = o.length; a < l; a++) {
+      const u = o[a].material === void 0 ? or(this.cache) : this.getDependency("material", o[a].material);
+      c.push(u);
+    }
+    return c.push(t.loadGeometries(o)), Promise.all(c).then(function(a) {
+      const l = a.slice(0, a.length - 1), u = a[a.length - 1], h = [];
+      for (let p = 0, g = u.length; p < g; p++) {
+        const A = u[p], m = o[p];
+        let f;
+        const x = l[p];
+        if (m.mode === O.TRIANGLES || m.mode === O.TRIANGLE_STRIP || m.mode === O.TRIANGLE_FAN || m.mode === void 0)
+          f = r.isSkinnedMesh === !0 ? new xn(A, x) : new vn(A, x), f.isSkinnedMesh === !0 && f.normalizeSkinWeights(), m.mode === O.TRIANGLE_STRIP ? f.geometry = Rt(f.geometry, _t) : m.mode === O.TRIANGLE_FAN && (f.geometry = Rt(f.geometry, tt));
+        else if (m.mode === O.LINES)
+          f = new bn(A, x);
+        else if (m.mode === O.LINE_STRIP)
+          f = new En(A, x);
+        else if (m.mode === O.LINE_LOOP)
+          f = new Rn(A, x);
+        else if (m.mode === O.POINTS)
+          f = new Mn(A, x);
+        else
+          throw new Error("THREE.GLTFLoader: Primitive mode unsupported: " + m.mode);
+        Object.keys(f.geometry.morphAttributes).length > 0 && ar(f, r), f.name = t.createUniqueName(r.name || "mesh_" + e), K(f, r), m.extensions && ee(n, f, m), t.assignFinalMaterial(f), h.push(f);
+      }
+      for (let p = 0, g = h.length; p < g; p++)
+        t.associations.set(h[p], {
+          meshes: e,
+          primitives: p
+        });
+      if (h.length === 1)
+        return r.extensions && ee(n, h[0], r), h[0];
+      const d = new Xe();
+      r.extensions && ee(n, d, r), t.associations.set(d, { meshes: e });
+      for (let p = 0, g = h.length; p < g; p++)
+        d.add(h[p]);
+      return d;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
+   * @param {number} cameraIndex
+   * @return {Promise<THREE.Camera>}
+   */
+  loadCamera(e) {
+    let t;
+    const s = this.json.cameras[e], n = s[s.type];
+    if (!n) {
+      console.warn("THREE.GLTFLoader: Missing camera parameters.");
+      return;
+    }
+    return s.type === "perspective" ? t = new wn(Sn.radToDeg(n.yfov), n.aspectRatio || 1, n.znear || 1, n.zfar || 2e6) : s.type === "orthographic" && (t = new yn(-n.xmag, n.xmag, n.ymag, -n.ymag, n.znear, n.zfar)), s.name && (t.name = this.createUniqueName(s.name)), K(t, s), Promise.resolve(t);
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
+   * @param {number} skinIndex
+   * @return {Promise<Skeleton>}
+   */
+  loadSkin(e) {
+    const t = this.json.skins[e], s = [];
+    for (let n = 0, r = t.joints.length; n < r; n++)
+      s.push(this._loadNodeShallow(t.joints[n]));
+    return t.inverseBindMatrices !== void 0 ? s.push(this.getDependency("accessor", t.inverseBindMatrices)) : s.push(null), Promise.all(s).then(function(n) {
+      const r = n.pop(), o = n, c = [], a = [];
+      for (let l = 0, u = o.length; l < u; l++) {
+        const h = o[l];
+        if (h) {
+          c.push(h);
+          const d = new Ne();
+          r !== null && d.fromArray(r.array, l * 16), a.push(d);
+        } else
+          console.warn('THREE.GLTFLoader: Joint "%s" could not be found.', t.joints[l]);
+      }
+      return new _n(c, a);
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
+   * @param {number} animationIndex
+   * @return {Promise<AnimationClip>}
+   */
+  loadAnimation(e) {
+    const t = this.json, s = this, n = t.animations[e], r = n.name ? n.name : "animation_" + e, o = [], c = [], a = [], l = [], u = [];
+    for (let h = 0, d = n.channels.length; h < d; h++) {
+      const p = n.channels[h], g = n.samplers[p.sampler], A = p.target, m = A.node, f = n.parameters !== void 0 ? n.parameters[g.input] : g.input, x = n.parameters !== void 0 ? n.parameters[g.output] : g.output;
+      A.node !== void 0 && (o.push(this.getDependency("node", m)), c.push(this.getDependency("accessor", f)), a.push(this.getDependency("accessor", x)), l.push(g), u.push(A));
+    }
+    return Promise.all([
+      Promise.all(o),
+      Promise.all(c),
+      Promise.all(a),
+      Promise.all(l),
+      Promise.all(u)
+    ]).then(function(h) {
+      const d = h[0], p = h[1], g = h[2], A = h[3], m = h[4], f = [];
+      for (let x = 0, v = d.length; x < v; x++) {
+        const b = d[x], y = p[x], L = g[x], _ = A[x], D = m[x];
+        if (b === void 0) continue;
+        b.updateMatrix && b.updateMatrix();
+        const M = s._createAnimationTracks(b, y, L, _, D);
+        if (M)
+          for (let P = 0; P < M.length; P++)
+            f.push(M[P]);
+      }
+      return new Ln(r, void 0, f);
+    });
+  }
+  createNodeMesh(e) {
+    const t = this.json, s = this, n = t.nodes[e];
+    return n.mesh === void 0 ? null : s.getDependency("mesh", n.mesh).then(function(r) {
+      const o = s._getNodeRef(s.meshCache, n.mesh, r);
+      return n.weights !== void 0 && o.traverse(function(c) {
+        if (c.isMesh)
+          for (let a = 0, l = n.weights.length; a < l; a++)
+            c.morphTargetInfluences[a] = n.weights[a];
+      }), o;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
+   * @param {number} nodeIndex
+   * @return {Promise<Object3D>}
+   */
+  loadNode(e) {
+    const t = this.json, s = this, n = t.nodes[e], r = s._loadNodeShallow(e), o = [], c = n.children || [];
+    for (let l = 0, u = c.length; l < u; l++)
+      o.push(s.getDependency("node", c[l]));
+    const a = n.skin === void 0 ? Promise.resolve(null) : s.getDependency("skin", n.skin);
+    return Promise.all([
+      r,
+      Promise.all(o),
+      a
+    ]).then(function(l) {
+      const u = l[0], h = l[1], d = l[2];
+      d !== null && u.traverse(function(p) {
+        p.isSkinnedMesh && p.bind(d, ur);
+      });
+      for (let p = 0, g = h.length; p < g; p++)
+        u.add(h[p]);
+      return u;
+    });
+  }
+  // ._loadNodeShallow() parses a single node.
+  // skin and child nodes are created and added in .loadNode() (no '_' prefix).
+  _loadNodeShallow(e) {
+    const t = this.json, s = this.extensions, n = this;
+    if (this.nodeCache[e] !== void 0)
+      return this.nodeCache[e];
+    const r = t.nodes[e], o = r.name ? n.createUniqueName(r.name) : "", c = [], a = n._invokeOne(function(l) {
+      return l.createNodeMesh && l.createNodeMesh(e);
+    });
+    return a && c.push(a), r.camera !== void 0 && c.push(n.getDependency("camera", r.camera).then(function(l) {
+      return n._getNodeRef(n.cameraCache, r.camera, l);
+    })), n._invokeAll(function(l) {
+      return l.createNodeAttachment && l.createNodeAttachment(e);
+    }).forEach(function(l) {
+      c.push(l);
+    }), this.nodeCache[e] = Promise.all(c).then(function(l) {
+      let u;
+      if (r.isBone === !0 ? u = new In() : l.length > 1 ? u = new Xe() : l.length === 1 ? u = l[0] : u = new Nt(), u !== l[0])
+        for (let h = 0, d = l.length; h < d; h++)
+          u.add(l[h]);
+      if (r.name && (u.userData.name = r.name, u.name = o), K(u, r), r.extensions && ee(s, u, r), r.matrix !== void 0) {
+        const h = new Ne();
+        h.fromArray(r.matrix), u.applyMatrix4(h);
+      } else
+        r.translation !== void 0 && u.position.fromArray(r.translation), r.rotation !== void 0 && u.quaternion.fromArray(r.rotation), r.scale !== void 0 && u.scale.fromArray(r.scale);
+      return n.associations.has(u) || n.associations.set(u, {}), n.associations.get(u).nodes = e, u;
+    }), this.nodeCache[e];
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes
+   * @param {number} sceneIndex
+   * @return {Promise<Group>}
+   */
+  loadScene(e) {
+    const t = this.extensions, s = this.json.scenes[e], n = this, r = new Xe();
+    s.name && (r.name = n.createUniqueName(s.name)), K(r, s), s.extensions && ee(t, r, s);
+    const o = s.nodes || [], c = [];
+    for (let a = 0, l = o.length; a < l; a++)
+      c.push(n.getDependency("node", o[a]));
+    return Promise.all(c).then(function(a) {
+      for (let u = 0, h = a.length; u < h; u++)
+        r.add(a[u]);
+      const l = (u) => {
+        const h = /* @__PURE__ */ new Map();
+        for (const [d, p] of n.associations)
+          (d instanceof je || d instanceof ft) && h.set(d, p);
+        return u.traverse((d) => {
+          const p = n.associations.get(d);
+          p != null && h.set(d, p);
+        }), h;
+      };
+      return n.associations = l(r), r;
+    });
+  }
+  _createAnimationTracks(e, t, s, n, r) {
+    const o = [], c = e.name ? e.name : e.uuid, a = [];
+    Q[r.path] === Q.weights ? e.traverse(function(d) {
+      d.morphTargetInfluences && a.push(d.name ? d.name : d.uuid);
+    }) : a.push(c);
+    let l;
+    switch (Q[r.path]) {
+      case Q.weights:
+        l = mt;
+        break;
+      case Q.rotation:
+        l = gt;
+        break;
+      case Q.position:
+      case Q.scale:
+        l = pt;
+        break;
+      default:
+        switch (s.itemSize) {
+          case 1:
+            l = mt;
+            break;
+          case 2:
+          case 3:
+          default:
+            l = pt;
+            break;
+        }
+        break;
+    }
+    const u = n.interpolation !== void 0 ? rr[n.interpolation] : Dt, h = this._getArrayFromAccessor(s);
+    for (let d = 0, p = a.length; d < p; d++) {
+      const g = new l(
+        a[d] + "." + Q[r.path],
+        t.array,
+        h,
+        u
+      );
+      n.interpolation === "CUBICSPLINE" && this._createCubicSplineTrackInterpolant(g), o.push(g);
+    }
+    return o;
+  }
+  _getArrayFromAccessor(e) {
+    let t = e.array;
+    if (e.normalized) {
+      const s = it(t.constructor), n = new Float32Array(t.length);
+      for (let r = 0, o = t.length; r < o; r++)
+        n[r] = t[r] * s;
+      t = n;
+    }
+    return t;
+  }
+  _createCubicSplineTrackInterpolant(e) {
+    e.createInterpolant = function(s) {
+      const n = this instanceof gt ? sr : Xt;
+      return new n(this.times, this.values, this.getValueSize() / 3, s);
+    }, e.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = !0;
+  }
+}
+function dr(i, e, t) {
+  const s = e.attributes, n = new Fn();
+  if (s.POSITION !== void 0) {
+    const c = t.json.accessors[s.POSITION], a = c.min, l = c.max;
+    if (a !== void 0 && l !== void 0) {
+      if (n.set(
+        new te(a[0], a[1], a[2]),
+        new te(l[0], l[1], l[2])
+      ), c.normalized) {
+        const u = it(le[c.componentType]);
+        n.min.multiplyScalar(u), n.max.multiplyScalar(u);
+      }
+    } else {
+      console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      return;
+    }
+  } else
+    return;
+  const r = e.targets;
+  if (r !== void 0) {
+    const c = new te(), a = new te();
+    for (let l = 0, u = r.length; l < u; l++) {
+      const h = r[l];
+      if (h.POSITION !== void 0) {
+        const d = t.json.accessors[h.POSITION], p = d.min, g = d.max;
+        if (p !== void 0 && g !== void 0) {
+          if (a.setX(Math.max(Math.abs(p[0]), Math.abs(g[0]))), a.setY(Math.max(Math.abs(p[1]), Math.abs(g[1]))), a.setZ(Math.max(Math.abs(p[2]), Math.abs(g[2]))), d.normalized) {
+            const A = it(le[d.componentType]);
+            a.multiplyScalar(A);
+          }
+          c.max(a);
+        } else
+          console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      }
+    }
+    n.expandByVector(c);
+  }
+  i.boundingBox = n;
+  const o = new On();
+  n.getCenter(o.center), o.radius = n.min.distanceTo(n.max) / 2, i.boundingSphere = o;
+}
+function yt(i, e, t) {
+  const s = e.attributes, n = [];
+  function r(o, c) {
+    return t.getDependency("accessor", o).then(function(a) {
+      i.setAttribute(c, a);
+    });
+  }
+  for (const o in s) {
+    const c = ot[o] || o.toLowerCase();
+    c in i.attributes || n.push(r(s[o], c));
+  }
+  if (e.indices !== void 0 && !i.index) {
+    const o = t.getDependency("accessor", e.indices).then(function(c) {
+      i.setIndex(c);
+    });
+    n.push(o);
+  }
+  return At.workingColorSpace !== V && "COLOR_0" in s && console.warn(`THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${At.workingColorSpace}" not supported.`), K(i, e), dr(i, e, t), Promise.all(n).then(function() {
+    return e.targets !== void 0 ? ir(i, e.targets, t) : i;
+  });
+}
+const Ce = [0, 0, -10], ne = [0.5, 0.5, 0.5], Kt = 1, Je = /* @__PURE__ */ new Map(), fr = (i) => {
+  const e = Je.get(i);
+  if (e) return e;
+  const t = new Ns(), s = Bt(i).then(
+    (n) => new Promise((r, o) => {
+      t.parse(n, "", r, o);
+    })
+  ).catch((n) => {
+    throw Je.delete(i), n;
+  });
+  return Je.set(i, s), s;
+}, Yt = ({
+  position: i,
+  rotation: e,
+  scale: t,
+  url: s,
+  showDebugMaterial: n = !1,
+  opacity: r = Kt
+}) => {
+  const o = s ?? new URL("/assets/xr/3d-models/head-occluder-v2.glb", Pe.assetStorageEndpoint).toString(), [c, a] = at(null);
+  $(() => {
+    let u = !1;
+    return fr(o).then((h) => {
+      u || a(h.scene);
+    }).catch((h) => {
+      u || console.error(`${Pe.loggerPrefix} head occluder load failed`, h);
+    }), () => {
+      u = !0;
+    };
+  }, [o]);
+  const l = j(() => {
+    if (!c) return null;
+    const u = c.clone();
+    return u.traverse((h) => {
+      h instanceof R.Mesh && (h.material = new R.MeshStandardMaterial({
+        color: 15132390,
+        colorWrite: n,
+        depthWrite: !0,
+        opacity: n ? r : 1,
+        side: R.DoubleSide,
+        transparent: n
+      }));
+    }), u;
+  }, [c, n, r]);
+  return $(() => {
+    if (l)
+      return () => {
+        l.traverse((u) => {
+          u instanceof R.Mesh && u.material.dispose();
+        });
+      };
+  }, [l]), l ? (i ? l.position.set(i[0], i[1], i[2]) : l.position.set(
+    Ce[0],
+    Ce[1],
+    Ce[2]
+  ), e && l.rotation.set(e[0], e[1], e[2]), t ? l.scale.set(t[0], t[1], t[2]) : l.scale.set(
+    ne[0],
+    ne[1],
+    ne[2]
+  ), l.renderOrder = -1, /* @__PURE__ */ T("primitive", { object: l })) : null;
+}, pr = 4, Yr = ({
+  children: i,
+  faceIndex: e = 0,
+  numFaces: t = pr,
+  scaleWithFace: s = !0,
+  occluder: n = !0,
+  showFaceMesh: r = !1,
+  faceMeshMaterial: o
+}) => {
+  const c = j(
+    () => new R.MeshBasicMaterial({
+      color: "#22c55e",
+      side: R.BackSide,
+      transparent: !0,
+      opacity: 0.35,
+      depthWrite: !1
+    }),
+    []
+  ), a = n === !1 ? null : n === !0 ? {} : n;
+  return /* @__PURE__ */ w(Hn, { faceIndex: e, numFaces: t, scaleWithFace: s, children: [
+    a && /* @__PURE__ */ T(
+      Yt,
+      {
+        position: a.position ?? Ce,
+        rotation: a.rotation,
+        scale: a.scale ?? ne,
+        url: a.url,
+        showDebugMaterial: a.showDebugMaterial,
+        opacity: a.opacity ?? Kt
+      }
+    ),
+    i,
+    r && /* @__PURE__ */ T(
+      jn,
+      {
+        faceIndex: e,
+        numFaces: t,
+        material: o ?? c
+      }
+    )
+  ] });
+}, mr = 57, gr = 15.5, et = mr / Math.PI / gr, Ar = -0.134, Tr = -0.024, Y = (i, e, t) => Math.min(t, Math.max(e, i)), Vt = (i, e) => i * e - e / 2, Wt = (i, e) => -(i * e - e / 2), xr = ({
+  eyeMidX: i,
+  noseX: e,
+  offsetX: t,
+  rawYaw: s,
+  sideMidX: n
+}) => {
+  const r = Y((Math.abs(s) - 0.18) / 0.42, 0, 1), o = n * 0.75 + i * 0.25, c = i * 0.7 + e * 0.3;
+  return o * (1 - r) + c * r + t;
+}, Vr = ({
+  baseScale: i,
+  pitchRadians: e
+}) => {
+  const t = e * 180 / Math.PI, n = 1 + Y((t - 6) / 22, 0, 1) * 0.22;
+  return [i[0] * n, i[1] * n, i[2] * n];
+}, Wr = ({ yawRadians: i }) => {
+  const e = Math.abs(i * 180 / Math.PI), s = 0.066 * Y((e - 8) / 12, 0, 1);
+  return Math.sign(i) * s;
+}, zr = ({
+  pitchRadians: i
+}) => {
+  const e = i * 180 / Math.PI;
+  return -0.026 * Y((-e - 6) / 18, 0, 1);
+}, qr = ({
+  baseOffset: i,
+  yawRadians: e
+}) => {
+  const t = Math.abs(e * 180 / Math.PI), s = Y((t - 8) / 24, 0, 1);
+  return i + s * 0.25;
+}, Zr = ({
+  baseOffsetY: i,
+  baseScaleY: e,
+  face: t
+}) => {
+  if (!t || t.bounds.width <= 0)
+    return {
+      aspectRatio: 0,
+      normalizedAspect: 0,
+      scaleY: e,
+      offsetY: i
+    };
+  const s = t.bounds.height / t.bounds.width, n = Y((s - 1.55) / 0.35, -1, 1);
+  return {
+    aspectRatio: s,
+    normalizedAspect: n,
+    scaleY: e + n * 0.06,
+    offsetY: i + n * 5e-3
+  };
+}, vr = ({
+  face: i,
+  offsetX: e,
+  offsetY: t,
+  scaleX: s,
+  scaleY: n
+}) => {
+  const r = i.bounds.width * s, o = i.bounds.height * n, c = i.bounds.centerX + e, a = i.bounds.centerY + t;
+  return {
+    x: c - r * 0.5,
+    y: a - o * 0.5,
+    width: r,
+    height: o,
+    centerX: c,
+    centerY: a
+  };
+}, br = ({
+  face: i,
+  height: e,
+  lockDepth: t,
+  lockRotation: s,
+  model: n,
+  offsetX: r,
+  offsetY: o,
+  scaleX: c,
+  scaleY: a,
+  scaleZ: l,
+  width: u
+}) => {
+  const h = vr({
+    face: i,
+    offsetX: r,
+    offsetY: o,
+    scaleX: c,
+    scaleY: a
+  }), d = i.landmarks[33], p = i.landmarks[263], g = i.landmarks[234], A = i.landmarks[454], m = i.landmarks[1], f = i.landmarks[10], x = i.landmarks[152], v = h.width * u, b = h.height * e, y = d && p ? (d.x + p.x) * 0.5 : i.bounds.centerX, L = d && p ? (d.y + p.y) * 0.5 : i.bounds.centerY - i.bounds.height * 0.15, _ = g && A ? (g.x + A.x) * 0.5 : y, D = (f == null ? void 0 : f.y) ?? i.bounds.minY, M = (x == null ? void 0 : x.y) ?? i.bounds.maxY, P = (D + M) * 0.5, re = d && p ? Math.atan2(p.y - d.y, p.x - d.x) : 0, I = m && i.bounds.width > 0 ? Y((m.x - i.bounds.centerX) / (i.bounds.width * 0.5), -1, 1) * 0.75 : 0, W = xr({
+    eyeMidX: y,
+    noseX: (m == null ? void 0 : m.x) ?? y,
+    offsetX: r,
+    rawYaw: I,
+    sideMidX: _
+  }), S = P * 0.75 + L * 0.25 + o, oe = n === "v2" ? Vt(W, u) : h.centerX * u - u / 2, z = n === "v2" ? Wt(i.bounds.centerY + o * 0.75, e) : -(h.centerY * e - e / 2), q = f && m ? Math.max(1e-4, m.y - f.y) : i.bounds.height * 0.42, ue = m && x ? Math.max(1e-4, x.y - m.y) : i.bounds.height * 0.58, he = (ue - q) / (ue + q), de = Y((he - Ar) / 0.28, -1, 1) * 0.58, fe = m && i.bounds.height > 0 ? Y(
+    (i.bounds.centerY - m.y) / (i.bounds.height * 0.5) - Tr,
+    -1,
+    1
+  ) * 0.18 : 0, ie = de * 0.82 + fe * 0.18, ae = s ? 0 : n === "v2" ? I * 0.72 : I, pe = s ? 0 : n === "v2" ? -ie * 0.78 : -ie, me = s ? 0 : -re, be = t ? v * et : n === "v2" ? v * (et + Math.abs(ae) * 0.18) : v * et;
+  return {
+    centerXPx: oe,
+    centerYPx: z,
+    depthPx: be * l,
+    heightPx: b,
+    pitch: pe,
+    rawPitch: ie,
+    rawPitchFromBalance: de,
+    rawPitchFromCenter: fe,
+    rawYaw: I,
+    rotationZ: me,
+    roll: re,
+    shape: h,
+    skullAnchorX: W,
+    skullAnchorY: S,
+    verticalBalance: he,
+    widthPx: v,
+    yaw: ae
+  };
+}, Er = ({
+  lockDepth: i,
+  lockRotation: e,
+  model: t,
+  face: s,
+  height: n,
+  headDepthOffset: r,
+  offsetX: o,
+  offsetY: c,
+  rotationOffsetX: a,
+  rotationOffsetY: l,
+  rotationOffsetZ: u,
+  scaleX: h,
+  scaleY: d,
+  scaleZ: p,
+  skullCenterMode: g,
+  skullVerticalBias: A,
+  width: m
+}) => zt({
+  lockDepth: i,
+  lockRotation: e,
+  model: t,
+  face: s,
+  height: n,
+  headDepthOffset: r,
+  offsetX: o,
+  offsetY: c,
+  rotationOffsetX: a,
+  rotationOffsetY: l,
+  rotationOffsetZ: u,
+  scaleX: h,
+  scaleY: d,
+  scaleZ: p,
+  skullCenterMode: g,
+  skullVerticalBias: A,
+  width: m
+}).pose, zt = ({
+  lockDepth: i,
+  lockRotation: e,
+  model: t,
+  face: s,
+  height: n,
+  headDepthOffset: r,
+  offsetX: o,
+  offsetY: c,
+  rotationOffsetX: a,
+  rotationOffsetY: l,
+  rotationOffsetZ: u,
+  scaleX: h,
+  scaleY: d,
+  scaleZ: p,
+  skullCenterMode: g,
+  skullVerticalBias: A,
+  width: m
+}) => {
+  const f = br({
+    face: s,
+    height: n,
+    lockDepth: i,
+    lockRotation: e,
+    model: t,
+    offsetX: o,
+    offsetY: c,
+    scaleX: h,
+    scaleY: d,
+    scaleZ: p,
+    width: m
+  });
+  if (g) {
+    const v = new te(
+      0,
+      f.heightPx * A,
+      -f.depthPx * r
+    ).applyEuler(
+      new Dn(f.pitch, f.yaw, f.rotationZ, "XYZ")
+    ), b = Vt(f.skullAnchorX, m), y = Wt(f.skullAnchorY, n);
+    return {
+      pose: {
+        boxCenterZ: v.z,
+        centerX: b + v.x,
+        centerY: y + v.y,
+        width: f.widthPx,
+        height: f.heightPx,
+        depth: f.depthPx,
+        rotationX: f.pitch + a,
+        rotationY: f.yaw + l,
+        rotationZ: f.rotationZ + u
+      },
+      debugMetrics: {
+        face: {
+          centerX: f.shape.centerX,
+          centerY: f.shape.centerY,
+          width: f.shape.width,
+          height: f.shape.height
+        },
+        normalized: {
+          rawPitch: f.rawPitch,
+          rawPitchFromBalance: f.rawPitchFromBalance,
+          rawPitchFromCenter: f.rawPitchFromCenter,
+          rawYaw: f.rawYaw,
+          roll: f.roll,
+          verticalBalance: f.verticalBalance
+        },
+        pose: {
+          pitch: f.pitch,
+          yaw: f.yaw,
+          rotationX: f.pitch + a,
+          rotationY: f.yaw + l,
+          rotationZ: f.rotationZ + u
+        },
+        skullAnchor: {
+          x: f.skullAnchorX,
+          y: f.skullAnchorY
+        },
+        center: {
+          x: b + v.x,
+          y: y + v.y,
+          z: v.z
+        },
+        depthPx: f.depthPx,
+        screen: {
+          widthPx: f.widthPx,
+          heightPx: f.heightPx
+        }
+      }
+    };
+  }
+  return {
+    pose: {
+      boxCenterZ: -f.depthPx * r,
+      centerX: f.centerXPx,
+      centerY: f.centerYPx,
+      width: f.widthPx,
+      height: f.heightPx,
+      depth: f.depthPx,
+      rotationX: f.pitch + a,
+      rotationY: f.yaw + l,
+      rotationZ: f.rotationZ + u
+    },
+    debugMetrics: {
+      face: {
+        centerX: f.shape.centerX,
+        centerY: f.shape.centerY,
+        width: f.shape.width,
+        height: f.shape.height
+      },
+      normalized: {
+        rawPitch: f.rawPitch,
+        rawPitchFromBalance: f.rawPitchFromBalance,
+        rawPitchFromCenter: f.rawPitchFromCenter,
+        rawYaw: f.rawYaw,
+        roll: f.roll,
+        verticalBalance: f.verticalBalance
+      },
+      pose: {
+        pitch: f.pitch,
+        yaw: f.yaw,
+        rotationX: f.pitch + a,
+        rotationY: f.yaw + l,
+        rotationZ: f.rotationZ + u
+      },
+      skullAnchor: {
+        x: f.skullAnchorX,
+        y: f.skullAnchorY
+      },
+      center: {
+        x: f.centerXPx,
+        y: f.centerYPx,
+        z: -f.depthPx * r
+      },
+      depthPx: f.depthPx,
+      screen: {
+        widthPx: f.widthPx,
+        heightPx: f.heightPx
+      }
+    }
+  };
+}, Qr = ({
+  lockDepth: i,
+  lockRotation: e,
+  model: t,
+  face: s,
+  height: n,
+  headDepthOffset: r,
+  offsetX: o,
+  offsetY: c,
+  rotationOffsetX: a,
+  rotationOffsetY: l,
+  rotationOffsetZ: u,
+  scaleX: h,
+  scaleY: d,
+  scaleZ: p,
+  skullCenterMode: g,
+  skullVerticalBias: A,
+  width: m
+}) => zt({
+  lockDepth: i,
+  lockRotation: e,
+  model: t,
+  face: s,
+  height: n,
+  headDepthOffset: r,
+  offsetX: o,
+  offsetY: c,
+  rotationOffsetX: a,
+  rotationOffsetY: l,
+  rotationOffsetZ: u,
+  scaleX: h,
+  scaleY: d,
+  scaleZ: p,
+  skullCenterMode: g,
+  skullVerticalBias: A,
+  width: m
+}).debugMetrics, $r = ({
+  boxColor: i,
+  boxOpacity: e,
+  face: t,
+  headDepthOffset: s,
+  lockDepth: n,
+  lockRotation: r,
+  model: o,
+  occluderOffset: c,
+  occluderOpacity: a,
+  occluderScale: l,
+  showOccluderProxy: u = !1,
+  offsetX: h,
+  offsetY: d,
+  pose: p,
+  rotationOffsetX: g,
+  rotationOffsetY: A,
+  rotationOffsetZ: m,
+  scaleX: f,
+  scaleY: x,
+  scaleZ: v,
+  show: b,
+  showCenterDot: y,
+  showFacePlaneReference: L,
+  showGizmo: _,
+  showHeadOccluder: D,
+  skullCenterMode: M,
+  skullVerticalBias: P,
+  url: re,
+  viewportHeight: I,
+  viewportWidth: W
+}) => {
+  const S = j(() => p || (!t || W <= 0 || I <= 0 ? null : Er({
+    face: t,
+    width: W,
+    height: I,
+    headDepthOffset: s,
+    lockDepth: n,
+    lockRotation: r,
+    model: o,
+    offsetX: h,
+    offsetY: d,
+    rotationOffsetX: g,
+    rotationOffsetY: A,
+    rotationOffsetZ: m,
+    scaleX: f,
+    scaleY: x,
+    scaleZ: v,
+    skullCenterMode: M,
+    skullVerticalBias: P
+  })), [
+    t,
+    s,
+    n,
+    r,
+    o,
+    h,
+    d,
+    g,
+    A,
+    m,
+    f,
+    x,
+    v,
+    M,
+    P,
+    p,
+    I,
+    W
+  ]);
+  if (!b || !S) return null;
+  const oe = M ? [0, -S.height * P, S.depth * s] : [0, 0, 0], z = S.height, q = [
+    ne[0] * l[0] * z,
+    ne[1] * l[1] * z,
+    ne[2] * l[2] * z
+  ];
+  return /* @__PURE__ */ w(rt, { children: [
+    /* @__PURE__ */ w(
+      "group",
+      {
+        position: [S.centerX, S.centerY, S.boxCenterZ],
+        rotation: [S.rotationX, S.rotationY, S.rotationZ],
+        children: [
+          /* @__PURE__ */ T("group", { scale: [S.width, S.height, S.depth], children: e > 0 && /* @__PURE__ */ w("mesh", { children: [
+            /* @__PURE__ */ T("boxGeometry", { args: [1, 1, 1] }),
+            /* @__PURE__ */ T("meshBasicMaterial", { color: i, wireframe: !0, transparent: !0, opacity: e })
+          ] }) }),
+          y && /* @__PURE__ */ w("mesh", { children: [
+            /* @__PURE__ */ T("sphereGeometry", { args: [6, 20, 20] }),
+            /* @__PURE__ */ T("meshBasicMaterial", { color: i })
+          ] }),
+          L && /* @__PURE__ */ w("group", { position: oe, children: [
+            /* @__PURE__ */ w("mesh", { rotation: [0, 0, Math.PI / 4], children: [
+              /* @__PURE__ */ T("ringGeometry", { args: [6, 8, 24] }),
+              /* @__PURE__ */ T("meshBasicMaterial", { color: "#f8fafc", side: Ie })
+            ] }),
+            /* @__PURE__ */ w("mesh", { rotation: [0, 0, Math.PI / 2], children: [
+              /* @__PURE__ */ T("planeGeometry", { args: [3, 16] }),
+              /* @__PURE__ */ T("meshBasicMaterial", { color: "#f8fafc", transparent: !0, opacity: 0.9, side: Ie })
+            ] }),
+            /* @__PURE__ */ w("mesh", { children: [
+              /* @__PURE__ */ T("planeGeometry", { args: [16, 3] }),
+              /* @__PURE__ */ T("meshBasicMaterial", { color: "#f8fafc", transparent: !0, opacity: 0.9, side: Ie })
+            ] })
+          ] }),
+          D && /* @__PURE__ */ w(rt, { children: [
+            u && /* @__PURE__ */ w("mesh", { position: c, scale: q, renderOrder: 20, children: [
+              /* @__PURE__ */ T("sphereGeometry", { args: [1, 24, 16] }),
+              /* @__PURE__ */ T(
+                "meshBasicMaterial",
+                {
+                  color: "#facc15",
+                  wireframe: !0,
+                  transparent: !0,
+                  opacity: 0.95,
+                  depthTest: !1,
+                  depthWrite: !1
+                }
+              )
+            ] }),
+            /* @__PURE__ */ T(
+              Yt,
+              {
+                opacity: a,
+                position: c,
+                scale: q,
+                showDebugMaterial: !0,
+                url: re
+              }
+            )
+          ] })
+        ]
+      }
+    ),
+    _ && /* @__PURE__ */ T(
+      "group",
+      {
+        position: [S.centerX, S.centerY, S.boxCenterZ],
+        rotation: [S.rotationX, S.rotationY, S.rotationZ],
+        renderOrder: 10,
+        children: /* @__PURE__ */ w("group", { children: [
+          /* @__PURE__ */ w("mesh", { children: [
+            /* @__PURE__ */ T("sphereGeometry", { args: [6, 20, 20] }),
+            /* @__PURE__ */ T("meshBasicMaterial", { color: "#e2e8f0", depthTest: !1, depthWrite: !1 })
+          ] }),
+          /* @__PURE__ */ w("mesh", { position: [18, 0, 0], rotation: [0, 0, -Math.PI / 2], children: [
+            /* @__PURE__ */ T("cylinderGeometry", { args: [1.6, 1.6, 24, 12] }),
+            /* @__PURE__ */ T("meshBasicMaterial", { color: "#ef4444", depthTest: !1, depthWrite: !1 })
+          ] }),
+          /* @__PURE__ */ w("mesh", { position: [34, 0, 0], rotation: [0, 0, -Math.PI / 2], children: [
+            /* @__PURE__ */ T("coneGeometry", { args: [4.2, 12, 16] }),
+            /* @__PURE__ */ T("meshBasicMaterial", { color: "#ef4444", depthTest: !1, depthWrite: !1 })
+          ] }),
+          /* @__PURE__ */ w("mesh", { position: [0, 18, 0], children: [
+            /* @__PURE__ */ T("cylinderGeometry", { args: [1.6, 1.6, 24, 12] }),
+            /* @__PURE__ */ T("meshBasicMaterial", { color: "#22c55e", depthTest: !1, depthWrite: !1 })
+          ] }),
+          /* @__PURE__ */ w("mesh", { position: [0, 34, 0], children: [
+            /* @__PURE__ */ T("coneGeometry", { args: [4.2, 12, 16] }),
+            /* @__PURE__ */ T("meshBasicMaterial", { color: "#22c55e", depthTest: !1, depthWrite: !1 })
+          ] }),
+          /* @__PURE__ */ w("mesh", { position: [0, 0, 18], rotation: [Math.PI / 2, 0, 0], children: [
+            /* @__PURE__ */ T("cylinderGeometry", { args: [1.6, 1.6, 24, 12] }),
+            /* @__PURE__ */ T("meshBasicMaterial", { color: "#3b82f6", depthTest: !1, depthWrite: !1 })
+          ] }),
+          /* @__PURE__ */ w("mesh", { position: [0, 0, 34], rotation: [Math.PI / 2, 0, 0], children: [
+            /* @__PURE__ */ T("coneGeometry", { args: [4.2, 12, 16] }),
+            /* @__PURE__ */ T("meshBasicMaterial", { color: "#3b82f6", depthTest: !1, depthWrite: !1 })
+          ] }),
+          /* @__PURE__ */ T(
+            Ye,
+            {
+              position: [42, 0, 0],
+              fontSize: 10,
+              color: "#ef4444",
+              anchorX: "center",
+              anchorY: "middle",
+              renderOrder: 11,
+              "material-depthTest": !1,
+              children: "X"
+            }
+          ),
+          /* @__PURE__ */ T(
+            Ye,
+            {
+              position: [0, 42, 0],
+              fontSize: 10,
+              color: "#22c55e",
+              anchorX: "center",
+              anchorY: "middle",
+              renderOrder: 11,
+              "material-depthTest": !1,
+              children: "Y"
+            }
+          ),
+          /* @__PURE__ */ T(
+            Ye,
+            {
+              position: [0, 0, 42],
+              fontSize: 10,
+              color: "#3b82f6",
+              anchorX: "center",
+              anchorY: "middle",
+              renderOrder: 11,
+              "material-depthTest": !1,
+              children: "Z"
+            }
+          )
+        ] })
+      }
+    )
+  ] });
+};
+export {
+  Cr as CanonicalFaceMeshRenderer,
+  Nr as DEFAULT_APPEARANCE,
+  ys as DEFAULT_FEATURE_GROUPS,
+  _s as DEFAULT_FEATURE_POINT_INDICES,
+  Pr as DEFAULT_MASKING,
+  ct as FACE_MASK_SIZE,
+  Gt as FACE_OVAL,
+  jr as FaceRetouchBackground,
+  Kt as HEAD_OCCLUDER_DEFAULT_OPACITY,
+  Ce as HEAD_OCCLUDER_DEFAULT_POSITION,
+  ne as HEAD_OCCLUDER_DEFAULT_SCALE,
+  Yr as HeadBinding,
+  $r as HeadBindingOccluder,
+  Yt as HeadOccluder,
+  Ht as INNER_MOUTH,
+  os as LEFT_EYE,
+  cs as LEFT_EYEBROW,
+  as as OUTER_LIPS,
+  is as RIGHT_EYE,
+  ls as RIGHT_EYEBROW,
+  Br as alphaMapOptions,
+  Tt as blendModeIndices,
+  Ur as blendModeOptions,
+  Zr as computeAdaptiveVerticalFit,
+  Er as computeHeadBindingCubePose,
+  Qr as computeHeadBindingDebugMetrics,
+  vr as computeHeadBindingShape,
+  qr as computeUniversalHeadDepthOffset,
+  Vr as computeUniversalOccluderScale,
+  zr as computeUniversalPitchOffsetY,
+  Wr as computeUniversalYawOffsetX,
+  Is as createFaceRetouchRegions,
+  ds as drawFaceRetouchMask,
+  fs as drawMouthRetouchMask,
+  Fr as materialTypeOptions,
+  Yn as parseCanonicalFaceModel,
+  Or as shaderPresetOptions,
+  Dr as sideOptions,
+  zt as solveHeadBinding,
+  Hr as supportsBlendMode,
+  Gr as supportsTexturePanel,
+  kr as textureMapOptions,
+  qn as useCanonicalFaceMesh,
+  Xr as useFaceRetouchMask,
+  Kr as useFaceRetouchRegions
+};