@limrun/ui 0.16.0 → 0.17.0-rc.2

package/dist/GLTFLoader-Cami_vza.mjs

@@ -0,0 +1,1679 @@
+import { L as Ae, a as G, F as he, M as w, V as fe, C as F, b, S as U, c as Le, P as Me, D as Se, d as K, e as C, I as ye, Q as de, f as we, O as pe, T as be, g as Ne, B as V, h as Ie, i as me, N as Oe, j as Ce, k as Fe, l as Q, m as ge, R as J, n as Pe, o as ke, p as He, q as z, r as De, s as Te, t as ve, u as v, v as Ge, w as Ue, x as Ke, y as Be, z as ee, A as je, E as Ve, G as ze, H as Xe, J as X, K as qe, U as We, W as Ye, X as Qe, Y as Je, Z as Ze, _ as $e, $ as Re, a0 as en, a1 as ne, a2 as te, a3 as se, a4 as ie, a5 as re, a6 as nn, a7 as tn, a8 as sn, a9 as rn, aa as on, ab as an } from "./duo-frame-Cmw4p2uN.mjs";
+function cn(f) {
+  const n = /* @__PURE__ */ new Map(), e = /* @__PURE__ */ new Map(), t = f.clone();
+  return Ee(f, t, function(s, i) {
+    n.set(i, s), e.set(s, i);
+  }), t.traverse(function(s) {
+    if (!s.isSkinnedMesh) return;
+    const i = s, o = n.get(s), a = o.skeleton.bones;
+    i.skeleton = o.skeleton.clone(), i.bindMatrix.copy(o.bindMatrix), i.skeleton.bones = a.map(function(r) {
+      return e.get(r);
+    }), i.bind(i.skeleton, i.bindMatrix);
+  }), t;
+}
+function Ee(f, n, e) {
+  e(f, n);
+  for (let t = 0; t < f.children.length; t++)
+    Ee(f.children[t], n.children[t], e);
+}
+class jn extends Ae {
+  /**
+   * Constructs a new glTF loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
+  constructor(n) {
+    super(n), this.dracoLoader = null, this.ktx2Loader = null, this.meshoptDecoder = null, this.pluginCallbacks = [], this.register(function(e) {
+      return new dn(e);
+    }), this.register(function(e) {
+      return new pn(e);
+    }), this.register(function(e) {
+      return new Ln(e);
+    }), this.register(function(e) {
+      return new Mn(e);
+    }), this.register(function(e) {
+      return new Sn(e);
+    }), this.register(function(e) {
+      return new gn(e);
+    }), this.register(function(e) {
+      return new Tn(e);
+    }), this.register(function(e) {
+      return new Rn(e);
+    }), this.register(function(e) {
+      return new En(e);
+    }), this.register(function(e) {
+      return new fn(e);
+    }), this.register(function(e) {
+      return new xn(e);
+    }), this.register(function(e) {
+      return new mn(e);
+    }), this.register(function(e) {
+      return new An(e);
+    }), this.register(function(e) {
+      return new _n(e);
+    }), this.register(function(e) {
+      return new ln(e);
+    }), this.register(function(e) {
+      return new oe(e, g.EXT_MESHOPT_COMPRESSION);
+    }), this.register(function(e) {
+      return new oe(e, g.KHR_MESHOPT_COMPRESSION);
+    }), this.register(function(e) {
+      return new yn(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(n, e, t, s) {
+    const i = this;
+    let o;
+    if (this.resourcePath !== "")
+      o = this.resourcePath;
+    else if (this.path !== "") {
+      const c = G.extractUrlBase(n);
+      o = G.resolveURL(c, this.path);
+    } else
+      o = G.extractUrlBase(n);
+    this.manager.itemStart(n);
+    const a = function(c) {
+      s ? s(c) : console.error(c), i.manager.itemError(n), i.manager.itemEnd(n);
+    }, r = new he(this.manager);
+    r.setPath(this.path), r.setResponseType("arraybuffer"), r.setRequestHeader(this.requestHeader), r.setWithCredentials(this.withCredentials), r.load(n, function(c) {
+      try {
+        i.parse(c, o, function(l) {
+          e(l), i.manager.itemEnd(n);
+        }, a);
+      } catch (l) {
+        a(l);
+      }
+    }, t, 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(n) {
+    return this.dracoLoader = n, 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(n) {
+    return this.ktx2Loader = n, 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(n) {
+    return this.meshoptDecoder = n, 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(n) {
+    return this.pluginCallbacks.indexOf(n) === -1 && this.pluginCallbacks.push(n), this;
+  }
+  /**
+   * Unregisters a plugin callback.
+   *
+   * @param {Function} callback - The callback function to unregister.
+   * @return {GLTFLoader} A reference to this loader.
+   */
+  unregister(n) {
+    return this.pluginCallbacks.indexOf(n) !== -1 && this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(n), 1), this;
+  }
+  /**
+   * Parses the given glTF 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(n, e, t, s) {
+    let i;
+    const o = {}, a = {}, r = new TextDecoder();
+    if (typeof n == "string")
+      i = JSON.parse(n);
+    else if (n instanceof ArrayBuffer)
+      if (r.decode(new Uint8Array(n, 0, 4)) === xe) {
+        try {
+          o[g.KHR_BINARY_GLTF] = new wn(n);
+        } catch (u) {
+          s && s(u);
+          return;
+        }
+        i = JSON.parse(o[g.KHR_BINARY_GLTF].content);
+      } else
+        i = JSON.parse(r.decode(n));
+    else
+      i = n;
+    if (i.asset === void 0 || i.asset.version[0] < 2) {
+      s && s(new Error("THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported."));
+      return;
+    }
+    const c = new Un(i, {
+      path: e || this.resourcePath || "",
+      crossOrigin: this.crossOrigin,
+      requestHeader: this.requestHeader,
+      manager: this.manager,
+      ktx2Loader: this.ktx2Loader,
+      meshoptDecoder: this.meshoptDecoder
+    });
+    c.fileLoader.setRequestHeader(this.requestHeader);
+    for (let l = 0; l < this.pluginCallbacks.length; l++) {
+      const u = this.pluginCallbacks[l](c);
+      u.name || console.error("THREE.GLTFLoader: Invalid plugin found: missing name"), a[u.name] = u, o[u.name] = !0;
+    }
+    if (i.extensionsUsed)
+      for (let l = 0; l < i.extensionsUsed.length; ++l) {
+        const u = i.extensionsUsed[l], h = i.extensionsRequired || [];
+        switch (u) {
+          case g.KHR_MATERIALS_UNLIT:
+            o[u] = new hn();
+            break;
+          case g.KHR_DRACO_MESH_COMPRESSION:
+            o[u] = new bn(i, this.dracoLoader);
+            break;
+          case g.KHR_TEXTURE_TRANSFORM:
+            o[u] = new Nn();
+            break;
+          case g.KHR_MESH_QUANTIZATION:
+            o[u] = new In();
+            break;
+          default:
+            h.indexOf(u) >= 0 && a[u] === void 0 && console.warn('THREE.GLTFLoader: Unknown extension "' + u + '".');
+        }
+      }
+    c.setExtensions(o), c.setPlugins(a), c.parse(t, s);
+  }
+  /**
+   * 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(n, e) {
+    const t = this;
+    return new Promise(function(s, i) {
+      t.parse(n, e, s, i);
+    });
+  }
+}
+function un() {
+  let f = {};
+  return {
+    get: function(n) {
+      return f[n];
+    },
+    add: function(n, e) {
+      f[n] = e;
+    },
+    remove: function(n) {
+      delete f[n];
+    },
+    removeAll: function() {
+      f = {};
+    }
+  };
+}
+function A(f, n, e) {
+  const t = f.json.materials[n];
+  return t.extensions && t.extensions[e] ? t.extensions[e] : null;
+}
+const g = {
+  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",
+  KHR_MESHOPT_COMPRESSION: "KHR_meshopt_compression",
+  EXT_MESH_GPU_INSTANCING: "EXT_mesh_gpu_instancing"
+};
+class ln {
+  constructor(n) {
+    this.parser = n, this.name = g.KHR_LIGHTS_PUNCTUAL, this.cache = { refs: {}, uses: {} };
+  }
+  _markDefs() {
+    const n = this.parser, e = this.parser.json.nodes || [];
+    for (let t = 0, s = e.length; t < s; t++) {
+      const i = e[t];
+      i.extensions && i.extensions[this.name] && i.extensions[this.name].light !== void 0 && n._addNodeRef(this.cache, i.extensions[this.name].light);
+    }
+  }
+  _loadLight(n) {
+    const e = this.parser, t = "light:" + n;
+    let s = e.cache.get(t);
+    if (s) return s;
+    const i = e.json, r = ((i.extensions && i.extensions[this.name] || {}).lights || [])[n];
+    let c;
+    const l = new F(16777215);
+    r.color !== void 0 && l.setRGB(r.color[0], r.color[1], r.color[2], b);
+    const u = r.range !== void 0 ? r.range : 0;
+    switch (r.type) {
+      case "directional":
+        c = new Se(l), c.target.position.set(0, 0, -1), c.add(c.target);
+        break;
+      case "point":
+        c = new Me(l), c.distance = u;
+        break;
+      case "spot":
+        c = new Le(l), c.distance = u, r.spot = r.spot || {}, r.spot.innerConeAngle = r.spot.innerConeAngle !== void 0 ? r.spot.innerConeAngle : 0, r.spot.outerConeAngle = r.spot.outerConeAngle !== void 0 ? r.spot.outerConeAngle : Math.PI / 4, c.angle = r.spot.outerConeAngle, c.penumbra = 1 - r.spot.innerConeAngle / r.spot.outerConeAngle, c.target.position.set(0, 0, -1), c.add(c.target);
+        break;
+      default:
+        throw new Error("THREE.GLTFLoader: Unexpected light type: " + r.type);
+    }
+    return c.position.set(0, 0, 0), y(c, r), r.intensity !== void 0 && (c.intensity = r.intensity), c.name = e.createUniqueName(r.name || "light_" + n), s = Promise.resolve(c), e.cache.add(t, s), s;
+  }
+  getDependency(n, e) {
+    if (n === "light")
+      return this._loadLight(e);
+  }
+  createNodeAttachment(n) {
+    const e = this, t = this.parser, i = t.json.nodes[n], a = (i.extensions && i.extensions[this.name] || {}).light;
+    return a === void 0 ? null : this._loadLight(a).then(function(r) {
+      return t._getNodeRef(e.cache, a, r);
+    });
+  }
+}
+class hn {
+  constructor() {
+    this.name = g.KHR_MATERIALS_UNLIT;
+  }
+  getMaterialType() {
+    return v;
+  }
+  extendParams(n, e, t) {
+    const s = [];
+    n.color = new F(1, 1, 1), n.opacity = 1;
+    const i = e.pbrMetallicRoughness;
+    if (i) {
+      if (Array.isArray(i.baseColorFactor)) {
+        const o = i.baseColorFactor;
+        n.color.setRGB(o[0], o[1], o[2], b), n.opacity = o[3];
+      }
+      i.baseColorTexture !== void 0 && s.push(t.assignTexture(n, "map", i.baseColorTexture, U));
+    }
+    return Promise.all(s);
+  }
+}
+class fn {
+  constructor(n) {
+    this.parser = n, this.name = g.KHR_MATERIALS_EMISSIVE_STRENGTH;
+  }
+  extendMaterialParams(n, e) {
+    const t = A(this.parser, n, this.name);
+    return t === null || t.emissiveStrength !== void 0 && (e.emissiveIntensity = t.emissiveStrength), Promise.resolve();
+  }
+}
+class dn {
+  constructor(n) {
+    this.parser = n, this.name = g.KHR_MATERIALS_CLEARCOAT;
+  }
+  getMaterialType(n) {
+    return A(this.parser, n, this.name) !== null ? w : null;
+  }
+  extendMaterialParams(n, e) {
+    const t = A(this.parser, n, this.name);
+    if (t === null) return Promise.resolve();
+    const s = [];
+    if (t.clearcoatFactor !== void 0 && (e.clearcoat = t.clearcoatFactor), t.clearcoatTexture !== void 0 && s.push(this.parser.assignTexture(e, "clearcoatMap", t.clearcoatTexture)), t.clearcoatRoughnessFactor !== void 0 && (e.clearcoatRoughness = t.clearcoatRoughnessFactor), t.clearcoatRoughnessTexture !== void 0 && s.push(this.parser.assignTexture(e, "clearcoatRoughnessMap", t.clearcoatRoughnessTexture)), t.clearcoatNormalTexture !== void 0 && (s.push(this.parser.assignTexture(e, "clearcoatNormalMap", t.clearcoatNormalTexture)), t.clearcoatNormalTexture.scale !== void 0)) {
+      const i = t.clearcoatNormalTexture.scale;
+      e.clearcoatNormalScale = new fe(i, i);
+    }
+    return Promise.all(s);
+  }
+}
+class pn {
+  constructor(n) {
+    this.parser = n, this.name = g.KHR_MATERIALS_DISPERSION;
+  }
+  getMaterialType(n) {
+    return A(this.parser, n, this.name) !== null ? w : null;
+  }
+  extendMaterialParams(n, e) {
+    const t = A(this.parser, n, this.name);
+    return t === null || (e.dispersion = t.dispersion !== void 0 ? t.dispersion : 0), Promise.resolve();
+  }
+}
+class mn {
+  constructor(n) {
+    this.parser = n, this.name = g.KHR_MATERIALS_IRIDESCENCE;
+  }
+  getMaterialType(n) {
+    return A(this.parser, n, this.name) !== null ? w : null;
+  }
+  extendMaterialParams(n, e) {
+    const t = A(this.parser, n, this.name);
+    if (t === null) return Promise.resolve();
+    const s = [];
+    return t.iridescenceFactor !== void 0 && (e.iridescence = t.iridescenceFactor), t.iridescenceTexture !== void 0 && s.push(this.parser.assignTexture(e, "iridescenceMap", t.iridescenceTexture)), t.iridescenceIor !== void 0 && (e.iridescenceIOR = t.iridescenceIor), e.iridescenceThicknessRange === void 0 && (e.iridescenceThicknessRange = [100, 400]), t.iridescenceThicknessMinimum !== void 0 && (e.iridescenceThicknessRange[0] = t.iridescenceThicknessMinimum), t.iridescenceThicknessMaximum !== void 0 && (e.iridescenceThicknessRange[1] = t.iridescenceThicknessMaximum), t.iridescenceThicknessTexture !== void 0 && s.push(this.parser.assignTexture(e, "iridescenceThicknessMap", t.iridescenceThicknessTexture)), Promise.all(s);
+  }
+}
+class gn {
+  constructor(n) {
+    this.parser = n, this.name = g.KHR_MATERIALS_SHEEN;
+  }
+  getMaterialType(n) {
+    return A(this.parser, n, this.name) !== null ? w : null;
+  }
+  extendMaterialParams(n, e) {
+    const t = A(this.parser, n, this.name);
+    if (t === null) return Promise.resolve();
+    const s = [];
+    if (e.sheenColor = new F(0, 0, 0), e.sheenRoughness = 0, e.sheen = 1, t.sheenColorFactor !== void 0) {
+      const i = t.sheenColorFactor;
+      e.sheenColor.setRGB(i[0], i[1], i[2], b);
+    }
+    return t.sheenRoughnessFactor !== void 0 && (e.sheenRoughness = t.sheenRoughnessFactor), t.sheenColorTexture !== void 0 && s.push(this.parser.assignTexture(e, "sheenColorMap", t.sheenColorTexture, U)), t.sheenRoughnessTexture !== void 0 && s.push(this.parser.assignTexture(e, "sheenRoughnessMap", t.sheenRoughnessTexture)), Promise.all(s);
+  }
+}
+class Tn {
+  constructor(n) {
+    this.parser = n, this.name = g.KHR_MATERIALS_TRANSMISSION;
+  }
+  getMaterialType(n) {
+    return A(this.parser, n, this.name) !== null ? w : null;
+  }
+  extendMaterialParams(n, e) {
+    const t = A(this.parser, n, this.name);
+    if (t === null) return Promise.resolve();
+    const s = [];
+    return t.transmissionFactor !== void 0 && (e.transmission = t.transmissionFactor), t.transmissionTexture !== void 0 && s.push(this.parser.assignTexture(e, "transmissionMap", t.transmissionTexture)), Promise.all(s);
+  }
+}
+class Rn {
+  constructor(n) {
+    this.parser = n, this.name = g.KHR_MATERIALS_VOLUME;
+  }
+  getMaterialType(n) {
+    return A(this.parser, n, this.name) !== null ? w : null;
+  }
+  extendMaterialParams(n, e) {
+    const t = A(this.parser, n, this.name);
+    if (t === null) return Promise.resolve();
+    const s = [];
+    e.thickness = t.thicknessFactor !== void 0 ? t.thicknessFactor : 0, t.thicknessTexture !== void 0 && s.push(this.parser.assignTexture(e, "thicknessMap", t.thicknessTexture)), e.attenuationDistance = t.attenuationDistance || 1 / 0;
+    const i = t.attenuationColor || [1, 1, 1];
+    return e.attenuationColor = new F().setRGB(i[0], i[1], i[2], b), Promise.all(s);
+  }
+}
+class En {
+  constructor(n) {
+    this.parser = n, this.name = g.KHR_MATERIALS_IOR;
+  }
+  getMaterialType(n) {
+    return A(this.parser, n, this.name) !== null ? w : null;
+  }
+  extendMaterialParams(n, e) {
+    const t = A(this.parser, n, this.name);
+    return t === null || (e.ior = t.ior !== void 0 ? t.ior : 1.5), Promise.resolve();
+  }
+}
+class xn {
+  constructor(n) {
+    this.parser = n, this.name = g.KHR_MATERIALS_SPECULAR;
+  }
+  getMaterialType(n) {
+    return A(this.parser, n, this.name) !== null ? w : null;
+  }
+  extendMaterialParams(n, e) {
+    const t = A(this.parser, n, this.name);
+    if (t === null) return Promise.resolve();
+    const s = [];
+    e.specularIntensity = t.specularFactor !== void 0 ? t.specularFactor : 1, t.specularTexture !== void 0 && s.push(this.parser.assignTexture(e, "specularIntensityMap", t.specularTexture));
+    const i = t.specularColorFactor || [1, 1, 1];
+    return e.specularColor = new F().setRGB(i[0], i[1], i[2], b), t.specularColorTexture !== void 0 && s.push(this.parser.assignTexture(e, "specularColorMap", t.specularColorTexture, U)), Promise.all(s);
+  }
+}
+class _n {
+  constructor(n) {
+    this.parser = n, this.name = g.EXT_MATERIALS_BUMP;
+  }
+  getMaterialType(n) {
+    return A(this.parser, n, this.name) !== null ? w : null;
+  }
+  extendMaterialParams(n, e) {
+    const t = A(this.parser, n, this.name);
+    if (t === null) return Promise.resolve();
+    const s = [];
+    return e.bumpScale = t.bumpFactor !== void 0 ? t.bumpFactor : 1, t.bumpTexture !== void 0 && s.push(this.parser.assignTexture(e, "bumpMap", t.bumpTexture)), Promise.all(s);
+  }
+}
+class An {
+  constructor(n) {
+    this.parser = n, this.name = g.KHR_MATERIALS_ANISOTROPY;
+  }
+  getMaterialType(n) {
+    return A(this.parser, n, this.name) !== null ? w : null;
+  }
+  extendMaterialParams(n, e) {
+    const t = A(this.parser, n, this.name);
+    if (t === null) return Promise.resolve();
+    const s = [];
+    return t.anisotropyStrength !== void 0 && (e.anisotropy = t.anisotropyStrength), t.anisotropyRotation !== void 0 && (e.anisotropyRotation = t.anisotropyRotation), t.anisotropyTexture !== void 0 && s.push(this.parser.assignTexture(e, "anisotropyMap", t.anisotropyTexture)), Promise.all(s);
+  }
+}
+class Ln {
+  constructor(n) {
+    this.parser = n, this.name = g.KHR_TEXTURE_BASISU;
+  }
+  loadTexture(n) {
+    const e = this.parser, t = e.json, s = t.textures[n];
+    if (!s.extensions || !s.extensions[this.name])
+      return null;
+    const i = s.extensions[this.name], o = e.options.ktx2Loader;
+    if (!o) {
+      if (t.extensionsRequired && t.extensionsRequired.indexOf(this.name) >= 0)
+        throw new Error("THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures");
+      return null;
+    }
+    return e.loadTextureImage(n, i.source, o);
+  }
+}
+class Mn {
+  constructor(n) {
+    this.parser = n, this.name = g.EXT_TEXTURE_WEBP;
+  }
+  loadTexture(n) {
+    const e = this.name, t = this.parser, s = t.json, i = s.textures[n];
+    if (!i.extensions || !i.extensions[e])
+      return null;
+    const o = i.extensions[e], a = s.images[o.source];
+    let r = t.textureLoader;
+    if (a.uri) {
+      const c = t.options.manager.getHandler(a.uri);
+      c !== null && (r = c);
+    }
+    return t.loadTextureImage(n, o.source, r);
+  }
+}
+class Sn {
+  constructor(n) {
+    this.parser = n, this.name = g.EXT_TEXTURE_AVIF;
+  }
+  loadTexture(n) {
+    const e = this.name, t = this.parser, s = t.json, i = s.textures[n];
+    if (!i.extensions || !i.extensions[e])
+      return null;
+    const o = i.extensions[e], a = s.images[o.source];
+    let r = t.textureLoader;
+    if (a.uri) {
+      const c = t.options.manager.getHandler(a.uri);
+      c !== null && (r = c);
+    }
+    return t.loadTextureImage(n, o.source, r);
+  }
+}
+class oe {
+  constructor(n, e) {
+    this.name = e, this.parser = n;
+  }
+  loadBufferView(n) {
+    const e = this.parser.json, t = e.bufferViews[n];
+    if (t.extensions && t.extensions[this.name]) {
+      const s = t.extensions[this.name], i = this.parser.getDependency("buffer", s.buffer), o = this.parser.options.meshoptDecoder;
+      if (!o || !o.supported) {
+        if (e.extensionsRequired && e.extensionsRequired.indexOf(this.name) >= 0)
+          throw new Error("THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files");
+        return null;
+      }
+      return i.then(function(a) {
+        const r = s.byteOffset || 0, c = s.byteLength || 0, l = s.count, u = s.byteStride, h = new Uint8Array(a, r, c);
+        return o.decodeGltfBufferAsync ? o.decodeGltfBufferAsync(l, u, h, s.mode, s.filter).then(function(d) {
+          return d.buffer;
+        }) : o.ready.then(function() {
+          const d = new ArrayBuffer(l * u);
+          return o.decodeGltfBuffer(new Uint8Array(d), l, u, h, s.mode, s.filter), d;
+        });
+      });
+    } else
+      return null;
+  }
+}
+class yn {
+  constructor(n) {
+    this.name = g.EXT_MESH_GPU_INSTANCING, this.parser = n;
+  }
+  createNodeMesh(n) {
+    const e = this.parser.json, t = e.nodes[n];
+    if (!t.extensions || !t.extensions[this.name] || t.mesh === void 0)
+      return null;
+    const s = e.meshes[t.mesh];
+    for (const c of s.primitives)
+      if (c.mode !== M.TRIANGLES && c.mode !== M.TRIANGLE_STRIP && c.mode !== M.TRIANGLE_FAN && c.mode !== void 0)
+        return null;
+    const o = t.extensions[this.name].attributes, a = [], r = {};
+    for (const c in o)
+      a.push(this.parser.getDependency("accessor", o[c]).then((l) => (r[c] = l, r[c])));
+    return a.length < 1 ? null : (a.push(this.parser.createNodeMesh(n)), Promise.all(a).then((c) => {
+      const l = c.pop(), u = l.isGroup ? l.children : [l], h = c[0].count, d = [];
+      for (const p of u) {
+        const R = new K(), m = new C(), T = new de(), _ = new C(1, 1, 1), x = new ye(p.geometry, p.material, h);
+        for (let E = 0; E < h; E++)
+          r.TRANSLATION && m.fromBufferAttribute(r.TRANSLATION, E), r.ROTATION && T.fromBufferAttribute(r.ROTATION, E), r.SCALE && _.fromBufferAttribute(r.SCALE, E), x.setMatrixAt(E, R.compose(m, T, _));
+        for (const E in r)
+          if (E === "_COLOR_0") {
+            const L = r[E];
+            x.instanceColor = new we(L.array, L.itemSize, L.normalized);
+          } else E !== "TRANSLATION" && E !== "ROTATION" && E !== "SCALE" && p.geometry.setAttribute(E, r[E]);
+        pe.prototype.copy.call(x, p), this.parser.assignFinalMaterial(x), d.push(x);
+      }
+      return l.isGroup ? (l.clear(), l.add(...d), l) : d[0];
+    }));
+  }
+}
+const xe = "glTF", D = 12, ae = { JSON: 1313821514, BIN: 5130562 };
+class wn {
+  constructor(n) {
+    this.name = g.KHR_BINARY_GLTF, this.content = null, this.body = null;
+    const e = new DataView(n, 0, D), t = new TextDecoder();
+    if (this.header = {
+      magic: t.decode(new Uint8Array(n.slice(0, 4))),
+      version: e.getUint32(4, !0),
+      length: e.getUint32(8, !0)
+    }, this.header.magic !== xe)
+      throw new Error("THREE.GLTFLoader: Unsupported glTF-Binary header.");
+    if (this.header.version < 2)
+      throw new Error("THREE.GLTFLoader: Legacy binary file detected.");
+    const s = this.header.length - D, i = new DataView(n, D);
+    let o = 0;
+    for (; o < s; ) {
+      const a = i.getUint32(o, !0);
+      o += 4;
+      const r = i.getUint32(o, !0);
+      if (o += 4, r === ae.JSON) {
+        const c = new Uint8Array(n, D + o, a);
+        this.content = t.decode(c);
+      } else if (r === ae.BIN) {
+        const c = D + o;
+        this.body = n.slice(c, c + a);
+      }
+      o += a;
+    }
+    if (this.content === null)
+      throw new Error("THREE.GLTFLoader: JSON content not found.");
+  }
+}
+class bn {
+  constructor(n, e) {
+    if (!e)
+      throw new Error("THREE.GLTFLoader: No DRACOLoader instance provided.");
+    this.name = g.KHR_DRACO_MESH_COMPRESSION, this.json = n, this.dracoLoader = e, this.dracoLoader.preload();
+  }
+  decodePrimitive(n, e) {
+    const t = this.json, s = this.dracoLoader, i = n.extensions[this.name].bufferView, o = n.extensions[this.name].attributes, a = {}, r = {}, c = {};
+    for (const l in o) {
+      const u = Z[l] || l.toLowerCase();
+      a[u] = o[l];
+    }
+    for (const l in n.attributes) {
+      const u = Z[l] || l.toLowerCase();
+      if (o[l] !== void 0) {
+        const h = t.accessors[n.attributes[l]], d = k[h.componentType];
+        c[u] = d.name, r[u] = h.normalized === !0;
+      }
+    }
+    return e.getDependency("bufferView", i).then(function(l) {
+      return new Promise(function(u, h) {
+        s.decodeDracoFile(l, function(d) {
+          for (const p in d.attributes) {
+            const R = d.attributes[p], m = r[p];
+            m !== void 0 && (R.normalized = m);
+          }
+          u(d);
+        }, a, c, b, h);
+      });
+    });
+  }
+}
+class Nn {
+  constructor() {
+    this.name = g.KHR_TEXTURE_TRANSFORM;
+  }
+  extendTexture(n, e) {
+    return (e.texCoord === void 0 || e.texCoord === n.channel) && e.offset === void 0 && e.rotation === void 0 && e.scale === void 0 || (n = n.clone(), e.texCoord !== void 0 && (n.channel = e.texCoord), e.offset !== void 0 && n.offset.fromArray(e.offset), e.rotation !== void 0 && (n.rotation = e.rotation), e.scale !== void 0 && n.repeat.fromArray(e.scale), n.needsUpdate = !0), n;
+  }
+}
+class In {
+  constructor() {
+    this.name = g.KHR_MESH_QUANTIZATION;
+  }
+}
+class _e extends tn {
+  constructor(n, e, t, s) {
+    super(n, e, t, s);
+  }
+  copySampleValue_(n) {
+    const e = this.resultBuffer, t = this.sampleValues, s = this.valueSize, i = n * s * 3 + s;
+    for (let o = 0; o !== s; o++)
+      e[o] = t[i + o];
+    return e;
+  }
+  interpolate_(n, e, t, s) {
+    const i = this.resultBuffer, o = this.sampleValues, a = this.valueSize, r = a * 2, c = a * 3, l = s - e, u = (t - e) / l, h = u * u, d = h * u, p = n * c, R = p - c, m = -2 * d + 3 * h, T = d - h, _ = 1 - m, x = T - h + u;
+    for (let E = 0; E !== a; E++) {
+      const L = o[R + E + a], N = o[R + E + r] * l, S = o[p + E + a], H = o[p + E] * l;
+      i[E] = _ * L + x * N + m * S + T * H;
+    }
+    return i;
+  }
+}
+const On = new de();
+class Cn extends _e {
+  interpolate_(n, e, t, s) {
+    const i = super.interpolate_(n, e, t, s);
+    return On.fromArray(i).normalize().toArray(i), i;
+  }
+}
+const M = {
+  POINTS: 0,
+  LINES: 1,
+  LINE_LOOP: 2,
+  LINE_STRIP: 3,
+  TRIANGLES: 4,
+  TRIANGLE_STRIP: 5,
+  TRIANGLE_FAN: 6
+}, k = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5125: Uint32Array,
+  5126: Float32Array
+}, ce = {
+  9728: ge,
+  9729: Q,
+  9984: Fe,
+  9985: Ce,
+  9986: Oe,
+  9987: me
+}, ue = {
+  33071: ke,
+  33648: Pe,
+  10497: J
+}, q = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+}, Z = {
+  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"
+}, I = {
+  scale: "scale",
+  translation: "position",
+  rotation: "quaternion",
+  weights: "morphTargetInfluences"
+}, Fn = {
+  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: Re,
+  STEP: $e
+}, W = {
+  OPAQUE: "OPAQUE",
+  MASK: "MASK",
+  BLEND: "BLEND"
+};
+function Pn(f) {
+  return f.DefaultMaterial === void 0 && (f.DefaultMaterial = new Te({
+    color: 16777215,
+    emissive: 0,
+    metalness: 1,
+    roughness: 1,
+    transparent: !1,
+    depthTest: !0,
+    side: nn
+  })), f.DefaultMaterial;
+}
+function O(f, n, e) {
+  for (const t in e.extensions)
+    f[t] === void 0 && (n.userData.gltfExtensions = n.userData.gltfExtensions || {}, n.userData.gltfExtensions[t] = e.extensions[t]);
+}
+function y(f, n) {
+  n.extras !== void 0 && (typeof n.extras == "object" ? Object.assign(f.userData, n.extras) : console.warn("THREE.GLTFLoader: Ignoring primitive type .extras, " + n.extras));
+}
+function kn(f, n, e) {
+  let t = !1, s = !1, i = !1;
+  for (let c = 0, l = n.length; c < l; c++) {
+    const u = n[c];
+    if (u.POSITION !== void 0 && (t = !0), u.NORMAL !== void 0 && (s = !0), u.COLOR_0 !== void 0 && (i = !0), t && s && i) break;
+  }
+  if (!t && !s && !i) return Promise.resolve(f);
+  const o = [], a = [], r = [];
+  for (let c = 0, l = n.length; c < l; c++) {
+    const u = n[c];
+    if (t) {
+      const h = u.POSITION !== void 0 ? e.getDependency("accessor", u.POSITION) : f.attributes.position;
+      o.push(h);
+    }
+    if (s) {
+      const h = u.NORMAL !== void 0 ? e.getDependency("accessor", u.NORMAL) : f.attributes.normal;
+      a.push(h);
+    }
+    if (i) {
+      const h = u.COLOR_0 !== void 0 ? e.getDependency("accessor", u.COLOR_0) : f.attributes.color;
+      r.push(h);
+    }
+  }
+  return Promise.all([
+    Promise.all(o),
+    Promise.all(a),
+    Promise.all(r)
+  ]).then(function(c) {
+    const l = c[0], u = c[1], h = c[2];
+    return t && (f.morphAttributes.position = l), s && (f.morphAttributes.normal = u), i && (f.morphAttributes.color = h), f.morphTargetsRelative = !0, f;
+  });
+}
+function Hn(f, n) {
+  if (f.updateMorphTargets(), n.weights !== void 0)
+    for (let e = 0, t = n.weights.length; e < t; e++)
+      f.morphTargetInfluences[e] = n.weights[e];
+  if (n.extras && Array.isArray(n.extras.targetNames)) {
+    const e = n.extras.targetNames;
+    if (f.morphTargetInfluences.length === e.length) {
+      f.morphTargetDictionary = {};
+      for (let t = 0, s = e.length; t < s; t++)
+        f.morphTargetDictionary[e[t]] = t;
+    } else
+      console.warn("THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.");
+  }
+}
+function Dn(f) {
+  let n;
+  const e = f.extensions && f.extensions[g.KHR_DRACO_MESH_COMPRESSION];
+  if (e ? n = "draco:" + e.bufferView + ":" + e.indices + ":" + Y(e.attributes) : n = f.indices + ":" + Y(f.attributes) + ":" + f.mode, f.targets !== void 0)
+    for (let t = 0, s = f.targets.length; t < s; t++)
+      n += ":" + Y(f.targets[t]);
+  return n;
+}
+function Y(f) {
+  let n = "";
+  const e = Object.keys(f).sort();
+  for (let t = 0, s = e.length; t < s; t++)
+    n += e[t] + ":" + f[e[t]] + ";";
+  return n;
+}
+function $(f) {
+  switch (f) {
+    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 vn(f) {
+  return f.search(/\.jpe?g($|\?)/i) > 0 || f.search(/^data\:image\/jpeg/) === 0 ? "image/jpeg" : f.search(/\.webp($|\?)/i) > 0 || f.search(/^data\:image\/webp/) === 0 ? "image/webp" : f.search(/\.ktx2($|\?)/i) > 0 || f.search(/^data\:image\/ktx2/) === 0 ? "image/ktx2" : "image/png";
+}
+const Gn = new K();
+class Un {
+  constructor(n = {}, e = {}) {
+    this.json = n, this.extensions = {}, this.plugins = {}, this.options = e, this.cache = new un(), 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 t = !1, s = -1, i = !1, o = -1;
+    if (typeof navigator < "u" && typeof navigator.userAgent < "u") {
+      const a = navigator.userAgent;
+      t = /^((?!chrome|android).)*safari/i.test(a) === !0;
+      const r = a.match(/Version\/(\d+)/);
+      s = t && r ? parseInt(r[1], 10) : -1, i = a.indexOf("Firefox") > -1, o = i ? a.match(/Firefox\/([0-9]+)\./)[1] : -1;
+    }
+    typeof createImageBitmap > "u" || t && s < 17 || i && o < 98 ? this.textureLoader = new be(this.options.manager) : this.textureLoader = new Ne(this.options.manager), this.textureLoader.setCrossOrigin(this.options.crossOrigin), this.textureLoader.setRequestHeader(this.options.requestHeader), this.fileLoader = new he(this.options.manager), this.fileLoader.setResponseType("arraybuffer"), this.options.crossOrigin === "use-credentials" && this.fileLoader.setWithCredentials(!0);
+  }
+  setExtensions(n) {
+    this.extensions = n;
+  }
+  setPlugins(n) {
+    this.plugins = n;
+  }
+  parse(n, e) {
+    const t = this, s = this.json, i = this.extensions;
+    this.cache.removeAll(), this.nodeCache = {}, this._invokeAll(function(o) {
+      return o._markDefs && o._markDefs();
+    }), Promise.all(this._invokeAll(function(o) {
+      return o.beforeRoot && o.beforeRoot();
+    })).then(function() {
+      return Promise.all([
+        t.getDependencies("scene"),
+        t.getDependencies("animation"),
+        t.getDependencies("camera")
+      ]);
+    }).then(function(o) {
+      const a = {
+        scene: o[0][s.scene || 0],
+        scenes: o[0],
+        animations: o[1],
+        cameras: o[2],
+        asset: s.asset,
+        parser: t,
+        userData: {}
+      };
+      return O(i, a, s), y(a, s), Promise.all(t._invokeAll(function(r) {
+        return r.afterRoot && r.afterRoot(a);
+      })).then(function() {
+        for (const r of a.scenes)
+          r.updateMatrixWorld();
+        n(a);
+      });
+    }).catch(e);
+  }
+  /**
+   * Marks the special nodes/meshes in json for efficient parse.
+   *
+   * @private
+   */
+  _markDefs() {
+    const n = this.json.nodes || [], e = this.json.skins || [], t = this.json.meshes || [];
+    for (let s = 0, i = e.length; s < i; s++) {
+      const o = e[s].joints;
+      for (let a = 0, r = o.length; a < r; a++)
+        n[o[a]].isBone = !0;
+    }
+    for (let s = 0, i = n.length; s < i; s++) {
+      const o = n[s];
+      o.mesh !== void 0 && (this._addNodeRef(this.meshCache, o.mesh), o.skin !== void 0 && (t[o.mesh].isSkinnedMesh = !0)), o.camera !== void 0 && this._addNodeRef(this.cameraCache, o.camera);
+    }
+  }
+  /**
+   * Counts references to shared node / Object3D resources. These resources
+   * can be reused, or "instantiated", at multiple nodes in the scene
+   * hierarchy. Mesh, Camera, and Light instances are instantiated and must
+   * be marked. Non-scenegraph resources (like Materials, Geometries, and
+   * Textures) can be reused directly and are not marked here.
+   *
+   * Example: CesiumMilkTruck sample model reuses "Wheel" meshes.
+   *
+   * @private
+   * @param {Object} cache
+   * @param {Object3D} index
+   */
+  _addNodeRef(n, e) {
+    e !== void 0 && (n.refs[e] === void 0 && (n.refs[e] = n.uses[e] = 0), n.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(n, e, t) {
+    if (n.refs[e] <= 1) return t;
+    const s = t.clone(), i = (o, a) => {
+      const r = this.associations.get(o);
+      r != null && this.associations.set(a, r);
+      for (const [c, l] of o.children.entries())
+        i(l, a.children[c]);
+    };
+    return i(t, s), s.name += "_instance_" + n.uses[e]++, s;
+  }
+  _invokeOne(n) {
+    const e = Object.values(this.plugins);
+    e.push(this);
+    for (let t = 0; t < e.length; t++) {
+      const s = n(e[t]);
+      if (s) return s;
+    }
+    return null;
+  }
+  _invokeAll(n) {
+    const e = Object.values(this.plugins);
+    e.unshift(this);
+    const t = [];
+    for (let s = 0; s < e.length; s++) {
+      const i = n(e[s]);
+      i && t.push(i);
+    }
+    return t;
+  }
+  /**
+   * Requests the specified dependency asynchronously, with caching.
+   *
+   * @private
+   * @param {string} type
+   * @param {number} index
+   * @return {Promise<Object3D|Material|Texture|AnimationClip|ArrayBuffer|Object>}
+   */
+  getDependency(n, e) {
+    const t = n + ":" + e;
+    let s = this.cache.get(t);
+    if (!s) {
+      switch (n) {
+        case "scene":
+          s = this.loadScene(e);
+          break;
+        case "node":
+          s = this._invokeOne(function(i) {
+            return i.loadNode && i.loadNode(e);
+          });
+          break;
+        case "mesh":
+          s = this._invokeOne(function(i) {
+            return i.loadMesh && i.loadMesh(e);
+          });
+          break;
+        case "accessor":
+          s = this.loadAccessor(e);
+          break;
+        case "bufferView":
+          s = this._invokeOne(function(i) {
+            return i.loadBufferView && i.loadBufferView(e);
+          });
+          break;
+        case "buffer":
+          s = this.loadBuffer(e);
+          break;
+        case "material":
+          s = this._invokeOne(function(i) {
+            return i.loadMaterial && i.loadMaterial(e);
+          });
+          break;
+        case "texture":
+          s = this._invokeOne(function(i) {
+            return i.loadTexture && i.loadTexture(e);
+          });
+          break;
+        case "skin":
+          s = this.loadSkin(e);
+          break;
+        case "animation":
+          s = this._invokeOne(function(i) {
+            return i.loadAnimation && i.loadAnimation(e);
+          });
+          break;
+        case "camera":
+          s = this.loadCamera(e);
+          break;
+        default:
+          if (s = this._invokeOne(function(i) {
+            return i != this && i.getDependency && i.getDependency(n, e);
+          }), !s)
+            throw new Error("Unknown type: " + n);
+          break;
+      }
+      this.cache.add(t, s);
+    }
+    return s;
+  }
+  /**
+   * Requests all dependencies of the specified type asynchronously, with caching.
+   *
+   * @private
+   * @param {string} type
+   * @return {Promise<Array<Object>>}
+   */
+  getDependencies(n) {
+    let e = this.cache.get(n);
+    if (!e) {
+      const t = this, s = this.json[n + (n === "mesh" ? "es" : "s")] || [];
+      e = Promise.all(s.map(function(i, o) {
+        return t.getDependency(n, o);
+      })), this.cache.add(n, 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(n) {
+    const e = this.json.buffers[n], t = 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 && n === 0)
+      return Promise.resolve(this.extensions[g.KHR_BINARY_GLTF].body);
+    const s = this.options;
+    return new Promise(function(i, o) {
+      t.load(G.resolveURL(e.uri, s.path), i, void 0, function() {
+        o(new Error('THREE.GLTFLoader: Failed to load buffer "' + e.uri + '".'));
+      });
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
+   *
+   * @private
+   * @param {number} bufferViewIndex
+   * @return {Promise<ArrayBuffer>}
+   */
+  loadBufferView(n) {
+    const e = this.json.bufferViews[n];
+    return this.getDependency("buffer", e.buffer).then(function(t) {
+      const s = e.byteLength || 0, i = e.byteOffset || 0;
+      return t.slice(i, i + s);
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
+   *
+   * @private
+   * @param {number} accessorIndex
+   * @return {Promise<BufferAttribute|InterleavedBufferAttribute>}
+   */
+  loadAccessor(n) {
+    const e = this, t = this.json, s = this.json.accessors[n];
+    if (s.bufferView === void 0 && s.sparse === void 0) {
+      const o = q[s.type], a = k[s.componentType], r = s.normalized === !0, c = new a(s.count * o);
+      return Promise.resolve(new V(c, o, r));
+    }
+    const i = [];
+    return s.bufferView !== void 0 ? i.push(this.getDependency("bufferView", s.bufferView)) : i.push(null), s.sparse !== void 0 && (i.push(this.getDependency("bufferView", s.sparse.indices.bufferView)), i.push(this.getDependency("bufferView", s.sparse.values.bufferView))), Promise.all(i).then(function(o) {
+      const a = o[0], r = q[s.type], c = k[s.componentType], l = c.BYTES_PER_ELEMENT, u = l * r, h = s.byteOffset || 0, d = s.bufferView !== void 0 ? t.bufferViews[s.bufferView].byteStride : void 0, p = s.normalized === !0;
+      let R, m;
+      if (d && d !== u) {
+        const T = Math.floor(h / d), _ = "InterleavedBuffer:" + s.bufferView + ":" + s.componentType + ":" + T + ":" + s.count;
+        let x = e.cache.get(_);
+        x || (R = new c(a, T * d, s.count * d / l), x = new Ie(R, d / l), e.cache.add(_, x)), m = new en(x, r, h % d / l, p);
+      } else
+        a === null ? R = new c(s.count * r) : R = new c(a, h, s.count * r), m = new V(R, r, p);
+      if (s.sparse !== void 0) {
+        const T = q.SCALAR, _ = k[s.sparse.indices.componentType], x = s.sparse.indices.byteOffset || 0, E = s.sparse.values.byteOffset || 0, L = new _(o[1], x, s.sparse.count * T), N = new c(o[2], E, s.sparse.count * r);
+        a !== null && (m = new V(m.array.slice(), m.itemSize, m.normalized)), m.normalized = !1;
+        for (let S = 0, H = L.length; S < H; S++) {
+          const P = L[S];
+          if (m.setX(P, N[S * r]), r >= 2 && m.setY(P, N[S * r + 1]), r >= 3 && m.setZ(P, N[S * r + 2]), r >= 4 && m.setW(P, N[S * r + 3]), r >= 5) throw new Error("THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.");
+        }
+        m.normalized = p;
+      }
+      return m;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures
+   *
+   * @private
+   * @param {number} textureIndex
+   * @return {Promise<?Texture>}
+   */
+  loadTexture(n) {
+    const e = this.json, t = this.options, i = e.textures[n].source, o = e.images[i];
+    let a = this.textureLoader;
+    if (o.uri) {
+      const r = t.manager.getHandler(o.uri);
+      r !== null && (a = r);
+    }
+    return this.loadTextureImage(n, i, a);
+  }
+  loadTextureImage(n, e, t) {
+    const s = this, i = this.json, o = i.textures[n], a = i.images[e], r = (a.uri || a.bufferView) + ":" + o.sampler;
+    if (this.textureCache[r])
+      return this.textureCache[r];
+    const c = this.loadImageSource(e, t).then(function(l) {
+      l.flipY = !1, l.name = o.name || a.name || "", l.name === "" && typeof a.uri == "string" && a.uri.startsWith("data:image/") === !1 && (l.name = a.uri);
+      const h = (i.samplers || {})[o.sampler] || {};
+      return l.magFilter = ce[h.magFilter] || Q, l.minFilter = ce[h.minFilter] || me, l.wrapS = ue[h.wrapS] || J, l.wrapT = ue[h.wrapT] || J, l.generateMipmaps = !l.isCompressedTexture && l.minFilter !== ge && l.minFilter !== Q, s.associations.set(l, { textures: n }), l;
+    }).catch(function() {
+      return null;
+    });
+    return this.textureCache[r] = c, c;
+  }
+  loadImageSource(n, e) {
+    const t = this, s = this.json, i = this.options;
+    if (this.sourceCache[n] !== void 0)
+      return this.sourceCache[n].then((u) => u.clone());
+    const o = s.images[n], a = self.URL || self.webkitURL;
+    let r = o.uri || "", c = !1;
+    if (o.bufferView !== void 0)
+      r = t.getDependency("bufferView", o.bufferView).then(function(u) {
+        c = !0;
+        const h = new Blob([u], { type: o.mimeType });
+        return r = a.createObjectURL(h), r;
+      });
+    else if (o.uri === void 0)
+      throw new Error("THREE.GLTFLoader: Image " + n + " is missing URI and bufferView");
+    const l = Promise.resolve(r).then(function(u) {
+      return new Promise(function(h, d) {
+        let p = h;
+        e.isImageBitmapLoader === !0 && (p = function(R) {
+          const m = new ne(R);
+          m.needsUpdate = !0, h(m);
+        }), e.load(G.resolveURL(u, i.path), p, void 0, d);
+      });
+    }).then(function(u) {
+      return c === !0 && a.revokeObjectURL(r), y(u, o), u.userData.mimeType = o.mimeType || vn(o.uri), u;
+    }).catch(function(u) {
+      throw console.error("THREE.GLTFLoader: Couldn't load texture", r), u;
+    });
+    return this.sourceCache[n] = l, l;
+  }
+  /**
+   * 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(n, e, t, s) {
+    const i = this;
+    return this.getDependency("texture", t.index).then(function(o) {
+      if (!o) return null;
+      if (t.texCoord !== void 0 && t.texCoord > 0 && (o = o.clone(), o.channel = t.texCoord), i.extensions[g.KHR_TEXTURE_TRANSFORM]) {
+        const a = t.extensions !== void 0 ? t.extensions[g.KHR_TEXTURE_TRANSFORM] : void 0;
+        if (a) {
+          const r = i.associations.get(o);
+          o = i.extensions[g.KHR_TEXTURE_TRANSFORM].extendTexture(o, a), i.associations.set(o, r);
+        }
+      }
+      return s !== void 0 && (o.colorSpace = s), n[e] = o, o;
+    });
+  }
+  /**
+   * Assigns final material to a Mesh, Line, or Points instance. The instance
+   * already has a material (generated from the glTF material options alone)
+   * but reuse of the same glTF material may require multiple threejs materials
+   * to accommodate different primitive types, defines, etc. New materials will
+   * be created if necessary, and reused from a cache.
+   *
+   * @private
+   * @param {Object3D} mesh Mesh, Line, or Points instance.
+   */
+  assignFinalMaterial(n) {
+    const e = n.geometry;
+    let t = n.material;
+    const s = e.attributes.tangent === void 0, i = e.attributes.color !== void 0, o = e.attributes.normal === void 0;
+    if (n.isPoints) {
+      const a = "PointsMaterial:" + t.uuid;
+      let r = this.cache.get(a);
+      r || (r = new He(), z.prototype.copy.call(r, t), r.color.copy(t.color), r.map = t.map, r.sizeAttenuation = !1, this.cache.add(a, r)), t = r;
+    } else if (n.isLine) {
+      const a = "LineBasicMaterial:" + t.uuid;
+      let r = this.cache.get(a);
+      r || (r = new De(), z.prototype.copy.call(r, t), r.color.copy(t.color), r.map = t.map, this.cache.add(a, r)), t = r;
+    }
+    if (s || i || o) {
+      let a = "ClonedMaterial:" + t.uuid + ":";
+      s && (a += "derivative-tangents:"), i && (a += "vertex-colors:"), o && (a += "flat-shading:");
+      let r = this.cache.get(a);
+      r || (r = t.clone(), i && (r.vertexColors = !0), o && (r.flatShading = !0), s && (r.normalScale && (r.normalScale.y *= -1), r.clearcoatNormalScale && (r.clearcoatNormalScale.y *= -1)), this.cache.add(a, r), this.associations.set(r, this.associations.get(t))), t = r;
+    }
+    n.material = t;
+  }
+  getMaterialType() {
+    return Te;
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
+   *
+   * @private
+   * @param {number} materialIndex
+   * @return {Promise<Material>}
+   */
+  loadMaterial(n) {
+    const e = this, t = this.json, s = this.extensions, i = t.materials[n];
+    let o;
+    const a = {}, r = i.extensions || {}, c = [];
+    if (r[g.KHR_MATERIALS_UNLIT]) {
+      const u = s[g.KHR_MATERIALS_UNLIT];
+      o = u.getMaterialType(), c.push(u.extendParams(a, i, e));
+    } else {
+      const u = i.pbrMetallicRoughness || {};
+      if (a.color = new F(1, 1, 1), a.opacity = 1, Array.isArray(u.baseColorFactor)) {
+        const h = u.baseColorFactor;
+        a.color.setRGB(h[0], h[1], h[2], b), a.opacity = h[3];
+      }
+      u.baseColorTexture !== void 0 && c.push(e.assignTexture(a, "map", u.baseColorTexture, U)), a.metalness = u.metallicFactor !== void 0 ? u.metallicFactor : 1, a.roughness = u.roughnessFactor !== void 0 ? u.roughnessFactor : 1, u.metallicRoughnessTexture !== void 0 && (c.push(e.assignTexture(a, "metalnessMap", u.metallicRoughnessTexture)), c.push(e.assignTexture(a, "roughnessMap", u.metallicRoughnessTexture))), o = this._invokeOne(function(h) {
+        return h.getMaterialType && h.getMaterialType(n);
+      }), c.push(Promise.all(this._invokeAll(function(h) {
+        return h.extendMaterialParams && h.extendMaterialParams(n, a);
+      })));
+    }
+    i.doubleSided === !0 && (a.side = ve);
+    const l = i.alphaMode || W.OPAQUE;
+    if (l === W.BLEND ? (a.transparent = !0, a.depthWrite = !1) : (a.transparent = !1, l === W.MASK && (a.alphaTest = i.alphaCutoff !== void 0 ? i.alphaCutoff : 0.5)), i.normalTexture !== void 0 && o !== v && (c.push(e.assignTexture(a, "normalMap", i.normalTexture)), a.normalScale = new fe(1, 1), i.normalTexture.scale !== void 0)) {
+      const u = i.normalTexture.scale;
+      a.normalScale.set(u, u);
+    }
+    if (i.occlusionTexture !== void 0 && o !== v && (c.push(e.assignTexture(a, "aoMap", i.occlusionTexture)), i.occlusionTexture.strength !== void 0 && (a.aoMapIntensity = i.occlusionTexture.strength)), i.emissiveFactor !== void 0 && o !== v) {
+      const u = i.emissiveFactor;
+      a.emissive = new F().setRGB(u[0], u[1], u[2], b);
+    }
+    return i.emissiveTexture !== void 0 && o !== v && c.push(e.assignTexture(a, "emissiveMap", i.emissiveTexture, U)), Promise.all(c).then(function() {
+      const u = new o(a);
+      return i.name && (u.name = i.name), y(u, i), e.associations.set(u, { materials: n }), i.extensions && O(s, u, i), u;
+    });
+  }
+  /**
+   * When Object3D instances are targeted by animation, they need unique names.
+   *
+   * @private
+   * @param {string} originalName
+   * @return {string}
+   */
+  createUniqueName(n) {
+    const e = Ge.sanitizeNodeName(n || "");
+    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(n) {
+    const e = this, t = this.extensions, s = this.primitiveCache;
+    function i(a) {
+      return t[g.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(a, e).then(function(r) {
+        return le(r, a, e);
+      });
+    }
+    const o = [];
+    for (let a = 0, r = n.length; a < r; a++) {
+      const c = n[a], l = Dn(c), u = s[l];
+      if (u)
+        o.push(u.promise);
+      else {
+        let h;
+        c.extensions && c.extensions[g.KHR_DRACO_MESH_COMPRESSION] ? h = i(c) : h = le(new Ue(), c, e), s[l] = { primitive: c, promise: h }, o.push(h);
+      }
+    }
+    return Promise.all(o);
+  }
+  /**
+   * 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(n) {
+    const e = this, t = this.json, s = this.extensions, i = t.meshes[n], o = i.primitives, a = [];
+    for (let r = 0, c = o.length; r < c; r++) {
+      const l = o[r].material === void 0 ? Pn(this.cache) : this.getDependency("material", o[r].material);
+      a.push(l);
+    }
+    return a.push(e.loadGeometries(o)), Promise.all(a).then(function(r) {
+      const c = r.slice(0, r.length - 1), l = r[r.length - 1], u = [];
+      for (let d = 0, p = l.length; d < p; d++) {
+        const R = l[d], m = o[d];
+        let T;
+        const _ = c[d];
+        if (m.mode === M.TRIANGLES || m.mode === M.TRIANGLE_STRIP || m.mode === M.TRIANGLE_FAN || m.mode === void 0)
+          T = i.isSkinnedMesh === !0 ? new Ke(R, _) : new Be(R, _), T.isSkinnedMesh === !0 && T.normalizeSkinWeights(), m.mode === M.TRIANGLE_STRIP ? T.geometry = ee(T.geometry, on) : m.mode === M.TRIANGLE_FAN && (T.geometry = ee(T.geometry, an));
+        else if (m.mode === M.LINES)
+          T = new je(R, _);
+        else if (m.mode === M.LINE_STRIP)
+          T = new Ve(R, _);
+        else if (m.mode === M.LINE_LOOP)
+          T = new ze(R, _);
+        else if (m.mode === M.POINTS)
+          T = new Xe(R, _);
+        else
+          throw new Error("THREE.GLTFLoader: Primitive mode unsupported: " + m.mode);
+        Object.keys(T.geometry.morphAttributes).length > 0 && Hn(T, i), T.name = e.createUniqueName(i.name || "mesh_" + n), y(T, i), m.extensions && O(s, T, m), e.assignFinalMaterial(T), u.push(T);
+      }
+      for (let d = 0, p = u.length; d < p; d++)
+        e.associations.set(u[d], {
+          meshes: n,
+          primitives: d
+        });
+      if (u.length === 1)
+        return i.extensions && O(s, u[0], i), u[0];
+      const h = new X();
+      i.extensions && O(s, h, i), e.associations.set(h, { meshes: n });
+      for (let d = 0, p = u.length; d < p; d++)
+        h.add(u[d]);
+      return h;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
+   *
+   * @private
+   * @param {number} cameraIndex
+   * @return {Promise<Camera>|undefined}
+   */
+  loadCamera(n) {
+    let e;
+    const t = this.json.cameras[n], s = t[t.type];
+    if (!s) {
+      console.warn("THREE.GLTFLoader: Missing camera parameters.");
+      return;
+    }
+    return t.type === "perspective" ? e = new qe(We.radToDeg(s.yfov), s.aspectRatio || 1, s.znear || 1, s.zfar || 2e6) : t.type === "orthographic" && (e = new Ye(-s.xmag, s.xmag, s.ymag, -s.ymag, s.znear, s.zfar)), t.name && (e.name = this.createUniqueName(t.name)), y(e, t), Promise.resolve(e);
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
+   *
+   * @private
+   * @param {number} skinIndex
+   * @return {Promise<Skeleton>}
+   */
+  loadSkin(n) {
+    const e = this.json.skins[n], t = [];
+    for (let s = 0, i = e.joints.length; s < i; s++)
+      t.push(this._loadNodeShallow(e.joints[s]));
+    return e.inverseBindMatrices !== void 0 ? t.push(this.getDependency("accessor", e.inverseBindMatrices)) : t.push(null), Promise.all(t).then(function(s) {
+      const i = s.pop(), o = s, a = [], r = [];
+      for (let c = 0, l = o.length; c < l; c++) {
+        const u = o[c];
+        if (u) {
+          a.push(u);
+          const h = new K();
+          i !== null && h.fromArray(i.array, c * 16), r.push(h);
+        } else
+          console.warn('THREE.GLTFLoader: Joint "%s" could not be found.', e.joints[c]);
+      }
+      return new Qe(a, r);
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
+   *
+   * @private
+   * @param {number} animationIndex
+   * @return {Promise<AnimationClip>}
+   */
+  loadAnimation(n) {
+    const e = this.json, t = this, s = e.animations[n], i = s.name ? s.name : "animation_" + n, o = [], a = [], r = [], c = [], l = [];
+    for (let u = 0, h = s.channels.length; u < h; u++) {
+      const d = s.channels[u], p = s.samplers[d.sampler], R = d.target, m = R.node, T = s.parameters !== void 0 ? s.parameters[p.input] : p.input, _ = s.parameters !== void 0 ? s.parameters[p.output] : p.output;
+      R.node !== void 0 && (o.push(this.getDependency("node", m)), a.push(this.getDependency("accessor", T)), r.push(this.getDependency("accessor", _)), c.push(p), l.push(R));
+    }
+    return Promise.all([
+      Promise.all(o),
+      Promise.all(a),
+      Promise.all(r),
+      Promise.all(c),
+      Promise.all(l)
+    ]).then(function(u) {
+      const h = u[0], d = u[1], p = u[2], R = u[3], m = u[4], T = [];
+      for (let x = 0, E = h.length; x < E; x++) {
+        const L = h[x], N = d[x], S = p[x], H = R[x], P = m[x];
+        if (L === void 0) continue;
+        L.updateMatrix && L.updateMatrix();
+        const B = t._createAnimationTracks(L, N, S, H, P);
+        if (B)
+          for (let j = 0; j < B.length; j++)
+            T.push(B[j]);
+      }
+      const _ = new Je(i, void 0, T);
+      return y(_, s), _;
+    });
+  }
+  createNodeMesh(n) {
+    const e = this.json, t = this, s = e.nodes[n];
+    return s.mesh === void 0 ? null : t.getDependency("mesh", s.mesh).then(function(i) {
+      const o = t._getNodeRef(t.meshCache, s.mesh, i);
+      return s.weights !== void 0 && o.traverse(function(a) {
+        if (a.isMesh)
+          for (let r = 0, c = s.weights.length; r < c; r++)
+            a.morphTargetInfluences[r] = s.weights[r];
+      }), o;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
+   *
+   * @private
+   * @param {number} nodeIndex
+   * @return {Promise<Object3D>}
+   */
+  loadNode(n) {
+    const e = this.json, t = this, s = e.nodes[n], i = t._loadNodeShallow(n), o = [], a = s.children || [];
+    for (let c = 0, l = a.length; c < l; c++)
+      o.push(t.getDependency("node", a[c]));
+    const r = s.skin === void 0 ? Promise.resolve(null) : t.getDependency("skin", s.skin);
+    return Promise.all([
+      i,
+      Promise.all(o),
+      r
+    ]).then(function(c) {
+      const l = c[0], u = c[1], h = c[2];
+      h !== null && l.traverse(function(d) {
+        d.isSkinnedMesh && d.bind(h, Gn);
+      });
+      for (let d = 0, p = u.length; d < p; d++)
+        l.add(u[d]);
+      if (l.userData.pivot !== void 0 && u.length > 0) {
+        const d = l.userData.pivot, p = u[0];
+        l.pivot = new C().fromArray(d), l.position.x -= d[0], l.position.y -= d[1], l.position.z -= d[2], p.position.set(0, 0, 0), delete l.userData.pivot;
+      }
+      return l;
+    });
+  }
+  // ._loadNodeShallow() parses a single node.
+  // skin and child nodes are created and added in .loadNode() (no '_' prefix).
+  _loadNodeShallow(n) {
+    const e = this.json, t = this.extensions, s = this;
+    if (this.nodeCache[n] !== void 0)
+      return this.nodeCache[n];
+    const i = e.nodes[n], o = i.name ? s.createUniqueName(i.name) : "", a = [], r = s._invokeOne(function(c) {
+      return c.createNodeMesh && c.createNodeMesh(n);
+    });
+    return r && a.push(r), i.camera !== void 0 && a.push(s.getDependency("camera", i.camera).then(function(c) {
+      return s._getNodeRef(s.cameraCache, i.camera, c);
+    })), s._invokeAll(function(c) {
+      return c.createNodeAttachment && c.createNodeAttachment(n);
+    }).forEach(function(c) {
+      a.push(c);
+    }), this.nodeCache[n] = Promise.all(a).then(function(c) {
+      let l;
+      if (i.isBone === !0 ? l = new Ze() : c.length > 1 ? l = new X() : c.length === 1 ? l = c[0] : l = new pe(), l !== c[0])
+        for (let u = 0, h = c.length; u < h; u++)
+          l.add(c[u]);
+      if (i.name && (l.userData.name = i.name, l.name = o), y(l, i), i.extensions && O(t, l, i), i.matrix !== void 0) {
+        const u = new K();
+        u.fromArray(i.matrix), l.applyMatrix4(u);
+      } else
+        i.translation !== void 0 && l.position.fromArray(i.translation), i.rotation !== void 0 && l.quaternion.fromArray(i.rotation), i.scale !== void 0 && l.scale.fromArray(i.scale);
+      if (!s.associations.has(l))
+        s.associations.set(l, {});
+      else if (i.mesh !== void 0 && s.meshCache.refs[i.mesh] > 1) {
+        const u = s.associations.get(l);
+        s.associations.set(l, { ...u });
+      }
+      return s.associations.get(l).nodes = n, l;
+    }), this.nodeCache[n];
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes
+   *
+   * @private
+   * @param {number} sceneIndex
+   * @return {Promise<Group>}
+   */
+  loadScene(n) {
+    const e = this.extensions, t = this.json.scenes[n], s = this, i = new X();
+    t.name && (i.name = s.createUniqueName(t.name)), y(i, t), t.extensions && O(e, i, t);
+    const o = t.nodes || [], a = [];
+    for (let r = 0, c = o.length; r < c; r++)
+      a.push(s.getDependency("node", o[r]));
+    return Promise.all(a).then(function(r) {
+      for (let l = 0, u = r.length; l < u; l++) {
+        const h = r[l];
+        h.parent !== null ? i.add(cn(h)) : i.add(h);
+      }
+      const c = (l) => {
+        const u = /* @__PURE__ */ new Map();
+        for (const [h, d] of s.associations)
+          (h instanceof z || h instanceof ne) && u.set(h, d);
+        return l.traverse((h) => {
+          const d = s.associations.get(h);
+          d != null && u.set(h, d);
+        }), u;
+      };
+      return s.associations = c(i), i;
+    });
+  }
+  _createAnimationTracks(n, e, t, s, i) {
+    const o = [], a = n.name ? n.name : n.uuid, r = [];
+    I[i.path] === I.weights ? n.traverse(function(h) {
+      h.morphTargetInfluences && r.push(h.name ? h.name : h.uuid);
+    }) : r.push(a);
+    let c;
+    switch (I[i.path]) {
+      case I.weights:
+        c = se;
+        break;
+      case I.rotation:
+        c = ie;
+        break;
+      case I.translation:
+      case I.scale:
+        c = te;
+        break;
+      default:
+        t.itemSize === 1 ? c = se : c = te;
+        break;
+    }
+    const l = s.interpolation !== void 0 ? Fn[s.interpolation] : Re, u = this._getArrayFromAccessor(t);
+    for (let h = 0, d = r.length; h < d; h++) {
+      const p = new c(
+        r[h] + "." + I[i.path],
+        e.array,
+        u,
+        l
+      );
+      s.interpolation === "CUBICSPLINE" && this._createCubicSplineTrackInterpolant(p), o.push(p);
+    }
+    return o;
+  }
+  _getArrayFromAccessor(n) {
+    let e = n.array;
+    if (n.normalized) {
+      const t = $(e.constructor), s = new Float32Array(e.length);
+      for (let i = 0, o = e.length; i < o; i++)
+        s[i] = e[i] * t;
+      e = s;
+    }
+    return e;
+  }
+  _createCubicSplineTrackInterpolant(n) {
+    n.createInterpolant = function(t) {
+      const s = this instanceof ie ? Cn : _e;
+      return new s(this.times, this.values, this.getValueSize() / 3, t);
+    }, n.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = !0;
+  }
+}
+function Kn(f, n, e) {
+  const t = n.attributes, s = new sn();
+  if (t.POSITION !== void 0) {
+    const a = e.json.accessors[t.POSITION], r = a.min, c = a.max;
+    if (r !== void 0 && c !== void 0) {
+      if (s.set(
+        new C(r[0], r[1], r[2]),
+        new C(c[0], c[1], c[2])
+      ), a.normalized) {
+        const l = $(k[a.componentType]);
+        s.min.multiplyScalar(l), s.max.multiplyScalar(l);
+      }
+    } else {
+      console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      return;
+    }
+  } else
+    return;
+  const i = n.targets;
+  if (i !== void 0) {
+    const a = new C(), r = new C();
+    for (let c = 0, l = i.length; c < l; c++) {
+      const u = i[c];
+      if (u.POSITION !== void 0) {
+        const h = e.json.accessors[u.POSITION], d = h.min, p = h.max;
+        if (d !== void 0 && p !== void 0) {
+          if (r.setX(Math.max(Math.abs(d[0]), Math.abs(p[0]))), r.setY(Math.max(Math.abs(d[1]), Math.abs(p[1]))), r.setZ(Math.max(Math.abs(d[2]), Math.abs(p[2]))), h.normalized) {
+            const R = $(k[h.componentType]);
+            r.multiplyScalar(R);
+          }
+          a.max(r);
+        } else
+          console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      }
+    }
+    s.expandByVector(a);
+  }
+  f.boundingBox = s;
+  const o = new rn();
+  s.getCenter(o.center), o.radius = s.min.distanceTo(s.max) / 2, f.boundingSphere = o;
+}
+function le(f, n, e) {
+  const t = n.attributes, s = [];
+  function i(o, a) {
+    return e.getDependency("accessor", o).then(function(r) {
+      f.setAttribute(a, r);
+    });
+  }
+  for (const o in t) {
+    const a = Z[o] || o.toLowerCase();
+    a in f.attributes || s.push(i(t[o], a));
+  }
+  if (n.indices !== void 0 && !f.index) {
+    const o = e.getDependency("accessor", n.indices).then(function(a) {
+      f.setIndex(a);
+    });
+    s.push(o);
+  }
+  return re.workingColorSpace !== b && "COLOR_0" in t && console.warn(`THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${re.workingColorSpace}" not supported.`), y(f, n), Kn(f, n, e), Promise.all(s).then(function() {
+    return n.targets !== void 0 ? kn(f, n.targets, e) : f;
+  });
+}
+export {
+  jn as GLTFLoader
+};