@mymosdk/avatar 0.1.0

package/dist/Avatar-DEkBZdcp.js

@@ -0,0 +1,2583 @@
+import * as M from "three";
+import { TrianglesDrawMode as Be, TriangleFanDrawMode as se, TriangleStripDrawMode as Re, Loader as ve, LoaderUtils as j, FileLoader as Me, MeshPhysicalMaterial as C, Vector2 as Ne, Color as z, LinearSRGBColorSpace as v, SRGBColorSpace as K, SpotLight as Pe, PointLight as Fe, DirectionalLight as De, Matrix4 as W, Vector3 as H, Quaternion as Ee, InstancedMesh as Oe, InstancedBufferAttribute as ze, Object3D as we, TextureLoader as He, ImageBitmapLoader as Ge, BufferAttribute as Q, InterleavedBuffer as Ue, InterleavedBufferAttribute as Ve, LinearMipmapLinearFilter as Le, NearestMipmapLinearFilter as je, LinearMipmapNearestFilter as Ke, NearestMipmapNearestFilter as Xe, LinearFilter as Se, NearestFilter as We, RepeatWrapping as ie, MirroredRepeatWrapping as Ye, ClampToEdgeWrapping as Qe, PointsMaterial as qe, Material as q, LineBasicMaterial as Ze, MeshStandardMaterial as be, DoubleSide as $e, MeshBasicMaterial as V, PropertyBinding as Je, BufferGeometry as et, SkinnedMesh as tt, Mesh as nt, LineSegments as st, Line as it, LineLoop as ot, Points as rt, Group as Z, PerspectiveCamera as at, MathUtils as ct, OrthographicCamera as lt, Skeleton as ht, AnimationClip as ut, Bone as dt, InterpolateDiscrete as ft, InterpolateLinear as Ie, Texture as ce, VectorKeyframeTrack as le, NumberKeyframeTrack as he, QuaternionKeyframeTrack as ue, ColorManagement as de, FrontSide as pt, Interpolant as mt, Box3 as gt, Sphere as At } from "three";
+import { VRMHumanBoneName as f, VRMLoaderPlugin as Tt } from "@pixiv/three-vrm";
+class xt {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(t, e) {
+    return this.listeners.has(t) || this.listeners.set(t, /* @__PURE__ */ new Set()), this.listeners.get(t).add(e), this;
+  }
+  off(t, e) {
+    return this.listeners.get(t)?.delete(e), this;
+  }
+  emit(t, e) {
+    this.listeners.get(t)?.forEach((s) => s(t, e));
+  }
+  removeAllListeners(t) {
+    t ? this.listeners.delete(t) : this.listeners.clear();
+  }
+}
+const _t = {
+  full: [0, 1, 0.5],
+  half: [0.48, 1, 0.5],
+  bust: [0.68, 1, 0.46],
+  face: [0.8, 1, 0.36]
+  // look well below center → full head/ears visible at top
+}, yt = {
+  full: { camY: 0, camZ: 2.8, lookY: 0 },
+  half: { camY: 0.5, camZ: 2, lookY: 0.4 },
+  bust: { camY: 0.8, camZ: 1, lookY: 0.55 },
+  face: { camY: 0.8, camZ: 0.7, lookY: 0.7 }
+}, Rt = {
+  "bottom-right": { bottom: "20px", right: "20px" },
+  "bottom-left": { bottom: "20px", left: "20px" },
+  "top-right": { top: "20px", right: "20px" },
+  "top-left": { top: "20px", left: "20px" }
+};
+class Mt {
+  constructor() {
+    this.clock = new M.Clock(), this.rafId = 0, this.tickCallbacks = [], this.currentModel = null, this.currentFraming = "full", this.currentTheme = "light", this.modelFraming = null, this.userSliceConfig = {}, this.userThemeConfig = {}, this._skeletonHelper = null, this.scene = new M.Scene(), this.camera = new M.PerspectiveCamera(45, 1, 0.1, 100);
+  }
+  setup(t) {
+    this.webgl = new M.WebGLRenderer({ antialias: !0, alpha: !0 }), this.webgl.setPixelRatio(Math.min(window.devicePixelRatio, 2)), this.webgl.setSize(t.size, t.size), this.webgl.shadowMap.enabled = t.shadows, this.webgl.shadowMap.type = M.PCFSoftShadowMap, this.webgl.outputColorSpace = M.SRGBColorSpace, this.webgl.toneMapping = M.ACESFilmicToneMapping, this._setupLights(), t.themeConfig && (this.userThemeConfig = t.themeConfig), this._createContainer(t), this.currentFraming = t.framing, t.framingConfig && (this.userSliceConfig = t.framingConfig), this._applyFraming(t.framing), this._startLoop();
+  }
+  _setupLights() {
+    const t = new M.AmbientLight(16777215, 0.8), e = new M.DirectionalLight(16777215, 1.5);
+    e.position.set(1.5, 3, 2.5);
+    const s = new M.DirectionalLight(8947967, 0.5);
+    s.position.set(-2, 0, 1), this.scene.add(t, e, s);
+  }
+  _createContainer(t) {
+    this.container = document.createElement("div");
+    const e = this.container.style;
+    e.position = "fixed", e.width = `${t.size}px`, e.height = `${t.size}px`, e.zIndex = String(t.zIndex), e.overflow = "hidden", e.borderRadius = "50%", e.cursor = "pointer", e.userSelect = "none", e.boxSizing = "border-box", this.currentTheme = t.theme, this._applyTheme(t.theme, t.size), this._applyPosition(t.position), this.container.appendChild(this.webgl.domElement), document.body.appendChild(this.container), t.draggable && this._makeDraggable();
+  }
+  setTheme(t) {
+    this.currentTheme = t, this._applyTheme(t, 0);
+  }
+  setThemeConfig(t) {
+    this.userThemeConfig = { ...this.userThemeConfig, ...t }, this._applyTheme(this.currentTheme, 0);
+  }
+  _applyTheme(t, e) {
+    const s = this.container.style;
+    if (t === "dark" ? (s.background = this.userThemeConfig.dark?.background ?? "radial-gradient(circle at 40% 35%, #2a2a4a 0%, #0d0d1a 100%)", s.boxShadow = this.userThemeConfig.dark?.boxShadow ?? "0 8px 32px rgba(0,0,0,0.5), 0 0 0 2px rgba(255,255,255,0.08)") : t === "light" ? (s.background = this.userThemeConfig.light?.background ?? "radial-gradient(circle at 40% 35%, #f8f8ff 0%, #e0e0f0 100%)", s.boxShadow = this.userThemeConfig.light?.boxShadow ?? "0 8px 32px rgba(0,0,0,0.15), 0 0 0 2px rgba(0,0,0,0.06)") : (s.background = "transparent", s.boxShadow = "none"), s.transition = "box-shadow 0.3s ease", s.setProperty("--ring-color", "transparent"), !document.getElementById("__mymo_styles__")) {
+      const n = document.createElement("style");
+      n.id = "__mymo_styles__", n.textContent = `
+        @keyframes mymo-ring {
+          0%   { box-shadow: 0 0 0 0px var(--ring-color); }
+          70%  { box-shadow: 0 0 0 10px transparent; }
+          100% { box-shadow: 0 0 0 0px transparent; }
+        }
+        [data-state] { animation: mymo-ring 1.2s ease-out infinite; }
+        [data-state=""] { animation: none; }
+      `, document.head.appendChild(n);
+    }
+  }
+  _applyPosition(t) {
+    const e = this.container.style;
+    e.top = e.bottom = e.left = e.right = "";
+    const s = Rt[t];
+    for (const [n, i] of Object.entries(s))
+      i !== void 0 && (e[n] = i);
+  }
+  _startLoop() {
+    const t = () => {
+      this.rafId = requestAnimationFrame(t);
+      const e = this.clock.getDelta();
+      for (const s of this.tickCallbacks) s(e);
+      this.webgl.render(this.scene, this.camera);
+    };
+    t();
+  }
+  _makeDraggable() {
+    let t = !1, e = 0, s = 0;
+    this.container.addEventListener("pointerdown", (n) => {
+      t = !0;
+      const i = this.container.getBoundingClientRect();
+      e = n.clientX - i.left, s = n.clientY - i.top, this.container.style.transition = "none", n.preventDefault();
+    }), window.addEventListener("pointermove", (n) => {
+      if (!t) return;
+      const i = this.container.style;
+      i.top = i.bottom = i.left = i.right = "", i.left = `${n.clientX - e}px`, i.top = `${n.clientY - s}px`;
+    }), window.addEventListener("pointerup", () => {
+      t = !1;
+    });
+  }
+  addTickCallback(t) {
+    this.tickCallbacks.push(t);
+  }
+  setModel(t) {
+    this.currentModel && this.scene.remove(this.currentModel), this._skeletonHelper && (this.scene.remove(this._skeletonHelper), this._skeletonHelper = null), this.currentModel = t, this._autoFit(t), this.scene.add(t), this.modelFraming = this._computeFraming(t), this._applyFraming(this.currentFraming);
+  }
+  // Toggle bone visualization for debugging — call avatar.renderer.debugBones()
+  debugBones(t) {
+    if (this.currentModel) {
+      if (t === !1) {
+        this._skeletonHelper && (this.scene.remove(this._skeletonHelper), this._skeletonHelper = null);
+        return;
+      }
+      this._skeletonHelper ? (this.scene.remove(this._skeletonHelper), this._skeletonHelper = null) : (this._skeletonHelper = new M.SkeletonHelper(this.currentModel), this.scene.add(this._skeletonHelper));
+    }
+  }
+  _computeFraming(t) {
+    const e = new M.Box3().setFromObject(t), s = e.max.y - e.min.y, n = Math.tan(this.camera.fov * Math.PI / 180 / 2), i = {};
+    for (const [o, a] of Object.entries(_t)) {
+      const r = this.userSliceConfig[o] ?? {}, c = r.from ?? a[0], u = r.to ?? a[1], h = r.lookBias ?? a[2], d = e.min.y + s * c, m = e.min.y + s * u - d, A = d + m * h, g = m / 2 / n * 1.15;
+      i[o] = { camY: A, camZ: g, lookY: A };
+    }
+    return i;
+  }
+  _autoFit(t) {
+    const e = new M.Box3().setFromObject(t), s = e.getCenter(new M.Vector3()), n = e.getSize(new M.Vector3()), o = 1.8 / Math.max(n.x, n.y, n.z);
+    t.scale.setScalar(o), t.position.set(-s.x * o, -s.y * o, -s.z * o);
+  }
+  _applyFraming(t) {
+    const { camY: e, camZ: s, lookY: n } = (this.modelFraming ?? yt)[t];
+    this.camera.position.set(0, e, s), this.camera.lookAt(0, n, 0);
+  }
+  // ── Public controls ──────────────────────────────────────────────────────
+  show() {
+    this.container.style.display = "";
+  }
+  hide() {
+    this.container.style.display = "none";
+  }
+  setFraming(t) {
+    this.currentFraming = t, this._applyFraming(t);
+  }
+  setFramingConfig(t) {
+    this.userSliceConfig = { ...this.userSliceConfig, ...t }, this.currentModel && (this.modelFraming = this._computeFraming(this.currentModel), this._applyFraming(this.currentFraming));
+  }
+  setPosition(t) {
+    this._applyPosition(t);
+  }
+  setSize(t) {
+    this.container.style.width = `${t}px`, this.container.style.height = `${t}px`, this.webgl.setSize(t, t);
+  }
+  moveTo(t, e) {
+    const s = this.container.style;
+    s.top = s.bottom = s.left = s.right = "", s.left = `${t}px`, s.top = `${e}px`;
+  }
+  getContainer() {
+    return this.container;
+  }
+  dispose() {
+    cancelAnimationFrame(this.rafId), this.tickCallbacks = [], this.webgl.dispose(), this.container.remove();
+  }
+}
+function y(l, t, e) {
+  return l + (t - l) * e;
+}
+function b(l) {
+  return l * l * (3 - 2 * l);
+}
+function fe(l) {
+  return Math.max(0, Math.min(1, l));
+}
+const w = Math.PI / 3.2, $ = -0.1, Nt = 0.1, X = -0.15, Et = {
+  wave: {
+    duration: 3,
+    fn(l, t) {
+      const e = t.humanoid, s = e.getNormalizedBoneNode(f.RightShoulder), n = e.getNormalizedBoneNode(f.RightUpperArm), i = e.getNormalizedBoneNode(f.RightLowerArm), o = e.getNormalizedBoneNode(f.RightHand), a = e.getNormalizedBoneNode(f.LeftUpperArm), r = b(fe(l / 0.25)), c = l > 0.8 ? b((l - 0.8) / 0.2) : 0, u = r * (1 - c);
+      s && (s.rotation.z = y(0, -0.2, u), s.rotation.x = 0, s.rotation.y = 0), n && (n.rotation.z = y(w, 0, u), n.rotation.x = 0, n.rotation.y = 0), i && (i.rotation.order = "XYZ", i.rotation.z = y($, -Math.PI / 2, u), i.rotation.x = 0, i.rotation.y = 0);
+      const h = l >= 0.25 && l <= 0.8 ? Math.sin((l - 0.25) / 0.55 * Math.PI * 4) : 0;
+      o && (o.rotation.x = y(X, -Math.PI / 2, u), o.rotation.y = h * 0.4 * u, o.rotation.z = 0), a && (a.rotation.z = -w);
+    }
+  },
+  nod: {
+    duration: 1.8,
+    fn(l, t) {
+      const e = t.humanoid, s = e.getNormalizedBoneNode(f.Neck), n = e.getNormalizedBoneNode(f.RightUpperArm), i = e.getNormalizedBoneNode(f.LeftUpperArm), o = l > 0.85 ? (1 - l) / 0.15 : 1;
+      s && (s.rotation.x = 0.32 * Math.max(0, Math.sin(l * Math.PI * 2)) * o), n && (n.rotation.z = w), i && (i.rotation.z = -w);
+    }
+  },
+  shakeHead: {
+    duration: 1.8,
+    fn(l, t) {
+      const e = t.humanoid, s = e.getNormalizedBoneNode(f.Neck), n = e.getNormalizedBoneNode(f.RightUpperArm), i = e.getNormalizedBoneNode(f.LeftUpperArm), o = l > 0.85 ? (1 - l) / 0.15 : 1;
+      s && (s.rotation.y = 0.35 * Math.sin(l * Math.PI * 2.5) * o), n && (n.rotation.z = w), i && (i.rotation.z = -w);
+    }
+  },
+  clap: {
+    duration: 2.2,
+    fn(l, t) {
+      const e = t.humanoid, s = e.getNormalizedBoneNode(f.RightUpperArm), n = e.getNormalizedBoneNode(f.LeftUpperArm), i = e.getNormalizedBoneNode(f.RightLowerArm), o = e.getNormalizedBoneNode(f.LeftLowerArm), a = b(fe(l / 0.2)), r = l > 0.8 ? b((l - 0.8) / 0.2) : 0, c = a * (1 - r), u = l >= 0.2 && l <= 0.8 ? Math.max(0, Math.sin((l - 0.2) / 0.6 * Math.PI * 10)) : 0, h = Math.PI / 2 - 0.08, d = Math.PI / 2 + 0.05, p = y(h, d, u);
+      s && (s.rotation.z = y(w, Math.PI / 3, c), s.rotation.y = y(0, p, c), s.rotation.x = 0), n && (n.rotation.z = y(-w, -Math.PI / 3, c), n.rotation.y = y(0, -p, c), n.rotation.x = 0);
+      const m = e.getNormalizedBoneNode(f.RightHand), A = e.getNormalizedBoneNode(f.LeftHand);
+      i && (i.rotation.z = y($, -Math.PI / 2.5, c), i.rotation.y = y(0, Math.PI / 2, c), i.rotation.x = 0), o && (o.rotation.z = y(Nt, Math.PI / 2.5, c), o.rotation.y = y(0, -Math.PI / 2, c), o.rotation.x = 0), m && (m.rotation.z = y(0, -Math.PI / 11.25, c), m.rotation.y = 0, m.rotation.x = y(X, 0, c)), A && (A.rotation.z = y(0, Math.PI / 11.25, c), A.rotation.y = 0, A.rotation.x = y(X, 0, c));
+    }
+  },
+  jump: {
+    duration: 1.5,
+    fn(l, t) {
+      const e = t.humanoid, s = e.getNormalizedBoneNode(f.Hips), n = e.getNormalizedBoneNode(f.Spine), i = e.getNormalizedBoneNode(f.Chest), o = e.getNormalizedBoneNode(f.RightUpperArm), a = e.getNormalizedBoneNode(f.LeftUpperArm), r = e.getNormalizedBoneNode(f.RightUpperLeg), c = e.getNormalizedBoneNode(f.LeftUpperLeg), u = e.getNormalizedBoneNode(f.RightLowerLeg), h = e.getNormalizedBoneNode(f.LeftLowerLeg), d = e.getNormalizedBoneNode(f.RightFoot), p = e.getNormalizedBoneNode(f.LeftFoot);
+      let m = 0, A = 0, g = 0, x = 0, _ = 0;
+      if (l < 0.22) {
+        const T = b(l / 0.22);
+        m = -0.12 * T, A = T, g = -T * 0.85, _ = T * 0.06;
+      } else if (l < 0.55) {
+        const T = b((l - 0.22) / 0.33);
+        m = y(-0.12, 0.22, T), A = y(1, 0, T), g = y(-0.85, 0.6, T), x = T * 0.5, _ = y(0.06, -0.05, T);
+      } else if (l < 0.72) {
+        const T = b((l - 0.55) / 0.17);
+        m = y(0.22, -0.07, T), A = T * 0.75, g = y(0.6, -0.6, T), x = y(0.5, 0, T), _ = y(-0.05, 0.07, T);
+      } else {
+        const T = b((l - 0.72) / 0.28);
+        m = y(-0.07, 0, T), A = y(0.75, 0, T), g = y(-0.6, 0, T), _ = y(0.07, 0, T);
+      }
+      const N = t.scene.userData.hipsRestY ?? 0;
+      s && (s.position.y = N + m), r && (r.rotation.x = -A * 0.35, r.rotation.z = 0, r.rotation.y = 0), c && (c.rotation.x = -A * 0.35, c.rotation.z = 0, c.rotation.y = 0), u && (u.rotation.x = A * 1.2, u.rotation.z = 0, u.rotation.y = 0), h && (h.rotation.x = A * 1.2, h.rotation.z = 0, h.rotation.y = 0), d && (d.rotation.x = g, d.rotation.z = 0, d.rotation.y = 0), p && (p.rotation.x = g, p.rotation.z = 0, p.rotation.y = 0), n && (n.rotation.x = _), i && (i.rotation.x = _ * 0.4), o && (o.rotation.z = w - x), a && (a.rotation.z = -w + x);
+    }
+  },
+  no: {
+    duration: 1.8,
+    fn(l, t) {
+      const e = t.humanoid, s = e.getNormalizedBoneNode(f.Neck), n = e.getNormalizedBoneNode(f.Head), i = e.getNormalizedBoneNode(f.RightUpperArm), o = e.getNormalizedBoneNode(f.LeftUpperArm), a = l < 0.12 ? b(l / 0.12) : l > 0.85 ? b((1 - l) / 0.15) : 1, r = Math.sin(l * Math.PI * 6) * a;
+      s && (s.rotation.y = r * 0.38), n && (n.rotation.y = r * 0.12), i && (i.rotation.z = w), o && (o.rotation.z = -w);
+    }
+  },
+  yes: {
+    duration: 2,
+    fn(l, t) {
+      const e = t.humanoid, s = e.getNormalizedBoneNode(f.Neck), n = e.getNormalizedBoneNode(f.Head), i = e.getNormalizedBoneNode(f.RightUpperArm), o = e.getNormalizedBoneNode(f.LeftUpperArm), a = l < 0.12 ? b(l / 0.12) : l > 0.85 ? b((1 - l) / 0.15) : 1, r = Math.max(0, Math.sin(l * Math.PI * 6)) * a;
+      s && (s.rotation.x = r * 0.3), n && (n.rotation.x = r * 0.12), i && (i.rotation.z = w), o && (o.rotation.z = -w);
+    }
+  },
+  thumbsUp: {
+    duration: 2.5,
+    fn(l, t) {
+      const e = t.humanoid, s = e.getNormalizedBoneNode(f.RightUpperArm), n = e.getNormalizedBoneNode(f.RightLowerArm), i = e.getNormalizedBoneNode(f.RightHand), o = e.getNormalizedBoneNode(f.LeftUpperArm), a = l < 0.2 ? b(l / 0.2) : l > 0.8 ? b(1 - (l - 0.8) / 0.2) : 1;
+      s && (s.rotation.y = y(0, 0.9, a), s.rotation.z = w, s.rotation.x = 0), n && (n.rotation.order = "XYZ", n.rotation.y = y(0, 1.8, a), n.rotation.z = y($, 0, a), n.rotation.x = 0), i && (i.rotation.x = y(X, -0.9, a), i.rotation.y = y(0, 0.05, a), i.rotation.z = y(0, 0.6, a));
+      const r = [
+        [f.RightIndexProximal, f.RightIndexIntermediate, f.RightIndexDistal],
+        [f.RightMiddleProximal, f.RightMiddleIntermediate, f.RightMiddleDistal],
+        [f.RightRingProximal, f.RightRingIntermediate, f.RightRingDistal],
+        [f.RightLittleProximal, f.RightLittleIntermediate, f.RightLittleDistal]
+      ];
+      for (const [d, p, m] of r) {
+        const A = y(0.28, 1.45, a), g = e.getNormalizedBoneNode(d), x = e.getNormalizedBoneNode(p), _ = e.getNormalizedBoneNode(m);
+        g && (g.rotation.z = A, g.rotation.x = 0), x && (x.rotation.z = A * 0.9, x.rotation.x = 0), _ && (_.rotation.z = A * 0.7, _.rotation.x = 0);
+      }
+      const c = e.getNormalizedBoneNode(f.RightThumbMetacarpal), u = e.getNormalizedBoneNode(f.RightThumbProximal), h = e.getNormalizedBoneNode(f.RightThumbDistal);
+      c && (c.rotation.x = y(0.2, 0.2, a), c.rotation.z = y(-0.3, -0.3, a), c.rotation.y = 0), u && (u.rotation.x = 0, u.rotation.z = 0, u.rotation.y = 0), h && (h.rotation.x = 0, h.rotation.z = 0, h.rotation.y = 0), o && (o.rotation.z = -w);
+    }
+  },
+  dance: {
+    duration: 3,
+    fn(l, t) {
+      const e = t.humanoid, s = e.getNormalizedBoneNode(f.Hips), n = e.getNormalizedBoneNode(f.Spine), i = e.getNormalizedBoneNode(f.Chest), o = e.getNormalizedBoneNode(f.Neck), a = e.getNormalizedBoneNode(f.RightUpperArm), r = e.getNormalizedBoneNode(f.LeftUpperArm), c = l < 0.1 ? l / 0.1 : l > 0.9 ? (1 - l) / 0.1 : 1, u = Math.sin(l * Math.PI * 4) * c, h = Math.sin(l * Math.PI * 4 + Math.PI) * c, d = t.scene.userData.hipsRestY ?? 0, p = e.getNormalizedBoneNode(f.RightUpperLeg), m = e.getNormalizedBoneNode(f.LeftUpperLeg), A = e.getNormalizedBoneNode(f.RightFoot), g = e.getNormalizedBoneNode(f.LeftFoot);
+      s && (s.position.y = d, s.rotation.z = h * 0.18, s.rotation.y = h * 0.06), p && (p.rotation.z = -h * 0.18, p.rotation.x = 0, p.rotation.y = 0), m && (m.rotation.z = -h * 0.18, m.rotation.x = 0, m.rotation.y = 0), A && (A.rotation.x = 0, A.rotation.z = 0, A.rotation.y = 0), g && (g.rotation.x = 0, g.rotation.z = 0, g.rotation.y = 0), n && (n.rotation.z = u * 0.1), i && (i.rotation.z = -u * 0.07), o && (o.rotation.z = Math.sin(l * Math.PI * 4 + Math.PI / 4) * 0.07 * c), a && (a.rotation.z = w - u * 0.5, a.rotation.x = Math.abs(u) * 0.1), r && (r.rotation.z = -w + u * 0.5, r.rotation.x = Math.abs(u) * 0.1);
+    }
+  }
+}, J = {
+  idle: [],
+  smile: ["Smile", "smile", "Happy", "happy", "mouthSmile", "Joy"],
+  sad: ["Sad", "sad", "Frown", "frown", "mouthFrown"],
+  happy: ["Smile", "smile", "Happy", "happy", "Joy", "joy"],
+  angry: ["Angry", "angry", "Frown", "frown", "Mad"],
+  surprised: ["Surprised", "surprised", "Awe", "awe", "Oh", "Shock"],
+  thinking: ["Thinking", "thinking", "Sad", "Awe"],
+  confused: ["Confused", "confused", "Awe", "Surprised"],
+  sleep: ["Sleep", "sleep", "Blink", "eyesClosed"]
+}, pe = {
+  idle: null,
+  smile: "happy",
+  happy: "happy",
+  sad: "sad",
+  angry: "angry",
+  surprised: "surprised",
+  thinking: "relaxed",
+  confused: "surprised",
+  sleep: "blink"
+}, me = ["Blink", "blink", "EyesClosed", "eyesClosed", "eyeBlink_L", "eyeBlink"], wt = [
+  "mouthOpen",
+  "MouthOpen",
+  "jawOpen",
+  "JawOpen",
+  "jaw_open",
+  "mouth_open",
+  "viseme_O",
+  "viseme_aa",
+  "A",
+  "open"
+], Lt = [
+  "Head",
+  "head",
+  "mixamorigHead",
+  "Bip01_Head",
+  "Bip001 Head",
+  "head_joint",
+  "HeadBone"
+], St = [/^bip_head/i, /^head$/i, /head_0/i], O = class O {
+  constructor() {
+    this.mixer = null, this.clips = [], this.currentAction = null, this.idleAction = null, this.vrm = null, this.morphMeshes = [], this.headBone = null, this.headBoneRestWorldQ = new M.Quaternion(), this.lookCurrentDelta = new M.Quaternion(), this.lookTargetDelta = new M.Quaternion(), this.lookSettled = !0, this._tmpParentWorldQInv = new M.Quaternion(), this._tmpDesiredWorldQ = new M.Quaternion(), this.blinkTimer = null, this.idleTimer = null, this.randomLookTimeout = null, this._vrmIdleTime = 0, this._gestureActive = !1, this._gestureElapsed = 0, this._gestureDuration = 0, this._gestureUpdateFn = null, this._pendingGesture = null;
+  }
+  init(t) {
+    if (this.dispose(), this.vrm = t.vrm ?? null, this.mixer = new M.AnimationMixer(t.scene), this.clips = t.animations, this.morphMeshes = [], this.headBone = null, this.vrm) {
+      const e = this.vrm.humanoid.getNormalizedBoneNode(f.Head);
+      e && (this.headBone = e, t.scene.updateWorldMatrix(!0, !0), this.headBone.getWorldQuaternion(this.headBoneRestWorldQ)), this._initVRMRestPose();
+    } else
+      t.scene.traverse((e) => {
+        if (e instanceof M.Bone && !this.headBone) {
+          const s = Lt.includes(e.name), n = !s && St.some((i) => i.test(e.name));
+          (s || n) && (this.headBone = e, t.scene.updateWorldMatrix(!0, !0), e.getWorldQuaternion(this.headBoneRestWorldQ));
+        }
+        (e instanceof M.Mesh || e instanceof M.SkinnedMesh) && e.morphTargetDictionary && Object.keys(e.morphTargetDictionary).length > 0 && this.morphMeshes.push(e);
+      });
+  }
+  update(t) {
+    if (this.mixer?.update(t), this._vrmIdleTime += t, this._gestureActive ? this._tickProceduralGesture(t) : this._updateVRMProceduralIdle(this._vrmIdleTime), this.vrm?.update(t), this.headBone) {
+      if (!this.lookSettled) {
+        const s = 1 - Math.pow(1e-4, t);
+        this.lookCurrentDelta.slerp(this.lookTargetDelta, s), this.lookCurrentDelta.angleTo(this.lookTargetDelta) < 0.01 && (this.lookCurrentDelta.copy(this.lookTargetDelta), this.lookSettled = !0);
+      }
+      this._tmpDesiredWorldQ.multiplyQuaternions(this.headBoneRestWorldQ, this.lookCurrentDelta);
+      const e = this.headBone.parent;
+      e ? (e.getWorldQuaternion(this._tmpParentWorldQInv), this._tmpParentWorldQInv.invert(), this.headBone.quaternion.multiplyQuaternions(this._tmpParentWorldQInv, this._tmpDesiredWorldQ)) : this.headBone.quaternion.copy(this._tmpDesiredWorldQ);
+    }
+  }
+  // ── Animation clips ───────────────────────────────────────────────────────────
+  play(t) {
+    const e = M.AnimationClip.findByName(this.clips, t);
+    !e || !this.mixer || this._transitionTo(this.mixer.clipAction(e));
+  }
+  stop() {
+    this.currentAction && (this.currentAction.fadeOut(0.3), this.currentAction = null, this.idleAction && this.idleAction.fadeIn(0.3).play());
+  }
+  _transitionTo(t, e = 0.3) {
+    this.currentAction !== t && (this.currentAction?.fadeOut(e), t.reset().fadeIn(e).play(), this.currentAction = t);
+  }
+  // ── Idle ──────────────────────────────────────────────────────────────────────
+  startIdle(t = 8e3) {
+    const e = this._findClip(/idle|breathing|float/i) ?? this.clips[0];
+    e && this.mixer && (this.idleAction = this.mixer.clipAction(e), this.idleAction.setLoop(M.LoopRepeat, 1 / 0), this.idleAction.play()), this.idleTimer = setInterval(() => {
+      this._randomIdleExpression();
+    }, t);
+  }
+  stopIdle() {
+    this.idleAction?.stop(), this.idleAction = null, this.idleTimer && (clearInterval(this.idleTimer), this.idleTimer = null);
+  }
+  _randomIdleExpression() {
+    const t = ["idle", "smile", "thinking"], e = t[Math.floor(Math.random() * t.length)];
+    e !== "idle" && (this.setExpression(e, 0.3), setTimeout(() => this.setExpression("idle", 0), 1200));
+  }
+  // ── Blink ─────────────────────────────────────────────────────────────────────
+  startBlink(t = 3500) {
+    this.blinkTimer = setInterval(() => {
+      this._doBlink();
+    }, t + Math.random() * 1e3 - 500);
+  }
+  stopBlink() {
+    this.blinkTimer && (clearInterval(this.blinkTimer), this.blinkTimer = null);
+  }
+  async _doBlink() {
+    this.vrm?.expressionManager ? (this.vrm.expressionManager.setValue("blink", 1), await this._delay(120), this.vrm.expressionManager.setValue("blink", 0)) : (this._setMorphTarget(me, 1), await this._delay(120), this._setMorphTarget(me, 0));
+  }
+  // ── Expressions ───────────────────────────────────────────────────────────────
+  setExpression(t, e = 1) {
+    if (this.vrm?.expressionManager) {
+      const n = this.vrm.expressionManager;
+      for (const o of Object.values(pe))
+        o && n.setValue(o, 0);
+      const i = pe[t];
+      i && n.setValue(i, e);
+      return;
+    }
+    if (t === "idle") {
+      for (const n of Object.values(J))
+        this._setMorphTarget(n, 0);
+      return;
+    }
+    const s = J[t];
+    if (s.length) {
+      for (const [n, i] of Object.entries(J))
+        n !== t && n !== "idle" && this._setMorphTarget(i, 0);
+      this._setMorphTarget(s, e);
+    }
+  }
+  setMouthMorph(t) {
+    const e = Math.max(0, Math.min(1, t));
+    if (this.vrm?.expressionManager) {
+      const s = this.vrm.expressionManager;
+      for (const n of O._VRM_VISEMES) s.setValue(n, 0);
+      if (e > 0.01) {
+        const n = Math.floor(performance.now() / 250) % O._VRM_VISEME_CYCLE.length, i = O._VRM_VISEME_CYCLE[n] ?? "aa";
+        s.setValue(i, e);
+      }
+      return;
+    }
+    this._setMorphTarget(wt, e);
+  }
+  // ── Gestures ──────────────────────────────────────────────────────────────────
+  playGesture(t) {
+    if (this.vrm) {
+      this._playVRMProceduralGesture(t);
+      return;
+    }
+    const e = this._findClip(new RegExp(t, "i"));
+    if (e && this.mixer) {
+      const s = this.mixer.clipAction(e);
+      s.setLoop(M.LoopOnce, 1), s.clampWhenFinished = !0, this._transitionTo(s), this.mixer.addEventListener("finished", (n) => {
+        n.action === s && (this.stop(), this.mixer?.removeEventListener("finished", () => {
+        }));
+      });
+    }
+  }
+  _playVRMProceduralGesture(t) {
+    if (this.vrm) {
+      if (this._gestureActive) {
+        const e = this._gestureDuration * 0.82;
+        this._gestureElapsed < e && (this._gestureElapsed = e), this._pendingGesture = t;
+        return;
+      }
+      this._startGesture(t);
+    }
+  }
+  _startGesture(t) {
+    const e = Et[t];
+    if (!e || !this.vrm) return;
+    const s = this.vrm;
+    this._gestureActive = !0, this._gestureElapsed = 0, this._gestureDuration = e.duration, this._gestureUpdateFn = (n) => e.fn(n, s), this._pendingGesture = null;
+  }
+  _tickProceduralGesture(t) {
+    if (!this._gestureUpdateFn) return;
+    this._gestureElapsed += t;
+    const e = Math.min(this._gestureElapsed / this._gestureDuration, 1);
+    this._gestureUpdateFn(e), e >= 1 && (this._gestureActive = !1, this._gestureUpdateFn = null, this._gestureElapsed = 0, this._pendingGesture && this._startGesture(this._pendingGesture));
+  }
+  // ── Look ──────────────────────────────────────────────────────────────────────
+  lookAt(t, e) {
+    const s = new M.Euler(e * 0.6, t * 0.75, 0, "YXZ");
+    this.lookTargetDelta.setFromEuler(s), this.lookSettled = !1;
+  }
+  lookForward() {
+    this.stopRandomLook(), this.lookTargetDelta.identity(), this.lookSettled = !1;
+  }
+  startRandomLook() {
+    this.stopRandomLook();
+    const t = () => {
+      const e = (Math.random() - 0.5) * 1.4, s = (Math.random() - 0.5) * 0.8;
+      this.lookAt(e, s), this.randomLookTimeout = setTimeout(t, 1500 + Math.random() * 2e3);
+    };
+    t();
+  }
+  stopRandomLook() {
+    this.randomLookTimeout && (clearTimeout(this.randomLookTimeout), this.randomLookTimeout = null);
+  }
+  stopLook() {
+    this.stopRandomLook(), this.lookTargetDelta.identity(), this.lookCurrentDelta.identity();
+  }
+  hasHeadBone() {
+    return this.headBone !== null;
+  }
+  // ── Helpers ───────────────────────────────────────────────────────────────────
+  _setMorphTarget(t, e) {
+    for (const s of this.morphMeshes) {
+      const n = s.morphTargetDictionary;
+      if (!(!n || !s.morphTargetInfluences))
+        for (const i of t) {
+          const o = n[i];
+          if (o !== void 0) {
+            s.morphTargetInfluences[o] = e;
+            break;
+          }
+        }
+    }
+  }
+  _initVRMRestPose() {
+    if (!this.vrm) return;
+    const t = this.vrm.humanoid, e = t.getNormalizedBoneNode(f.RightUpperArm), s = t.getNormalizedBoneNode(f.LeftUpperArm);
+    e && (e.rotation.z = Math.PI / 6), s && (s.rotation.z = -Math.PI / 6);
+    const n = t.getNormalizedBoneNode(f.Hips);
+    n && (this.vrm.scene.userData.hipsRestY = n.position.y);
+  }
+  _updateVRMProceduralIdle(t) {
+    if (!this.vrm) return;
+    const e = this.vrm.humanoid, s = e.getNormalizedBoneNode(f.Hips);
+    s && (s.position.y = this.vrm.scene.userData.hipsRestY ?? 0);
+    const n = Math.sin(t * 1.8), i = Math.sin(t * 0.7), o = e.getNormalizedBoneNode(f.Spine), a = e.getNormalizedBoneNode(f.Chest);
+    o && (o.rotation.z = i * 8e-3), a && (a.rotation.x = n * 0.015);
+    const r = e.getNormalizedBoneNode(f.RightUpperArm), c = e.getNormalizedBoneNode(f.LeftUpperArm);
+    r && (r.rotation.z = Math.PI / 3.2 + n * 0.018, r.rotation.y = 0, r.rotation.x = 0), c && (c.rotation.z = -(Math.PI / 3.2 + n * 0.018), c.rotation.y = 0, c.rotation.x = 0);
+    const u = e.getNormalizedBoneNode(f.RightLowerArm), h = e.getNormalizedBoneNode(f.LeftLowerArm);
+    u && (u.rotation.order = "XYZ", u.rotation.z = -0.1, u.rotation.y = 0, u.rotation.x = 0), h && (h.rotation.z = 0.1, h.rotation.y = 0, h.rotation.x = 0);
+    const d = e.getNormalizedBoneNode(f.RightHand), p = e.getNormalizedBoneNode(f.LeftHand);
+    d && (d.rotation.x = -0.15, d.rotation.y = 0, d.rotation.z = 0), p && (p.rotation.x = -0.15, p.rotation.y = 0, p.rotation.z = 0);
+    const m = 0.28 + n * 0.06, A = [
+      [f.RightIndexProximal, f.RightIndexIntermediate, f.RightIndexDistal],
+      [f.RightMiddleProximal, f.RightMiddleIntermediate, f.RightMiddleDistal],
+      [f.RightRingProximal, f.RightRingIntermediate, f.RightRingDistal],
+      [f.RightLittleProximal, f.RightLittleIntermediate, f.RightLittleDistal]
+    ];
+    for (const [N, T, S] of A) {
+      const L = e.getNormalizedBoneNode(N), E = e.getNormalizedBoneNode(T), I = e.getNormalizedBoneNode(S);
+      L && (L.rotation.z = m, L.rotation.x = 0), E && (E.rotation.z = m * 0.8, E.rotation.x = 0), I && (I.rotation.z = m * 0.5, I.rotation.x = 0);
+    }
+    const g = [
+      [f.LeftIndexProximal, f.LeftIndexIntermediate, f.LeftIndexDistal],
+      [f.LeftMiddleProximal, f.LeftMiddleIntermediate, f.LeftMiddleDistal],
+      [f.LeftRingProximal, f.LeftRingIntermediate, f.LeftRingDistal],
+      [f.LeftLittleProximal, f.LeftLittleIntermediate, f.LeftLittleDistal]
+    ];
+    for (const [N, T, S] of g) {
+      const L = e.getNormalizedBoneNode(N), E = e.getNormalizedBoneNode(T), I = e.getNormalizedBoneNode(S);
+      L && (L.rotation.z = -m, L.rotation.x = 0), E && (E.rotation.z = -m * 0.8, E.rotation.x = 0), I && (I.rotation.z = -m * 0.5, I.rotation.x = 0);
+    }
+    const x = e.getNormalizedBoneNode(f.RightThumbProximal), _ = e.getNormalizedBoneNode(f.LeftThumbProximal);
+    x && (x.rotation.z = -0.3, x.rotation.x = 0.2), _ && (_.rotation.z = 0.3, _.rotation.x = 0.2);
+  }
+  _findClip(t) {
+    return this.clips.find((e) => t.test(e.name));
+  }
+  _delay(t) {
+    return new Promise((e) => setTimeout(e, t));
+  }
+  dispose() {
+    this.stopBlink(), this.stopIdle(), this.stopRandomLook(), this.stopLook(), this.mixer?.stopAllAction(), this.mixer = null, this.vrm = null, this.clips = [], this.morphMeshes = [], this.headBone = null, this.lookCurrentDelta.identity(), this.lookTargetDelta.identity(), this.lookSettled = !0, this.currentAction = null, this.idleAction = null, this._gestureActive = !1, this._gestureUpdateFn = null, this._gestureElapsed = 0, this._pendingGesture = null;
+  }
+};
+O._VRM_VISEME_CYCLE = ["aa", "aa", "oh", "aa", "ih", "aa", "ee", "ou"], O._VRM_VISEMES = ["aa", "ih", "ou", "ee", "oh"];
+let oe = O;
+class bt {
+  constructor() {
+    this.context = null, this.source = null, this.analyser = null, this.gainNode = null, this.dataArray = new Float32Array(0), this._endedCallback = null;
+  }
+  _ctx() {
+    return (!this.context || this.context.state === "closed") && (this.context = new AudioContext()), this.context;
+  }
+  async play(t) {
+    const e = this._ctx();
+    e.state === "suspended" && await e.resume(), this._stopSource();
+    const s = await this._toBuffer(e, t);
+    return this.analyser = e.createAnalyser(), this.analyser.fftSize = 512, this.analyser.smoothingTimeConstant = 0.6, this.dataArray = new Float32Array(this.analyser.frequencyBinCount), this.gainNode = e.createGain(), this.source = e.createBufferSource(), this.source.buffer = s, this.source.connect(this.analyser), this.analyser.connect(this.gainNode), this.gainNode.connect(e.destination), new Promise((n) => {
+      this.source.onended = () => {
+        this._endedCallback?.(), n();
+      }, this.source.start(0);
+    });
+  }
+  pause() {
+    this.context?.suspend();
+  }
+  async resume() {
+    await this.context?.resume();
+  }
+  stop() {
+    this._stopSource();
+  }
+  // RMS amplitude in 0–1 range — used by LipSync each frame
+  getAmplitude() {
+    if (!this.analyser || this.dataArray.length === 0) return 0;
+    this.analyser.getFloatTimeDomainData(this.dataArray);
+    let t = 0;
+    for (const e of this.dataArray) t += e * e;
+    return Math.sqrt(t / this.dataArray.length);
+  }
+  set onEnded(t) {
+    this._endedCallback = t;
+  }
+  async _toBuffer(t, e) {
+    if (e instanceof AudioBuffer) return e;
+    if (typeof e == "string") {
+      const n = await (await fetch(e)).arrayBuffer();
+      return t.decodeAudioData(n);
+    }
+    return t.decodeAudioData(e.slice(0));
+  }
+  _stopSource() {
+    try {
+      this.source?.stop();
+    } catch {
+    }
+    this.source?.disconnect(), this.source = null;
+  }
+  dispose() {
+    this._stopSource(), this.context?.close(), this.context = null, this.analyser = null, this.gainNode = null;
+  }
+}
+const It = {
+  sil: 0,
+  // silence
+  PP: 0.05,
+  // p, b, m
+  FF: 0.2,
+  // f, v
+  TH: 0.25,
+  // th
+  DD: 0.3,
+  // d, t
+  kk: 0.35,
+  // k, g
+  CH: 0.5,
+  // ch, j
+  SS: 0.2,
+  // s, z
+  nn: 0.15,
+  // n, l
+  RR: 0.4,
+  // r
+  aa: 1,
+  // a (open)
+  E: 0.7,
+  // e
+  ih: 0.5,
+  // i
+  oh: 0.85,
+  // o
+  ou: 0.6
+  // u
+};
+class kt {
+  constructor(t, e) {
+    this.audioEngine = t, this.onMouth = e, this.rafId = 0;
+  }
+  // Manual viseme — maps phoneme to mouth openness
+  setViseme(t) {
+    this.onMouth(It[t] ?? 0);
+  }
+  // Direct mouth shape override (0–1)
+  setMouth(t) {
+    this.onMouth(Math.max(0, Math.min(1, t)));
+  }
+  // Drive mouth from a volume value (0–1), e.g. from external TTS
+  setVolume(t) {
+    this.onMouth(Math.max(0, Math.min(1, t)));
+  }
+  // Auto lip sync: reads amplitude from AudioEngine every frame via RAF
+  startAutoSync() {
+    this.stopAutoSync();
+    const t = () => {
+      const e = this.audioEngine.getAmplitude();
+      this.onMouth(Math.min(1, e * 10)), this.rafId = requestAnimationFrame(t);
+    };
+    this.rafId = requestAnimationFrame(t);
+  }
+  stopAutoSync() {
+    cancelAnimationFrame(this.rafId), this.rafId = 0, this.onMouth(0);
+  }
+}
+function ge(l, t) {
+  if (t === Be)
+    return console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles."), l;
+  if (t === se || t === Re) {
+    let e = l.getIndex();
+    if (e === null) {
+      const o = [], a = l.getAttribute("position");
+      if (a !== void 0) {
+        for (let r = 0; r < a.count; r++)
+          o.push(r);
+        l.setIndex(o), e = l.getIndex();
+      } else
+        return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible."), l;
+    }
+    const s = e.count - 2, n = [];
+    if (t === se)
+      for (let o = 1; o <= s; o++)
+        n.push(e.getX(0)), n.push(e.getX(o)), n.push(e.getX(o + 1));
+    else
+      for (let o = 0; o < s; o++)
+        o % 2 === 0 ? (n.push(e.getX(o)), n.push(e.getX(o + 1)), n.push(e.getX(o + 2))) : (n.push(e.getX(o + 2)), n.push(e.getX(o + 1)), n.push(e.getX(o)));
+    n.length / 3 !== s && console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unable to generate correct amount of triangles.");
+    const i = l.clone();
+    return i.setIndex(n), i.clearGroups(), i;
+  } else
+    return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unknown draw mode:", t), l;
+}
+class Ae extends ve {
+  constructor(t) {
+    super(t), this.dracoLoader = null, this.ktx2Loader = null, this.meshoptDecoder = null, this.pluginCallbacks = [], this.register(function(e) {
+      return new Ft(e);
+    }), this.register(function(e) {
+      return new Dt(e);
+    }), this.register(function(e) {
+      return new Xt(e);
+    }), this.register(function(e) {
+      return new Wt(e);
+    }), this.register(function(e) {
+      return new Yt(e);
+    }), this.register(function(e) {
+      return new zt(e);
+    }), this.register(function(e) {
+      return new Ht(e);
+    }), this.register(function(e) {
+      return new Gt(e);
+    }), this.register(function(e) {
+      return new Ut(e);
+    }), this.register(function(e) {
+      return new Pt(e);
+    }), this.register(function(e) {
+      return new Vt(e);
+    }), this.register(function(e) {
+      return new Ot(e);
+    }), this.register(function(e) {
+      return new Kt(e);
+    }), this.register(function(e) {
+      return new jt(e);
+    }), this.register(function(e) {
+      return new Bt(e);
+    }), this.register(function(e) {
+      return new Qt(e);
+    }), this.register(function(e) {
+      return new qt(e);
+    });
+  }
+  load(t, e, s, n) {
+    const i = this;
+    let o;
+    if (this.resourcePath !== "")
+      o = this.resourcePath;
+    else if (this.path !== "") {
+      const c = j.extractUrlBase(t);
+      o = j.resolveURL(c, this.path);
+    } else
+      o = j.extractUrlBase(t);
+    this.manager.itemStart(t);
+    const a = function(c) {
+      n ? n(c) : console.error(c), i.manager.itemError(t), i.manager.itemEnd(t);
+    }, r = new Me(this.manager);
+    r.setPath(this.path), r.setResponseType("arraybuffer"), r.setRequestHeader(this.requestHeader), r.setWithCredentials(this.withCredentials), r.load(t, function(c) {
+      try {
+        i.parse(c, o, function(u) {
+          e(u), i.manager.itemEnd(t);
+        }, a);
+      } catch (u) {
+        a(u);
+      }
+    }, s, a);
+  }
+  setDRACOLoader(t) {
+    return this.dracoLoader = t, this;
+  }
+  setDDSLoader() {
+    throw new Error(
+      'THREE.GLTFLoader: "MSFT_texture_dds" no longer supported. Please update to "KHR_texture_basisu".'
+    );
+  }
+  setKTX2Loader(t) {
+    return this.ktx2Loader = t, this;
+  }
+  setMeshoptDecoder(t) {
+    return this.meshoptDecoder = t, this;
+  }
+  register(t) {
+    return this.pluginCallbacks.indexOf(t) === -1 && this.pluginCallbacks.push(t), this;
+  }
+  unregister(t) {
+    return this.pluginCallbacks.indexOf(t) !== -1 && this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(t), 1), this;
+  }
+  parse(t, e, s, n) {
+    let i;
+    const o = {}, a = {}, r = new TextDecoder();
+    if (typeof t == "string")
+      i = JSON.parse(t);
+    else if (t instanceof ArrayBuffer)
+      if (r.decode(new Uint8Array(t, 0, 4)) === ke) {
+        try {
+          o[R.KHR_BINARY_GLTF] = new Zt(t);
+        } catch (h) {
+          n && n(h);
+          return;
+        }
+        i = JSON.parse(o[R.KHR_BINARY_GLTF].content);
+      } else
+        i = JSON.parse(r.decode(t));
+    else
+      i = t;
+    if (i.asset === void 0 || i.asset.version[0] < 2) {
+      n && n(new Error("THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported."));
+      return;
+    }
+    const c = new un(i, {
+      path: e || this.resourcePath || "",
+      crossOrigin: this.crossOrigin,
+      requestHeader: this.requestHeader,
+      manager: this.manager,
+      ktx2Loader: this.ktx2Loader,
+      meshoptDecoder: this.meshoptDecoder
+    });
+    c.fileLoader.setRequestHeader(this.requestHeader);
+    for (let u = 0; u < this.pluginCallbacks.length; u++) {
+      const h = this.pluginCallbacks[u](c);
+      h.name || console.error("THREE.GLTFLoader: Invalid plugin found: missing name"), a[h.name] = h, o[h.name] = !0;
+    }
+    if (i.extensionsUsed)
+      for (let u = 0; u < i.extensionsUsed.length; ++u) {
+        const h = i.extensionsUsed[u], d = i.extensionsRequired || [];
+        switch (h) {
+          case R.KHR_MATERIALS_UNLIT:
+            o[h] = new vt();
+            break;
+          case R.KHR_DRACO_MESH_COMPRESSION:
+            o[h] = new $t(i, this.dracoLoader);
+            break;
+          case R.KHR_TEXTURE_TRANSFORM:
+            o[h] = new Jt();
+            break;
+          case R.KHR_MESH_QUANTIZATION:
+            o[h] = new en();
+            break;
+          default:
+            d.indexOf(h) >= 0 && a[h] === void 0 && console.warn('THREE.GLTFLoader: Unknown extension "' + h + '".');
+        }
+      }
+    c.setExtensions(o), c.setPlugins(a), c.parse(s, n);
+  }
+  parseAsync(t, e) {
+    const s = this;
+    return new Promise(function(n, i) {
+      s.parse(t, e, n, i);
+    });
+  }
+}
+function Ct() {
+  let l = {};
+  return {
+    get: function(t) {
+      return l[t];
+    },
+    add: function(t, e) {
+      l[t] = e;
+    },
+    remove: function(t) {
+      delete l[t];
+    },
+    removeAll: function() {
+      l = {};
+    }
+  };
+}
+const R = {
+  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 Bt {
+  constructor(t) {
+    this.parser = t, this.name = R.KHR_LIGHTS_PUNCTUAL, this.cache = { refs: {}, uses: {} };
+  }
+  _markDefs() {
+    const t = this.parser, e = this.parser.json.nodes || [];
+    for (let s = 0, n = e.length; s < n; s++) {
+      const i = e[s];
+      i.extensions && i.extensions[this.name] && i.extensions[this.name].light !== void 0 && t._addNodeRef(this.cache, i.extensions[this.name].light);
+    }
+  }
+  _loadLight(t) {
+    const e = this.parser, s = "light:" + t;
+    let n = e.cache.get(s);
+    if (n) return n;
+    const i = e.json, r = ((i.extensions && i.extensions[this.name] || {}).lights || [])[t];
+    let c;
+    const u = new z(16777215);
+    r.color !== void 0 && u.setRGB(r.color[0], r.color[1], r.color[2], v);
+    const h = r.range !== void 0 ? r.range : 0;
+    switch (r.type) {
+      case "directional":
+        c = new De(u), c.target.position.set(0, 0, -1), c.add(c.target);
+        break;
+      case "point":
+        c = new Fe(u), c.distance = h;
+        break;
+      case "spot":
+        c = new Pe(u), c.distance = h, r.spot = r.spot || {}, r.spot.innerConeAngle = r.spot.innerConeAngle !== void 0 ? r.spot.innerConeAngle : 0, r.spot.outerConeAngle = r.spot.outerConeAngle !== void 0 ? r.spot.outerConeAngle : Math.PI / 4, c.angle = r.spot.outerConeAngle, c.penumbra = 1 - r.spot.innerConeAngle / r.spot.outerConeAngle, c.target.position.set(0, 0, -1), c.add(c.target);
+        break;
+      default:
+        throw new Error("THREE.GLTFLoader: Unexpected light type: " + r.type);
+    }
+    return c.position.set(0, 0, 0), c.decay = 2, B(c, r), r.intensity !== void 0 && (c.intensity = r.intensity), c.name = e.createUniqueName(r.name || "light_" + t), n = Promise.resolve(c), e.cache.add(s, n), n;
+  }
+  getDependency(t, e) {
+    if (t === "light")
+      return this._loadLight(e);
+  }
+  createNodeAttachment(t) {
+    const e = this, s = this.parser, i = s.json.nodes[t], a = (i.extensions && i.extensions[this.name] || {}).light;
+    return a === void 0 ? null : this._loadLight(a).then(function(r) {
+      return s._getNodeRef(e.cache, a, r);
+    });
+  }
+}
+class vt {
+  constructor() {
+    this.name = R.KHR_MATERIALS_UNLIT;
+  }
+  getMaterialType() {
+    return V;
+  }
+  extendParams(t, e, s) {
+    const n = [];
+    t.color = new z(1, 1, 1), t.opacity = 1;
+    const i = e.pbrMetallicRoughness;
+    if (i) {
+      if (Array.isArray(i.baseColorFactor)) {
+        const o = i.baseColorFactor;
+        t.color.setRGB(o[0], o[1], o[2], v), t.opacity = o[3];
+      }
+      i.baseColorTexture !== void 0 && n.push(s.assignTexture(t, "map", i.baseColorTexture, K));
+    }
+    return Promise.all(n);
+  }
+}
+class Pt {
+  constructor(t) {
+    this.parser = t, this.name = R.KHR_MATERIALS_EMISSIVE_STRENGTH;
+  }
+  extendMaterialParams(t, e) {
+    const n = this.parser.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = n.extensions[this.name].emissiveStrength;
+    return i !== void 0 && (e.emissiveIntensity = i), Promise.resolve();
+  }
+}
+class Ft {
+  constructor(t) {
+    this.parser = t, this.name = R.KHR_MATERIALS_CLEARCOAT;
+  }
+  getMaterialType(t) {
+    const s = this.parser.json.materials[t];
+    return !s.extensions || !s.extensions[this.name] ? null : C;
+  }
+  extendMaterialParams(t, e) {
+    const s = this.parser, n = s.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], o = n.extensions[this.name];
+    if (o.clearcoatFactor !== void 0 && (e.clearcoat = o.clearcoatFactor), o.clearcoatTexture !== void 0 && i.push(s.assignTexture(e, "clearcoatMap", o.clearcoatTexture)), o.clearcoatRoughnessFactor !== void 0 && (e.clearcoatRoughness = o.clearcoatRoughnessFactor), o.clearcoatRoughnessTexture !== void 0 && i.push(s.assignTexture(e, "clearcoatRoughnessMap", o.clearcoatRoughnessTexture)), o.clearcoatNormalTexture !== void 0 && (i.push(s.assignTexture(e, "clearcoatNormalMap", o.clearcoatNormalTexture)), o.clearcoatNormalTexture.scale !== void 0)) {
+      const a = o.clearcoatNormalTexture.scale;
+      e.clearcoatNormalScale = new Ne(a, a);
+    }
+    return Promise.all(i);
+  }
+}
+class Dt {
+  constructor(t) {
+    this.parser = t, this.name = R.KHR_MATERIALS_DISPERSION;
+  }
+  getMaterialType(t) {
+    const s = this.parser.json.materials[t];
+    return !s.extensions || !s.extensions[this.name] ? null : C;
+  }
+  extendMaterialParams(t, e) {
+    const n = this.parser.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = n.extensions[this.name];
+    return e.dispersion = i.dispersion !== void 0 ? i.dispersion : 0, Promise.resolve();
+  }
+}
+class Ot {
+  constructor(t) {
+    this.parser = t, this.name = R.KHR_MATERIALS_IRIDESCENCE;
+  }
+  getMaterialType(t) {
+    const s = this.parser.json.materials[t];
+    return !s.extensions || !s.extensions[this.name] ? null : C;
+  }
+  extendMaterialParams(t, e) {
+    const s = this.parser, n = s.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], o = n.extensions[this.name];
+    return o.iridescenceFactor !== void 0 && (e.iridescence = o.iridescenceFactor), o.iridescenceTexture !== void 0 && i.push(s.assignTexture(e, "iridescenceMap", o.iridescenceTexture)), o.iridescenceIor !== void 0 && (e.iridescenceIOR = o.iridescenceIor), e.iridescenceThicknessRange === void 0 && (e.iridescenceThicknessRange = [100, 400]), o.iridescenceThicknessMinimum !== void 0 && (e.iridescenceThicknessRange[0] = o.iridescenceThicknessMinimum), o.iridescenceThicknessMaximum !== void 0 && (e.iridescenceThicknessRange[1] = o.iridescenceThicknessMaximum), o.iridescenceThicknessTexture !== void 0 && i.push(s.assignTexture(e, "iridescenceThicknessMap", o.iridescenceThicknessTexture)), Promise.all(i);
+  }
+}
+class zt {
+  constructor(t) {
+    this.parser = t, this.name = R.KHR_MATERIALS_SHEEN;
+  }
+  getMaterialType(t) {
+    const s = this.parser.json.materials[t];
+    return !s.extensions || !s.extensions[this.name] ? null : C;
+  }
+  extendMaterialParams(t, e) {
+    const s = this.parser, n = s.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [];
+    e.sheenColor = new z(0, 0, 0), e.sheenRoughness = 0, e.sheen = 1;
+    const o = n.extensions[this.name];
+    if (o.sheenColorFactor !== void 0) {
+      const a = o.sheenColorFactor;
+      e.sheenColor.setRGB(a[0], a[1], a[2], v);
+    }
+    return o.sheenRoughnessFactor !== void 0 && (e.sheenRoughness = o.sheenRoughnessFactor), o.sheenColorTexture !== void 0 && i.push(s.assignTexture(e, "sheenColorMap", o.sheenColorTexture, K)), o.sheenRoughnessTexture !== void 0 && i.push(s.assignTexture(e, "sheenRoughnessMap", o.sheenRoughnessTexture)), Promise.all(i);
+  }
+}
+class Ht {
+  constructor(t) {
+    this.parser = t, this.name = R.KHR_MATERIALS_TRANSMISSION;
+  }
+  getMaterialType(t) {
+    const s = this.parser.json.materials[t];
+    return !s.extensions || !s.extensions[this.name] ? null : C;
+  }
+  extendMaterialParams(t, e) {
+    const s = this.parser, n = s.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], o = n.extensions[this.name];
+    return o.transmissionFactor !== void 0 && (e.transmission = o.transmissionFactor), o.transmissionTexture !== void 0 && i.push(s.assignTexture(e, "transmissionMap", o.transmissionTexture)), Promise.all(i);
+  }
+}
+class Gt {
+  constructor(t) {
+    this.parser = t, this.name = R.KHR_MATERIALS_VOLUME;
+  }
+  getMaterialType(t) {
+    const s = this.parser.json.materials[t];
+    return !s.extensions || !s.extensions[this.name] ? null : C;
+  }
+  extendMaterialParams(t, e) {
+    const s = this.parser, n = s.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], o = n.extensions[this.name];
+    e.thickness = o.thicknessFactor !== void 0 ? o.thicknessFactor : 0, o.thicknessTexture !== void 0 && i.push(s.assignTexture(e, "thicknessMap", o.thicknessTexture)), e.attenuationDistance = o.attenuationDistance || 1 / 0;
+    const a = o.attenuationColor || [1, 1, 1];
+    return e.attenuationColor = new z().setRGB(a[0], a[1], a[2], v), Promise.all(i);
+  }
+}
+class Ut {
+  constructor(t) {
+    this.parser = t, this.name = R.KHR_MATERIALS_IOR;
+  }
+  getMaterialType(t) {
+    const s = this.parser.json.materials[t];
+    return !s.extensions || !s.extensions[this.name] ? null : C;
+  }
+  extendMaterialParams(t, e) {
+    const n = this.parser.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = n.extensions[this.name];
+    return e.ior = i.ior !== void 0 ? i.ior : 1.5, Promise.resolve();
+  }
+}
+class Vt {
+  constructor(t) {
+    this.parser = t, this.name = R.KHR_MATERIALS_SPECULAR;
+  }
+  getMaterialType(t) {
+    const s = this.parser.json.materials[t];
+    return !s.extensions || !s.extensions[this.name] ? null : C;
+  }
+  extendMaterialParams(t, e) {
+    const s = this.parser, n = s.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], o = n.extensions[this.name];
+    e.specularIntensity = o.specularFactor !== void 0 ? o.specularFactor : 1, o.specularTexture !== void 0 && i.push(s.assignTexture(e, "specularIntensityMap", o.specularTexture));
+    const a = o.specularColorFactor || [1, 1, 1];
+    return e.specularColor = new z().setRGB(a[0], a[1], a[2], v), o.specularColorTexture !== void 0 && i.push(s.assignTexture(e, "specularColorMap", o.specularColorTexture, K)), Promise.all(i);
+  }
+}
+class jt {
+  constructor(t) {
+    this.parser = t, this.name = R.EXT_MATERIALS_BUMP;
+  }
+  getMaterialType(t) {
+    const s = this.parser.json.materials[t];
+    return !s.extensions || !s.extensions[this.name] ? null : C;
+  }
+  extendMaterialParams(t, e) {
+    const s = this.parser, n = s.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], o = n.extensions[this.name];
+    return e.bumpScale = o.bumpFactor !== void 0 ? o.bumpFactor : 1, o.bumpTexture !== void 0 && i.push(s.assignTexture(e, "bumpMap", o.bumpTexture)), Promise.all(i);
+  }
+}
+class Kt {
+  constructor(t) {
+    this.parser = t, this.name = R.KHR_MATERIALS_ANISOTROPY;
+  }
+  getMaterialType(t) {
+    const s = this.parser.json.materials[t];
+    return !s.extensions || !s.extensions[this.name] ? null : C;
+  }
+  extendMaterialParams(t, e) {
+    const s = this.parser, n = s.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], o = n.extensions[this.name];
+    return o.anisotropyStrength !== void 0 && (e.anisotropy = o.anisotropyStrength), o.anisotropyRotation !== void 0 && (e.anisotropyRotation = o.anisotropyRotation), o.anisotropyTexture !== void 0 && i.push(s.assignTexture(e, "anisotropyMap", o.anisotropyTexture)), Promise.all(i);
+  }
+}
+class Xt {
+  constructor(t) {
+    this.parser = t, this.name = R.KHR_TEXTURE_BASISU;
+  }
+  loadTexture(t) {
+    const e = this.parser, s = e.json, n = s.textures[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return null;
+    const i = n.extensions[this.name], o = e.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 e.loadTextureImage(t, i.source, o);
+  }
+}
+class Wt {
+  constructor(t) {
+    this.parser = t, this.name = R.EXT_TEXTURE_WEBP, this.isSupported = null;
+  }
+  loadTexture(t) {
+    const e = this.name, s = this.parser, n = s.json, i = n.textures[t];
+    if (!i.extensions || !i.extensions[e])
+      return null;
+    const o = i.extensions[e], a = n.images[o.source];
+    let r = s.textureLoader;
+    if (a.uri) {
+      const c = s.options.manager.getHandler(a.uri);
+      c !== null && (r = c);
+    }
+    return this.detectSupport().then(function(c) {
+      if (c) return s.loadTextureImage(t, o.source, r);
+      if (n.extensionsRequired && n.extensionsRequired.indexOf(e) >= 0)
+        throw new Error("THREE.GLTFLoader: WebP required by asset but unsupported.");
+      return s.loadTexture(t);
+    });
+  }
+  detectSupport() {
+    return this.isSupported || (this.isSupported = new Promise(function(t) {
+      const e = new Image();
+      e.src = "data:image/webp;base64,UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA", e.onload = e.onerror = function() {
+        t(e.height === 1);
+      };
+    })), this.isSupported;
+  }
+}
+class Yt {
+  constructor(t) {
+    this.parser = t, this.name = R.EXT_TEXTURE_AVIF, this.isSupported = null;
+  }
+  loadTexture(t) {
+    const e = this.name, s = this.parser, n = s.json, i = n.textures[t];
+    if (!i.extensions || !i.extensions[e])
+      return null;
+    const o = i.extensions[e], a = n.images[o.source];
+    let r = s.textureLoader;
+    if (a.uri) {
+      const c = s.options.manager.getHandler(a.uri);
+      c !== null && (r = c);
+    }
+    return this.detectSupport().then(function(c) {
+      if (c) return s.loadTextureImage(t, o.source, r);
+      if (n.extensionsRequired && n.extensionsRequired.indexOf(e) >= 0)
+        throw new Error("THREE.GLTFLoader: AVIF required by asset but unsupported.");
+      return s.loadTexture(t);
+    });
+  }
+  detectSupport() {
+    return this.isSupported || (this.isSupported = new Promise(function(t) {
+      const e = new Image();
+      e.src = "data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAABcAAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAEAAAABAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQAMAAAAABNjb2xybmNseAACAAIABoAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAAB9tZGF0EgAKCBgABogQEDQgMgkQAAAAB8dSLfI=", e.onload = e.onerror = function() {
+        t(e.height === 1);
+      };
+    })), this.isSupported;
+  }
+}
+class Qt {
+  constructor(t) {
+    this.name = R.EXT_MESHOPT_COMPRESSION, this.parser = t;
+  }
+  loadBufferView(t) {
+    const e = this.parser.json, s = e.bufferViews[t];
+    if (s.extensions && s.extensions[this.name]) {
+      const n = s.extensions[this.name], i = this.parser.getDependency("buffer", n.buffer), o = this.parser.options.meshoptDecoder;
+      if (!o || !o.supported) {
+        if (e.extensionsRequired && e.extensionsRequired.indexOf(this.name) >= 0)
+          throw new Error("THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files");
+        return null;
+      }
+      return i.then(function(a) {
+        const r = n.byteOffset || 0, c = n.byteLength || 0, u = n.count, h = n.byteStride, d = new Uint8Array(a, r, c);
+        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 qt {
+  constructor(t) {
+    this.name = R.EXT_MESH_GPU_INSTANCING, this.parser = t;
+  }
+  createNodeMesh(t) {
+    const e = this.parser.json, s = e.nodes[t];
+    if (!s.extensions || !s.extensions[this.name] || s.mesh === void 0)
+      return null;
+    const n = e.meshes[s.mesh];
+    for (const c of n.primitives)
+      if (c.mode !== k.TRIANGLES && c.mode !== k.TRIANGLE_STRIP && c.mode !== k.TRIANGLE_FAN && c.mode !== void 0)
+        return null;
+    const o = s.extensions[this.name].attributes, a = [], r = {};
+    for (const c in o)
+      a.push(this.parser.getDependency("accessor", o[c]).then((u) => (r[c] = u, r[c])));
+    return a.length < 1 ? null : (a.push(this.parser.createNodeMesh(t)), Promise.all(a).then((c) => {
+      const u = c.pop(), h = u.isGroup ? u.children : [u], d = c[0].count, p = [];
+      for (const m of h) {
+        const A = new W(), g = new H(), x = new Ee(), _ = new H(1, 1, 1), N = new Oe(m.geometry, m.material, d);
+        for (let T = 0; T < d; T++)
+          r.TRANSLATION && g.fromBufferAttribute(r.TRANSLATION, T), r.ROTATION && x.fromBufferAttribute(r.ROTATION, T), r.SCALE && _.fromBufferAttribute(r.SCALE, T), N.setMatrixAt(T, A.compose(g, x, _));
+        for (const T in r)
+          if (T === "_COLOR_0") {
+            const S = r[T];
+            N.instanceColor = new ze(S.array, S.itemSize, S.normalized);
+          } else T !== "TRANSLATION" && T !== "ROTATION" && T !== "SCALE" && m.geometry.setAttribute(T, r[T]);
+        we.prototype.copy.call(N, m), this.parser.assignFinalMaterial(N), p.push(N);
+      }
+      return u.isGroup ? (u.clear(), u.add(...p), u) : p[0];
+    }));
+  }
+}
+const ke = "glTF", U = 12, Te = { JSON: 1313821514, BIN: 5130562 };
+class Zt {
+  constructor(t) {
+    this.name = R.KHR_BINARY_GLTF, this.content = null, this.body = null;
+    const e = new DataView(t, 0, U), s = new TextDecoder();
+    if (this.header = {
+      magic: s.decode(new Uint8Array(t.slice(0, 4))),
+      version: e.getUint32(4, !0),
+      length: e.getUint32(8, !0)
+    }, this.header.magic !== ke)
+      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 - U, i = new DataView(t, U);
+    let o = 0;
+    for (; o < n; ) {
+      const a = i.getUint32(o, !0);
+      o += 4;
+      const r = i.getUint32(o, !0);
+      if (o += 4, r === Te.JSON) {
+        const c = new Uint8Array(t, U + o, a);
+        this.content = s.decode(c);
+      } else if (r === Te.BIN) {
+        const c = U + o;
+        this.body = t.slice(c, c + a);
+      }
+      o += a;
+    }
+    if (this.content === null)
+      throw new Error("THREE.GLTFLoader: JSON content not found.");
+  }
+}
+class $t {
+  constructor(t, e) {
+    if (!e)
+      throw new Error("THREE.GLTFLoader: No DRACOLoader instance provided.");
+    this.name = R.KHR_DRACO_MESH_COMPRESSION, this.json = t, this.dracoLoader = e, this.dracoLoader.preload();
+  }
+  decodePrimitive(t, e) {
+    const s = this.json, n = this.dracoLoader, i = t.extensions[this.name].bufferView, o = t.extensions[this.name].attributes, a = {}, r = {}, c = {};
+    for (const u in o) {
+      const h = re[u] || u.toLowerCase();
+      a[h] = o[u];
+    }
+    for (const u in t.attributes) {
+      const h = re[u] || u.toLowerCase();
+      if (o[u] !== void 0) {
+        const d = s.accessors[t.attributes[u]], p = G[d.componentType];
+        c[h] = p.name, r[h] = d.normalized === !0;
+      }
+    }
+    return e.getDependency("bufferView", i).then(function(u) {
+      return new Promise(function(h, d) {
+        n.decodeDracoFile(u, function(p) {
+          for (const m in p.attributes) {
+            const A = p.attributes[m], g = r[m];
+            g !== void 0 && (A.normalized = g);
+          }
+          h(p);
+        }, a, c, v, d);
+      });
+    });
+  }
+}
+class Jt {
+  constructor() {
+    this.name = R.KHR_TEXTURE_TRANSFORM;
+  }
+  extendTexture(t, e) {
+    return (e.texCoord === void 0 || e.texCoord === t.channel) && e.offset === void 0 && e.rotation === void 0 && e.scale === void 0 || (t = t.clone(), e.texCoord !== void 0 && (t.channel = e.texCoord), e.offset !== void 0 && t.offset.fromArray(e.offset), e.rotation !== void 0 && (t.rotation = e.rotation), e.scale !== void 0 && t.repeat.fromArray(e.scale), t.needsUpdate = !0), t;
+  }
+}
+class en {
+  constructor() {
+    this.name = R.KHR_MESH_QUANTIZATION;
+  }
+}
+class Ce extends mt {
+  constructor(t, e, s, n) {
+    super(t, e, s, n);
+  }
+  copySampleValue_(t) {
+    const e = this.resultBuffer, s = this.sampleValues, n = this.valueSize, i = t * n * 3 + n;
+    for (let o = 0; o !== n; o++)
+      e[o] = s[i + o];
+    return e;
+  }
+  interpolate_(t, e, s, n) {
+    const i = this.resultBuffer, o = this.sampleValues, a = this.valueSize, r = a * 2, c = a * 3, u = n - e, h = (s - e) / u, d = h * h, p = d * h, m = t * c, A = m - c, g = -2 * p + 3 * d, x = p - d, _ = 1 - g, N = x - d + h;
+    for (let T = 0; T !== a; T++) {
+      const S = o[A + T + a], L = o[A + T + r] * u, E = o[m + T + a], I = o[m + T] * u;
+      i[T] = _ * S + N * L + g * E + x * I;
+    }
+    return i;
+  }
+}
+const tn = new Ee();
+class nn extends Ce {
+  interpolate_(t, e, s, n) {
+    const i = super.interpolate_(t, e, s, n);
+    return tn.fromArray(i).normalize().toArray(i), i;
+  }
+}
+const k = {
+  POINTS: 0,
+  LINES: 1,
+  LINE_LOOP: 2,
+  LINE_STRIP: 3,
+  TRIANGLES: 4,
+  TRIANGLE_STRIP: 5,
+  TRIANGLE_FAN: 6
+}, G = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5125: Uint32Array,
+  5126: Float32Array
+}, xe = {
+  9728: We,
+  9729: Se,
+  9984: Xe,
+  9985: Ke,
+  9986: je,
+  9987: Le
+}, _e = {
+  33071: Qe,
+  33648: Ye,
+  10497: ie
+}, ee = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+}, re = {
+  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"
+}, F = {
+  scale: "scale",
+  translation: "position",
+  rotation: "quaternion",
+  weights: "morphTargetInfluences"
+}, sn = {
+  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: Ie,
+  STEP: ft
+}, te = {
+  OPAQUE: "OPAQUE",
+  MASK: "MASK",
+  BLEND: "BLEND"
+};
+function on(l) {
+  return l.DefaultMaterial === void 0 && (l.DefaultMaterial = new be({
+    color: 16777215,
+    emissive: 0,
+    metalness: 1,
+    roughness: 1,
+    transparent: !1,
+    depthTest: !0,
+    side: pt
+  })), l.DefaultMaterial;
+}
+function D(l, t, e) {
+  for (const s in e.extensions)
+    l[s] === void 0 && (t.userData.gltfExtensions = t.userData.gltfExtensions || {}, t.userData.gltfExtensions[s] = e.extensions[s]);
+}
+function B(l, t) {
+  t.extras !== void 0 && (typeof t.extras == "object" ? Object.assign(l.userData, t.extras) : console.warn("THREE.GLTFLoader: Ignoring primitive type .extras, " + t.extras));
+}
+function rn(l, t, e) {
+  let s = !1, n = !1, i = !1;
+  for (let c = 0, u = t.length; c < u; c++) {
+    const h = t[c];
+    if (h.POSITION !== void 0 && (s = !0), h.NORMAL !== void 0 && (n = !0), h.COLOR_0 !== void 0 && (i = !0), s && n && i) break;
+  }
+  if (!s && !n && !i) return Promise.resolve(l);
+  const o = [], a = [], r = [];
+  for (let c = 0, u = t.length; c < u; c++) {
+    const h = t[c];
+    if (s) {
+      const d = h.POSITION !== void 0 ? e.getDependency("accessor", h.POSITION) : l.attributes.position;
+      o.push(d);
+    }
+    if (n) {
+      const d = h.NORMAL !== void 0 ? e.getDependency("accessor", h.NORMAL) : l.attributes.normal;
+      a.push(d);
+    }
+    if (i) {
+      const d = h.COLOR_0 !== void 0 ? e.getDependency("accessor", h.COLOR_0) : l.attributes.color;
+      r.push(d);
+    }
+  }
+  return Promise.all([
+    Promise.all(o),
+    Promise.all(a),
+    Promise.all(r)
+  ]).then(function(c) {
+    const u = c[0], h = c[1], d = c[2];
+    return s && (l.morphAttributes.position = u), n && (l.morphAttributes.normal = h), i && (l.morphAttributes.color = d), l.morphTargetsRelative = !0, l;
+  });
+}
+function an(l, t) {
+  if (l.updateMorphTargets(), t.weights !== void 0)
+    for (let e = 0, s = t.weights.length; e < s; e++)
+      l.morphTargetInfluences[e] = t.weights[e];
+  if (t.extras && Array.isArray(t.extras.targetNames)) {
+    const e = t.extras.targetNames;
+    if (l.morphTargetInfluences.length === e.length) {
+      l.morphTargetDictionary = {};
+      for (let s = 0, n = e.length; s < n; s++)
+        l.morphTargetDictionary[e[s]] = s;
+    } else
+      console.warn("THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.");
+  }
+}
+function cn(l) {
+  let t;
+  const e = l.extensions && l.extensions[R.KHR_DRACO_MESH_COMPRESSION];
+  if (e ? t = "draco:" + e.bufferView + ":" + e.indices + ":" + ne(e.attributes) : t = l.indices + ":" + ne(l.attributes) + ":" + l.mode, l.targets !== void 0)
+    for (let s = 0, n = l.targets.length; s < n; s++)
+      t += ":" + ne(l.targets[s]);
+  return t;
+}
+function ne(l) {
+  let t = "";
+  const e = Object.keys(l).sort();
+  for (let s = 0, n = e.length; s < n; s++)
+    t += e[s] + ":" + l[e[s]] + ";";
+  return t;
+}
+function ae(l) {
+  switch (l) {
+    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 ln(l) {
+  return l.search(/\.jpe?g($|\?)/i) > 0 || l.search(/^data\:image\/jpeg/) === 0 ? "image/jpeg" : l.search(/\.webp($|\?)/i) > 0 || l.search(/^data\:image\/webp/) === 0 ? "image/webp" : "image/png";
+}
+const hn = new W();
+class un {
+  constructor(t = {}, e = {}) {
+    this.json = t, this.extensions = {}, this.plugins = {}, this.options = e, this.cache = new Ct(), 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, i = -1;
+    typeof navigator < "u" && (s = /^((?!chrome|android).)*safari/i.test(navigator.userAgent) === !0, n = navigator.userAgent.indexOf("Firefox") > -1, i = n ? navigator.userAgent.match(/Firefox\/([0-9]+)\./)[1] : -1), typeof createImageBitmap > "u" || s || n && i < 98 ? this.textureLoader = new He(this.options.manager) : this.textureLoader = new Ge(this.options.manager), this.textureLoader.setCrossOrigin(this.options.crossOrigin), this.textureLoader.setRequestHeader(this.options.requestHeader), this.fileLoader = new Me(this.options.manager), this.fileLoader.setResponseType("arraybuffer"), this.options.crossOrigin === "use-credentials" && this.fileLoader.setWithCredentials(!0);
+  }
+  setExtensions(t) {
+    this.extensions = t;
+  }
+  setPlugins(t) {
+    this.plugins = t;
+  }
+  parse(t, e) {
+    const s = this, n = this.json, i = 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 a = {
+        scene: o[0][n.scene || 0],
+        scenes: o[0],
+        animations: o[1],
+        cameras: o[2],
+        asset: n.asset,
+        parser: s,
+        userData: {}
+      };
+      return D(i, a, n), B(a, n), Promise.all(s._invokeAll(function(r) {
+        return r.afterRoot && r.afterRoot(a);
+      })).then(function() {
+        for (const r of a.scenes)
+          r.updateMatrixWorld();
+        t(a);
+      });
+    }).catch(e);
+  }
+  /**
+   * Marks the special nodes/meshes in json for efficient parse.
+   */
+  _markDefs() {
+    const t = this.json.nodes || [], e = this.json.skins || [], s = this.json.meshes || [];
+    for (let n = 0, i = e.length; n < i; n++) {
+      const o = e[n].joints;
+      for (let a = 0, r = o.length; a < r; a++)
+        t[o[a]].isBone = !0;
+    }
+    for (let n = 0, i = t.length; n < i; n++) {
+      const o = t[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.
+   */
+  _addNodeRef(t, e) {
+    e !== void 0 && (t.refs[e] === void 0 && (t.refs[e] = t.uses[e] = 0), t.refs[e]++);
+  }
+  /** Returns a reference to a shared resource, cloning it if necessary. */
+  _getNodeRef(t, e, s) {
+    if (t.refs[e] <= 1) return s;
+    const n = s.clone(), i = (o, a) => {
+      const r = this.associations.get(o);
+      r != null && this.associations.set(a, r);
+      for (const [c, u] of o.children.entries())
+        i(u, a.children[c]);
+    };
+    return i(s, n), n.name += "_instance_" + t.uses[e]++, n;
+  }
+  _invokeOne(t) {
+    const e = Object.values(this.plugins);
+    e.push(this);
+    for (let s = 0; s < e.length; s++) {
+      const n = t(e[s]);
+      if (n) return n;
+    }
+    return null;
+  }
+  _invokeAll(t) {
+    const e = Object.values(this.plugins);
+    e.unshift(this);
+    const s = [];
+    for (let n = 0; n < e.length; n++) {
+      const i = t(e[n]);
+      i && s.push(i);
+    }
+    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(t, e) {
+    const s = t + ":" + e;
+    let n = this.cache.get(s);
+    if (!n) {
+      switch (t) {
+        case "scene":
+          n = this.loadScene(e);
+          break;
+        case "node":
+          n = this._invokeOne(function(i) {
+            return i.loadNode && i.loadNode(e);
+          });
+          break;
+        case "mesh":
+          n = this._invokeOne(function(i) {
+            return i.loadMesh && i.loadMesh(e);
+          });
+          break;
+        case "accessor":
+          n = this.loadAccessor(e);
+          break;
+        case "bufferView":
+          n = this._invokeOne(function(i) {
+            return i.loadBufferView && i.loadBufferView(e);
+          });
+          break;
+        case "buffer":
+          n = this.loadBuffer(e);
+          break;
+        case "material":
+          n = this._invokeOne(function(i) {
+            return i.loadMaterial && i.loadMaterial(e);
+          });
+          break;
+        case "texture":
+          n = this._invokeOne(function(i) {
+            return i.loadTexture && i.loadTexture(e);
+          });
+          break;
+        case "skin":
+          n = this.loadSkin(e);
+          break;
+        case "animation":
+          n = this._invokeOne(function(i) {
+            return i.loadAnimation && i.loadAnimation(e);
+          });
+          break;
+        case "camera":
+          n = this.loadCamera(e);
+          break;
+        default:
+          if (n = this._invokeOne(function(i) {
+            return i != this && i.getDependency && i.getDependency(t, e);
+          }), !n)
+            throw new Error("Unknown type: " + t);
+          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(t) {
+    let e = this.cache.get(t);
+    if (!e) {
+      const s = this, n = this.json[t + (t === "mesh" ? "es" : "s")] || [];
+      e = Promise.all(n.map(function(i, o) {
+        return s.getDependency(t, o);
+      })), this.cache.add(t, e);
+    }
+    return e;
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
+   * @param {number} bufferIndex
+   * @return {Promise<ArrayBuffer>}
+   */
+  loadBuffer(t) {
+    const e = this.json.buffers[t], s = this.fileLoader;
+    if (e.type && e.type !== "arraybuffer")
+      throw new Error("THREE.GLTFLoader: " + e.type + " buffer type is not supported.");
+    if (e.uri === void 0 && t === 0)
+      return Promise.resolve(this.extensions[R.KHR_BINARY_GLTF].body);
+    const n = this.options;
+    return new Promise(function(i, o) {
+      s.load(j.resolveURL(e.uri, n.path), i, void 0, function() {
+        o(new Error('THREE.GLTFLoader: Failed to load buffer "' + e.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(t) {
+    const e = this.json.bufferViews[t];
+    return this.getDependency("buffer", e.buffer).then(function(s) {
+      const n = e.byteLength || 0, i = e.byteOffset || 0;
+      return s.slice(i, i + n);
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
+   * @param {number} accessorIndex
+   * @return {Promise<BufferAttribute|InterleavedBufferAttribute>}
+   */
+  loadAccessor(t) {
+    const e = this, s = this.json, n = this.json.accessors[t];
+    if (n.bufferView === void 0 && n.sparse === void 0) {
+      const o = ee[n.type], a = G[n.componentType], r = n.normalized === !0, c = new a(n.count * o);
+      return Promise.resolve(new Q(c, o, r));
+    }
+    const i = [];
+    return n.bufferView !== void 0 ? i.push(this.getDependency("bufferView", n.bufferView)) : i.push(null), n.sparse !== void 0 && (i.push(this.getDependency("bufferView", n.sparse.indices.bufferView)), i.push(this.getDependency("bufferView", n.sparse.values.bufferView))), Promise.all(i).then(function(o) {
+      const a = o[0], r = ee[n.type], c = G[n.componentType], u = c.BYTES_PER_ELEMENT, h = u * r, d = n.byteOffset || 0, p = n.bufferView !== void 0 ? s.bufferViews[n.bufferView].byteStride : void 0, m = n.normalized === !0;
+      let A, g;
+      if (p && p !== h) {
+        const x = Math.floor(d / p), _ = "InterleavedBuffer:" + n.bufferView + ":" + n.componentType + ":" + x + ":" + n.count;
+        let N = e.cache.get(_);
+        N || (A = new c(a, x * p, n.count * p / u), N = new Ue(A, p / u), e.cache.add(_, N)), g = new Ve(N, r, d % p / u, m);
+      } else
+        a === null ? A = new c(n.count * r) : A = new c(a, d, n.count * r), g = new Q(A, r, m);
+      if (n.sparse !== void 0) {
+        const x = ee.SCALAR, _ = G[n.sparse.indices.componentType], N = n.sparse.indices.byteOffset || 0, T = n.sparse.values.byteOffset || 0, S = new _(o[1], N, n.sparse.count * x), L = new c(o[2], T, n.sparse.count * r);
+        a !== null && (g = new Q(g.array.slice(), g.itemSize, g.normalized));
+        for (let E = 0, I = S.length; E < I; E++) {
+          const P = S[E];
+          if (g.setX(P, L[E * r]), r >= 2 && g.setY(P, L[E * r + 1]), r >= 3 && g.setZ(P, L[E * r + 2]), r >= 4 && g.setW(P, L[E * r + 3]), r >= 5) throw new Error("THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.");
+        }
+      }
+      return g;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures
+   * @param {number} textureIndex
+   * @return {Promise<THREE.Texture|null>}
+   */
+  loadTexture(t) {
+    const e = this.json, s = this.options, i = e.textures[t].source, o = e.images[i];
+    let a = this.textureLoader;
+    if (o.uri) {
+      const r = s.manager.getHandler(o.uri);
+      r !== null && (a = r);
+    }
+    return this.loadTextureImage(t, i, a);
+  }
+  loadTextureImage(t, e, s) {
+    const n = this, i = this.json, o = i.textures[t], a = i.images[e], r = (a.uri || a.bufferView) + ":" + o.sampler;
+    if (this.textureCache[r])
+      return this.textureCache[r];
+    const c = this.loadImageSource(e, s).then(function(u) {
+      u.flipY = !1, u.name = o.name || a.name || "", u.name === "" && typeof a.uri == "string" && a.uri.startsWith("data:image/") === !1 && (u.name = a.uri);
+      const d = (i.samplers || {})[o.sampler] || {};
+      return u.magFilter = xe[d.magFilter] || Se, u.minFilter = xe[d.minFilter] || Le, u.wrapS = _e[d.wrapS] || ie, u.wrapT = _e[d.wrapT] || ie, n.associations.set(u, { textures: t }), u;
+    }).catch(function() {
+      return null;
+    });
+    return this.textureCache[r] = c, c;
+  }
+  loadImageSource(t, e) {
+    const s = this, n = this.json, i = this.options;
+    if (this.sourceCache[t] !== void 0)
+      return this.sourceCache[t].then((h) => h.clone());
+    const o = n.images[t], a = self.URL || self.webkitURL;
+    let r = o.uri || "", c = !1;
+    if (o.bufferView !== void 0)
+      r = s.getDependency("bufferView", o.bufferView).then(function(h) {
+        c = !0;
+        const d = new Blob([h], { type: o.mimeType });
+        return r = a.createObjectURL(d), r;
+      });
+    else if (o.uri === void 0)
+      throw new Error("THREE.GLTFLoader: Image " + t + " is missing URI and bufferView");
+    const u = Promise.resolve(r).then(function(h) {
+      return new Promise(function(d, p) {
+        let m = d;
+        e.isImageBitmapLoader === !0 && (m = function(A) {
+          const g = new ce(A);
+          g.needsUpdate = !0, d(g);
+        }), e.load(j.resolveURL(h, i.path), m, void 0, p);
+      });
+    }).then(function(h) {
+      return c === !0 && a.revokeObjectURL(r), B(h, o), h.userData.mimeType = o.mimeType || ln(o.uri), h;
+    }).catch(function(h) {
+      throw console.error("THREE.GLTFLoader: Couldn't load texture", r), h;
+    });
+    return this.sourceCache[t] = u, u;
+  }
+  /**
+   * Asynchronously assigns a texture to the given material parameters.
+   * @param {Object} materialParams
+   * @param {string} mapName
+   * @param {Object} mapDef
+   * @return {Promise<Texture>}
+   */
+  assignTexture(t, e, s, n) {
+    const i = 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), i.extensions[R.KHR_TEXTURE_TRANSFORM]) {
+        const a = s.extensions !== void 0 ? s.extensions[R.KHR_TEXTURE_TRANSFORM] : void 0;
+        if (a) {
+          const r = i.associations.get(o);
+          o = i.extensions[R.KHR_TEXTURE_TRANSFORM].extendTexture(o, a), i.associations.set(o, r);
+        }
+      }
+      return n !== void 0 && (o.colorSpace = n), t[e] = 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(t) {
+    const e = t.geometry;
+    let s = t.material;
+    const n = e.attributes.tangent === void 0, i = e.attributes.color !== void 0, o = e.attributes.normal === void 0;
+    if (t.isPoints) {
+      const a = "PointsMaterial:" + s.uuid;
+      let r = this.cache.get(a);
+      r || (r = new qe(), q.prototype.copy.call(r, s), r.color.copy(s.color), r.map = s.map, r.sizeAttenuation = !1, this.cache.add(a, r)), s = r;
+    } else if (t.isLine) {
+      const a = "LineBasicMaterial:" + s.uuid;
+      let r = this.cache.get(a);
+      r || (r = new Ze(), q.prototype.copy.call(r, s), r.color.copy(s.color), r.map = s.map, this.cache.add(a, r)), s = r;
+    }
+    if (n || i || o) {
+      let a = "ClonedMaterial:" + s.uuid + ":";
+      n && (a += "derivative-tangents:"), i && (a += "vertex-colors:"), o && (a += "flat-shading:");
+      let r = this.cache.get(a);
+      r || (r = s.clone(), i && (r.vertexColors = !0), o && (r.flatShading = !0), n && (r.normalScale && (r.normalScale.y *= -1), r.clearcoatNormalScale && (r.clearcoatNormalScale.y *= -1)), this.cache.add(a, r), this.associations.set(r, this.associations.get(s))), s = r;
+    }
+    t.material = s;
+  }
+  getMaterialType() {
+    return be;
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
+   * @param {number} materialIndex
+   * @return {Promise<Material>}
+   */
+  loadMaterial(t) {
+    const e = this, s = this.json, n = this.extensions, i = s.materials[t];
+    let o;
+    const a = {}, r = i.extensions || {}, c = [];
+    if (r[R.KHR_MATERIALS_UNLIT]) {
+      const h = n[R.KHR_MATERIALS_UNLIT];
+      o = h.getMaterialType(), c.push(h.extendParams(a, i, e));
+    } else {
+      const h = i.pbrMetallicRoughness || {};
+      if (a.color = new z(1, 1, 1), a.opacity = 1, Array.isArray(h.baseColorFactor)) {
+        const d = h.baseColorFactor;
+        a.color.setRGB(d[0], d[1], d[2], v), a.opacity = d[3];
+      }
+      h.baseColorTexture !== void 0 && c.push(e.assignTexture(a, "map", h.baseColorTexture, K)), a.metalness = h.metallicFactor !== void 0 ? h.metallicFactor : 1, a.roughness = h.roughnessFactor !== void 0 ? h.roughnessFactor : 1, h.metallicRoughnessTexture !== void 0 && (c.push(e.assignTexture(a, "metalnessMap", h.metallicRoughnessTexture)), c.push(e.assignTexture(a, "roughnessMap", h.metallicRoughnessTexture))), o = this._invokeOne(function(d) {
+        return d.getMaterialType && d.getMaterialType(t);
+      }), c.push(Promise.all(this._invokeAll(function(d) {
+        return d.extendMaterialParams && d.extendMaterialParams(t, a);
+      })));
+    }
+    i.doubleSided === !0 && (a.side = $e);
+    const u = i.alphaMode || te.OPAQUE;
+    if (u === te.BLEND ? (a.transparent = !0, a.depthWrite = !1) : (a.transparent = !1, u === te.MASK && (a.alphaTest = i.alphaCutoff !== void 0 ? i.alphaCutoff : 0.5)), i.normalTexture !== void 0 && o !== V && (c.push(e.assignTexture(a, "normalMap", i.normalTexture)), a.normalScale = new Ne(1, 1), i.normalTexture.scale !== void 0)) {
+      const h = i.normalTexture.scale;
+      a.normalScale.set(h, h);
+    }
+    if (i.occlusionTexture !== void 0 && o !== V && (c.push(e.assignTexture(a, "aoMap", i.occlusionTexture)), i.occlusionTexture.strength !== void 0 && (a.aoMapIntensity = i.occlusionTexture.strength)), i.emissiveFactor !== void 0 && o !== V) {
+      const h = i.emissiveFactor;
+      a.emissive = new z().setRGB(h[0], h[1], h[2], v);
+    }
+    return i.emissiveTexture !== void 0 && o !== V && c.push(e.assignTexture(a, "emissiveMap", i.emissiveTexture, K)), Promise.all(c).then(function() {
+      const h = new o(a);
+      return i.name && (h.name = i.name), B(h, i), e.associations.set(h, { materials: t }), i.extensions && D(n, h, i), h;
+    });
+  }
+  /** When Object3D instances are targeted by animation, they need unique names. */
+  createUniqueName(t) {
+    const e = Je.sanitizeNodeName(t || "");
+    return e in this.nodeNamesUsed ? e + "_" + ++this.nodeNamesUsed[e] : (this.nodeNamesUsed[e] = 0, e);
+  }
+  /**
+   * 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(t) {
+    const e = this, s = this.extensions, n = this.primitiveCache;
+    function i(a) {
+      return s[R.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(a, e).then(function(r) {
+        return ye(r, a, e);
+      });
+    }
+    const o = [];
+    for (let a = 0, r = t.length; a < r; a++) {
+      const c = t[a], u = cn(c), h = n[u];
+      if (h)
+        o.push(h.promise);
+      else {
+        let d;
+        c.extensions && c.extensions[R.KHR_DRACO_MESH_COMPRESSION] ? d = i(c) : d = ye(new et(), c, e), n[u] = { primitive: c, 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(t) {
+    const e = this, s = this.json, n = this.extensions, i = s.meshes[t], o = i.primitives, a = [];
+    for (let r = 0, c = o.length; r < c; r++) {
+      const u = o[r].material === void 0 ? on(this.cache) : this.getDependency("material", o[r].material);
+      a.push(u);
+    }
+    return a.push(e.loadGeometries(o)), Promise.all(a).then(function(r) {
+      const c = r.slice(0, r.length - 1), u = r[r.length - 1], h = [];
+      for (let p = 0, m = u.length; p < m; p++) {
+        const A = u[p], g = o[p];
+        let x;
+        const _ = c[p];
+        if (g.mode === k.TRIANGLES || g.mode === k.TRIANGLE_STRIP || g.mode === k.TRIANGLE_FAN || g.mode === void 0)
+          x = i.isSkinnedMesh === !0 ? new tt(A, _) : new nt(A, _), x.isSkinnedMesh === !0 && x.normalizeSkinWeights(), g.mode === k.TRIANGLE_STRIP ? x.geometry = ge(x.geometry, Re) : g.mode === k.TRIANGLE_FAN && (x.geometry = ge(x.geometry, se));
+        else if (g.mode === k.LINES)
+          x = new st(A, _);
+        else if (g.mode === k.LINE_STRIP)
+          x = new it(A, _);
+        else if (g.mode === k.LINE_LOOP)
+          x = new ot(A, _);
+        else if (g.mode === k.POINTS)
+          x = new rt(A, _);
+        else
+          throw new Error("THREE.GLTFLoader: Primitive mode unsupported: " + g.mode);
+        Object.keys(x.geometry.morphAttributes).length > 0 && an(x, i), x.name = e.createUniqueName(i.name || "mesh_" + t), B(x, i), g.extensions && D(n, x, g), e.assignFinalMaterial(x), h.push(x);
+      }
+      for (let p = 0, m = h.length; p < m; p++)
+        e.associations.set(h[p], {
+          meshes: t,
+          primitives: p
+        });
+      if (h.length === 1)
+        return i.extensions && D(n, h[0], i), h[0];
+      const d = new Z();
+      i.extensions && D(n, d, i), e.associations.set(d, { meshes: t });
+      for (let p = 0, m = h.length; p < m; 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(t) {
+    let e;
+    const s = this.json.cameras[t], n = s[s.type];
+    if (!n) {
+      console.warn("THREE.GLTFLoader: Missing camera parameters.");
+      return;
+    }
+    return s.type === "perspective" ? e = new at(ct.radToDeg(n.yfov), n.aspectRatio || 1, n.znear || 1, n.zfar || 2e6) : s.type === "orthographic" && (e = new lt(-n.xmag, n.xmag, n.ymag, -n.ymag, n.znear, n.zfar)), s.name && (e.name = this.createUniqueName(s.name)), B(e, s), Promise.resolve(e);
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
+   * @param {number} skinIndex
+   * @return {Promise<Skeleton>}
+   */
+  loadSkin(t) {
+    const e = this.json.skins[t], s = [];
+    for (let n = 0, i = e.joints.length; n < i; n++)
+      s.push(this._loadNodeShallow(e.joints[n]));
+    return e.inverseBindMatrices !== void 0 ? s.push(this.getDependency("accessor", e.inverseBindMatrices)) : s.push(null), Promise.all(s).then(function(n) {
+      const i = n.pop(), o = n, a = [], r = [];
+      for (let c = 0, u = o.length; c < u; c++) {
+        const h = o[c];
+        if (h) {
+          a.push(h);
+          const d = new W();
+          i !== null && d.fromArray(i.array, c * 16), r.push(d);
+        } else
+          console.warn('THREE.GLTFLoader: Joint "%s" could not be found.', e.joints[c]);
+      }
+      return new ht(a, r);
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
+   * @param {number} animationIndex
+   * @return {Promise<AnimationClip>}
+   */
+  loadAnimation(t) {
+    const e = this.json, s = this, n = e.animations[t], i = n.name ? n.name : "animation_" + t, o = [], a = [], r = [], c = [], u = [];
+    for (let h = 0, d = n.channels.length; h < d; h++) {
+      const p = n.channels[h], m = n.samplers[p.sampler], A = p.target, g = A.node, x = n.parameters !== void 0 ? n.parameters[m.input] : m.input, _ = n.parameters !== void 0 ? n.parameters[m.output] : m.output;
+      A.node !== void 0 && (o.push(this.getDependency("node", g)), a.push(this.getDependency("accessor", x)), r.push(this.getDependency("accessor", _)), c.push(m), u.push(A));
+    }
+    return Promise.all([
+      Promise.all(o),
+      Promise.all(a),
+      Promise.all(r),
+      Promise.all(c),
+      Promise.all(u)
+    ]).then(function(h) {
+      const d = h[0], p = h[1], m = h[2], A = h[3], g = h[4], x = [];
+      for (let _ = 0, N = d.length; _ < N; _++) {
+        const T = d[_], S = p[_], L = m[_], E = A[_], I = g[_];
+        if (T === void 0) continue;
+        T.updateMatrix && T.updateMatrix();
+        const P = s._createAnimationTracks(T, S, L, E, I);
+        if (P)
+          for (let Y = 0; Y < P.length; Y++)
+            x.push(P[Y]);
+      }
+      return new ut(i, void 0, x);
+    });
+  }
+  createNodeMesh(t) {
+    const e = this.json, s = this, n = e.nodes[t];
+    return n.mesh === void 0 ? null : s.getDependency("mesh", n.mesh).then(function(i) {
+      const o = s._getNodeRef(s.meshCache, n.mesh, i);
+      return n.weights !== void 0 && o.traverse(function(a) {
+        if (a.isMesh)
+          for (let r = 0, c = n.weights.length; r < c; r++)
+            a.morphTargetInfluences[r] = n.weights[r];
+      }), o;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
+   * @param {number} nodeIndex
+   * @return {Promise<Object3D>}
+   */
+  loadNode(t) {
+    const e = this.json, s = this, n = e.nodes[t], i = s._loadNodeShallow(t), o = [], a = n.children || [];
+    for (let c = 0, u = a.length; c < u; c++)
+      o.push(s.getDependency("node", a[c]));
+    const r = n.skin === void 0 ? Promise.resolve(null) : s.getDependency("skin", n.skin);
+    return Promise.all([
+      i,
+      Promise.all(o),
+      r
+    ]).then(function(c) {
+      const u = c[0], h = c[1], d = c[2];
+      d !== null && u.traverse(function(p) {
+        p.isSkinnedMesh && p.bind(d, hn);
+      });
+      for (let p = 0, m = h.length; p < m; 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(t) {
+    const e = this.json, s = this.extensions, n = this;
+    if (this.nodeCache[t] !== void 0)
+      return this.nodeCache[t];
+    const i = e.nodes[t], o = i.name ? n.createUniqueName(i.name) : "", a = [], r = n._invokeOne(function(c) {
+      return c.createNodeMesh && c.createNodeMesh(t);
+    });
+    return r && a.push(r), i.camera !== void 0 && a.push(n.getDependency("camera", i.camera).then(function(c) {
+      return n._getNodeRef(n.cameraCache, i.camera, c);
+    })), n._invokeAll(function(c) {
+      return c.createNodeAttachment && c.createNodeAttachment(t);
+    }).forEach(function(c) {
+      a.push(c);
+    }), this.nodeCache[t] = Promise.all(a).then(function(c) {
+      let u;
+      if (i.isBone === !0 ? u = new dt() : c.length > 1 ? u = new Z() : c.length === 1 ? u = c[0] : u = new we(), u !== c[0])
+        for (let h = 0, d = c.length; h < d; h++)
+          u.add(c[h]);
+      if (i.name && (u.userData.name = i.name, u.name = o), B(u, i), i.extensions && D(s, u, i), i.matrix !== void 0) {
+        const h = new W();
+        h.fromArray(i.matrix), u.applyMatrix4(h);
+      } else
+        i.translation !== void 0 && u.position.fromArray(i.translation), i.rotation !== void 0 && u.quaternion.fromArray(i.rotation), i.scale !== void 0 && u.scale.fromArray(i.scale);
+      return n.associations.has(u) || n.associations.set(u, {}), n.associations.get(u).nodes = t, u;
+    }), this.nodeCache[t];
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes
+   * @param {number} sceneIndex
+   * @return {Promise<Group>}
+   */
+  loadScene(t) {
+    const e = this.extensions, s = this.json.scenes[t], n = this, i = new Z();
+    s.name && (i.name = n.createUniqueName(s.name)), B(i, s), s.extensions && D(e, i, s);
+    const o = s.nodes || [], a = [];
+    for (let r = 0, c = o.length; r < c; r++)
+      a.push(n.getDependency("node", o[r]));
+    return Promise.all(a).then(function(r) {
+      for (let u = 0, h = r.length; u < h; u++)
+        i.add(r[u]);
+      const c = (u) => {
+        const h = /* @__PURE__ */ new Map();
+        for (const [d, p] of n.associations)
+          (d instanceof q || d instanceof ce) && h.set(d, p);
+        return u.traverse((d) => {
+          const p = n.associations.get(d);
+          p != null && h.set(d, p);
+        }), h;
+      };
+      return n.associations = c(i), i;
+    });
+  }
+  _createAnimationTracks(t, e, s, n, i) {
+    const o = [], a = t.name ? t.name : t.uuid, r = [];
+    F[i.path] === F.weights ? t.traverse(function(d) {
+      d.morphTargetInfluences && r.push(d.name ? d.name : d.uuid);
+    }) : r.push(a);
+    let c;
+    switch (F[i.path]) {
+      case F.weights:
+        c = he;
+        break;
+      case F.rotation:
+        c = ue;
+        break;
+      case F.position:
+      case F.scale:
+        c = le;
+        break;
+      default:
+        switch (s.itemSize) {
+          case 1:
+            c = he;
+            break;
+          case 2:
+          case 3:
+          default:
+            c = le;
+            break;
+        }
+        break;
+    }
+    const u = n.interpolation !== void 0 ? sn[n.interpolation] : Ie, h = this._getArrayFromAccessor(s);
+    for (let d = 0, p = r.length; d < p; d++) {
+      const m = new c(
+        r[d] + "." + F[i.path],
+        e.array,
+        h,
+        u
+      );
+      n.interpolation === "CUBICSPLINE" && this._createCubicSplineTrackInterpolant(m), o.push(m);
+    }
+    return o;
+  }
+  _getArrayFromAccessor(t) {
+    let e = t.array;
+    if (t.normalized) {
+      const s = ae(e.constructor), n = new Float32Array(e.length);
+      for (let i = 0, o = e.length; i < o; i++)
+        n[i] = e[i] * s;
+      e = n;
+    }
+    return e;
+  }
+  _createCubicSplineTrackInterpolant(t) {
+    t.createInterpolant = function(s) {
+      const n = this instanceof ue ? nn : Ce;
+      return new n(this.times, this.values, this.getValueSize() / 3, s);
+    }, t.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = !0;
+  }
+}
+function dn(l, t, e) {
+  const s = t.attributes, n = new gt();
+  if (s.POSITION !== void 0) {
+    const a = e.json.accessors[s.POSITION], r = a.min, c = a.max;
+    if (r !== void 0 && c !== void 0) {
+      if (n.set(
+        new H(r[0], r[1], r[2]),
+        new H(c[0], c[1], c[2])
+      ), a.normalized) {
+        const u = ae(G[a.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 i = t.targets;
+  if (i !== void 0) {
+    const a = new H(), r = new H();
+    for (let c = 0, u = i.length; c < u; c++) {
+      const h = i[c];
+      if (h.POSITION !== void 0) {
+        const d = e.json.accessors[h.POSITION], p = d.min, m = d.max;
+        if (p !== void 0 && m !== void 0) {
+          if (r.setX(Math.max(Math.abs(p[0]), Math.abs(m[0]))), r.setY(Math.max(Math.abs(p[1]), Math.abs(m[1]))), r.setZ(Math.max(Math.abs(p[2]), Math.abs(m[2]))), d.normalized) {
+            const A = ae(G[d.componentType]);
+            r.multiplyScalar(A);
+          }
+          a.max(r);
+        } else
+          console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      }
+    }
+    n.expandByVector(a);
+  }
+  l.boundingBox = n;
+  const o = new At();
+  n.getCenter(o.center), o.radius = n.min.distanceTo(n.max) / 2, l.boundingSphere = o;
+}
+function ye(l, t, e) {
+  const s = t.attributes, n = [];
+  function i(o, a) {
+    return e.getDependency("accessor", o).then(function(r) {
+      l.setAttribute(a, r);
+    });
+  }
+  for (const o in s) {
+    const a = re[o] || o.toLowerCase();
+    a in l.attributes || n.push(i(s[o], a));
+  }
+  if (t.indices !== void 0 && !l.index) {
+    const o = e.getDependency("accessor", t.indices).then(function(a) {
+      l.setIndex(a);
+    });
+    n.push(o);
+  }
+  return de.workingColorSpace !== v && "COLOR_0" in s && console.warn(`THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${de.workingColorSpace}" not supported.`), B(l, t), dn(l, t, e), Promise.all(n).then(function() {
+    return t.targets !== void 0 ? rn(l, t.targets, e) : l;
+  });
+}
+const fn = "https://cdn.jsdelivr.net/npm/@mymo";
+class pn {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  async load(t) {
+    const e = this._resolve(t), s = this.cache.get(e);
+    if (s) return s;
+    const i = e.endsWith(".vrm") ? await this._loadVRM(e) : await this._loadGLB(e);
+    return this.cache.set(e, i), i;
+  }
+  _resolve(t) {
+    return t.startsWith("http") || t.startsWith("/") || t.endsWith(".glb") || t.endsWith(".vrm") ? t : `${fn}/model-${t}/latest/${t}.glb`;
+  }
+  async _loadGLB(t) {
+    console.warn(
+      "[mymo-avatar] GLB support is best-effort. For guaranteed expressions, gestures, lip sync, and blink, use a VRM model."
+    );
+    const e = new Ae(), s = await this._load(e, t);
+    return this._prepareMeshes(s.scene), { scene: s.scene, animations: s.animations };
+  }
+  async _loadVRM(t) {
+    const e = new Ae();
+    e.register((i) => new Tt(i));
+    const s = await this._load(e, t), n = s.userData.vrm;
+    return this._prepareMeshes(n.scene), { scene: n.scene, animations: s.animations, vrm: n };
+  }
+  _prepareMeshes(t) {
+    t.traverse((e) => {
+      (e instanceof M.Mesh || e instanceof M.SkinnedMesh) && (e.castShadow = !0, e.receiveShadow = !0, e.morphTargetInfluences && e.morphTargetInfluences.fill(0));
+    });
+  }
+  _load(t, e) {
+    return new Promise((s, n) => {
+      t.load(
+        e,
+        s,
+        void 0,
+        (i) => n(new Error(`Failed to load model: ${e} — ${String(i)}`))
+      );
+    });
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+}
+class mn {
+  constructor() {
+    this.installed = /* @__PURE__ */ new Map();
+  }
+  use(t, e, s) {
+    this.installed.has(t.name) || (t.install(e, s), this.installed.set(t.name, t));
+  }
+  has(t) {
+    return this.installed.has(t);
+  }
+}
+const gn = {
+  "pulse-blue": "rgba(96,165,250,0.7)",
+  "pulse-green": "rgba(74,222,128,0.7)",
+  "pulse-red": "rgba(248,113,113,0.7)",
+  "pulse-orange": "rgba(251,146,60,0.7)"
+}, An = {
+  model: "maya",
+  position: "bottom-right",
+  size: 180,
+  theme: "light",
+  framing: "full",
+  draggable: !1,
+  shadows: !1,
+  idle: !0,
+  idleInterval: 8e3,
+  blink: !0,
+  blinkInterval: 3500,
+  lipSync: !0,
+  followMouse: !1,
+  autoHide: !1,
+  zIndex: 99999,
+  framingConfig: {},
+  themeConfig: {}
+};
+class _n {
+  constructor(t = {}) {
+    this._boundMouseLook = (e) => {
+      const s = e.clientX / window.innerWidth * 2 - 1, n = e.clientY / window.innerHeight * 2 - 1;
+      this.animation.lookAt(s, n);
+    }, this.options = { ...An, ...t }, this.events = new xt(), this.renderer = new Mt(), this.animation = new oe(), this.audio = new bt(), this.lipSync = new kt(this.audio, (e) => this.animation.setMouthMorph(e)), this.loader = new pn(), this.plugins = new mn(), this.renderer.setup(this.options), this.renderer.addTickCallback((e) => this.animation.update(e)), this._bindContainerEvents(), this._initialize().catch((e) => console.error("[mymo-avatar]", e));
+  }
+  async _initialize() {
+    try {
+      const t = await this.loader.load(this.options.model);
+      this.renderer.setModel(t.scene), this.animation.init(t), this.options.idle && this.animation.startIdle(this.options.idleInterval), this.options.blink && this.animation.startBlink(this.options.blinkInterval), this.options.followMouse && this._bindMouseLook(), this.events.emit("loaded"), this.events.emit("modelLoaded", { model: this.options.model });
+    } catch (t) {
+      console.error("[mymo-avatar] Failed to load model:", t);
+    }
+  }
+  _bindContainerEvents() {
+    this.renderer.getContainer().addEventListener("click", () => {
+      this.events.emit("click");
+    });
+  }
+  _bindMouseLook() {
+    window.addEventListener("mousemove", this._boundMouseLook);
+  }
+  // ── Visibility ────────────────────────────────────────────────────────────
+  debugBones(t) {
+    return this.renderer.debugBones(t), this;
+  }
+  show() {
+    return this.renderer.show(), this;
+  }
+  hide() {
+    return this.renderer.hide(), this;
+  }
+  destroy() {
+    window.removeEventListener("mousemove", this._boundMouseLook), this.animation.stopLook(), this.animation.dispose(), this.audio.dispose(), this.renderer.dispose(), this.events.removeAllListeners();
+  }
+  // ── Position & Size ───────────────────────────────────────────────────────
+  move(t, e) {
+    return this.renderer.moveTo(t, e), this;
+  }
+  position(t) {
+    return this.renderer.setPosition(t), this;
+  }
+  scale(t) {
+    const e = parseInt(this.renderer.getContainer().style.width, 10) || this.options.size;
+    return this.renderer.setSize(e * t), this;
+  }
+  size(t) {
+    return this.renderer.setSize(t), this;
+  }
+  frame(t) {
+    return this.renderer.setFraming(t), this;
+  }
+  setFramingConfig(t) {
+    return this.renderer.setFramingConfig(t), this;
+  }
+  setTheme(t) {
+    return this.renderer.setTheme(t), this;
+  }
+  setThemeConfig(t) {
+    return this.renderer.setThemeConfig(t), this;
+  }
+  // ── Expressions ───────────────────────────────────────────────────────────
+  expression(t, e = 1) {
+    return this.animation.setExpression(t, e), this;
+  }
+  smile() {
+    return this.expression("smile");
+  }
+  sad() {
+    return this.expression("sad");
+  }
+  happy() {
+    return this.expression("happy");
+  }
+  angry() {
+    return this.expression("angry");
+  }
+  surprised() {
+    return this.expression("surprised");
+  }
+  thinking() {
+    return this.expression("thinking");
+  }
+  confused() {
+    return this.expression("confused");
+  }
+  sleep() {
+    return this.expression("sleep");
+  }
+  idle() {
+    return this.expression("idle");
+  }
+  // ── Gestures ──────────────────────────────────────────────────────────────
+  wave() {
+    return this._gesture("wave");
+  }
+  nod() {
+    return this._gesture("nod");
+  }
+  shakeHead() {
+    return this._gesture("shakeHead");
+  }
+  clap() {
+    return this._gesture("clap");
+  }
+  jump() {
+    return this._gesture("jump");
+  }
+  dance() {
+    return this._gesture("dance");
+  }
+  yes() {
+    return this._gesture("yes");
+  }
+  no() {
+    return this._gesture("no");
+  }
+  thumbsUp() {
+    return this._gesture("thumbsUp");
+  }
+  _gesture(t) {
+    return this.events.emit("animationStart", { gesture: t }), this.animation.playGesture(t), this;
+  }
+  // ── Look ──────────────────────────────────────────────────────────────────
+  lookAtMouse() {
+    return this._bindMouseLook(), this;
+  }
+  lookAt(t, e) {
+    const s = t / window.innerWidth * 2 - 1, n = e / window.innerHeight * 2 - 1;
+    return this.animation.lookAt(s, n), this;
+  }
+  lookForward() {
+    return window.removeEventListener("mousemove", this._boundMouseLook), this.animation.lookForward(), this;
+  }
+  randomLook() {
+    return this.animation.startRandomLook(), this;
+  }
+  // ── Speech ────────────────────────────────────────────────────────────────
+  async talk(t) {
+    return this.events.emit("speechStart"), this.options.lipSync && this.lipSync.startAutoSync(), await this.audio.play(t), this.options.lipSync && this.lipSync.stopAutoSync(), this.events.emit("speechEnd"), this;
+  }
+  startTalking() {
+    return this.events.emit("speechStart"), this.options.lipSync && this.lipSync.startAutoSync(), this;
+  }
+  stopTalking() {
+    return this.audio.stop(), this.lipSync.stopAutoSync(), this.events.emit("speechEnd"), this;
+  }
+  pauseTalking() {
+    return this.audio.pause(), this;
+  }
+  // ── Lip Sync ──────────────────────────────────────────────────────────────
+  setViseme(t) {
+    return this.lipSync.setViseme(t), this;
+  }
+  setMouth(t) {
+    return this.lipSync.setMouth(t), this;
+  }
+  setVolume(t) {
+    return this.lipSync.setVolume(t), this;
+  }
+  // ── States ────────────────────────────────────────────────────────────────
+  setState(t) {
+    const e = {
+      loading: { expression: "thinking", animation: "Idle", ring: "pulse-blue" },
+      success: { expression: "happy", animation: "Yes", ring: "pulse-green" },
+      error: { expression: "sad", animation: "No", ring: "pulse-red" },
+      warning: { expression: "surprised", animation: "Idle", ring: "pulse-orange" },
+      typing: { expression: "thinking", animation: "Idle", ring: "" },
+      listening: { expression: "smile", animation: "Idle", ring: "pulse-blue" },
+      processing: { expression: "thinking", animation: "Idle", ring: "pulse-blue" },
+      complete: { expression: "happy", animation: "ThumbsUp", ring: "pulse-green" }
+    }, { expression: s, animation: n, ring: i } = e[t];
+    this.animation.setExpression(s), this.animation.play(n);
+    const o = this.renderer.getContainer();
+    return o.dataset.state = t, o.style.setProperty("--ring-color", i ? gn[i] ?? "transparent" : "transparent"), this.events.emit("animationStart", { state: t }), this;
+  }
+  loading() {
+    return this.setState("loading");
+  }
+  success() {
+    return this.setState("success");
+  }
+  error() {
+    return this.setState("error");
+  }
+  warning() {
+    return this.setState("warning");
+  }
+  typing() {
+    return this.setState("typing");
+  }
+  listening() {
+    return this.setState("listening");
+  }
+  processing() {
+    return this.setState("processing");
+  }
+  complete() {
+    return this.setState("complete");
+  }
+  clearState() {
+    this.animation.setExpression("idle"), this.animation.stop();
+    const t = this.renderer.getContainer();
+    return t.dataset.state = "", t.style.setProperty("--ring-color", "transparent"), this.events.emit("animationEnd"), this;
+  }
+  // ── Animations ────────────────────────────────────────────────────────────
+  play(t) {
+    return this.events.emit("animationStart", { name: t }), this.animation.play(t), this;
+  }
+  stop() {
+    return this.animation.stop(), this.events.emit("animationEnd"), this;
+  }
+  // ── Models ────────────────────────────────────────────────────────────────
+  async load(t) {
+    const e = await this.loader.load(t);
+    return this.animation.dispose(), this.renderer.setModel(e.scene), this.animation.init(e), this.options.idle && this.animation.startIdle(this.options.idleInterval), this.options.blink && this.animation.startBlink(this.options.blinkInterval), this.events.emit("modelLoaded", { model: t }), this;
+  }
+  // ── Events ────────────────────────────────────────────────────────────────
+  on(t, e) {
+    return this.events.on(t, e), this;
+  }
+  off(t, e) {
+    return this.events.off(t, e), this;
+  }
+  // ── Plugins ───────────────────────────────────────────────────────────────
+  use(t, e) {
+    return this.plugins.use(t, this, e), this;
+  }
+}
+export {
+  _n as A
+};
+//# sourceMappingURL=Avatar-DEkBZdcp.js.map