@streamoji/avatar-widget 0.1.0 → 0.2.0

package/dist/avatar-widget.js

@@ -1,87 +1,1788 @@
-import { jsx as f, jsxs as ne } from "react/jsx-runtime";
-import { memo as kt, useMemo as ze, useRef as c, useState as k, useEffect as z, useCallback as Ue, useLayoutEffect as Rt, Suspense as Lt } from "react";
-import { useFrame as At, Canvas as Mt, useThree as Et } from "@react-three/fiber";
-import { useGLTF as Ge, Environment as Tt } from "@react-three/drei";
-import * as Ie from "three";
-import { GLTFLoader as It } from "three/examples/jsm/loaders/GLTFLoader.js";
-const H = (...d) => {
-}, Ct = (...d) => {
-}, ot = ({ analyser: d }) => {
-  const y = c(null), v = c(null);
-  return z(() => {
-    const p = y.current;
-    if (!p) return;
-    const I = p.getContext("2d", { alpha: !0 });
-    if (!I) return;
-    let E, R = null;
-    d && (d.fftSize = 128, R = new Uint8Array(d.frequencyBinCount));
-    const ge = () => {
-      E = requestAnimationFrame(ge), (p.width !== p.offsetWidth || p.height !== p.offsetHeight) && (p.width = p.offsetWidth, p.height = p.offsetHeight);
-      const re = p.width, C = p.height;
-      if (re === 0 || C === 0) return;
-      const L = C / 2;
-      I.clearRect(0, 0, re, C), I.fillStyle = "#1e293b";
-      const Q = 2, A = Q + 2, le = re * 0.95, m = Math.floor(le / A);
-      (!v.current || v.current.length !== m) && (v.current = new Float32Array(m).fill(2));
-      const be = m * A, ie = (re - be) / 2;
-      d && R && d.getByteFrequencyData(R);
-      const ue = R ? R.length : 0, N = Math.floor(ue * 0.7) / m, O = new Float32Array(m);
-      for (let b = 0; b < m; b++) {
-        let P = 0;
-        if (R && N > 0) {
-          const _ = Math.floor(b * N), Z = Math.floor((b + 1) * N);
-          for (let ee = _; ee < Z; ee++) {
-            const de = R[ee] || 0;
-            de > P && (P = de);
+import { jsx as N, jsxs as de } from "react/jsx-runtime";
+import { memo as bn, useMemo as gt, useRef as L, useState as K, useEffect as ie, useCallback as Ye, useLayoutEffect as _n, Suspense as xn } from "react";
+import { useFrame as wn, Canvas as Rn, useThree as Sn } from "@react-three/fiber";
+import { useGLTF as ct, Environment as yn } from "@react-three/drei";
+import * as Ge from "three";
+import { TrianglesDrawMode as An, TriangleFanDrawMode as Tt, TriangleStripDrawMode as Wt, Loader as En, LoaderUtils as Ke, FileLoader as Xt, MeshPhysicalMaterial as ge, Vector2 as zt, Color as ve, LinearSRGBColorSpace as Re, SRGBColorSpace as We, SpotLight as Ln, PointLight as Mn, DirectionalLight as In, Matrix4 as Qe, Vector3 as Oe, Quaternion as $t, InstancedMesh as vn, InstancedBufferAttribute as kn, Object3D as qt, TextureLoader as Nn, ImageBitmapLoader as Cn, BufferAttribute as ut, InterleavedBuffer as On, InterleavedBufferAttribute as Dn, LinearMipmapLinearFilter as Yt, NearestMipmapLinearFilter as Fn, LinearMipmapNearestFilter as Pn, NearestMipmapNearestFilter as Un, LinearFilter as bt, NearestFilter as Jt, RepeatWrapping as _t, MirroredRepeatWrapping as Hn, ClampToEdgeWrapping as Bn, PointsMaterial as Gn, Material as lt, LineBasicMaterial as jn, MeshStandardMaterial as Qt, DoubleSide as Vn, MeshBasicMaterial as Ve, PropertyBinding as Kn, BufferGeometry as Wn, SkinnedMesh as Xn, Mesh as zn, LineSegments as $n, Line as qn, LineLoop as Yn, Points as Jn, Group as dt, PerspectiveCamera as Qn, MathUtils as Zn, OrthographicCamera as es, Skeleton as ts, AnimationClip as ns, Bone as ss, InterpolateDiscrete as rs, InterpolateLinear as Zt, Texture as Nt, VectorKeyframeTrack as Ct, NumberKeyframeTrack as Ot, QuaternionKeyframeTrack as Dt, ColorManagement as Ft, FrontSide as is, Interpolant as os, Box3 as as, Sphere as cs } from "three";
+function Pt(d, t) {
+  if (t === An)
+    return console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles."), d;
+  if (t === Tt || t === Wt) {
+    let e = d.getIndex();
+    if (e === null) {
+      const s = [], a = d.getAttribute("position");
+      if (a !== void 0) {
+        for (let o = 0; o < a.count; o++)
+          s.push(o);
+        d.setIndex(s), e = d.getIndex();
+      } else
+        return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible."), d;
+    }
+    const r = e.count - 2, n = [];
+    if (t === Tt)
+      for (let s = 1; s <= r; s++)
+        n.push(e.getX(0)), n.push(e.getX(s)), n.push(e.getX(s + 1));
+    else
+      for (let s = 0; s < r; s++)
+        s % 2 === 0 ? (n.push(e.getX(s)), n.push(e.getX(s + 1)), n.push(e.getX(s + 2))) : (n.push(e.getX(s + 2)), n.push(e.getX(s + 1)), n.push(e.getX(s)));
+    n.length / 3 !== r && console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unable to generate correct amount of triangles.");
+    const i = d.clone();
+    return i.setIndex(n), i.clearGroups(), i;
+  } else
+    return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unknown draw mode:", t), d;
+}
+class us extends En {
+  /**
+   * Constructs a new glTF loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
+  constructor(t) {
+    super(t), this.dracoLoader = null, this.ktx2Loader = null, this.meshoptDecoder = null, this.pluginCallbacks = [], this.register(function(e) {
+      return new ps(e);
+    }), this.register(function(e) {
+      return new ms(e);
+    }), this.register(function(e) {
+      return new ys(e);
+    }), this.register(function(e) {
+      return new As(e);
+    }), this.register(function(e) {
+      return new Es(e);
+    }), this.register(function(e) {
+      return new Ts(e);
+    }), this.register(function(e) {
+      return new bs(e);
+    }), this.register(function(e) {
+      return new _s(e);
+    }), this.register(function(e) {
+      return new xs(e);
+    }), this.register(function(e) {
+      return new hs(e);
+    }), this.register(function(e) {
+      return new ws(e);
+    }), this.register(function(e) {
+      return new gs(e);
+    }), this.register(function(e) {
+      return new Ss(e);
+    }), this.register(function(e) {
+      return new Rs(e);
+    }), this.register(function(e) {
+      return new ds(e);
+    }), this.register(function(e) {
+      return new Ls(e);
+    }), this.register(function(e) {
+      return new Ms(e);
+    });
+  }
+  /**
+   * Starts loading from the given URL and passes the loaded glTF asset
+   * to the `onLoad()` callback.
+   *
+   * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
+   * @param {function(GLTFLoader~LoadObject)} onLoad - Executed when the loading process has been finished.
+   * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
+   * @param {onErrorCallback} onError - Executed when errors occur.
+   */
+  load(t, e, r, n) {
+    const i = this;
+    let s;
+    if (this.resourcePath !== "")
+      s = this.resourcePath;
+    else if (this.path !== "") {
+      const c = Ke.extractUrlBase(t);
+      s = Ke.resolveURL(c, this.path);
+    } else
+      s = Ke.extractUrlBase(t);
+    this.manager.itemStart(t);
+    const a = function(c) {
+      n ? n(c) : console.error(c), i.manager.itemError(t), i.manager.itemEnd(t);
+    }, o = new Xt(this.manager);
+    o.setPath(this.path), o.setResponseType("arraybuffer"), o.setRequestHeader(this.requestHeader), o.setWithCredentials(this.withCredentials), o.load(t, function(c) {
+      try {
+        i.parse(c, s, function(u) {
+          e(u), i.manager.itemEnd(t);
+        }, a);
+      } catch (u) {
+        a(u);
+      }
+    }, r, a);
+  }
+  /**
+   * Sets the given Draco loader to this loader. Required for decoding assets
+   * compressed with the `KHR_draco_mesh_compression` extension.
+   *
+   * @param {DRACOLoader} dracoLoader - The Draco loader to set.
+   * @return {GLTFLoader} A reference to this loader.
+   */
+  setDRACOLoader(t) {
+    return this.dracoLoader = t, this;
+  }
+  /**
+   * Sets the given KTX2 loader to this loader. Required for loading KTX2
+   * compressed textures.
+   *
+   * @param {KTX2Loader} ktx2Loader - The KTX2 loader to set.
+   * @return {GLTFLoader} A reference to this loader.
+   */
+  setKTX2Loader(t) {
+    return this.ktx2Loader = t, this;
+  }
+  /**
+   * Sets the given meshopt decoder. Required for decoding assets
+   * compressed with the `EXT_meshopt_compression` extension.
+   *
+   * @param {Object} meshoptDecoder - The meshopt decoder to set.
+   * @return {GLTFLoader} A reference to this loader.
+   */
+  setMeshoptDecoder(t) {
+    return this.meshoptDecoder = t, this;
+  }
+  /**
+   * Registers a plugin callback. This API is internally used to implement the various
+   * glTF extensions but can also used by third-party code to add additional logic
+   * to the loader.
+   *
+   * @param {function(parser:GLTFParser)} callback - The callback function to register.
+   * @return {GLTFLoader} A reference to this loader.
+   */
+  register(t) {
+    return this.pluginCallbacks.indexOf(t) === -1 && this.pluginCallbacks.push(t), this;
+  }
+  /**
+   * Unregisters a plugin callback.
+   *
+   * @param {Function} callback - The callback function to unregister.
+   * @return {GLTFLoader} A reference to this loader.
+   */
+  unregister(t) {
+    return this.pluginCallbacks.indexOf(t) !== -1 && this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(t), 1), this;
+  }
+  /**
+   * Parses the given FBX data and returns the resulting group.
+   *
+   * @param {string|ArrayBuffer} data - The raw glTF data.
+   * @param {string} path - The URL base path.
+   * @param {function(GLTFLoader~LoadObject)} onLoad - Executed when the loading process has been finished.
+   * @param {onErrorCallback} onError - Executed when errors occur.
+   */
+  parse(t, e, r, n) {
+    let i;
+    const s = {}, a = {}, o = new TextDecoder();
+    if (typeof t == "string")
+      i = JSON.parse(t);
+    else if (t instanceof ArrayBuffer)
+      if (o.decode(new Uint8Array(t, 0, 4)) === en) {
+        try {
+          s[k.KHR_BINARY_GLTF] = new Is(t);
+        } catch (l) {
+          n && n(l);
+          return;
+        }
+        i = JSON.parse(s[k.KHR_BINARY_GLTF].content);
+      } else
+        i = JSON.parse(o.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 js(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 l = this.pluginCallbacks[u](c);
+      l.name || console.error("THREE.GLTFLoader: Invalid plugin found: missing name"), a[l.name] = l, s[l.name] = !0;
+    }
+    if (i.extensionsUsed)
+      for (let u = 0; u < i.extensionsUsed.length; ++u) {
+        const l = i.extensionsUsed[u], f = i.extensionsRequired || [];
+        switch (l) {
+          case k.KHR_MATERIALS_UNLIT:
+            s[l] = new fs();
+            break;
+          case k.KHR_DRACO_MESH_COMPRESSION:
+            s[l] = new vs(i, this.dracoLoader);
+            break;
+          case k.KHR_TEXTURE_TRANSFORM:
+            s[l] = new ks();
+            break;
+          case k.KHR_MESH_QUANTIZATION:
+            s[l] = new Ns();
+            break;
+          default:
+            f.indexOf(l) >= 0 && a[l] === void 0 && console.warn('THREE.GLTFLoader: Unknown extension "' + l + '".');
+        }
+      }
+    c.setExtensions(s), c.setPlugins(a), c.parse(r, n);
+  }
+  /**
+   * Async version of {@link GLTFLoader#parse}.
+   *
+   * @async
+   * @param {string|ArrayBuffer} data - The raw glTF data.
+   * @param {string} path - The URL base path.
+   * @return {Promise<GLTFLoader~LoadObject>} A Promise that resolves with the loaded glTF when the parsing has been finished.
+   */
+  parseAsync(t, e) {
+    const r = this;
+    return new Promise(function(n, i) {
+      r.parse(t, e, n, i);
+    });
+  }
+}
+function ls() {
+  let d = {};
+  return {
+    get: function(t) {
+      return d[t];
+    },
+    add: function(t, e) {
+      d[t] = e;
+    },
+    remove: function(t) {
+      delete d[t];
+    },
+    removeAll: function() {
+      d = {};
+    }
+  };
+}
+const k = {
+  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 ds {
+  constructor(t) {
+    this.parser = t, this.name = k.KHR_LIGHTS_PUNCTUAL, this.cache = { refs: {}, uses: {} };
+  }
+  _markDefs() {
+    const t = this.parser, e = this.parser.json.nodes || [];
+    for (let r = 0, n = e.length; r < n; r++) {
+      const i = e[r];
+      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, r = "light:" + t;
+    let n = e.cache.get(r);
+    if (n) return n;
+    const i = e.json, o = ((i.extensions && i.extensions[this.name] || {}).lights || [])[t];
+    let c;
+    const u = new ve(16777215);
+    o.color !== void 0 && u.setRGB(o.color[0], o.color[1], o.color[2], Re);
+    const l = o.range !== void 0 ? o.range : 0;
+    switch (o.type) {
+      case "directional":
+        c = new In(u), c.target.position.set(0, 0, -1), c.add(c.target);
+        break;
+      case "point":
+        c = new Mn(u), c.distance = l;
+        break;
+      case "spot":
+        c = new Ln(u), c.distance = l, o.spot = o.spot || {}, o.spot.innerConeAngle = o.spot.innerConeAngle !== void 0 ? o.spot.innerConeAngle : 0, o.spot.outerConeAngle = o.spot.outerConeAngle !== void 0 ? o.spot.outerConeAngle : Math.PI / 4, c.angle = o.spot.outerConeAngle, c.penumbra = 1 - o.spot.innerConeAngle / o.spot.outerConeAngle, c.target.position.set(0, 0, -1), c.add(c.target);
+        break;
+      default:
+        throw new Error("THREE.GLTFLoader: Unexpected light type: " + o.type);
+    }
+    return c.position.set(0, 0, 0), me(c, o), o.intensity !== void 0 && (c.intensity = o.intensity), c.name = e.createUniqueName(o.name || "light_" + t), n = Promise.resolve(c), e.cache.add(r, n), n;
+  }
+  getDependency(t, e) {
+    if (t === "light")
+      return this._loadLight(e);
+  }
+  createNodeAttachment(t) {
+    const e = this, r = this.parser, i = r.json.nodes[t], a = (i.extensions && i.extensions[this.name] || {}).light;
+    return a === void 0 ? null : this._loadLight(a).then(function(o) {
+      return r._getNodeRef(e.cache, a, o);
+    });
+  }
+}
+class fs {
+  constructor() {
+    this.name = k.KHR_MATERIALS_UNLIT;
+  }
+  getMaterialType() {
+    return Ve;
+  }
+  extendParams(t, e, r) {
+    const n = [];
+    t.color = new ve(1, 1, 1), t.opacity = 1;
+    const i = e.pbrMetallicRoughness;
+    if (i) {
+      if (Array.isArray(i.baseColorFactor)) {
+        const s = i.baseColorFactor;
+        t.color.setRGB(s[0], s[1], s[2], Re), t.opacity = s[3];
+      }
+      i.baseColorTexture !== void 0 && n.push(r.assignTexture(t, "map", i.baseColorTexture, We));
+    }
+    return Promise.all(n);
+  }
+}
+class hs {
+  constructor(t) {
+    this.parser = t, this.name = k.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 ps {
+  constructor(t) {
+    this.parser = t, this.name = k.KHR_MATERIALS_CLEARCOAT;
+  }
+  getMaterialType(t) {
+    const r = this.parser.json.materials[t];
+    return !r.extensions || !r.extensions[this.name] ? null : ge;
+  }
+  extendMaterialParams(t, e) {
+    const r = this.parser, n = r.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], s = n.extensions[this.name];
+    if (s.clearcoatFactor !== void 0 && (e.clearcoat = s.clearcoatFactor), s.clearcoatTexture !== void 0 && i.push(r.assignTexture(e, "clearcoatMap", s.clearcoatTexture)), s.clearcoatRoughnessFactor !== void 0 && (e.clearcoatRoughness = s.clearcoatRoughnessFactor), s.clearcoatRoughnessTexture !== void 0 && i.push(r.assignTexture(e, "clearcoatRoughnessMap", s.clearcoatRoughnessTexture)), s.clearcoatNormalTexture !== void 0 && (i.push(r.assignTexture(e, "clearcoatNormalMap", s.clearcoatNormalTexture)), s.clearcoatNormalTexture.scale !== void 0)) {
+      const a = s.clearcoatNormalTexture.scale;
+      e.clearcoatNormalScale = new zt(a, a);
+    }
+    return Promise.all(i);
+  }
+}
+class ms {
+  constructor(t) {
+    this.parser = t, this.name = k.KHR_MATERIALS_DISPERSION;
+  }
+  getMaterialType(t) {
+    const r = this.parser.json.materials[t];
+    return !r.extensions || !r.extensions[this.name] ? null : ge;
+  }
+  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 gs {
+  constructor(t) {
+    this.parser = t, this.name = k.KHR_MATERIALS_IRIDESCENCE;
+  }
+  getMaterialType(t) {
+    const r = this.parser.json.materials[t];
+    return !r.extensions || !r.extensions[this.name] ? null : ge;
+  }
+  extendMaterialParams(t, e) {
+    const r = this.parser, n = r.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], s = n.extensions[this.name];
+    return s.iridescenceFactor !== void 0 && (e.iridescence = s.iridescenceFactor), s.iridescenceTexture !== void 0 && i.push(r.assignTexture(e, "iridescenceMap", s.iridescenceTexture)), s.iridescenceIor !== void 0 && (e.iridescenceIOR = s.iridescenceIor), e.iridescenceThicknessRange === void 0 && (e.iridescenceThicknessRange = [100, 400]), s.iridescenceThicknessMinimum !== void 0 && (e.iridescenceThicknessRange[0] = s.iridescenceThicknessMinimum), s.iridescenceThicknessMaximum !== void 0 && (e.iridescenceThicknessRange[1] = s.iridescenceThicknessMaximum), s.iridescenceThicknessTexture !== void 0 && i.push(r.assignTexture(e, "iridescenceThicknessMap", s.iridescenceThicknessTexture)), Promise.all(i);
+  }
+}
+class Ts {
+  constructor(t) {
+    this.parser = t, this.name = k.KHR_MATERIALS_SHEEN;
+  }
+  getMaterialType(t) {
+    const r = this.parser.json.materials[t];
+    return !r.extensions || !r.extensions[this.name] ? null : ge;
+  }
+  extendMaterialParams(t, e) {
+    const r = this.parser, n = r.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [];
+    e.sheenColor = new ve(0, 0, 0), e.sheenRoughness = 0, e.sheen = 1;
+    const s = n.extensions[this.name];
+    if (s.sheenColorFactor !== void 0) {
+      const a = s.sheenColorFactor;
+      e.sheenColor.setRGB(a[0], a[1], a[2], Re);
+    }
+    return s.sheenRoughnessFactor !== void 0 && (e.sheenRoughness = s.sheenRoughnessFactor), s.sheenColorTexture !== void 0 && i.push(r.assignTexture(e, "sheenColorMap", s.sheenColorTexture, We)), s.sheenRoughnessTexture !== void 0 && i.push(r.assignTexture(e, "sheenRoughnessMap", s.sheenRoughnessTexture)), Promise.all(i);
+  }
+}
+class bs {
+  constructor(t) {
+    this.parser = t, this.name = k.KHR_MATERIALS_TRANSMISSION;
+  }
+  getMaterialType(t) {
+    const r = this.parser.json.materials[t];
+    return !r.extensions || !r.extensions[this.name] ? null : ge;
+  }
+  extendMaterialParams(t, e) {
+    const r = this.parser, n = r.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], s = n.extensions[this.name];
+    return s.transmissionFactor !== void 0 && (e.transmission = s.transmissionFactor), s.transmissionTexture !== void 0 && i.push(r.assignTexture(e, "transmissionMap", s.transmissionTexture)), Promise.all(i);
+  }
+}
+class _s {
+  constructor(t) {
+    this.parser = t, this.name = k.KHR_MATERIALS_VOLUME;
+  }
+  getMaterialType(t) {
+    const r = this.parser.json.materials[t];
+    return !r.extensions || !r.extensions[this.name] ? null : ge;
+  }
+  extendMaterialParams(t, e) {
+    const r = this.parser, n = r.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], s = n.extensions[this.name];
+    e.thickness = s.thicknessFactor !== void 0 ? s.thicknessFactor : 0, s.thicknessTexture !== void 0 && i.push(r.assignTexture(e, "thicknessMap", s.thicknessTexture)), e.attenuationDistance = s.attenuationDistance || 1 / 0;
+    const a = s.attenuationColor || [1, 1, 1];
+    return e.attenuationColor = new ve().setRGB(a[0], a[1], a[2], Re), Promise.all(i);
+  }
+}
+class xs {
+  constructor(t) {
+    this.parser = t, this.name = k.KHR_MATERIALS_IOR;
+  }
+  getMaterialType(t) {
+    const r = this.parser.json.materials[t];
+    return !r.extensions || !r.extensions[this.name] ? null : ge;
+  }
+  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 ws {
+  constructor(t) {
+    this.parser = t, this.name = k.KHR_MATERIALS_SPECULAR;
+  }
+  getMaterialType(t) {
+    const r = this.parser.json.materials[t];
+    return !r.extensions || !r.extensions[this.name] ? null : ge;
+  }
+  extendMaterialParams(t, e) {
+    const r = this.parser, n = r.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], s = n.extensions[this.name];
+    e.specularIntensity = s.specularFactor !== void 0 ? s.specularFactor : 1, s.specularTexture !== void 0 && i.push(r.assignTexture(e, "specularIntensityMap", s.specularTexture));
+    const a = s.specularColorFactor || [1, 1, 1];
+    return e.specularColor = new ve().setRGB(a[0], a[1], a[2], Re), s.specularColorTexture !== void 0 && i.push(r.assignTexture(e, "specularColorMap", s.specularColorTexture, We)), Promise.all(i);
+  }
+}
+class Rs {
+  constructor(t) {
+    this.parser = t, this.name = k.EXT_MATERIALS_BUMP;
+  }
+  getMaterialType(t) {
+    const r = this.parser.json.materials[t];
+    return !r.extensions || !r.extensions[this.name] ? null : ge;
+  }
+  extendMaterialParams(t, e) {
+    const r = this.parser, n = r.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], s = n.extensions[this.name];
+    return e.bumpScale = s.bumpFactor !== void 0 ? s.bumpFactor : 1, s.bumpTexture !== void 0 && i.push(r.assignTexture(e, "bumpMap", s.bumpTexture)), Promise.all(i);
+  }
+}
+class Ss {
+  constructor(t) {
+    this.parser = t, this.name = k.KHR_MATERIALS_ANISOTROPY;
+  }
+  getMaterialType(t) {
+    const r = this.parser.json.materials[t];
+    return !r.extensions || !r.extensions[this.name] ? null : ge;
+  }
+  extendMaterialParams(t, e) {
+    const r = this.parser, n = r.json.materials[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], s = n.extensions[this.name];
+    return s.anisotropyStrength !== void 0 && (e.anisotropy = s.anisotropyStrength), s.anisotropyRotation !== void 0 && (e.anisotropyRotation = s.anisotropyRotation), s.anisotropyTexture !== void 0 && i.push(r.assignTexture(e, "anisotropyMap", s.anisotropyTexture)), Promise.all(i);
+  }
+}
+class ys {
+  constructor(t) {
+    this.parser = t, this.name = k.KHR_TEXTURE_BASISU;
+  }
+  loadTexture(t) {
+    const e = this.parser, r = e.json, n = r.textures[t];
+    if (!n.extensions || !n.extensions[this.name])
+      return null;
+    const i = n.extensions[this.name], s = e.options.ktx2Loader;
+    if (!s) {
+      if (r.extensionsRequired && r.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, s);
+  }
+}
+class As {
+  constructor(t) {
+    this.parser = t, this.name = k.EXT_TEXTURE_WEBP;
+  }
+  loadTexture(t) {
+    const e = this.name, r = this.parser, n = r.json, i = n.textures[t];
+    if (!i.extensions || !i.extensions[e])
+      return null;
+    const s = i.extensions[e], a = n.images[s.source];
+    let o = r.textureLoader;
+    if (a.uri) {
+      const c = r.options.manager.getHandler(a.uri);
+      c !== null && (o = c);
+    }
+    return r.loadTextureImage(t, s.source, o);
+  }
+}
+class Es {
+  constructor(t) {
+    this.parser = t, this.name = k.EXT_TEXTURE_AVIF;
+  }
+  loadTexture(t) {
+    const e = this.name, r = this.parser, n = r.json, i = n.textures[t];
+    if (!i.extensions || !i.extensions[e])
+      return null;
+    const s = i.extensions[e], a = n.images[s.source];
+    let o = r.textureLoader;
+    if (a.uri) {
+      const c = r.options.manager.getHandler(a.uri);
+      c !== null && (o = c);
+    }
+    return r.loadTextureImage(t, s.source, o);
+  }
+}
+class Ls {
+  constructor(t) {
+    this.name = k.EXT_MESHOPT_COMPRESSION, this.parser = t;
+  }
+  loadBufferView(t) {
+    const e = this.parser.json, r = e.bufferViews[t];
+    if (r.extensions && r.extensions[this.name]) {
+      const n = r.extensions[this.name], i = this.parser.getDependency("buffer", n.buffer), s = this.parser.options.meshoptDecoder;
+      if (!s || !s.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 o = n.byteOffset || 0, c = n.byteLength || 0, u = n.count, l = n.byteStride, f = new Uint8Array(a, o, c);
+        return s.decodeGltfBufferAsync ? s.decodeGltfBufferAsync(u, l, f, n.mode, n.filter).then(function(h) {
+          return h.buffer;
+        }) : s.ready.then(function() {
+          const h = new ArrayBuffer(u * l);
+          return s.decodeGltfBuffer(new Uint8Array(h), u, l, f, n.mode, n.filter), h;
+        });
+      });
+    } else
+      return null;
+  }
+}
+class Ms {
+  constructor(t) {
+    this.name = k.EXT_MESH_GPU_INSTANCING, this.parser = t;
+  }
+  createNodeMesh(t) {
+    const e = this.parser.json, r = e.nodes[t];
+    if (!r.extensions || !r.extensions[this.name] || r.mesh === void 0)
+      return null;
+    const n = e.meshes[r.mesh];
+    for (const c of n.primitives)
+      if (c.mode !== ce.TRIANGLES && c.mode !== ce.TRIANGLE_STRIP && c.mode !== ce.TRIANGLE_FAN && c.mode !== void 0)
+        return null;
+    const s = r.extensions[this.name].attributes, a = [], o = {};
+    for (const c in s)
+      a.push(this.parser.getDependency("accessor", s[c]).then((u) => (o[c] = u, o[c])));
+    return a.length < 1 ? null : (a.push(this.parser.createNodeMesh(t)), Promise.all(a).then((c) => {
+      const u = c.pop(), l = u.isGroup ? u.children : [u], f = c[0].count, h = [];
+      for (const T of l) {
+        const m = new Qe(), b = new Oe(), S = new $t(), P = new Oe(1, 1, 1), D = new vn(T.geometry, T.material, f);
+        for (let y = 0; y < f; y++)
+          o.TRANSLATION && b.fromBufferAttribute(o.TRANSLATION, y), o.ROTATION && S.fromBufferAttribute(o.ROTATION, y), o.SCALE && P.fromBufferAttribute(o.SCALE, y), D.setMatrixAt(y, m.compose(b, S, P));
+        for (const y in o)
+          if (y === "_COLOR_0") {
+            const F = o[y];
+            D.instanceColor = new kn(F.array, F.itemSize, F.normalized);
+          } else y !== "TRANSLATION" && y !== "ROTATION" && y !== "SCALE" && T.geometry.setAttribute(y, o[y]);
+        qt.prototype.copy.call(D, T), this.parser.assignFinalMaterial(D), h.push(D);
+      }
+      return u.isGroup ? (u.clear(), u.add(...h), u) : h[0];
+    }));
+  }
+}
+const en = "glTF", je = 12, Ut = { JSON: 1313821514, BIN: 5130562 };
+class Is {
+  constructor(t) {
+    this.name = k.KHR_BINARY_GLTF, this.content = null, this.body = null;
+    const e = new DataView(t, 0, je), r = new TextDecoder();
+    if (this.header = {
+      magic: r.decode(new Uint8Array(t.slice(0, 4))),
+      version: e.getUint32(4, !0),
+      length: e.getUint32(8, !0)
+    }, this.header.magic !== en)
+      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 - je, i = new DataView(t, je);
+    let s = 0;
+    for (; s < n; ) {
+      const a = i.getUint32(s, !0);
+      s += 4;
+      const o = i.getUint32(s, !0);
+      if (s += 4, o === Ut.JSON) {
+        const c = new Uint8Array(t, je + s, a);
+        this.content = r.decode(c);
+      } else if (o === Ut.BIN) {
+        const c = je + s;
+        this.body = t.slice(c, c + a);
+      }
+      s += a;
+    }
+    if (this.content === null)
+      throw new Error("THREE.GLTFLoader: JSON content not found.");
+  }
+}
+class vs {
+  constructor(t, e) {
+    if (!e)
+      throw new Error("THREE.GLTFLoader: No DRACOLoader instance provided.");
+    this.name = k.KHR_DRACO_MESH_COMPRESSION, this.json = t, this.dracoLoader = e, this.dracoLoader.preload();
+  }
+  decodePrimitive(t, e) {
+    const r = this.json, n = this.dracoLoader, i = t.extensions[this.name].bufferView, s = t.extensions[this.name].attributes, a = {}, o = {}, c = {};
+    for (const u in s) {
+      const l = xt[u] || u.toLowerCase();
+      a[l] = s[u];
+    }
+    for (const u in t.attributes) {
+      const l = xt[u] || u.toLowerCase();
+      if (s[u] !== void 0) {
+        const f = r.accessors[t.attributes[u]], h = De[f.componentType];
+        c[l] = h.name, o[l] = f.normalized === !0;
+      }
+    }
+    return e.getDependency("bufferView", i).then(function(u) {
+      return new Promise(function(l, f) {
+        n.decodeDracoFile(u, function(h) {
+          for (const T in h.attributes) {
+            const m = h.attributes[T], b = o[T];
+            b !== void 0 && (m.normalized = b);
+          }
+          l(h);
+        }, a, c, Re, f);
+      });
+    });
+  }
+}
+class ks {
+  constructor() {
+    this.name = k.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 Ns {
+  constructor() {
+    this.name = k.KHR_MESH_QUANTIZATION;
+  }
+}
+class tn extends os {
+  constructor(t, e, r, n) {
+    super(t, e, r, n);
+  }
+  copySampleValue_(t) {
+    const e = this.resultBuffer, r = this.sampleValues, n = this.valueSize, i = t * n * 3 + n;
+    for (let s = 0; s !== n; s++)
+      e[s] = r[i + s];
+    return e;
+  }
+  interpolate_(t, e, r, n) {
+    const i = this.resultBuffer, s = this.sampleValues, a = this.valueSize, o = a * 2, c = a * 3, u = n - e, l = (r - e) / u, f = l * l, h = f * l, T = t * c, m = T - c, b = -2 * h + 3 * f, S = h - f, P = 1 - b, D = S - f + l;
+    for (let y = 0; y !== a; y++) {
+      const F = s[m + y + a], C = s[m + y + o] * u, H = s[T + y + a], B = s[T + y] * u;
+      i[y] = P * F + D * C + b * H + S * B;
+    }
+    return i;
+  }
+}
+const Cs = new $t();
+class Os extends tn {
+  interpolate_(t, e, r, n) {
+    const i = super.interpolate_(t, e, r, n);
+    return Cs.fromArray(i).normalize().toArray(i), i;
+  }
+}
+const ce = {
+  POINTS: 0,
+  LINES: 1,
+  LINE_LOOP: 2,
+  LINE_STRIP: 3,
+  TRIANGLES: 4,
+  TRIANGLE_STRIP: 5,
+  TRIANGLE_FAN: 6
+}, De = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5125: Uint32Array,
+  5126: Float32Array
+}, Ht = {
+  9728: Jt,
+  9729: bt,
+  9984: Un,
+  9985: Pn,
+  9986: Fn,
+  9987: Yt
+}, Bt = {
+  33071: Bn,
+  33648: Hn,
+  10497: _t
+}, ft = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+}, xt = {
+  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"
+}, Se = {
+  scale: "scale",
+  translation: "position",
+  rotation: "quaternion",
+  weights: "morphTargetInfluences"
+}, Ds = {
+  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: Zt,
+  STEP: rs
+}, ht = {
+  OPAQUE: "OPAQUE",
+  MASK: "MASK",
+  BLEND: "BLEND"
+};
+function Fs(d) {
+  return d.DefaultMaterial === void 0 && (d.DefaultMaterial = new Qt({
+    color: 16777215,
+    emissive: 0,
+    metalness: 1,
+    roughness: 1,
+    transparent: !1,
+    depthTest: !0,
+    side: is
+  })), d.DefaultMaterial;
+}
+function Ie(d, t, e) {
+  for (const r in e.extensions)
+    d[r] === void 0 && (t.userData.gltfExtensions = t.userData.gltfExtensions || {}, t.userData.gltfExtensions[r] = e.extensions[r]);
+}
+function me(d, t) {
+  t.extras !== void 0 && (typeof t.extras == "object" ? Object.assign(d.userData, t.extras) : console.warn("THREE.GLTFLoader: Ignoring primitive type .extras, " + t.extras));
+}
+function Ps(d, t, e) {
+  let r = !1, n = !1, i = !1;
+  for (let c = 0, u = t.length; c < u; c++) {
+    const l = t[c];
+    if (l.POSITION !== void 0 && (r = !0), l.NORMAL !== void 0 && (n = !0), l.COLOR_0 !== void 0 && (i = !0), r && n && i) break;
+  }
+  if (!r && !n && !i) return Promise.resolve(d);
+  const s = [], a = [], o = [];
+  for (let c = 0, u = t.length; c < u; c++) {
+    const l = t[c];
+    if (r) {
+      const f = l.POSITION !== void 0 ? e.getDependency("accessor", l.POSITION) : d.attributes.position;
+      s.push(f);
+    }
+    if (n) {
+      const f = l.NORMAL !== void 0 ? e.getDependency("accessor", l.NORMAL) : d.attributes.normal;
+      a.push(f);
+    }
+    if (i) {
+      const f = l.COLOR_0 !== void 0 ? e.getDependency("accessor", l.COLOR_0) : d.attributes.color;
+      o.push(f);
+    }
+  }
+  return Promise.all([
+    Promise.all(s),
+    Promise.all(a),
+    Promise.all(o)
+  ]).then(function(c) {
+    const u = c[0], l = c[1], f = c[2];
+    return r && (d.morphAttributes.position = u), n && (d.morphAttributes.normal = l), i && (d.morphAttributes.color = f), d.morphTargetsRelative = !0, d;
+  });
+}
+function Us(d, t) {
+  if (d.updateMorphTargets(), t.weights !== void 0)
+    for (let e = 0, r = t.weights.length; e < r; e++)
+      d.morphTargetInfluences[e] = t.weights[e];
+  if (t.extras && Array.isArray(t.extras.targetNames)) {
+    const e = t.extras.targetNames;
+    if (d.morphTargetInfluences.length === e.length) {
+      d.morphTargetDictionary = {};
+      for (let r = 0, n = e.length; r < n; r++)
+        d.morphTargetDictionary[e[r]] = r;
+    } else
+      console.warn("THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.");
+  }
+}
+function Hs(d) {
+  let t;
+  const e = d.extensions && d.extensions[k.KHR_DRACO_MESH_COMPRESSION];
+  if (e ? t = "draco:" + e.bufferView + ":" + e.indices + ":" + pt(e.attributes) : t = d.indices + ":" + pt(d.attributes) + ":" + d.mode, d.targets !== void 0)
+    for (let r = 0, n = d.targets.length; r < n; r++)
+      t += ":" + pt(d.targets[r]);
+  return t;
+}
+function pt(d) {
+  let t = "";
+  const e = Object.keys(d).sort();
+  for (let r = 0, n = e.length; r < n; r++)
+    t += e[r] + ":" + d[e[r]] + ";";
+  return t;
+}
+function wt(d) {
+  switch (d) {
+    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 Bs(d) {
+  return d.search(/\.jpe?g($|\?)/i) > 0 || d.search(/^data\:image\/jpeg/) === 0 ? "image/jpeg" : d.search(/\.webp($|\?)/i) > 0 || d.search(/^data\:image\/webp/) === 0 ? "image/webp" : d.search(/\.ktx2($|\?)/i) > 0 || d.search(/^data\:image\/ktx2/) === 0 ? "image/ktx2" : "image/png";
+}
+const Gs = new Qe();
+class js {
+  constructor(t = {}, e = {}) {
+    this.json = t, this.extensions = {}, this.plugins = {}, this.options = e, this.cache = new ls(), 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 r = !1, n = -1, i = !1, s = -1;
+    if (typeof navigator < "u") {
+      const a = navigator.userAgent;
+      r = /^((?!chrome|android).)*safari/i.test(a) === !0;
+      const o = a.match(/Version\/(\d+)/);
+      n = r && o ? parseInt(o[1], 10) : -1, i = a.indexOf("Firefox") > -1, s = i ? a.match(/Firefox\/([0-9]+)\./)[1] : -1;
+    }
+    typeof createImageBitmap > "u" || r && n < 17 || i && s < 98 ? this.textureLoader = new Nn(this.options.manager) : this.textureLoader = new Cn(this.options.manager), this.textureLoader.setCrossOrigin(this.options.crossOrigin), this.textureLoader.setRequestHeader(this.options.requestHeader), this.fileLoader = new Xt(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 r = this, n = this.json, i = this.extensions;
+    this.cache.removeAll(), this.nodeCache = {}, this._invokeAll(function(s) {
+      return s._markDefs && s._markDefs();
+    }), Promise.all(this._invokeAll(function(s) {
+      return s.beforeRoot && s.beforeRoot();
+    })).then(function() {
+      return Promise.all([
+        r.getDependencies("scene"),
+        r.getDependencies("animation"),
+        r.getDependencies("camera")
+      ]);
+    }).then(function(s) {
+      const a = {
+        scene: s[0][n.scene || 0],
+        scenes: s[0],
+        animations: s[1],
+        cameras: s[2],
+        asset: n.asset,
+        parser: r,
+        userData: {}
+      };
+      return Ie(i, a, n), me(a, n), Promise.all(r._invokeAll(function(o) {
+        return o.afterRoot && o.afterRoot(a);
+      })).then(function() {
+        for (const o of a.scenes)
+          o.updateMatrixWorld();
+        t(a);
+      });
+    }).catch(e);
+  }
+  /**
+   * Marks the special nodes/meshes in json for efficient parse.
+   *
+   * @private
+   */
+  _markDefs() {
+    const t = this.json.nodes || [], e = this.json.skins || [], r = this.json.meshes || [];
+    for (let n = 0, i = e.length; n < i; n++) {
+      const s = e[n].joints;
+      for (let a = 0, o = s.length; a < o; a++)
+        t[s[a]].isBone = !0;
+    }
+    for (let n = 0, i = t.length; n < i; n++) {
+      const s = t[n];
+      s.mesh !== void 0 && (this._addNodeRef(this.meshCache, s.mesh), s.skin !== void 0 && (r[s.mesh].isSkinnedMesh = !0)), s.camera !== void 0 && this._addNodeRef(this.cameraCache, s.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.
+   *
+   * @private
+   * @param {Object} cache
+   * @param {Object3D} index
+   */
+  _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.
+   *
+   * @private
+   * @param {Object} cache
+   * @param {number} index
+   * @param {Object} object
+   * @return {Object}
+   */
+  _getNodeRef(t, e, r) {
+    if (t.refs[e] <= 1) return r;
+    const n = r.clone(), i = (s, a) => {
+      const o = this.associations.get(s);
+      o != null && this.associations.set(a, o);
+      for (const [c, u] of s.children.entries())
+        i(u, a.children[c]);
+    };
+    return i(r, n), n.name += "_instance_" + t.uses[e]++, n;
+  }
+  _invokeOne(t) {
+    const e = Object.values(this.plugins);
+    e.push(this);
+    for (let r = 0; r < e.length; r++) {
+      const n = t(e[r]);
+      if (n) return n;
+    }
+    return null;
+  }
+  _invokeAll(t) {
+    const e = Object.values(this.plugins);
+    e.unshift(this);
+    const r = [];
+    for (let n = 0; n < e.length; n++) {
+      const i = t(e[n]);
+      i && r.push(i);
+    }
+    return r;
+  }
+  /**
+   * Requests the specified dependency asynchronously, with caching.
+   *
+   * @private
+   * @param {string} type
+   * @param {number} index
+   * @return {Promise<Object3D|Material|Texture|AnimationClip|ArrayBuffer|Object>}
+   */
+  getDependency(t, e) {
+    const r = t + ":" + e;
+    let n = this.cache.get(r);
+    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(r, n);
+    }
+    return n;
+  }
+  /**
+   * Requests all dependencies of the specified type asynchronously, with caching.
+   *
+   * @private
+   * @param {string} type
+   * @return {Promise<Array<Object>>}
+   */
+  getDependencies(t) {
+    let e = this.cache.get(t);
+    if (!e) {
+      const r = this, n = this.json[t + (t === "mesh" ? "es" : "s")] || [];
+      e = Promise.all(n.map(function(i, s) {
+        return r.getDependency(t, s);
+      })), this.cache.add(t, e);
+    }
+    return e;
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
+   *
+   * @private
+   * @param {number} bufferIndex
+   * @return {Promise<ArrayBuffer>}
+   */
+  loadBuffer(t) {
+    const e = this.json.buffers[t], r = 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[k.KHR_BINARY_GLTF].body);
+    const n = this.options;
+    return new Promise(function(i, s) {
+      r.load(Ke.resolveURL(e.uri, n.path), i, void 0, function() {
+        s(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
+   *
+   * @private
+   * @param {number} bufferViewIndex
+   * @return {Promise<ArrayBuffer>}
+   */
+  loadBufferView(t) {
+    const e = this.json.bufferViews[t];
+    return this.getDependency("buffer", e.buffer).then(function(r) {
+      const n = e.byteLength || 0, i = e.byteOffset || 0;
+      return r.slice(i, i + n);
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
+   *
+   * @private
+   * @param {number} accessorIndex
+   * @return {Promise<BufferAttribute|InterleavedBufferAttribute>}
+   */
+  loadAccessor(t) {
+    const e = this, r = this.json, n = this.json.accessors[t];
+    if (n.bufferView === void 0 && n.sparse === void 0) {
+      const s = ft[n.type], a = De[n.componentType], o = n.normalized === !0, c = new a(n.count * s);
+      return Promise.resolve(new ut(c, s, o));
+    }
+    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(s) {
+      const a = s[0], o = ft[n.type], c = De[n.componentType], u = c.BYTES_PER_ELEMENT, l = u * o, f = n.byteOffset || 0, h = n.bufferView !== void 0 ? r.bufferViews[n.bufferView].byteStride : void 0, T = n.normalized === !0;
+      let m, b;
+      if (h && h !== l) {
+        const S = Math.floor(f / h), P = "InterleavedBuffer:" + n.bufferView + ":" + n.componentType + ":" + S + ":" + n.count;
+        let D = e.cache.get(P);
+        D || (m = new c(a, S * h, n.count * h / u), D = new On(m, h / u), e.cache.add(P, D)), b = new Dn(D, o, f % h / u, T);
+      } else
+        a === null ? m = new c(n.count * o) : m = new c(a, f, n.count * o), b = new ut(m, o, T);
+      if (n.sparse !== void 0) {
+        const S = ft.SCALAR, P = De[n.sparse.indices.componentType], D = n.sparse.indices.byteOffset || 0, y = n.sparse.values.byteOffset || 0, F = new P(s[1], D, n.sparse.count * S), C = new c(s[2], y, n.sparse.count * o);
+        a !== null && (b = new ut(b.array.slice(), b.itemSize, b.normalized)), b.normalized = !1;
+        for (let H = 0, B = F.length; H < B; H++) {
+          const O = F[H];
+          if (b.setX(O, C[H * o]), o >= 2 && b.setY(O, C[H * o + 1]), o >= 3 && b.setZ(O, C[H * o + 2]), o >= 4 && b.setW(O, C[H * o + 3]), o >= 5) throw new Error("THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.");
+        }
+        b.normalized = T;
+      }
+      return b;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures
+   *
+   * @private
+   * @param {number} textureIndex
+   * @return {Promise<?Texture>}
+   */
+  loadTexture(t) {
+    const e = this.json, r = this.options, i = e.textures[t].source, s = e.images[i];
+    let a = this.textureLoader;
+    if (s.uri) {
+      const o = r.manager.getHandler(s.uri);
+      o !== null && (a = o);
+    }
+    return this.loadTextureImage(t, i, a);
+  }
+  loadTextureImage(t, e, r) {
+    const n = this, i = this.json, s = i.textures[t], a = i.images[e], o = (a.uri || a.bufferView) + ":" + s.sampler;
+    if (this.textureCache[o])
+      return this.textureCache[o];
+    const c = this.loadImageSource(e, r).then(function(u) {
+      u.flipY = !1, u.name = s.name || a.name || "", u.name === "" && typeof a.uri == "string" && a.uri.startsWith("data:image/") === !1 && (u.name = a.uri);
+      const f = (i.samplers || {})[s.sampler] || {};
+      return u.magFilter = Ht[f.magFilter] || bt, u.minFilter = Ht[f.minFilter] || Yt, u.wrapS = Bt[f.wrapS] || _t, u.wrapT = Bt[f.wrapT] || _t, u.generateMipmaps = !u.isCompressedTexture && u.minFilter !== Jt && u.minFilter !== bt, n.associations.set(u, { textures: t }), u;
+    }).catch(function() {
+      return null;
+    });
+    return this.textureCache[o] = c, c;
+  }
+  loadImageSource(t, e) {
+    const r = this, n = this.json, i = this.options;
+    if (this.sourceCache[t] !== void 0)
+      return this.sourceCache[t].then((l) => l.clone());
+    const s = n.images[t], a = self.URL || self.webkitURL;
+    let o = s.uri || "", c = !1;
+    if (s.bufferView !== void 0)
+      o = r.getDependency("bufferView", s.bufferView).then(function(l) {
+        c = !0;
+        const f = new Blob([l], { type: s.mimeType });
+        return o = a.createObjectURL(f), o;
+      });
+    else if (s.uri === void 0)
+      throw new Error("THREE.GLTFLoader: Image " + t + " is missing URI and bufferView");
+    const u = Promise.resolve(o).then(function(l) {
+      return new Promise(function(f, h) {
+        let T = f;
+        e.isImageBitmapLoader === !0 && (T = function(m) {
+          const b = new Nt(m);
+          b.needsUpdate = !0, f(b);
+        }), e.load(Ke.resolveURL(l, i.path), T, void 0, h);
+      });
+    }).then(function(l) {
+      return c === !0 && a.revokeObjectURL(o), me(l, s), l.userData.mimeType = s.mimeType || Bs(s.uri), l;
+    }).catch(function(l) {
+      throw console.error("THREE.GLTFLoader: Couldn't load texture", o), l;
+    });
+    return this.sourceCache[t] = u, u;
+  }
+  /**
+   * Asynchronously assigns a texture to the given material parameters.
+   *
+   * @private
+   * @param {Object} materialParams
+   * @param {string} mapName
+   * @param {Object} mapDef
+   * @param {string} [colorSpace]
+   * @return {Promise<Texture>}
+   */
+  assignTexture(t, e, r, n) {
+    const i = this;
+    return this.getDependency("texture", r.index).then(function(s) {
+      if (!s) return null;
+      if (r.texCoord !== void 0 && r.texCoord > 0 && (s = s.clone(), s.channel = r.texCoord), i.extensions[k.KHR_TEXTURE_TRANSFORM]) {
+        const a = r.extensions !== void 0 ? r.extensions[k.KHR_TEXTURE_TRANSFORM] : void 0;
+        if (a) {
+          const o = i.associations.get(s);
+          s = i.extensions[k.KHR_TEXTURE_TRANSFORM].extendTexture(s, a), i.associations.set(s, o);
+        }
+      }
+      return n !== void 0 && (s.colorSpace = n), t[e] = s, s;
+    });
+  }
+  /**
+   * 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.
+   *
+   * @private
+   * @param {Object3D} mesh Mesh, Line, or Points instance.
+   */
+  assignFinalMaterial(t) {
+    const e = t.geometry;
+    let r = t.material;
+    const n = e.attributes.tangent === void 0, i = e.attributes.color !== void 0, s = e.attributes.normal === void 0;
+    if (t.isPoints) {
+      const a = "PointsMaterial:" + r.uuid;
+      let o = this.cache.get(a);
+      o || (o = new Gn(), lt.prototype.copy.call(o, r), o.color.copy(r.color), o.map = r.map, o.sizeAttenuation = !1, this.cache.add(a, o)), r = o;
+    } else if (t.isLine) {
+      const a = "LineBasicMaterial:" + r.uuid;
+      let o = this.cache.get(a);
+      o || (o = new jn(), lt.prototype.copy.call(o, r), o.color.copy(r.color), o.map = r.map, this.cache.add(a, o)), r = o;
+    }
+    if (n || i || s) {
+      let a = "ClonedMaterial:" + r.uuid + ":";
+      n && (a += "derivative-tangents:"), i && (a += "vertex-colors:"), s && (a += "flat-shading:");
+      let o = this.cache.get(a);
+      o || (o = r.clone(), i && (o.vertexColors = !0), s && (o.flatShading = !0), n && (o.normalScale && (o.normalScale.y *= -1), o.clearcoatNormalScale && (o.clearcoatNormalScale.y *= -1)), this.cache.add(a, o), this.associations.set(o, this.associations.get(r))), r = o;
+    }
+    t.material = r;
+  }
+  getMaterialType() {
+    return Qt;
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
+   *
+   * @private
+   * @param {number} materialIndex
+   * @return {Promise<Material>}
+   */
+  loadMaterial(t) {
+    const e = this, r = this.json, n = this.extensions, i = r.materials[t];
+    let s;
+    const a = {}, o = i.extensions || {}, c = [];
+    if (o[k.KHR_MATERIALS_UNLIT]) {
+      const l = n[k.KHR_MATERIALS_UNLIT];
+      s = l.getMaterialType(), c.push(l.extendParams(a, i, e));
+    } else {
+      const l = i.pbrMetallicRoughness || {};
+      if (a.color = new ve(1, 1, 1), a.opacity = 1, Array.isArray(l.baseColorFactor)) {
+        const f = l.baseColorFactor;
+        a.color.setRGB(f[0], f[1], f[2], Re), a.opacity = f[3];
+      }
+      l.baseColorTexture !== void 0 && c.push(e.assignTexture(a, "map", l.baseColorTexture, We)), a.metalness = l.metallicFactor !== void 0 ? l.metallicFactor : 1, a.roughness = l.roughnessFactor !== void 0 ? l.roughnessFactor : 1, l.metallicRoughnessTexture !== void 0 && (c.push(e.assignTexture(a, "metalnessMap", l.metallicRoughnessTexture)), c.push(e.assignTexture(a, "roughnessMap", l.metallicRoughnessTexture))), s = this._invokeOne(function(f) {
+        return f.getMaterialType && f.getMaterialType(t);
+      }), c.push(Promise.all(this._invokeAll(function(f) {
+        return f.extendMaterialParams && f.extendMaterialParams(t, a);
+      })));
+    }
+    i.doubleSided === !0 && (a.side = Vn);
+    const u = i.alphaMode || ht.OPAQUE;
+    if (u === ht.BLEND ? (a.transparent = !0, a.depthWrite = !1) : (a.transparent = !1, u === ht.MASK && (a.alphaTest = i.alphaCutoff !== void 0 ? i.alphaCutoff : 0.5)), i.normalTexture !== void 0 && s !== Ve && (c.push(e.assignTexture(a, "normalMap", i.normalTexture)), a.normalScale = new zt(1, 1), i.normalTexture.scale !== void 0)) {
+      const l = i.normalTexture.scale;
+      a.normalScale.set(l, l);
+    }
+    if (i.occlusionTexture !== void 0 && s !== Ve && (c.push(e.assignTexture(a, "aoMap", i.occlusionTexture)), i.occlusionTexture.strength !== void 0 && (a.aoMapIntensity = i.occlusionTexture.strength)), i.emissiveFactor !== void 0 && s !== Ve) {
+      const l = i.emissiveFactor;
+      a.emissive = new ve().setRGB(l[0], l[1], l[2], Re);
+    }
+    return i.emissiveTexture !== void 0 && s !== Ve && c.push(e.assignTexture(a, "emissiveMap", i.emissiveTexture, We)), Promise.all(c).then(function() {
+      const l = new s(a);
+      return i.name && (l.name = i.name), me(l, i), e.associations.set(l, { materials: t }), i.extensions && Ie(n, l, i), l;
+    });
+  }
+  /**
+   * When Object3D instances are targeted by animation, they need unique names.
+   *
+   * @private
+   * @param {string} originalName
+   * @return {string}
+   */
+  createUniqueName(t) {
+    const e = Kn.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.
+   *
+   * @private
+   * @param {Array<GLTF.Primitive>} primitives
+   * @return {Promise<Array<BufferGeometry>>}
+   */
+  loadGeometries(t) {
+    const e = this, r = this.extensions, n = this.primitiveCache;
+    function i(a) {
+      return r[k.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(a, e).then(function(o) {
+        return Gt(o, a, e);
+      });
+    }
+    const s = [];
+    for (let a = 0, o = t.length; a < o; a++) {
+      const c = t[a], u = Hs(c), l = n[u];
+      if (l)
+        s.push(l.promise);
+      else {
+        let f;
+        c.extensions && c.extensions[k.KHR_DRACO_MESH_COMPRESSION] ? f = i(c) : f = Gt(new Wn(), c, e), n[u] = { primitive: c, promise: f }, s.push(f);
+      }
+    }
+    return Promise.all(s);
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes
+   *
+   * @private
+   * @param {number} meshIndex
+   * @return {Promise<Group|Mesh|SkinnedMesh|Line|Points>}
+   */
+  loadMesh(t) {
+    const e = this, r = this.json, n = this.extensions, i = r.meshes[t], s = i.primitives, a = [];
+    for (let o = 0, c = s.length; o < c; o++) {
+      const u = s[o].material === void 0 ? Fs(this.cache) : this.getDependency("material", s[o].material);
+      a.push(u);
+    }
+    return a.push(e.loadGeometries(s)), Promise.all(a).then(function(o) {
+      const c = o.slice(0, o.length - 1), u = o[o.length - 1], l = [];
+      for (let h = 0, T = u.length; h < T; h++) {
+        const m = u[h], b = s[h];
+        let S;
+        const P = c[h];
+        if (b.mode === ce.TRIANGLES || b.mode === ce.TRIANGLE_STRIP || b.mode === ce.TRIANGLE_FAN || b.mode === void 0)
+          S = i.isSkinnedMesh === !0 ? new Xn(m, P) : new zn(m, P), S.isSkinnedMesh === !0 && S.normalizeSkinWeights(), b.mode === ce.TRIANGLE_STRIP ? S.geometry = Pt(S.geometry, Wt) : b.mode === ce.TRIANGLE_FAN && (S.geometry = Pt(S.geometry, Tt));
+        else if (b.mode === ce.LINES)
+          S = new $n(m, P);
+        else if (b.mode === ce.LINE_STRIP)
+          S = new qn(m, P);
+        else if (b.mode === ce.LINE_LOOP)
+          S = new Yn(m, P);
+        else if (b.mode === ce.POINTS)
+          S = new Jn(m, P);
+        else
+          throw new Error("THREE.GLTFLoader: Primitive mode unsupported: " + b.mode);
+        Object.keys(S.geometry.morphAttributes).length > 0 && Us(S, i), S.name = e.createUniqueName(i.name || "mesh_" + t), me(S, i), b.extensions && Ie(n, S, b), e.assignFinalMaterial(S), l.push(S);
+      }
+      for (let h = 0, T = l.length; h < T; h++)
+        e.associations.set(l[h], {
+          meshes: t,
+          primitives: h
+        });
+      if (l.length === 1)
+        return i.extensions && Ie(n, l[0], i), l[0];
+      const f = new dt();
+      i.extensions && Ie(n, f, i), e.associations.set(f, { meshes: t });
+      for (let h = 0, T = l.length; h < T; h++)
+        f.add(l[h]);
+      return f;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
+   *
+   * @private
+   * @param {number} cameraIndex
+   * @return {Promise<Camera>|undefined}
+   */
+  loadCamera(t) {
+    let e;
+    const r = this.json.cameras[t], n = r[r.type];
+    if (!n) {
+      console.warn("THREE.GLTFLoader: Missing camera parameters.");
+      return;
+    }
+    return r.type === "perspective" ? e = new Qn(Zn.radToDeg(n.yfov), n.aspectRatio || 1, n.znear || 1, n.zfar || 2e6) : r.type === "orthographic" && (e = new es(-n.xmag, n.xmag, n.ymag, -n.ymag, n.znear, n.zfar)), r.name && (e.name = this.createUniqueName(r.name)), me(e, r), Promise.resolve(e);
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
+   *
+   * @private
+   * @param {number} skinIndex
+   * @return {Promise<Skeleton>}
+   */
+  loadSkin(t) {
+    const e = this.json.skins[t], r = [];
+    for (let n = 0, i = e.joints.length; n < i; n++)
+      r.push(this._loadNodeShallow(e.joints[n]));
+    return e.inverseBindMatrices !== void 0 ? r.push(this.getDependency("accessor", e.inverseBindMatrices)) : r.push(null), Promise.all(r).then(function(n) {
+      const i = n.pop(), s = n, a = [], o = [];
+      for (let c = 0, u = s.length; c < u; c++) {
+        const l = s[c];
+        if (l) {
+          a.push(l);
+          const f = new Qe();
+          i !== null && f.fromArray(i.array, c * 16), o.push(f);
+        } else
+          console.warn('THREE.GLTFLoader: Joint "%s" could not be found.', e.joints[c]);
+      }
+      return new ts(a, o);
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
+   *
+   * @private
+   * @param {number} animationIndex
+   * @return {Promise<AnimationClip>}
+   */
+  loadAnimation(t) {
+    const e = this.json, r = this, n = e.animations[t], i = n.name ? n.name : "animation_" + t, s = [], a = [], o = [], c = [], u = [];
+    for (let l = 0, f = n.channels.length; l < f; l++) {
+      const h = n.channels[l], T = n.samplers[h.sampler], m = h.target, b = m.node, S = n.parameters !== void 0 ? n.parameters[T.input] : T.input, P = n.parameters !== void 0 ? n.parameters[T.output] : T.output;
+      m.node !== void 0 && (s.push(this.getDependency("node", b)), a.push(this.getDependency("accessor", S)), o.push(this.getDependency("accessor", P)), c.push(T), u.push(m));
+    }
+    return Promise.all([
+      Promise.all(s),
+      Promise.all(a),
+      Promise.all(o),
+      Promise.all(c),
+      Promise.all(u)
+    ]).then(function(l) {
+      const f = l[0], h = l[1], T = l[2], m = l[3], b = l[4], S = [];
+      for (let D = 0, y = f.length; D < y; D++) {
+        const F = f[D], C = h[D], H = T[D], B = m[D], O = b[D];
+        if (F === void 0) continue;
+        F.updateMatrix && F.updateMatrix();
+        const U = r._createAnimationTracks(F, C, H, B, O);
+        if (U)
+          for (let Z = 0; Z < U.length; Z++)
+            S.push(U[Z]);
+      }
+      const P = new ns(i, void 0, S);
+      return me(P, n), P;
+    });
+  }
+  createNodeMesh(t) {
+    const e = this.json, r = this, n = e.nodes[t];
+    return n.mesh === void 0 ? null : r.getDependency("mesh", n.mesh).then(function(i) {
+      const s = r._getNodeRef(r.meshCache, n.mesh, i);
+      return n.weights !== void 0 && s.traverse(function(a) {
+        if (a.isMesh)
+          for (let o = 0, c = n.weights.length; o < c; o++)
+            a.morphTargetInfluences[o] = n.weights[o];
+      }), s;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
+   *
+   * @private
+   * @param {number} nodeIndex
+   * @return {Promise<Object3D>}
+   */
+  loadNode(t) {
+    const e = this.json, r = this, n = e.nodes[t], i = r._loadNodeShallow(t), s = [], a = n.children || [];
+    for (let c = 0, u = a.length; c < u; c++)
+      s.push(r.getDependency("node", a[c]));
+    const o = n.skin === void 0 ? Promise.resolve(null) : r.getDependency("skin", n.skin);
+    return Promise.all([
+      i,
+      Promise.all(s),
+      o
+    ]).then(function(c) {
+      const u = c[0], l = c[1], f = c[2];
+      f !== null && u.traverse(function(h) {
+        h.isSkinnedMesh && h.bind(f, Gs);
+      });
+      for (let h = 0, T = l.length; h < T; h++)
+        u.add(l[h]);
+      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, r = this.extensions, n = this;
+    if (this.nodeCache[t] !== void 0)
+      return this.nodeCache[t];
+    const i = e.nodes[t], s = i.name ? n.createUniqueName(i.name) : "", a = [], o = n._invokeOne(function(c) {
+      return c.createNodeMesh && c.createNodeMesh(t);
+    });
+    return o && a.push(o), 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 ss() : c.length > 1 ? u = new dt() : c.length === 1 ? u = c[0] : u = new qt(), u !== c[0])
+        for (let l = 0, f = c.length; l < f; l++)
+          u.add(c[l]);
+      if (i.name && (u.userData.name = i.name, u.name = s), me(u, i), i.extensions && Ie(r, u, i), i.matrix !== void 0) {
+        const l = new Qe();
+        l.fromArray(i.matrix), u.applyMatrix4(l);
+      } 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);
+      if (!n.associations.has(u))
+        n.associations.set(u, {});
+      else if (i.mesh !== void 0 && n.meshCache.refs[i.mesh] > 1) {
+        const l = n.associations.get(u);
+        n.associations.set(u, { ...l });
+      }
+      return n.associations.get(u).nodes = t, u;
+    }), this.nodeCache[t];
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes
+   *
+   * @private
+   * @param {number} sceneIndex
+   * @return {Promise<Group>}
+   */
+  loadScene(t) {
+    const e = this.extensions, r = this.json.scenes[t], n = this, i = new dt();
+    r.name && (i.name = n.createUniqueName(r.name)), me(i, r), r.extensions && Ie(e, i, r);
+    const s = r.nodes || [], a = [];
+    for (let o = 0, c = s.length; o < c; o++)
+      a.push(n.getDependency("node", s[o]));
+    return Promise.all(a).then(function(o) {
+      for (let u = 0, l = o.length; u < l; u++)
+        i.add(o[u]);
+      const c = (u) => {
+        const l = /* @__PURE__ */ new Map();
+        for (const [f, h] of n.associations)
+          (f instanceof lt || f instanceof Nt) && l.set(f, h);
+        return u.traverse((f) => {
+          const h = n.associations.get(f);
+          h != null && l.set(f, h);
+        }), l;
+      };
+      return n.associations = c(i), i;
+    });
+  }
+  _createAnimationTracks(t, e, r, n, i) {
+    const s = [], a = t.name ? t.name : t.uuid, o = [];
+    Se[i.path] === Se.weights ? t.traverse(function(f) {
+      f.morphTargetInfluences && o.push(f.name ? f.name : f.uuid);
+    }) : o.push(a);
+    let c;
+    switch (Se[i.path]) {
+      case Se.weights:
+        c = Ot;
+        break;
+      case Se.rotation:
+        c = Dt;
+        break;
+      case Se.translation:
+      case Se.scale:
+        c = Ct;
+        break;
+      default:
+        r.itemSize === 1 ? c = Ot : c = Ct;
+        break;
+    }
+    const u = n.interpolation !== void 0 ? Ds[n.interpolation] : Zt, l = this._getArrayFromAccessor(r);
+    for (let f = 0, h = o.length; f < h; f++) {
+      const T = new c(
+        o[f] + "." + Se[i.path],
+        e.array,
+        l,
+        u
+      );
+      n.interpolation === "CUBICSPLINE" && this._createCubicSplineTrackInterpolant(T), s.push(T);
+    }
+    return s;
+  }
+  _getArrayFromAccessor(t) {
+    let e = t.array;
+    if (t.normalized) {
+      const r = wt(e.constructor), n = new Float32Array(e.length);
+      for (let i = 0, s = e.length; i < s; i++)
+        n[i] = e[i] * r;
+      e = n;
+    }
+    return e;
+  }
+  _createCubicSplineTrackInterpolant(t) {
+    t.createInterpolant = function(r) {
+      const n = this instanceof Dt ? Os : tn;
+      return new n(this.times, this.values, this.getValueSize() / 3, r);
+    }, t.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = !0;
+  }
+}
+function Vs(d, t, e) {
+  const r = t.attributes, n = new as();
+  if (r.POSITION !== void 0) {
+    const a = e.json.accessors[r.POSITION], o = a.min, c = a.max;
+    if (o !== void 0 && c !== void 0) {
+      if (n.set(
+        new Oe(o[0], o[1], o[2]),
+        new Oe(c[0], c[1], c[2])
+      ), a.normalized) {
+        const u = wt(De[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 Oe(), o = new Oe();
+    for (let c = 0, u = i.length; c < u; c++) {
+      const l = i[c];
+      if (l.POSITION !== void 0) {
+        const f = e.json.accessors[l.POSITION], h = f.min, T = f.max;
+        if (h !== void 0 && T !== void 0) {
+          if (o.setX(Math.max(Math.abs(h[0]), Math.abs(T[0]))), o.setY(Math.max(Math.abs(h[1]), Math.abs(T[1]))), o.setZ(Math.max(Math.abs(h[2]), Math.abs(T[2]))), f.normalized) {
+            const m = wt(De[f.componentType]);
+            o.multiplyScalar(m);
+          }
+          a.max(o);
+        } else
+          console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      }
+    }
+    n.expandByVector(a);
+  }
+  d.boundingBox = n;
+  const s = new cs();
+  n.getCenter(s.center), s.radius = n.min.distanceTo(n.max) / 2, d.boundingSphere = s;
+}
+function Gt(d, t, e) {
+  const r = t.attributes, n = [];
+  function i(s, a) {
+    return e.getDependency("accessor", s).then(function(o) {
+      d.setAttribute(a, o);
+    });
+  }
+  for (const s in r) {
+    const a = xt[s] || s.toLowerCase();
+    a in d.attributes || n.push(i(r[s], a));
+  }
+  if (t.indices !== void 0 && !d.index) {
+    const s = e.getDependency("accessor", t.indices).then(function(a) {
+      d.setIndex(a);
+    });
+    n.push(s);
+  }
+  return Ft.workingColorSpace !== Re && "COLOR_0" in r && console.warn(`THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${Ft.workingColorSpace}" not supported.`), me(d, t), Vs(d, t, e), Promise.all(n).then(function() {
+    return t.targets !== void 0 ? Ps(d, t.targets, e) : d;
+  });
+}
+const Q = (...d) => {
+}, Ks = (...d) => {
+}, jt = ({ analyser: d }) => {
+  const t = L(null), e = L(null);
+  return ie(() => {
+    const r = t.current;
+    if (!r) return;
+    const n = r.getContext("2d", { alpha: !0 });
+    if (!n) return;
+    let i, s = null;
+    d && (d.fftSize = 128, s = new Uint8Array(d.frequencyBinCount));
+    const a = () => {
+      i = requestAnimationFrame(a), (r.width !== r.offsetWidth || r.height !== r.offsetHeight) && (r.width = r.offsetWidth, r.height = r.offsetHeight);
+      const o = r.width, c = r.height;
+      if (o === 0 || c === 0) return;
+      const u = c / 2;
+      n.clearRect(0, 0, o, c), n.fillStyle = "#1e293b";
+      const l = 2, h = l + 2, T = o * 0.95, m = Math.floor(T / h);
+      (!e.current || e.current.length !== m) && (e.current = new Float32Array(m).fill(2));
+      const b = m * h, S = (o - b) / 2;
+      d && s && d.getByteFrequencyData(s);
+      const P = s ? s.length : 0, y = Math.floor(P * 0.7) / m, F = new Float32Array(m);
+      for (let C = 0; C < m; C++) {
+        let H = 0;
+        if (s && y > 0) {
+          const U = Math.floor(C * y), Z = Math.floor((C + 1) * y);
+          for (let ue = U; ue < Z; ue++) {
+            const Te = s[ue] || 0;
+            Te > H && (H = Te);
           }
         }
-        P < 10 && (P = 0);
-        const M = P / 255, g = P > 0 ? Math.max(2, Math.pow(M, 1.4) * C * 0.25) : 2;
-        O[b] = g;
+        H < 10 && (H = 0);
+        const B = H / 255, O = H > 0 ? Math.max(2, Math.pow(B, 1.4) * c * 0.25) : 2;
+        F[C] = O;
       }
-      for (let b = 0; b < m; b++) {
-        const P = m - 1 - b, M = Math.max(O[b], O[P]), g = v.current[b] + (M - v.current[b]) * 0.3;
-        v.current[b] = g;
-        const _ = ie + b * A, Z = L - g / 2;
-        I.beginPath(), I.roundRect ? I.roundRect(_, Z, Q, g, 4) : I.fillRect(_, Z, Q, g), I.fill();
+      for (let C = 0; C < m; C++) {
+        const H = m - 1 - C, B = Math.max(F[C], F[H]), O = e.current[C] + (B - e.current[C]) * 0.3;
+        e.current[C] = O;
+        const U = S + C * h, Z = u - O / 2;
+        n.beginPath(), n.roundRect ? n.roundRect(U, Z, l, O, 4) : n.fillRect(U, Z, l, O), n.fill();
       }
     };
-    return ge(), () => {
-      cancelAnimationFrame(E);
+    return a(), () => {
+      cancelAnimationFrame(i);
     };
-  }, [d]), /* @__PURE__ */ f("canvas", { ref: y, style: { width: "100%", height: "100%", display: "block" } });
-}, at = "https://ai.streamoji.com", Ot = "https://pub-48df6f7d60d6440bbd01676ea5d90e55.r2.dev";
-async function Dt(d) {
-  const y = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(d));
-  return Array.from(new Uint8Array(y)).map((v) => v.toString(16).padStart(2, "0")).join("");
+  }, [d]), /* @__PURE__ */ N("canvas", { ref: t, style: { width: "100%", height: "100%", display: "block" } });
+}, Vt = "https://ai.streamoji.com", Ws = "https://pub-48df6f7d60d6440bbd01676ea5d90e55.r2.dev";
+async function Xs(d) {
+  const t = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(d));
+  return Array.from(new Uint8Array(t)).map((e) => e.toString(16).padStart(2, "0")).join("");
 }
-function Ft(d) {
-  const [y, v] = k(null);
-  return z(() => {
+function zs(d) {
+  const [t, e] = K(null);
+  return ie(() => {
     if (!d) {
-      v(null);
+      e(null);
       return;
     }
-    let p = !1;
-    return Dt(d).then((I) => {
-      if (p) return;
-      const E = `${Ot}/${I}.glb`;
-      fetch(E, { method: "HEAD" }).then((R) => {
-        p || v(R.ok ? E : null);
+    let r = !1;
+    return Xs(d).then((n) => {
+      if (r) return;
+      const i = `${Ws}/${n}.glb`;
+      fetch(i, { method: "HEAD" }).then((s) => {
+        r || e(s.ok ? i : null);
       }).catch(() => {
-        p || v(null);
+        r || e(null);
       });
     }), () => {
-      p = !0;
+      r = !0;
     };
-  }, [d]), y;
+  }, [d]), t;
 }
-const Ut = [
+const $s = [
   "https://pub-be53cae7bd99457a8c1f11b4d38f1672.r2.dev/masculine/idle/M_Standing_Idle_Variations_001.glb",
   "https://pub-be53cae7bd99457a8c1f11b4d38f1672.r2.dev/masculine/idle/M_Standing_Idle_Variations_002.glb",
   "https://pub-be53cae7bd99457a8c1f11b4d38f1672.r2.dev/masculine/idle/M_Standing_Idle_002.glb",
   "https://pub-be53cae7bd99457a8c1f11b4d38f1672.r2.dev/masculine/idle/M_Standing_Idle_Variations_005.glb"
-], Nt = [
+], qs = [
   {
     id: "m_expr_01",
     name: "Friendly Wave",
@@ -247,17 +1948,17 @@ const Ut = [
     name: "Take It Easy",
     url: "https://pub-be53cae7bd99457a8c1f11b4d38f1672.r2.dev/masculine/expression/F_Talking_Variations_006.glb"
   }
-], Wt = [
+], Ys = [
   "https://pub-be53cae7bd99457a8c1f11b4d38f1672.r2.dev/masculine/expression/M_Talking_Variations_005.glb",
   "https://pub-be53cae7bd99457a8c1f11b4d38f1672.r2.dev/masculine/expression/M_Talking_Variations_007.glb"
-], Pt = {
+], Js = {
   zoom: 0.85,
   position: [0.15, -0.8, 0],
   scale: 1.5,
   rotation: [0.15, 0.02, 0]
-}, Vt = [-0.45, 1.9, 0.1], Bt = {
+}, Qs = [-0.45, 1.9, 0.1], Zs = {
   browInnerUp: 0.2
-}, Ye = 0.18, $t = 1, Ne = {
+}, mt = 0.18, er = 1, Je = {
   neutral: { eyeLookDownLeft: 0.1, eyeLookDownRight: 0.1 },
   happy: { mouthSmileLeft: 0.2, mouthSmileRight: 0.2, eyeLookDownLeft: 0.1, eyeLookDownRight: 0.1 },
   sad: { eyeLookDownLeft: 0.2, eyeLookDownRight: 0.2, browDownRight: 0.1, browInnerUp: 0.6, browOuterUpRight: 0.2, eyeSquintLeft: 0.7, eyeSquintRight: 0.7, mouthFrownLeft: 0.8, mouthFrownRight: 0.8, mouthLeft: 0.2, mouthPucker: 0.5, mouthRollLower: 0.2, mouthRollUpper: 0.2, mouthShrugLower: 0.2, mouthShrugUpper: 0.2, mouthStretchLeft: 0.4 },
@@ -265,7 +1966,7 @@ const Ut = [
   fear: { browInnerUp: 0.7, eyeSquintLeft: 0.5, eyeSquintRight: 0.5, eyeWideLeft: 0.6, eyeWideRight: 0.6, mouthClose: 0.1, mouthFunnel: 0.3, mouthShrugLower: 0.5, mouthShrugUpper: 0.5 },
   disgust: { browDownLeft: 0.7, browDownRight: 0.1, browInnerUp: 0.3, eyeSquintLeft: 1, eyeSquintRight: 1, eyeWideLeft: 0.5, eyeWideRight: 0.5, mouthLeft: 0.4, mouthPressLeft: 0.3, mouthRollLower: 0.3, mouthShrugLower: 0.3, mouthShrugUpper: 0.8, mouthUpperUpLeft: 0.3, noseSneerLeft: 1, noseSneerRight: 0.7 },
   love: { browInnerUp: 0.4, browOuterUpLeft: 0.2, browOuterUpRight: 0.2, mouthSmileLeft: 0.2, mouthSmileRight: 0.2, eyeBlinkLeft: 0.6, eyeBlinkRight: 0.6, eyeWideLeft: 0.7, eyeWideRight: 0.7, mouthDimpleLeft: 0.1, mouthDimpleRight: 0.1, mouthPressLeft: 0.2, mouthShrugUpper: 0.2, mouthUpperUpLeft: 0.1, mouthUpperUpRight: 0.1 }
-}, Ht = [
+}, tr = [
   { key: "viseme_aa", mix: { jawOpen: 0.6 } },
   { key: "viseme_E", mix: { mouthPressLeft: 0.8, mouthPressRight: 0.8, mouthDimpleLeft: 1, mouthDimpleRight: 1, jawOpen: 0.3 } },
   { key: "viseme_I", mix: { mouthPressLeft: 0.6, mouthPressRight: 0.6, mouthDimpleLeft: 0.6, mouthDimpleRight: 0.6, jawOpen: 0.2 } },
@@ -281,7 +1982,7 @@ const Ut = [
   { key: "viseme_kk", mix: { mouthLowerDownLeft: 0.4, mouthLowerDownRight: 0.4, mouthDimpleLeft: 0.3, mouthDimpleRight: 0.3, mouthFunnel: 0.3, mouthPucker: 0.3, jawOpen: 0.15 } },
   { key: "viseme_nn", mix: { mouthLowerDownLeft: 0.4, mouthLowerDownRight: 0.4, mouthDimpleLeft: 0.3, mouthDimpleRight: 0.3, mouthFunnel: 0.3, mouthPucker: 0.3, jawOpen: 0.15, tongueOut: 0.2 } },
   { key: "viseme_sil", mix: {} }
-], jt = {
+], nr = {
   aei: [{ v: "E", w: 0.8 }, { v: "I", w: 0.2 }],
   ee: [{ v: "I", w: 1 }],
   oo: [{ v: "O", w: 1 }],
@@ -298,466 +1999,466 @@ const Ut = [
   cdgknstxyz: [{ v: "DD", w: 0.6 }, { v: "SS", w: 0.4 }],
   sil: [{ v: "sil", w: 1 }]
 };
-function Jt(d) {
+function sr(d) {
   if (!d) return [{ v: "sil", w: 1 }];
-  const y = d.toLowerCase();
-  return jt[y] ?? [{ v: "sil", w: 1 }];
+  const t = d.toLowerCase();
+  return nr[t] ?? [{ v: "sil", w: 1 }];
 }
-function qt({ target: d }) {
-  const { camera: y } = Et();
-  return z(() => {
-    y.lookAt(...d);
-  }, [y, d]), null;
+function rr({ target: d }) {
+  const { camera: t } = Sn();
+  return ie(() => {
+    t.lookAt(...d);
+  }, [t, d]), null;
 }
-function q(d, y, v) {
+function ne(d, t, e) {
   if (!d || !d.morphTargetDictionary) return;
-  const p = d, I = p.morphTargetDictionary, E = p.morphTargetInfluences;
-  if (E)
-    for (const R in I)
-      R.toLowerCase() === y.toLowerCase() && (E[I[R]] = v);
+  const r = d, n = r.morphTargetDictionary, i = r.morphTargetInfluences;
+  if (i)
+    for (const s in n)
+      s.toLowerCase() === t.toLowerCase() && (i[n[s]] = e);
 }
-function ct(d, y = 0.97) {
+function Kt(d, t = 0.97) {
   if (!d) return;
-  const v = d;
-  if (v.morphTargetInfluences)
-    for (let p = 0; p < v.morphTargetInfluences.length; p++)
-      v.morphTargetInfluences[p] *= y;
+  const e = d;
+  if (e.morphTargetInfluences)
+    for (let r = 0; r < e.morphTargetInfluences.length; r++)
+      e.morphTargetInfluences[r] *= t;
 }
-const Gt = kt(({ avatarUrl: d, isPlayingRef: y, visemeQueueRef: v, audioContextRef: p, responseAudioStartTimeRef: I, adjustments: E, mood: R, expression: ge, agentResponse: re, isSpeaking: C, nextStartTimeRef: L, stopPlayback: Q, setIsSpeaking: W, expressionUrl: A, onExpressionFinished: le }) => {
-  const { scene: m } = Ge(d), be = Ge(Ut), ie = ze(() => be.flatMap((h) => h.animations), [be]), ue = Ge(Wt), se = ze(() => ue.flatMap((h) => h.animations), [ue]), N = c(null), O = c(null), b = c(null), P = c([]), [M] = k(() => new Ie.AnimationMixer(m)), g = c({}), _ = c(null), Z = c(0), ee = c(!1), de = c(0), _e = c(null);
-  z(() => {
-    if (!(!ie || !m)) {
-      if (ie.forEach((h, o) => {
-        const r = `idle_${o}`;
-        if (!g.current[r]) {
-          const t = M.clipAction(h, m);
-          t.name = r, t.setLoop(Ie.LoopOnce, 1), t.clampWhenFinished = !0, g.current[r] = t;
+const ir = bn(({ avatarUrl: d, isPlayingRef: t, visemeQueueRef: e, audioContextRef: r, responseAudioStartTimeRef: n, adjustments: i, mood: s, expression: a, agentResponse: o, isSpeaking: c, nextStartTimeRef: u, stopPlayback: l, setIsSpeaking: f, expressionUrl: h, onExpressionFinished: T }) => {
+  const { scene: m } = ct(d), b = ct($s), S = gt(() => b.flatMap((v) => v.animations), [b]), P = ct(Ys), D = gt(() => P.flatMap((v) => v.animations), [P]), y = L(null), F = L(null), C = L(null), H = L([]), [B] = K(() => new Ge.AnimationMixer(m)), O = L({}), U = L(null), Z = L(0), ue = L(!1), Te = L(0), ye = L(null);
+  ie(() => {
+    if (!(!S || !m)) {
+      if (S.forEach((v, A) => {
+        const x = `idle_${A}`;
+        if (!O.current[x]) {
+          const g = B.clipAction(v, m);
+          g.name = x, g.setLoop(Ge.LoopOnce, 1), g.clampWhenFinished = !0, O.current[x] = g;
         }
-      }), se.forEach((h, o) => {
-        const r = `talk_${o}`;
-        if (!g.current[r]) {
-          const t = M.clipAction(h, m);
-          t.name = r, t.setLoop(Ie.LoopOnce, 1), t.clampWhenFinished = !0, g.current[r] = t;
+      }), D.forEach((v, A) => {
+        const x = `talk_${A}`;
+        if (!O.current[x]) {
+          const g = B.clipAction(v, m);
+          g.name = x, g.setLoop(Ge.LoopOnce, 1), g.clampWhenFinished = !0, O.current[x] = g;
         }
-      }), ie.length > 0) {
-        const h = g.current.idle_0, o = _.current && M.existingAction(_.current.getClip());
-        h && !o && (h.reset().fadeIn(0.5).play(), _.current = h);
+      }), S.length > 0) {
+        const v = O.current.idle_0, A = U.current && B.existingAction(U.current.getClip());
+        v && !A && (v.reset().fadeIn(0.5).play(), U.current = v);
       }
       return () => {
-        M.stopAllAction(), g.current = {}, _.current = null;
+        B.stopAllAction(), O.current = {}, U.current = null;
       };
     }
-  }, [ie, se, m, M]);
-  const Ce = c("");
-  z(() => {
-    if (!A || !m || A === Ce.current) return;
-    Ce.current = A, _e.current = A, new It().load(A, (o) => {
-      if (o.animations && o.animations.length > 0) {
-        const r = o.animations[0], t = M.clipAction(r, m);
-        if (t.name = `EXPR_${A}`, t.setLoop(Ie.LoopOnce, 1), t.clampWhenFinished = !0, g.current[`EXPR_${A}`] = t, C && _e.current === A) {
-          const l = _.current;
-          t.reset().fadeIn(0.3).play(), l && l !== t && l.crossFadeTo(t, 0.3, !0), _.current = t, _e.current = null;
+  }, [S, D, m, B]);
+  const Xe = L("");
+  ie(() => {
+    if (!h || !m || h === Xe.current) return;
+    Xe.current = h, ye.current = h, new us().load(h, (A) => {
+      if (A.animations && A.animations.length > 0) {
+        const x = A.animations[0], g = B.clipAction(x, m);
+        if (g.name = `EXPR_${h}`, g.setLoop(Ge.LoopOnce, 1), g.clampWhenFinished = !0, O.current[`EXPR_${h}`] = g, c && ye.current === h) {
+          const M = U.current;
+          g.reset().fadeIn(0.3).play(), M && M !== g && M.crossFadeTo(g, 0.3, !0), U.current = g, ye.current = null;
         }
       }
-    }, void 0, (o) => {
-      console.error(`[ANIMATION] Failed to load ${A}`, o);
+    }, void 0, (A) => {
+      console.error(`[ANIMATION] Failed to load ${h}`, A);
     });
-  }, [A, m, M, C]), z(() => {
-    const h = (o) => {
-      const r = o.action, t = r.name || "";
-      if (t.startsWith("idle_")) {
-        const j = (parseInt(t.split("_")[1]) + 1) % ie.length, D = g.current[`idle_${j}`];
-        D && (D.reset().fadeIn(0.5).play(), r.crossFadeTo(D, 0.5, !0), _.current = D);
-      } else if (t.startsWith("EXPR_")) {
-        if (C) {
-          const l = g.current.talk_0;
-          l && (l.reset().fadeIn(0.5).play(), r.crossFadeTo(l, 0.5, !0), _.current = l);
+  }, [h, m, B, c]), ie(() => {
+    const v = (A) => {
+      const x = A.action, g = x.name || "";
+      if (g.startsWith("idle_")) {
+        const ee = (parseInt(g.split("_")[1]) + 1) % S.length, X = O.current[`idle_${ee}`];
+        X && (X.reset().fadeIn(0.5).play(), x.crossFadeTo(X, 0.5, !0), U.current = X);
+      } else if (g.startsWith("EXPR_")) {
+        if (c) {
+          const M = O.current.talk_0;
+          M && (M.reset().fadeIn(0.5).play(), x.crossFadeTo(M, 0.5, !0), U.current = M);
         } else {
-          const l = g.current.idle_0;
-          l && (l.reset().fadeIn(0.5).play(), r.crossFadeTo(l, 0.5, !0), _.current = l);
+          const M = O.current.idle_0;
+          M && (M.reset().fadeIn(0.5).play(), x.crossFadeTo(M, 0.5, !0), U.current = M);
         }
-        le && le();
-      } else if (t.startsWith("talk_"))
-        if (C) {
-          const j = (parseInt(t.split("_")[1]) + 1) % se.length, D = g.current[`talk_${j}`];
-          D && (D.reset().fadeIn(0.3).play(), r.crossFadeTo(D, 0.3, !0), _.current = D);
+        T && T();
+      } else if (g.startsWith("talk_"))
+        if (c) {
+          const ee = (parseInt(g.split("_")[1]) + 1) % D.length, X = O.current[`talk_${ee}`];
+          X && (X.reset().fadeIn(0.3).play(), x.crossFadeTo(X, 0.3, !0), U.current = X);
         } else {
-          const l = g.current.idle_0;
-          l && (l.reset().fadeIn(0.5).play(), r.crossFadeTo(l, 0.5, !0), _.current = l);
+          const M = O.current.idle_0;
+          M && (M.reset().fadeIn(0.5).play(), x.crossFadeTo(M, 0.5, !0), U.current = M);
         }
     };
-    return M.addEventListener("finished", h), () => M.removeEventListener("finished", h);
-  }, [M, ie, se, C, le]), z(() => {
-    if (C && m) {
-      const h = _.current, o = h?.name || "";
-      if (o.startsWith("idle_") || o.startsWith("talk_") || o === "") {
-        const r = _e.current;
-        if (r) {
-          const t = g.current[`EXPR_${r}`];
-          if (t) {
-            t.reset().fadeIn(0.3).play(), h && h !== t && h.crossFadeTo(t, 0.3, !0), _.current = t, _e.current = null;
+    return B.addEventListener("finished", v), () => B.removeEventListener("finished", v);
+  }, [B, S, D, c, T]), ie(() => {
+    if (c && m) {
+      const v = U.current, A = v?.name || "";
+      if (A.startsWith("idle_") || A.startsWith("talk_") || A === "") {
+        const x = ye.current;
+        if (x) {
+          const g = O.current[`EXPR_${x}`];
+          if (g) {
+            g.reset().fadeIn(0.3).play(), v && v !== g && v.crossFadeTo(g, 0.3, !0), U.current = g, ye.current = null;
             return;
           }
         }
-        if (o.startsWith("idle_") || o === "") {
-          const t = g.current.talk_0;
-          t && (t.reset().fadeIn(0.5).play(), h && h.crossFadeTo(t, 0.5, !0), _.current = t);
+        if (A.startsWith("idle_") || A === "") {
+          const g = O.current.talk_0;
+          g && (g.reset().fadeIn(0.5).play(), v && v.crossFadeTo(g, 0.5, !0), U.current = g);
         }
       }
-    } else if (!C && m) {
-      const h = _.current, o = h?.name || "";
-      if (o.startsWith("talk_") || o.startsWith("EXPR_")) {
-        const r = g.current.idle_0;
-        r && (r.reset().fadeIn(0.5).play(), h && h.crossFadeTo(r, 0.5, !0), _.current = r);
+    } else if (!c && m) {
+      const v = U.current, A = v?.name || "";
+      if (A.startsWith("talk_") || A.startsWith("EXPR_")) {
+        const x = O.current.idle_0;
+        x && (x.reset().fadeIn(0.5).play(), v && v.crossFadeTo(x, 0.5, !0), U.current = x);
       }
     }
-  }, [C, m, A]), z(() => {
+  }, [c, m, h]), ie(() => {
     if (!m) return;
-    m.traverse((r) => {
-      if (r.isMesh && r.morphTargetDictionary) {
-        const t = r.name.toLowerCase();
-        (t.includes("head") || t.includes("avatar")) && (O.current = r, H(`[ANIMATION] Found head mesh: ${r.name}`)), t.includes("teeth") && (b.current = r, H(`[ANIMATION] Found teeth mesh: ${r.name}`));
+    m.traverse((x) => {
+      if (x.isMesh && x.morphTargetDictionary) {
+        const g = x.name.toLowerCase();
+        (g.includes("head") || g.includes("avatar")) && (F.current = x, Q(`[ANIMATION] Found head mesh: ${x.name}`)), g.includes("teeth") && (C.current = x, Q(`[ANIMATION] Found teeth mesh: ${x.name}`));
       }
     });
-    const h = O.current?.morphTargetDictionary;
-    h && Object.keys(h).filter((r) => r.toLowerCase().includes("brow"));
-    const o = [];
-    m.traverse((r) => {
-      if (r.isMesh) {
-        const l = r.morphTargetDictionary;
-        l && Object.keys(l).some((j) => j.toLowerCase().includes("brow")) && o.push(r);
+    const v = F.current?.morphTargetDictionary;
+    v && Object.keys(v).filter((x) => x.toLowerCase().includes("brow"));
+    const A = [];
+    m.traverse((x) => {
+      if (x.isMesh) {
+        const M = x.morphTargetDictionary;
+        M && Object.keys(M).some((ee) => ee.toLowerCase().includes("brow")) && A.push(x);
       }
-    }), P.current = o, o.length > 0 && H("[ANIMATION] Meshes with brow morphs:", o.length);
+    }), H.current = A, A.length > 0 && Q("[ANIMATION] Meshes with brow morphs:", A.length);
   }, [m]);
-  const We = (h, o = 1) => {
-    const r = `viseme_${h}`.toLowerCase(), t = Ht.find((l) => l.key.toLowerCase() === r);
-    if (t)
-      for (const l in t.mix) {
-        const j = t.mix[l] * o;
-        q(O.current, l, j), q(b.current, l, j);
+  const Ze = (v, A = 1) => {
+    const x = `viseme_${v}`.toLowerCase(), g = tr.find((M) => M.key.toLowerCase() === x);
+    if (g)
+      for (const M in g.mix) {
+        const ee = g.mix[M] * A;
+        ne(F.current, M, ee), ne(C.current, M, ee);
       }
-  }, Pe = (h) => {
-    const o = Ne[h] ?? Ne.neutral;
-    for (const r in o)
-      q(O.current, r, o[r]), q(b.current, r, o[r]);
+  }, et = (v) => {
+    const A = Je[v] ?? Je.neutral;
+    for (const x in A)
+      ne(F.current, x, A[x]), ne(C.current, x, A[x]);
   };
-  return At((h, o) => {
-    const r = Math.pow(0.88, 60 * o);
-    ct(O.current, r), ct(b.current, r), Pe(R);
-    const t = h.clock.elapsedTime;
-    let l = 0;
-    if (Math.floor(t) % 5 === 0 && Math.floor((t - o) % 5) !== 0) {
-      let J = null;
-      m.traverse((G) => {
-        G.name.toLowerCase().includes("hips") && (J = G);
+  return wn((v, A) => {
+    const x = Math.pow(0.88, 60 * A);
+    Kt(F.current, x), Kt(C.current, x), et(s);
+    const g = v.clock.elapsedTime;
+    let M = 0;
+    if (Math.floor(g) % 5 === 0 && Math.floor((g - A) % 5) !== 0) {
+      let te = null;
+      m.traverse((se) => {
+        se.name.toLowerCase().includes("hips") && (te = se);
       });
-      const fe = J ? `Hips Y: ${J.position.y.toFixed(4)}` : "Hips not found";
-      H(`[ANIMATION] Mixer Time: ${M.time.toFixed(2)}, ${fe}`);
+      const _e = te ? `Hips Y: ${te.position.y.toFixed(4)}` : "Hips not found";
+      Q(`[ANIMATION] Mixer Time: ${B.time.toFixed(2)}, ${_e}`);
     }
-    if (M.update(o), t > Z.current && !ee.current && (ee.current = !0, de.current = t), ee.current) {
-      const fe = (t - de.current) / 0.3;
-      if (fe >= 1)
-        ee.current = !1, Z.current = t + 2 + Math.random() * 5;
+    if (B.update(A), g > Z.current && !ue.current && (ue.current = !0, Te.current = g), ue.current) {
+      const _e = (g - Te.current) / 0.3;
+      if (_e >= 1)
+        ue.current = !1, Z.current = g + 2 + Math.random() * 5;
       else {
-        const G = fe < 0.5 ? fe * 2 : (1 - fe) * 2;
-        q(O.current, "eyeBlinkLeft", G), q(O.current, "eyeBlinkRight", G), q(b.current, "eyeBlinkLeft", G), q(b.current, "eyeBlinkRight", G), l = G * Bt.browInnerUp;
+        const se = _e < 0.5 ? _e * 2 : (1 - _e) * 2;
+        ne(F.current, "eyeBlinkLeft", se), ne(F.current, "eyeBlinkRight", se), ne(C.current, "eyeBlinkLeft", se), ne(C.current, "eyeBlinkRight", se), M = se * Zs.browInnerUp;
       }
     }
-    const j = Ne[R] ?? Ne.neutral, D = j.browInnerUp ?? 0, we = j.browOuterUpLeft ?? 0, Le = j.browOuterUpRight ?? 0, xe = t * $t, Ae = Ye * Math.sin(xe), Me = Ye * 0.7 * Math.sin(xe + 0.7), Xe = Ye * 0.7 * Math.sin(xe + 1.3), ke = (J) => Math.max(0, Math.min(1, J)), Ee = ke(D + Ae), Te = ke(we + Me), he = ke(Le + Xe), ve = ke(Ee + l);
-    if (q(O.current, "browInnerUp", ve), q(b.current, "browInnerUp", ve), q(O.current, "browOuterUpLeft", Te), q(b.current, "browOuterUpLeft", Te), q(O.current, "browOuterUpRight", he), q(b.current, "browOuterUpRight", he), N.current) {
-      const J = y.current ? 0 : E.rotation[1];
-      N.current.rotation.y = Ie.MathUtils.lerp(N.current.rotation.y, J, 0.1), N.current.position.set(...E.position), N.current.scale.setScalar(E.scale), N.current.rotation.x = E.rotation[0], N.current.rotation.z = E.rotation[2];
+    const ee = Je[s] ?? Je.neutral, X = ee.browInnerUp ?? 0, Ae = ee.browOuterUpLeft ?? 0, Fe = ee.browOuterUpRight ?? 0, ke = g * er, Pe = mt * Math.sin(ke), Ue = mt * 0.7 * Math.sin(ke + 0.7), Rt = mt * 0.7 * Math.sin(ke + 1.3), Ne = (te) => Math.max(0, Math.min(1, te)), He = Ne(X + Pe), Be = Ne(Ae + Ue), be = Ne(Fe + Rt), Ee = Ne(He + M);
+    if (ne(F.current, "browInnerUp", Ee), ne(C.current, "browInnerUp", Ee), ne(F.current, "browOuterUpLeft", Be), ne(C.current, "browOuterUpLeft", Be), ne(F.current, "browOuterUpRight", be), ne(C.current, "browOuterUpRight", be), y.current) {
+      const te = t.current ? 0 : i.rotation[1];
+      y.current.rotation.y = Ge.MathUtils.lerp(y.current.rotation.y, te, 0.1), y.current.position.set(...i.position), y.current.scale.setScalar(i.scale), y.current.rotation.x = i.rotation[0], y.current.rotation.z = i.rotation[2];
     }
-    if (y.current && p.current) {
-      const J = p.current.currentTime, X = (J - I.current) * 1e3 - -150;
-      for (let oe = 0; oe < v.current.length; oe++) {
-        const K = v.current[oe];
-        X >= K.vtime && X < K.vtime + K.vduration && We(K.viseme, K.weight ?? 1);
+    if (t.current && r.current) {
+      const te = r.current.currentTime, oe = (te - n.current) * 1e3 - -150;
+      for (let fe = 0; fe < e.current.length; fe++) {
+        const ae = e.current[fe];
+        oe >= ae.vtime && oe < ae.vtime + ae.vduration && Ze(ae.viseme, ae.weight ?? 1);
       }
-      J > L.current + 0.5 && (Q(), W(!1));
+      te > u.current + 0.5 && (l(), f(!1));
     }
-  }), /* @__PURE__ */ f("group", { ref: N, children: /* @__PURE__ */ f("primitive", { object: m }) });
+  }), /* @__PURE__ */ N("group", { ref: y, children: /* @__PURE__ */ N("primitive", { object: m }) });
 });
-function Yt(d) {
+function or(d) {
   return d ? d.charAt(0).toUpperCase() + d.slice(1).toLowerCase() : "";
 }
-const zt = ({ token: d, agentToken: y, onNavigationRequested: v } = {}) => {
-  const p = d ?? y ?? "", I = Ft(p || void 0), [E, R] = k(""), [ge, re] = k(""), [C, L] = k("Ready"), [Q, W] = k(!1), [A, le] = k(!1), m = c(!1), be = c([]), ie = c(0), ue = c(!1), se = c([]), N = c(null), O = c([]);
-  c([]);
-  const b = c([]), P = c(0), M = c(0), g = c(0), _ = c(0), [Z, ee] = k(null), de = c(null), [_e, Ce] = k("neutral"), [We, Pe] = k(""), [h, o] = k(""), [r, t] = k("Chat with us"), [l, j] = k(null), [D, we] = k("hidden"), [Le, xe] = k(""), Ae = c(null), Me = c(D);
-  Me.current = D;
-  const [Xe, ke] = k(null), Ee = c(null), Te = c(null), [he, ve] = k("hidden"), [J, fe] = k(""), G = c(he);
-  G.current = he;
-  const X = c(""), oe = c(!1), K = c(""), Re = ze(() => C === "Thinking..." || C === "Processing Voice..." ? C : l != null && l !== "" && l !== "none" && l !== "<none>" ? `Enter ${Yt(l)}` : null, [C, l]), Oe = Re != null && Re !== "";
-  z(() => {
-    const e = Me.current;
-    if (!(e === "exiting" || e === "entering")) {
-      if (e === "hidden") {
-        Oe && (xe(Re ?? ""), we("entering"));
+const ar = ({ token: d, agentToken: t, onNavigationRequested: e } = {}) => {
+  const r = d ?? t ?? "", n = zs(r || void 0), [i, s] = K(""), [a, o] = K(""), [c, u] = K("Ready"), [l, f] = K(!1), [h, T] = K(!1), m = L(!1), b = L([]), S = L(0), P = L(!1), D = L([]), y = L(null), F = L([]);
+  L([]);
+  const C = L([]), H = L(0), B = L(0), O = L(0), U = L(0), [Z, ue] = K(null), Te = L(null), [ye, Xe] = K("neutral"), [Ze, et] = K(""), [v, A] = K(""), [x, g] = K("Chat with us"), [M, ee] = K(null), [X, Ae] = K("hidden"), [Fe, ke] = K(""), Pe = L(null), Ue = L(X);
+  Ue.current = X;
+  const [Rt, Ne] = K(null), He = L(null), Be = L(null), [be, Ee] = K("hidden"), [te, _e] = K(""), se = L(be);
+  se.current = be;
+  const oe = L(""), fe = L(!1), ae = L(""), Ce = gt(() => c === "Thinking..." || c === "Processing Voice..." ? c : M != null && M !== "" && M !== "none" && M !== "<none>" ? `Enter ${or(M)}` : null, [c, M]), ze = Ce != null && Ce !== "";
+  ie(() => {
+    const p = Ue.current;
+    if (!(p === "exiting" || p === "entering")) {
+      if (p === "hidden") {
+        ze && (ke(Ce ?? ""), Ae("entering"));
         return;
       }
-      e === "visible" && (!Oe || Re !== Le) && (Ae.current = Oe ? Re : null, we("exiting"));
+      p === "visible" && (!ze || Ce !== Fe) && (Pe.current = ze ? Ce : null, Ae("exiting"));
     }
-  }, [Oe, Re, D, Le]);
-  const lt = Ue(() => {
-    const e = Me.current;
-    if (e === "exiting") {
-      we("hidden");
-      const i = Ae.current;
-      Ae.current = null, i != null && i !== "" && (xe(i), we("entering"));
-    } else e === "entering" && we("visible");
-  }, []), ut = (e) => {
-    if (!e) return;
-    if (e.mood != null) {
-      const n = String(e.mood).toLowerCase();
-      Ce(n);
+  }, [ze, Ce, X, Fe]);
+  const nn = Ye(() => {
+    const p = Ue.current;
+    if (p === "exiting") {
+      Ae("hidden");
+      const w = Pe.current;
+      Pe.current = null, w != null && w !== "" && (ke(w), Ae("entering"));
+    } else p === "entering" && Ae("visible");
+  }, []), sn = (p) => {
+    if (!p) return;
+    if (p.mood != null) {
+      const _ = String(p.mood).toLowerCase();
+      Xe(_);
     }
-    if (e.expression != null) {
-      const n = String(e.expression).trim();
-      Pe(n);
-      const u = Nt.find((w) => w.name.toLowerCase() === n.toLowerCase());
-      H(`[STREAM] Animation match for "${n}": ${u ? u.name : "NONE"}`), o(u?.url ?? "");
+    if (p.expression != null) {
+      const _ = String(p.expression).trim();
+      et(_);
+      const I = qs.find((G) => G.name.toLowerCase() === _.toLowerCase());
+      Q(`[STREAM] Animation match for "${_}": ${I ? I.name : "NONE"}`), A(I?.url ?? "");
     }
-    if (e.navigation != null) {
-      const n = String(e.navigation).trim();
-      n !== "" && (v ? v(n) : window.open(n, "_blank"));
+    if (p.navigation != null) {
+      const _ = String(p.navigation).trim();
+      _ !== "" && (e ? e(_) : window.location.href = _);
     }
-    const i = e.ask_for || e.lead_capture?.ask_for, s = i ? String(i).trim().toLowerCase() : "", a = s === "none" || s === "<none>";
-    if (i && !a) {
-      const n = s;
-      j(n || null), t(n === "email" ? "Enter your email" : n === "name" ? "Enter your name" : n === "phone" ? "Enter your phone number" : "Chat with us");
-    } else (a || e.ask_for === null || e.lead_capture && e.lead_capture.ask_for === null || e.ask_for === "none") && (j(null), r !== "Chat with us" && t("Chat with us"));
-    e.collected, e.valid;
-  }, dt = (e) => {
-    const i = e.trim();
-    if (!i) return null;
-    if (i.startsWith("{"))
+    const w = p.ask_for || p.lead_capture?.ask_for, R = w ? String(w).trim().toLowerCase() : "", E = R === "none" || R === "<none>";
+    if (w && !E) {
+      const _ = R;
+      ee(_ || null), g(_ === "email" ? "Enter your email" : _ === "name" ? "Enter your name" : _ === "phone" ? "Enter your phone number" : "Chat with us");
+    } else (E || p.ask_for === null || p.lead_capture && p.lead_capture.ask_for === null || p.ask_for === "none") && (ee(null), x !== "Chat with us" && g("Chat with us"));
+    p.collected, p.valid;
+  }, rn = (p) => {
+    const w = p.trim();
+    if (!w) return null;
+    if (w.startsWith("{"))
       try {
-        return JSON.parse(i);
+        return JSON.parse(w);
       } catch {
         return null;
       }
-    if (i.includes(":")) {
-      const s = i.split(":"), a = s[0].trim().toLowerCase(), n = s.slice(1).join(":").trim();
-      return { [a]: n };
+    if (w.includes(":")) {
+      const R = w.split(":"), E = R[0].trim().toLowerCase(), _ = R.slice(1).join(":").trim();
+      return { [E]: _ };
     }
     return null;
-  }, ht = Ue(() => {
-  }, []), Ke = (e) => {
-    if (oe.current)
-      e === "§" ? oe.current = !1 : (K.current += e, re((i) => i + e));
-    else if (e === "§") {
-      oe.current = !0;
+  }, on = Ye(() => {
+  }, []), St = (p) => {
+    if (fe.current)
+      p === "§" ? fe.current = !1 : (ae.current += p, o((w) => w + p));
+    else if (p === "§") {
+      fe.current = !0;
       return;
     } else
-      for (X.current += e; X.current.includes(`
+      for (oe.current += p; oe.current.includes(`
 `); ) {
-        const i = X.current.indexOf(`
-`), s = X.current.slice(0, i).trim();
-        X.current = X.current.slice(i + 1);
-        const a = dt(s);
-        a && ut(a);
+        const w = oe.current.indexOf(`
+`), R = oe.current.slice(0, w).trim();
+        oe.current = oe.current.slice(w + 1);
+        const E = rn(R);
+        E && sn(E);
       }
   };
-  z(() => {
+  ie(() => {
     (async () => {
       if (!sessionStorage.getItem("STREAMOJI_LEADS_SESSION_LEAD_ID")) {
-        const s = "secret", a = Math.floor(Date.now() / 1e3).toString();
+        const R = "secret", E = Math.floor(Date.now() / 1e3).toString();
         try {
-          const n = new TextEncoder(), u = await crypto.subtle.importKey(
+          const _ = new TextEncoder(), I = await crypto.subtle.importKey(
             "raw",
-            n.encode(s),
+            _.encode(R),
             { name: "HMAC", hash: "SHA-256" },
             !1,
             ["sign"]
-          ), w = await crypto.subtle.sign(
+          ), G = await crypto.subtle.sign(
             "HMAC",
-            u,
-            n.encode(a)
-          ), V = Array.from(new Uint8Array(w)).map((S) => S.toString(16).padStart(2, "0")).join("");
-          sessionStorage.setItem("STREAMOJI_LEADS_SESSION_LEAD_ID", V), H("[SESSION] New HMAC UID generated and saved:", V);
-        } catch (n) {
-          console.error("[SESSION] HMAC generation failed:", n);
-          const u = Math.random().toString(36) + Date.now().toString();
-          sessionStorage.setItem("STREAMOJI_LEADS_SESSION_LEAD_ID", u);
+            I,
+            _.encode(E)
+          ), q = Array.from(new Uint8Array(G)).map((j) => j.toString(16).padStart(2, "0")).join("");
+          sessionStorage.setItem("STREAMOJI_LEADS_SESSION_LEAD_ID", q), Q("[SESSION] New HMAC UID generated and saved:", q);
+        } catch (_) {
+          console.error("[SESSION] HMAC generation failed:", _);
+          const I = Math.random().toString(36) + Date.now().toString();
+          sessionStorage.setItem("STREAMOJI_LEADS_SESSION_LEAD_ID", I);
         }
       }
       sessionStorage.getItem("STREAMOJI_LEADS_SESSION_MESSAGES") || sessionStorage.setItem("STREAMOJI_LEADS_SESSION_MESSAGES", JSON.stringify([]));
     })();
   }, []);
-  const Qe = () => {
+  const yt = () => {
     try {
       return JSON.parse(sessionStorage.getItem("STREAMOJI_LEADS_SESSION_MESSAGES") || "[]");
     } catch {
       return [];
     }
-  }, ft = (e) => {
-    sessionStorage.setItem("STREAMOJI_LEADS_SESSION_MESSAGES", JSON.stringify(e));
-  }, [Ve, Be] = k(!1), [Ze, $e] = k(0), ae = c(null), De = c([]), et = c(0), [tt, pt] = k(null), [mt, He] = k(null), pe = c(null), Se = c(null), je = Ue(() => {
-    se.current = [], ue.current = !1, le(!1), P.current = 0, M.current = 0, g.current = 0, O.current.forEach((e) => {
+  }, an = (p) => {
+    sessionStorage.setItem("STREAMOJI_LEADS_SESSION_MESSAGES", JSON.stringify(p));
+  }, [tt, nt] = K(!1), [At, st] = K(0), he = L(null), $e = L([]), Et = L(0), [Lt, cn] = K(null), [un, rt] = K(null), xe = L(null), Le = L(null), it = Ye(() => {
+    D.current = [], P.current = !1, T(!1), H.current = 0, B.current = 0, O.current = 0, F.current.forEach((p) => {
       try {
-        e.stop();
+        p.stop();
       } catch {
       }
-    }), Ee.current && (clearTimeout(Ee.current), Ee.current = null), ke(null), o(""), O.current = [];
-  }, []), gt = async () => {
+    }), He.current && (clearTimeout(He.current), He.current = null), Ne(null), A(""), F.current = [];
+  }, []), ln = async () => {
     try {
-      const e = await navigator.mediaDevices.getUserMedia({ audio: !0 }), i = window.AudioContext || window.webkitAudioContext, s = new i(), a = s.createMediaStreamSource(e), n = s.createAnalyser();
-      n.fftSize = 64, a.connect(n), pe.current = s, Se.current = a, He(n);
-      const u = new MediaRecorder(e);
-      ae.current = u, De.current = [], u.ondataavailable = (w) => {
-        w.data.size > 0 && De.current.push(w.data);
-      }, u.onstop = async () => {
-        const w = Date.now() - et.current;
-        if (He(null), Se.current && (Se.current.disconnect(), Se.current = null), pe.current && pe.current.state !== "closed" && (pe.current.close(), pe.current = null), w < 1e3) {
-          L("Recording too short. Hold or click longer."), W(!1);
+      const p = await navigator.mediaDevices.getUserMedia({ audio: !0 }), w = window.AudioContext || window.webkitAudioContext, R = new w(), E = R.createMediaStreamSource(p), _ = R.createAnalyser();
+      _.fftSize = 64, E.connect(_), xe.current = R, Le.current = E, rt(_);
+      const I = new MediaRecorder(p);
+      he.current = I, $e.current = [], I.ondataavailable = (G) => {
+        G.data.size > 0 && $e.current.push(G.data);
+      }, I.onstop = async () => {
+        const G = Date.now() - Et.current;
+        if (rt(null), Le.current && (Le.current.disconnect(), Le.current = null), xe.current && xe.current.state !== "closed" && (xe.current.close(), xe.current = null), G < 1e3) {
+          u("Recording too short. Hold or click longer."), f(!1);
           return;
         }
-        const x = new Blob(De.current, { type: "audio/wav" });
-        await vt(x);
-      }, et.current = Date.now(), u.start(100), Be(!0), L("Listening...");
-    } catch (e) {
-      console.error("Error accessing microphone:", e), L("Mic Access Error");
+        const V = new Blob($e.current, { type: "audio/wav" });
+        await pn(V);
+      }, Et.current = Date.now(), I.start(100), nt(!0), u("Listening...");
+    } catch (p) {
+      console.error("Error accessing microphone:", p), u("Mic Access Error");
     }
-  }, bt = () => {
-    ae.current && ae.current.state !== "inactive" && (ae.current.stop(), ae.current.stream.getTracks().forEach((e) => e.stop()), Be(!1));
-  }, _t = () => {
-    ae.current && ae.current.state !== "inactive" && (ae.current.onstop = null, ae.current.stop(), ae.current.stream.getTracks().forEach((e) => e.stop()), He(null), Se.current && (Se.current.disconnect(), Se.current = null), pe.current && pe.current.state !== "closed" && (pe.current.close(), pe.current = null), Be(!1), De.current = [], L("Ready"));
+  }, dn = () => {
+    he.current && he.current.state !== "inactive" && (he.current.stop(), he.current.stream.getTracks().forEach((p) => p.stop()), nt(!1));
+  }, fn = () => {
+    he.current && he.current.state !== "inactive" && (he.current.onstop = null, he.current.stop(), he.current.stream.getTracks().forEach((p) => p.stop()), rt(null), Le.current && (Le.current.disconnect(), Le.current = null), xe.current && xe.current.state !== "closed" && (xe.current.close(), xe.current = null), nt(!1), $e.current = [], u("Ready"));
   };
-  z(() => {
-    if (!A) return;
-    const e = () => {
-      const i = g.current;
-      if (i <= 0) return;
-      const s = N.current, a = P.current;
-      if (!s) return;
-      const n = s.currentTime - a, u = Math.min(Math.max(0, n), i), w = ge.trim().length;
+  ie(() => {
+    if (!h) return;
+    const p = () => {
+      const w = O.current;
       if (w <= 0) return;
-      const x = Math.min(
-        Math.round(u / i * w),
-        w
+      const R = y.current, E = H.current;
+      if (!R) return;
+      const _ = R.currentTime - E, I = Math.min(Math.max(0, _), w), G = a.trim().length;
+      if (G <= 0) return;
+      const V = Math.min(
+        Math.round(I / w * G),
+        G
       );
-      ee(x);
+      ue(V);
     };
-    return clearInterval(de.current ?? void 0), de.current = setInterval(e, 90), () => clearInterval(de.current ?? void 0);
-  }, [A, ge, g.current]), z(() => {
-    let e;
-    return Ve ? ($e(0), e = window.setInterval(() => {
-      $e((i) => i + 1);
-    }, 1e3)) : $e(0), () => clearInterval(e);
-  }, [Ve]);
-  const wt = (e) => {
-    const i = e.numberOfChannels, s = e.length * i * 2 + 44, a = new ArrayBuffer(s), n = new DataView(a);
-    let u = 0;
-    const w = (F) => {
-      n.setUint16(u, F, !0), u += 2;
-    }, x = (F) => {
-      n.setUint32(u, F, !0), u += 4;
+    return clearInterval(Te.current ?? void 0), Te.current = setInterval(p, 90), () => clearInterval(Te.current ?? void 0);
+  }, [h, a, O.current]), ie(() => {
+    let p;
+    return tt ? (st(0), p = window.setInterval(() => {
+      st((w) => w + 1);
+    }, 1e3)) : st(0), () => clearInterval(p);
+  }, [tt]);
+  const hn = (p) => {
+    const w = p.numberOfChannels, R = p.length * w * 2 + 44, E = new ArrayBuffer(R), _ = new DataView(E);
+    let I = 0;
+    const G = (z) => {
+      _.setUint16(I, z, !0), I += 2;
+    }, V = (z) => {
+      _.setUint32(I, z, !0), I += 4;
     };
-    x(1179011410), x(s - 8), x(1163280727), x(544501094), x(16), w(1), w(i), x(e.sampleRate), x(e.sampleRate * 2 * i), w(i * 2), w(16), x(1635017060), x(s - u - 4);
-    const V = [];
-    for (let F = 0; F < i; F++) V.push(e.getChannelData(F));
-    let S = 0;
-    for (; u < s; ) {
-      for (let F = 0; F < i; F++) {
-        let B = Math.max(-1, Math.min(1, V[F][S]));
-        B = B < 0 ? B * 32768 : B * 32767, n.setInt16(u, B, !0), u += 2;
+    V(1179011410), V(R - 8), V(1163280727), V(544501094), V(16), G(1), G(w), V(p.sampleRate), V(p.sampleRate * 2 * w), G(w * 2), G(16), V(1635017060), V(R - I - 4);
+    const q = [];
+    for (let z = 0; z < w; z++) q.push(p.getChannelData(z));
+    let j = 0;
+    for (; I < R; ) {
+      for (let z = 0; z < w; z++) {
+        let Y = Math.max(-1, Math.min(1, q[z][j]));
+        Y = Y < 0 ? Y * 32768 : Y * 32767, _.setInt16(I, Y, !0), I += 2;
       }
-      S++;
+      j++;
     }
-    return new Blob([a], { type: "audio/wav" });
-  }, Je = async (e, i, s = !1) => {
+    return new Blob([E], { type: "audio/wav" });
+  }, ot = async (p, w, R = !1) => {
     if (m.current) {
-      be.current.push({ audio: e, visemes: i, isNewSegment: s });
+      b.current.push({ audio: p, visemes: w, isNewSegment: R });
       return;
     }
     m.current = !0;
     try {
-      const a = window.AudioContext || window.webkitAudioContext, n = N.current ?? new a();
-      n.state === "suspended" && await n.resume(), N.current = n;
-      const u = window.atob(e), w = new Uint8Array(u.length);
-      for (let U = 0; U < u.length; U++) w[U] = u.charCodeAt(U);
-      const x = await n.decodeAudioData(w.buffer.slice(0));
-      g.current += x.duration;
-      const V = n.currentTime;
-      let S = M.current;
-      const F = !ue.current;
-      S < V && (S = V + 0.1), M.current = S + x.duration;
-      const B = n.createBufferSource();
-      B.buffer = x;
-      let $ = tt;
-      if ((!$ || $.context !== n) && ($ = n.createAnalyser(), $.fftSize = 64, $.connect(n.destination), pt($)), B.connect($), O.current.push(B), F) {
-        ue.current = !0, le(!0), H(`[AUDIO] setIsSpeaking(true) - First chunk starting at ${S.toFixed(3)}`), P.current = S;
-        const U = (S - V) * 1e3;
-        ie.current = performance.now() + U, H(`[AUDIO] Response started. Initial startTime: ${S.toFixed(3)}, CT: ${V.toFixed(3)}`);
+      const E = window.AudioContext || window.webkitAudioContext, _ = y.current ?? new E();
+      _.state === "suspended" && await _.resume(), y.current = _;
+      const I = window.atob(p), G = new Uint8Array(I.length);
+      for (let $ = 0; $ < I.length; $++) G[$] = I.charCodeAt($);
+      const V = await _.decodeAudioData(G.buffer.slice(0));
+      O.current += V.duration;
+      const q = _.currentTime;
+      let j = B.current;
+      const z = !P.current;
+      j < q && (j = q + 0.1), B.current = j + V.duration;
+      const Y = _.createBufferSource();
+      Y.buffer = V;
+      let J = Lt;
+      if ((!J || J.context !== _) && (J = _.createAnalyser(), J.fftSize = 64, J.connect(_.destination), cn(J)), Y.connect(J), F.current.push(Y), z) {
+        P.current = !0, T(!0), Q(`[AUDIO] setIsSpeaking(true) - First chunk starting at ${j.toFixed(3)}`), H.current = j;
+        const $ = (j - q) * 1e3;
+        S.current = performance.now() + $, Q(`[AUDIO] Response started. Initial startTime: ${j.toFixed(3)}, CT: ${q.toFixed(3)}`);
       }
-      B.start(S);
-      const Y = (S - P.current) * 1e3;
-      s && (_.current = Y, H(`[AUDIO] New segment detected at +${Y.toFixed(0)}ms. Resetting segment offset.`)), i.forEach((U, me) => {
-        const T = U.symbol ?? "";
-        if (T) {
-          const te = Jt(T), ce = Math.round(U.start * 1e3), ye = Math.round((U.duration ?? 0) * 1e3), it = _.current + ce;
-          me < 3 && H(`[AUDIO] Viseme "${T}": segment_relative=${ce}ms, segment_offset=${_.current.toFixed(0)}ms => vtime=${it}ms`), te.forEach((st) => {
-            se.current.push({ viseme: st.v, weight: st.w, vtime: it, vduration: ye });
+      Y.start(j);
+      const re = (j - H.current) * 1e3;
+      R && (U.current = re, Q(`[AUDIO] New segment detected at +${re.toFixed(0)}ms. Resetting segment offset.`)), w.forEach(($, we) => {
+        const W = $.symbol ?? "";
+        if (W) {
+          const le = sr(W), pe = Math.round($.start * 1e3), Me = Math.round(($.duration ?? 0) * 1e3), vt = U.current + pe;
+          we < 3 && Q(`[AUDIO] Viseme "${W}": segment_relative=${pe}ms, segment_offset=${U.current.toFixed(0)}ms => vtime=${vt}ms`), le.forEach((kt) => {
+            D.current.push({ viseme: kt.v, weight: kt.w, vtime: vt, vduration: Me });
           });
         }
-      }), L("Speaking...");
+      }), u("Speaking...");
     } finally {
-      if (m.current = !1, be.current.length > 0) {
-        const a = be.current.shift();
-        a && Je(a.audio, a.visemes, a.isNewSegment);
+      if (m.current = !1, b.current.length > 0) {
+        const E = b.current.shift();
+        E && ot(E.audio, E.visemes, E.isNewSegment);
       }
     }
-  }, vt = async (e) => {
+  }, pn = async (p) => {
     try {
-      W(!0), K.current = "", re(""), L("Processing Voice...");
-      const i = await e.arrayBuffer(), a = await new (window.AudioContext || window.webkitAudioContext)().decodeAudioData(i), n = wt(a), u = new FileReader();
-      u.readAsDataURL(n), u.onloadend = async () => {
-        const w = u.result.split(",")[1];
-        je(), R(""), X.current = "", oe.current = !1;
-        const x = `${at}/stt?token=${encodeURIComponent(p)}`, V = await fetch(x, {
+      f(!0), ae.current = "", o(""), u("Processing Voice...");
+      const w = await p.arrayBuffer(), E = await new (window.AudioContext || window.webkitAudioContext)().decodeAudioData(w), _ = hn(E), I = new FileReader();
+      I.readAsDataURL(_), I.onloadend = async () => {
+        const G = I.result.split(",")[1];
+        it(), s(""), oe.current = "", fe.current = !1;
+        const V = `${Vt}/stt?token=${encodeURIComponent(r)}`, q = await fetch(V, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ audio_base64: w, audio_format: "wav" })
+          body: JSON.stringify({ audio_base64: G, audio_format: "wav" })
         });
-        if (!V.ok) {
-          const me = await V.text();
-          let T = "STT Failed";
+        if (!q.ok) {
+          const we = await q.text();
+          let W = "STT Failed";
           try {
-            T = JSON.parse(me).error || T;
+            W = JSON.parse(we).error || W;
           } catch {
-            me && (T = me.slice(0, 200));
+            we && (W = we.slice(0, 200));
           }
-          throw new Error(T);
+          throw new Error(W);
         }
-        const S = V.body;
-        if (H("this is body" + S), !S) {
-          L("STT Failed"), W(!1);
+        const j = q.body;
+        if (Q("this is body" + j), !j) {
+          u("STT Failed"), f(!1);
           return;
         }
-        const F = S.getReader(), B = new TextDecoder();
-        let $ = "", Y = !1;
-        const U = async (me, T) => {
-          switch (me) {
+        const z = j.getReader(), Y = new TextDecoder();
+        let J = "", re = !1;
+        const $ = async (we, W) => {
+          switch (we) {
             case "transcript":
-              T.transcript != null && R(String(T.transcript));
+              W.transcript != null && s(String(W.transcript));
               break;
             case "text": {
-              const te = T.delta ?? T.text ?? "";
-              te && Ke(te);
+              const le = W.delta ?? W.text ?? "";
+              le && St(le);
               break;
             }
             case "audio": {
-              const te = T.chunk, ce = T.visemes ?? [], ye = !!T.is_new_segment;
-              te && await Je(te, ce, ye);
+              const le = W.chunk, pe = W.visemes ?? [], Me = !!W.is_new_segment;
+              le && await ot(le, pe, Me);
               break;
             }
             case "done": {
-              Y = !0, L("Ready"), W(!1);
+              re = !0, u("Ready"), f(!1);
               break;
             }
             case "error": {
-              Y = !0, L("STT Failed"), W(!1);
+              re = !0, u("STT Failed"), f(!1);
               break;
             }
             default:
@@ -765,165 +2466,168 @@ const zt = ({ token: d, agentToken: y, onNavigationRequested: v } = {}) => {
           }
         };
         for (; ; ) {
-          const { done: me, value: T } = await F.read();
-          T && ($ += B.decode(T, { stream: !0 }));
-          const te = $.split(`
+          const { done: we, value: W } = await z.read();
+          W && (J += Y.decode(W, { stream: !0 }));
+          const le = J.split(`
 
 `);
-          $ = te.pop() ?? "";
-          for (const ce of te) {
-            const ye = Fe(ce);
-            ye && await U(ye.event, ye.data);
+          J = le.pop() ?? "";
+          for (const pe of le) {
+            const Me = qe(pe);
+            Me && await $(Me.event, Me.data);
           }
-          if (me) {
-            if ($.trim()) {
-              const ce = Fe($.trim());
-              ce && await U(ce.event, ce.data);
+          if (we) {
+            if (J.trim()) {
+              const pe = qe(J.trim());
+              pe && await $(pe.event, pe.data);
             }
-            Y || (L("Ready"), W(!1));
+            re || (u("Ready"), f(!1));
             break;
           }
         }
       };
-    } catch (i) {
-      console.error("Audio Submission Error:", i), L("STT Failed"), W(!1);
+    } catch (w) {
+      console.error("Audio Submission Error:", w), u("STT Failed"), f(!1);
     }
-  }, St = async (e) => {
-    e && e.preventDefault(), K.current = "", re(""), !(!E || Q) && await yt(E);
-  }, Fe = (e) => {
-    const i = e.split(/\r?\n/);
-    let s = "", a = "";
-    for (const u of i)
-      u.startsWith("event:") ? s = u.slice(6).trim() : u.startsWith("data:") && (a = u.slice(5).trim());
-    if (!s) return null;
-    let n = {};
-    if (a)
+  }, mn = async (p) => {
+    p && p.preventDefault(), ae.current = "", o(""), !(!i || l) && await gn(i);
+  }, qe = (p) => {
+    const w = p.split(/\r?\n/);
+    let R = "", E = "";
+    for (const I of w)
+      I.startsWith("event:") ? R = I.slice(6).trim() : I.startsWith("data:") && (E = I.slice(5).trim());
+    if (!R) return null;
+    let _ = {};
+    if (E)
       try {
-        n = JSON.parse(a);
+        _ = JSON.parse(E);
       } catch {
-        n = { raw: a };
+        _ = { raw: E };
       }
-    return { event: s, data: n };
-  }, nt = (e, i) => {
-    switch (e) {
+    return { event: R, data: _ };
+  }, Mt = (p, w) => {
+    switch (p) {
       case "connected":
-        X.current = "", oe.current = !1;
+        oe.current = "", fe.current = !1;
         break;
       case "text": {
-        const s = i.delta ?? "";
-        s && Ke(s);
+        const R = w.delta ?? "";
+        R && St(R);
         break;
       }
       case "audio": {
-        const s = i.chunk, a = i.visemes ?? [];
-        s && Je(s, a);
+        const R = w.chunk, E = w.visemes ?? [];
+        R && ot(R, E);
         break;
       }
       case "done": {
-        const s = Qe(), a = K.current.trim(), n = [
-          ...s,
-          { role: "user", content: E || "..." },
-          { role: "assistant", content: a }
+        const R = yt(), E = ae.current.trim(), _ = [
+          ...R,
+          { role: "user", content: i || "..." },
+          { role: "assistant", content: E }
         ];
-        ft(n), b.current = [...se.current], L("Ready"), W(!1), R("");
+        an(_), C.current = [...D.current], u("Ready"), f(!1), s("");
         break;
       }
       case "error": {
-        const s = i.message ?? "Unknown error";
-        K.current = s, re(s), L("Agent Failed"), W(!1);
+        const R = w.message ?? "Unknown error";
+        ae.current = R, o(R), u("Agent Failed"), f(!1);
         break;
       }
     }
-  }, yt = async (e) => {
-    W(!0), L("Thinking..."), K.current = "", X.current = "", oe.current = !1, je(), g.current = 0, ee(0);
-    const i = `${at}/agent/chat?token=${encodeURIComponent(p)}`;
+  }, gn = async (p) => {
+    f(!0), u("Thinking..."), ae.current = "", oe.current = "", fe.current = !1, it(), O.current = 0, ue(0);
+    const w = `${Vt}/agent/chat?token=${encodeURIComponent(r)}`;
     try {
-      const s = Qe();
-      let a = sessionStorage.getItem("STREAMOJI_LEADS_SESSION_LEAD_ID");
-      a || (Ct("[CHAT] Session UID missing at send time! Generating emergency backup."), a = "emergency-" + Math.random().toString(36).substring(7), sessionStorage.setItem("STREAMOJI_LEADS_SESSION_LEAD_ID", a));
-      const n = {
-        history: s,
-        question: e,
-        lead_id: a
+      const R = yt();
+      let E = sessionStorage.getItem("STREAMOJI_LEADS_SESSION_LEAD_ID");
+      E || (Ks("[CHAT] Session UID missing at send time! Generating emergency backup."), E = "emergency-" + Math.random().toString(36).substring(7), sessionStorage.setItem("STREAMOJI_LEADS_SESSION_LEAD_ID", E));
+      const _ = {
+        history: R,
+        question: p,
+        lead_id: E
       };
-      H("[CHAT] Sending payload:", n);
-      const u = await fetch(i, {
+      Q("[CHAT] Sending payload:", _);
+      const I = await fetch(w, {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(n)
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(_),
+        cache: "default"
       });
-      if (!u.ok)
+      if (!I.ok)
         throw new Error("Agent request failed");
-      const w = u.body;
-      if (!w) {
-        L("Agent Failed"), W(!1);
+      const G = I.body;
+      if (!G) {
+        u("Agent Failed"), f(!1);
         return;
       }
-      const x = w.getReader(), V = new TextDecoder();
-      let S = "";
+      const V = G.getReader(), q = new TextDecoder();
+      let j = "";
       for (; ; ) {
-        const { done: F, value: B } = await x.read();
-        H(`[SSE] Chunk received. done=${F}, length=${B?.length || 0}`), B && (S += V.decode(B, { stream: !0 }));
-        const $ = S.split(`
+        const { done: z, value: Y } = await V.read();
+        Q(`[SSE] Chunk received. done=${z}, length=${Y?.length || 0}`), Y && (j += q.decode(Y, { stream: !0 }));
+        const J = j.split(`
 
 `);
-        S = $.pop() ?? "";
-        for (const Y of $) {
-          H(`[SSE] Processing block: ${Y.slice(0, 50)}...`);
-          const U = Fe(Y);
-          U && (H(`[SSE] Event: ${U.event}`), nt(U.event, U.data));
+        j = J.pop() ?? "";
+        for (const re of J) {
+          Q(`[SSE] Processing block: ${re.slice(0, 50)}...`);
+          const $ = qe(re);
+          $ && (Q(`[SSE] Event: ${$.event}`), Mt($.event, $.data));
         }
-        if (F) {
-          if (H("[SSE] Stream finished"), S.trim()) {
-            const Y = Fe(S.trim());
-            Y && nt(Y.event, Y.data);
+        if (z) {
+          if (Q("[SSE] Stream finished"), j.trim()) {
+            const re = qe(j.trim());
+            re && Mt(re.event, re.data);
           }
-          L("Ready"), W(!1), R("");
+          u("Ready"), f(!1), s("");
           break;
         }
       }
-    } catch (s) {
-      console.error("Chat Error:", s), L("Agent Failed"), W(!1);
+    } catch (R) {
+      console.error("Chat Error:", R), u("Agent Failed"), f(!1);
     }
-  }, rt = ge.trim(), qe = rt && A ? rt.slice(0, Z != null && Z > 0 ? Z : 0) : "";
-  z(() => {
-    const e = G.current;
-    e !== "exiting" && (qe ? (fe(qe), e === "hidden" && ve("entering")) : (e === "visible" || e === "entering") && ve("exiting"));
-  }, [qe, he]);
-  const xt = Ue(() => {
-    const e = G.current;
-    e === "entering" ? ve("visible") : e === "exiting" && ve("hidden");
+  }, It = a.trim(), at = It && h ? It.slice(0, Z != null && Z > 0 ? Z : 0) : "";
+  ie(() => {
+    const p = se.current;
+    p !== "exiting" && (at ? (_e(at), p === "hidden" && Ee("entering")) : (p === "visible" || p === "entering") && Ee("exiting"));
+  }, [at, be]);
+  const Tn = Ye(() => {
+    const p = se.current;
+    p === "entering" ? Ee("visible") : p === "exiting" && Ee("hidden");
   }, []);
-  return Rt(() => {
-    const e = Te.current;
-    e && (e.scrollTop = e.scrollHeight);
-  }, [J]), /* @__PURE__ */ ne("div", { className: "avatar-widget-container", children: [
-    /* @__PURE__ */ ne("div", { className: "avatar-input-area", children: [
-      D !== "hidden" ? /* @__PURE__ */ f(
+  return _n(() => {
+    const p = Be.current;
+    p && (p.scrollTop = p.scrollHeight);
+  }, [te]), /* @__PURE__ */ de("div", { className: "avatar-widget-container", children: [
+    /* @__PURE__ */ de("div", { className: "avatar-input-area", children: [
+      X !== "hidden" ? /* @__PURE__ */ N(
         "div",
         {
-          className: `avatar-thinking-tab${D === "exiting" ? " avatar-thinking-tab--exiting" : D === "entering" ? " avatar-thinking-tab--entering" : ""}`,
-          onAnimationEnd: lt,
-          children: Le
+          className: `avatar-thinking-tab${X === "exiting" ? " avatar-thinking-tab--exiting" : X === "entering" ? " avatar-thinking-tab--entering" : ""}`,
+          onAnimationEnd: nn,
+          children: Fe
         }
       ) : null,
-      /* @__PURE__ */ f("div", { className: "avatar-input-container", children: /* @__PURE__ */ f("div", { style: { display: "flex", alignItems: "center", width: "100%", height: "100%" }, children: Ve ? /* @__PURE__ */ ne("div", { className: "avatar-input-recording", children: [
-        /* @__PURE__ */ f(
+      /* @__PURE__ */ N("div", { className: "avatar-input-container", children: /* @__PURE__ */ N("div", { style: { display: "flex", alignItems: "center", width: "100%", height: "100%" }, children: tt ? /* @__PURE__ */ de("div", { className: "avatar-input-recording", children: [
+        /* @__PURE__ */ N(
           "button",
           {
             type: "button",
             className: "avatar-recording-cancel",
-            onClick: _t,
+            onClick: fn,
             title: "Cancel",
-            children: /* @__PURE__ */ ne("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2.5", strokeLinecap: "round", strokeLinejoin: "round", style: { display: "block" }, children: [
-              /* @__PURE__ */ f("line", { x1: "18", y1: "6", x2: "6", y2: "18" }),
-              /* @__PURE__ */ f("line", { x1: "6", y1: "6", x2: "18", y2: "18" })
+            children: /* @__PURE__ */ de("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2.5", strokeLinecap: "round", strokeLinejoin: "round", style: { display: "block" }, children: [
+              /* @__PURE__ */ N("line", { x1: "18", y1: "6", x2: "6", y2: "18" }),
+              /* @__PURE__ */ N("line", { x1: "6", y1: "6", x2: "18", y2: "18" })
             ] })
           }
         ),
-        /* @__PURE__ */ ne("div", { style: { flex: 1, height: "100%", position: "relative", display: "flex", alignItems: "center", minWidth: 0 }, children: [
-          /* @__PURE__ */ f("div", { style: { flex: 1, height: "100%" }, children: /* @__PURE__ */ f(ot, { analyser: mt }) }),
-          /* @__PURE__ */ ne("span", { style: {
+        /* @__PURE__ */ de("div", { style: { flex: 1, height: "100%", position: "relative", display: "flex", alignItems: "center", minWidth: 0 }, children: [
+          /* @__PURE__ */ N("div", { style: { flex: 1, height: "100%" }, children: /* @__PURE__ */ N(jt, { analyser: un }) }),
+          /* @__PURE__ */ de("span", { style: {
             fontSize: "0.75rem",
             color: "#64748b",
             fontWeight: 500,
@@ -932,75 +2636,75 @@ const zt = ({ token: d, agentToken: y, onNavigationRequested: v } = {}) => {
             textAlign: "right",
             fontVariantNumeric: "tabular-nums"
           }, children: [
-            Math.floor(Ze / 60),
+            Math.floor(At / 60),
             ":",
-            String(Ze % 60).padStart(2, "0")
+            String(At % 60).padStart(2, "0")
           ] })
         ] }),
-        /* @__PURE__ */ f(
+        /* @__PURE__ */ N(
           "button",
           {
             type: "button",
             className: "avatar-recording-confirm",
-            onClick: bt,
+            onClick: dn,
             title: "Send",
-            children: /* @__PURE__ */ f("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2.5", strokeLinecap: "round", strokeLinejoin: "round", style: { display: "block" }, children: /* @__PURE__ */ f("polyline", { points: "20 6 9 17 4 12" }) })
+            children: /* @__PURE__ */ N("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2.5", strokeLinecap: "round", strokeLinejoin: "round", style: { display: "block" }, children: /* @__PURE__ */ N("polyline", { points: "20 6 9 17 4 12" }) })
           }
         )
-      ] }) : A ? /* @__PURE__ */ f("div", { style: { flex: 1, height: "100%", display: "flex", alignItems: "center", paddingRight: "8px" }, children: /* @__PURE__ */ f(ot, { analyser: tt }) }) : Q ? /* @__PURE__ */ f("div", { style: { flex: 1, height: "100%", display: "flex", alignItems: "center", justifyContent: "center" }, children: /* @__PURE__ */ f("div", { className: "avatar-input-loader" }) }) : /* @__PURE__ */ ne("form", { onSubmit: St, style: { flex: 1, display: "flex", height: "100%", alignItems: "center" }, children: [
-        /* @__PURE__ */ f(
+      ] }) : h ? /* @__PURE__ */ N("div", { style: { flex: 1, height: "100%", display: "flex", alignItems: "center", paddingRight: "8px" }, children: /* @__PURE__ */ N(jt, { analyser: Lt }) }) : l ? /* @__PURE__ */ N("div", { style: { flex: 1, height: "100%", display: "flex", alignItems: "center", justifyContent: "center" }, children: /* @__PURE__ */ N("div", { className: "avatar-input-loader" }) }) : /* @__PURE__ */ de("form", { onSubmit: mn, style: { flex: 1, display: "flex", height: "100%", alignItems: "center" }, children: [
+        /* @__PURE__ */ N(
           "input",
           {
             id: "avatar-text-input",
             type: "text",
-            value: E,
-            onChange: (e) => R(e.target.value),
+            value: i,
+            onChange: (p) => s(p.target.value),
             placeholder: "Ask me anything",
-            disabled: Q,
+            disabled: l,
             autoComplete: "off",
             style: { width: "100%", height: "100%" }
           }
         ),
-        E.trim() === "" ? /* @__PURE__ */ f(
+        i.trim() === "" ? /* @__PURE__ */ N(
           "button",
           {
             type: "button",
             className: "mic-button",
-            onClick: gt,
-            disabled: Q,
+            onClick: ln,
+            disabled: l,
             style: { backgroundColor: "#1e4a5e" },
-            children: /* @__PURE__ */ ne("svg", { width: "28", height: "28", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [
-              /* @__PURE__ */ f("path", { d: "M12 14C13.66 14 15 12.66 15 11V5C15 3.34 13.66 2 12 2C10.34 2 9 3.34 9 5V11C9 12.66 10.34 14 12 14Z", fill: "white" }),
-              /* @__PURE__ */ f("path", { d: "M17 11C17 13.76 14.76 16 12 16C9.24 16 7 13.76 7 11H5C5 14.53 7.61 17.43 11 17.93V21H13V17.93C16.39 17.43 19 14.53 19 11H17Z", fill: "white" })
+            children: /* @__PURE__ */ de("svg", { width: "28", height: "28", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [
+              /* @__PURE__ */ N("path", { d: "M12 14C13.66 14 15 12.66 15 11V5C15 3.34 13.66 2 12 2C10.34 2 9 3.34 9 5V11C9 12.66 10.34 14 12 14Z", fill: "white" }),
+              /* @__PURE__ */ N("path", { d: "M17 11C17 13.76 14.76 16 12 16C9.24 16 7 13.76 7 11H5C5 14.53 7.61 17.43 11 17.93V21H13V17.93C16.39 17.43 19 14.53 19 11H17Z", fill: "white" })
             ] })
           }
-        ) : /* @__PURE__ */ f(
+        ) : /* @__PURE__ */ N(
           "button",
           {
             type: "submit",
             className: "mic-button",
-            disabled: Q,
+            disabled: l,
             style: { backgroundColor: "#1e4a5e" },
             title: "Send",
-            children: /* @__PURE__ */ ne("svg", { width: "22", height: "22", viewBox: "0 0 24 24", fill: "none", "aria-hidden": "true", children: [
-              /* @__PURE__ */ f("path", { d: "M22 2L11 13", stroke: "white", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }),
-              /* @__PURE__ */ f("path", { d: "M22 2L15 22L11 13L2 9L22 2Z", stroke: "white", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" })
+            children: /* @__PURE__ */ de("svg", { width: "22", height: "22", viewBox: "0 0 24 24", fill: "none", "aria-hidden": "true", children: [
+              /* @__PURE__ */ N("path", { d: "M22 2L11 13", stroke: "white", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }),
+              /* @__PURE__ */ N("path", { d: "M22 2L15 22L11 13L2 9L22 2Z", stroke: "white", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" })
             ] })
           }
         )
       ] }) }) })
     ] }),
-    /* @__PURE__ */ f("div", { className: "avatar-wrapper", children: /* @__PURE__ */ ne("div", { className: "avatar-scene-wrapper", children: [
-      he !== "hidden" && /* @__PURE__ */ f(
+    /* @__PURE__ */ N("div", { className: "avatar-wrapper", children: /* @__PURE__ */ de("div", { className: "avatar-scene-wrapper", children: [
+      be !== "hidden" && /* @__PURE__ */ N(
         "div",
         {
-          className: `avatar-bubble${he === "entering" ? " avatar-bubble--entering" : he === "exiting" ? " avatar-bubble--exiting" : ""}`,
-          onAnimationEnd: xt,
-          children: /* @__PURE__ */ f("div", { ref: Te, className: "avatar-bubble__content", children: J })
+          className: `avatar-bubble${be === "entering" ? " avatar-bubble--entering" : be === "exiting" ? " avatar-bubble--exiting" : ""}`,
+          onAnimationEnd: Tn,
+          children: /* @__PURE__ */ N("div", { ref: Be, className: "avatar-bubble__content", children: te })
         }
       ),
-      /* @__PURE__ */ f("div", { className: "avatar-canvas-layer", style: { width: 600, height: 600 }, children: /* @__PURE__ */ ne(
-        Mt,
+      /* @__PURE__ */ N("div", { className: "avatar-canvas-layer", style: { width: 600, height: 600 }, children: /* @__PURE__ */ de(
+        Rn,
         {
           shadows: !0,
           camera: { position: [0.2, 1.4, 3], fov: 42 },
@@ -1008,28 +2712,28 @@ const zt = ({ token: d, agentToken: y, onNavigationRequested: v } = {}) => {
           dpr: 1.8,
           style: { pointerEvents: "none", width: "100%", height: "100%" },
           children: [
-            /* @__PURE__ */ f(qt, { target: Vt }),
-            /* @__PURE__ */ f("ambientLight", { intensity: 0.7 }),
-            /* @__PURE__ */ f("directionalLight", { position: [0, 2, 2], intensity: 1 }),
-            /* @__PURE__ */ f(Tt, { preset: "city" }),
-            /* @__PURE__ */ f(Lt, { fallback: null, children: I !== null && /* @__PURE__ */ f(
-              Gt,
+            /* @__PURE__ */ N(rr, { target: Qs }),
+            /* @__PURE__ */ N("ambientLight", { intensity: 0.7 }),
+            /* @__PURE__ */ N("directionalLight", { position: [0, 2, 2], intensity: 1 }),
+            /* @__PURE__ */ N(yn, { preset: "city" }),
+            /* @__PURE__ */ N(xn, { fallback: null, children: n !== null && /* @__PURE__ */ N(
+              ir,
               {
-                avatarUrl: I,
-                isPlayingRef: ue,
-                visemeQueueRef: se,
-                audioContextRef: N,
-                responseAudioStartTimeRef: P,
-                adjustments: Pt,
-                mood: _e,
-                expression: We,
-                agentResponse: ge,
-                isSpeaking: A,
-                nextStartTimeRef: M,
-                stopPlayback: je,
-                setIsSpeaking: le,
-                expressionUrl: h,
-                onExpressionFinished: ht
+                avatarUrl: n,
+                isPlayingRef: P,
+                visemeQueueRef: D,
+                audioContextRef: y,
+                responseAudioStartTimeRef: H,
+                adjustments: Js,
+                mood: ye,
+                expression: Ze,
+                agentResponse: a,
+                isSpeaking: h,
+                nextStartTimeRef: B,
+                stopPlayback: it,
+                setIsSpeaking: T,
+                expressionUrl: v,
+                onExpressionFinished: on
               }
             ) })
           ]
@@ -1037,17 +2741,17 @@ const zt = ({ token: d, agentToken: y, onNavigationRequested: v } = {}) => {
       ) })
     ] }) })
   ] });
-}, tn = ({
+}, hr = ({
   token: d,
-  onNavigationRequested: y
-}) => /* @__PURE__ */ f(
-  zt,
+  onNavigationRequested: t
+}) => /* @__PURE__ */ N(
+  ar,
   {
     token: d,
-    onNavigationRequested: y
+    onNavigationRequested: t
   }
 );
 export {
-  tn as AvatarWidget
+  hr as AvatarWidget
 };
 //# sourceMappingURL=avatar-widget.js.map