ss-component-new 1.2.2 → 1.2.4

package/dist/threePreview-CyYfnbB6.js

@@ -0,0 +1,1972 @@
+import { ref as K, shallowRef as je, defineComponent as Be, watch as Z, onMounted as Ke, nextTick as Ve, onBeforeUnmount as ze, resolveComponent as Xe, createElementBlock as ee, openBlock as ne, createElementVNode as _, withDirectives as z, createCommentVNode as he, createVNode as H, unref as y, toDisplayString as pe, withCtx as qe, isRef as $, vModelRadio as J, vShow as We } from "vue";
+import { u as Ye, a as $e, b as Je, S as j } from "./iconfont-ljBfzBSE.js";
+import { M as Qe, O as Ze, S as en } from "./STLLoader-DmGTF0Nv.js";
+import { v as nn, w as ce, x as ye, y as tn, z as W, F as be, I as O, J as Se, C as G, K as F, b as Y, N as sn, g as rn, D as on, k as Q, V as B, O as an, Q as Ne, R as cn, U as Ie, Y as ln, Z as un, _ as te, $ as dn, a0 as Ce, a1 as fn, a2 as hn, a3 as pn, a4 as le, a5 as Oe, a6 as ue, a7 as mn, a8 as gn, a9 as Tn, aa as se, ab as xn, n as ve, i as Rn, ac as q, ad as En, p as An, ae as Ln, e as ke, af as _n, r as Mn, ag as wn, ah as yn, o as re, P as bn, l as Sn, ai as Nn, aj as In, ak as Cn, al as On, am as vn, an as Fe, ao as kn, ap as me, aq as ge, ar as Te, as as xe, at as Re, au as Fn, av as Pn, B as Pe, aw as Dn, h as Hn } from "./three-viewport-gizmo-BHznJ6W3.js";
+import { E as Ee } from "./index-UN4JU0ly.js";
+import { _ as Un } from "./_plugin-vue_export-helper-CHgC5LLL.js";
+function Ae(d, n) {
+  if (n === nn)
+    return console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles."), d;
+  if (n === ce || n === ye) {
+    let e = d.getIndex();
+    if (e === null) {
+      const r = [], a = d.getAttribute("position");
+      if (a !== void 0) {
+        for (let o = 0; o < a.count; o++)
+          r.push(o);
+        d.setIndex(r), e = d.getIndex();
+      } else
+        return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible."), d;
+    }
+    const i = e.count - 2, t = [];
+    if (n === ce)
+      for (let r = 1; r <= i; r++)
+        t.push(e.getX(0)), t.push(e.getX(r)), t.push(e.getX(r + 1));
+    else
+      for (let r = 0; r < i; r++)
+        r % 2 === 0 ? (t.push(e.getX(r)), t.push(e.getX(r + 1)), t.push(e.getX(r + 2))) : (t.push(e.getX(r + 2)), t.push(e.getX(r + 1)), t.push(e.getX(r)));
+    t.length / 3 !== i && console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unable to generate correct amount of triangles.");
+    const s = d.clone();
+    return s.setIndex(t), s.clearGroups(), s;
+  } else
+    return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unknown draw mode:", n), d;
+}
+class Gn extends tn {
+  /**
+   * 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 zn(e);
+    }), this.register(function(e) {
+      return new Xn(e);
+    }), this.register(function(e) {
+      return new nt(e);
+    }), this.register(function(e) {
+      return new tt(e);
+    }), this.register(function(e) {
+      return new st(e);
+    }), this.register(function(e) {
+      return new Wn(e);
+    }), this.register(function(e) {
+      return new Yn(e);
+    }), this.register(function(e) {
+      return new $n(e);
+    }), this.register(function(e) {
+      return new Jn(e);
+    }), this.register(function(e) {
+      return new Vn(e);
+    }), this.register(function(e) {
+      return new Qn(e);
+    }), this.register(function(e) {
+      return new qn(e);
+    }), this.register(function(e) {
+      return new et(e);
+    }), this.register(function(e) {
+      return new Zn(e);
+    }), this.register(function(e) {
+      return new Bn(e);
+    }), this.register(function(e) {
+      return new rt(e);
+    }), this.register(function(e) {
+      return new it(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, i, t) {
+    const s = this;
+    let r;
+    if (this.resourcePath !== "")
+      r = this.resourcePath;
+    else if (this.path !== "") {
+      const c = W.extractUrlBase(n);
+      r = W.resolveURL(c, this.path);
+    } else
+      r = W.extractUrlBase(n);
+    this.manager.itemStart(n);
+    const a = function(c) {
+      t ? t(c) : console.error(c), s.manager.itemError(n), s.manager.itemEnd(n);
+    }, o = new be(this.manager);
+    o.setPath(this.path), o.setResponseType("arraybuffer"), o.setRequestHeader(this.requestHeader), o.setWithCredentials(this.withCredentials), o.load(n, function(c) {
+      try {
+        s.parse(c, r, function(u) {
+          e(u), s.manager.itemEnd(n);
+        }, a);
+      } catch (u) {
+        a(u);
+      }
+    }, i, 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 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(n, e, i, t) {
+    let s;
+    const r = {}, a = {}, o = new TextDecoder();
+    if (typeof n == "string")
+      s = JSON.parse(n);
+    else if (n instanceof ArrayBuffer)
+      if (o.decode(new Uint8Array(n, 0, 4)) === De) {
+        try {
+          r[E.KHR_BINARY_GLTF] = new ot(n);
+        } catch (l) {
+          t && t(l);
+          return;
+        }
+        s = JSON.parse(r[E.KHR_BINARY_GLTF].content);
+      } else
+        s = JSON.parse(o.decode(n));
+    else
+      s = n;
+    if (s.asset === void 0 || s.asset.version[0] < 2) {
+      t && t(new Error("THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported."));
+      return;
+    }
+    const c = new Rt(s, {
+      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, r[l.name] = !0;
+    }
+    if (s.extensionsUsed)
+      for (let u = 0; u < s.extensionsUsed.length; ++u) {
+        const l = s.extensionsUsed[u], f = s.extensionsRequired || [];
+        switch (l) {
+          case E.KHR_MATERIALS_UNLIT:
+            r[l] = new Kn();
+            break;
+          case E.KHR_DRACO_MESH_COMPRESSION:
+            r[l] = new at(s, this.dracoLoader);
+            break;
+          case E.KHR_TEXTURE_TRANSFORM:
+            r[l] = new ct();
+            break;
+          case E.KHR_MESH_QUANTIZATION:
+            r[l] = new lt();
+            break;
+          default:
+            f.indexOf(l) >= 0 && a[l] === void 0 && console.warn('THREE.GLTFLoader: Unknown extension "' + l + '".');
+        }
+      }
+    c.setExtensions(r), c.setPlugins(a), c.parse(i, t);
+  }
+  /**
+   * 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 i = this;
+    return new Promise(function(t, s) {
+      i.parse(n, e, t, s);
+    });
+  }
+}
+function jn() {
+  let d = {};
+  return {
+    get: function(n) {
+      return d[n];
+    },
+    add: function(n, e) {
+      d[n] = e;
+    },
+    remove: function(n) {
+      delete d[n];
+    },
+    removeAll: function() {
+      d = {};
+    }
+  };
+}
+const E = {
+  KHR_BINARY_GLTF: "KHR_binary_glTF",
+  KHR_DRACO_MESH_COMPRESSION: "KHR_draco_mesh_compression",
+  KHR_LIGHTS_PUNCTUAL: "KHR_lights_punctual",
+  KHR_MATERIALS_CLEARCOAT: "KHR_materials_clearcoat",
+  KHR_MATERIALS_DISPERSION: "KHR_materials_dispersion",
+  KHR_MATERIALS_IOR: "KHR_materials_ior",
+  KHR_MATERIALS_SHEEN: "KHR_materials_sheen",
+  KHR_MATERIALS_SPECULAR: "KHR_materials_specular",
+  KHR_MATERIALS_TRANSMISSION: "KHR_materials_transmission",
+  KHR_MATERIALS_IRIDESCENCE: "KHR_materials_iridescence",
+  KHR_MATERIALS_ANISOTROPY: "KHR_materials_anisotropy",
+  KHR_MATERIALS_UNLIT: "KHR_materials_unlit",
+  KHR_MATERIALS_VOLUME: "KHR_materials_volume",
+  KHR_TEXTURE_BASISU: "KHR_texture_basisu",
+  KHR_TEXTURE_TRANSFORM: "KHR_texture_transform",
+  KHR_MESH_QUANTIZATION: "KHR_mesh_quantization",
+  KHR_MATERIALS_EMISSIVE_STRENGTH: "KHR_materials_emissive_strength",
+  EXT_MATERIALS_BUMP: "EXT_materials_bump",
+  EXT_TEXTURE_WEBP: "EXT_texture_webp",
+  EXT_TEXTURE_AVIF: "EXT_texture_avif",
+  EXT_MESHOPT_COMPRESSION: "EXT_meshopt_compression",
+  EXT_MESH_GPU_INSTANCING: "EXT_mesh_gpu_instancing"
+};
+class Bn {
+  constructor(n) {
+    this.parser = n, this.name = E.KHR_LIGHTS_PUNCTUAL, this.cache = { refs: {}, uses: {} };
+  }
+  _markDefs() {
+    const n = this.parser, e = this.parser.json.nodes || [];
+    for (let i = 0, t = e.length; i < t; i++) {
+      const s = e[i];
+      s.extensions && s.extensions[this.name] && s.extensions[this.name].light !== void 0 && n._addNodeRef(this.cache, s.extensions[this.name].light);
+    }
+  }
+  _loadLight(n) {
+    const e = this.parser, i = "light:" + n;
+    let t = e.cache.get(i);
+    if (t) return t;
+    const s = e.json, o = ((s.extensions && s.extensions[this.name] || {}).lights || [])[n];
+    let c;
+    const u = new G(16777215);
+    o.color !== void 0 && u.setRGB(o.color[0], o.color[1], o.color[2], F);
+    const l = o.range !== void 0 ? o.range : 0;
+    switch (o.type) {
+      case "directional":
+        c = new on(u), c.target.position.set(0, 0, -1), c.add(c.target);
+        break;
+      case "point":
+        c = new rn(u), c.distance = l;
+        break;
+      case "spot":
+        c = new sn(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), k(c, o), o.intensity !== void 0 && (c.intensity = o.intensity), c.name = e.createUniqueName(o.name || "light_" + n), t = Promise.resolve(c), e.cache.add(i, t), t;
+  }
+  getDependency(n, e) {
+    if (n === "light")
+      return this._loadLight(e);
+  }
+  createNodeAttachment(n) {
+    const e = this, i = this.parser, s = i.json.nodes[n], a = (s.extensions && s.extensions[this.name] || {}).light;
+    return a === void 0 ? null : this._loadLight(a).then(function(o) {
+      return i._getNodeRef(e.cache, a, o);
+    });
+  }
+}
+class Kn {
+  constructor() {
+    this.name = E.KHR_MATERIALS_UNLIT;
+  }
+  getMaterialType() {
+    return q;
+  }
+  extendParams(n, e, i) {
+    const t = [];
+    n.color = new G(1, 1, 1), n.opacity = 1;
+    const s = e.pbrMetallicRoughness;
+    if (s) {
+      if (Array.isArray(s.baseColorFactor)) {
+        const r = s.baseColorFactor;
+        n.color.setRGB(r[0], r[1], r[2], F), n.opacity = r[3];
+      }
+      s.baseColorTexture !== void 0 && t.push(i.assignTexture(n, "map", s.baseColorTexture, Y));
+    }
+    return Promise.all(t);
+  }
+}
+class Vn {
+  constructor(n) {
+    this.parser = n, this.name = E.KHR_MATERIALS_EMISSIVE_STRENGTH;
+  }
+  extendMaterialParams(n, e) {
+    const t = this.parser.json.materials[n];
+    if (!t.extensions || !t.extensions[this.name])
+      return Promise.resolve();
+    const s = t.extensions[this.name].emissiveStrength;
+    return s !== void 0 && (e.emissiveIntensity = s), Promise.resolve();
+  }
+}
+class zn {
+  constructor(n) {
+    this.parser = n, this.name = E.KHR_MATERIALS_CLEARCOAT;
+  }
+  getMaterialType(n) {
+    const i = this.parser.json.materials[n];
+    return !i.extensions || !i.extensions[this.name] ? null : O;
+  }
+  extendMaterialParams(n, e) {
+    const i = this.parser, t = i.json.materials[n];
+    if (!t.extensions || !t.extensions[this.name])
+      return Promise.resolve();
+    const s = [], r = t.extensions[this.name];
+    if (r.clearcoatFactor !== void 0 && (e.clearcoat = r.clearcoatFactor), r.clearcoatTexture !== void 0 && s.push(i.assignTexture(e, "clearcoatMap", r.clearcoatTexture)), r.clearcoatRoughnessFactor !== void 0 && (e.clearcoatRoughness = r.clearcoatRoughnessFactor), r.clearcoatRoughnessTexture !== void 0 && s.push(i.assignTexture(e, "clearcoatRoughnessMap", r.clearcoatRoughnessTexture)), r.clearcoatNormalTexture !== void 0 && (s.push(i.assignTexture(e, "clearcoatNormalMap", r.clearcoatNormalTexture)), r.clearcoatNormalTexture.scale !== void 0)) {
+      const a = r.clearcoatNormalTexture.scale;
+      e.clearcoatNormalScale = new Se(a, a);
+    }
+    return Promise.all(s);
+  }
+}
+class Xn {
+  constructor(n) {
+    this.parser = n, this.name = E.KHR_MATERIALS_DISPERSION;
+  }
+  getMaterialType(n) {
+    const i = this.parser.json.materials[n];
+    return !i.extensions || !i.extensions[this.name] ? null : O;
+  }
+  extendMaterialParams(n, e) {
+    const t = this.parser.json.materials[n];
+    if (!t.extensions || !t.extensions[this.name])
+      return Promise.resolve();
+    const s = t.extensions[this.name];
+    return e.dispersion = s.dispersion !== void 0 ? s.dispersion : 0, Promise.resolve();
+  }
+}
+class qn {
+  constructor(n) {
+    this.parser = n, this.name = E.KHR_MATERIALS_IRIDESCENCE;
+  }
+  getMaterialType(n) {
+    const i = this.parser.json.materials[n];
+    return !i.extensions || !i.extensions[this.name] ? null : O;
+  }
+  extendMaterialParams(n, e) {
+    const i = this.parser, t = i.json.materials[n];
+    if (!t.extensions || !t.extensions[this.name])
+      return Promise.resolve();
+    const s = [], r = t.extensions[this.name];
+    return r.iridescenceFactor !== void 0 && (e.iridescence = r.iridescenceFactor), r.iridescenceTexture !== void 0 && s.push(i.assignTexture(e, "iridescenceMap", r.iridescenceTexture)), r.iridescenceIor !== void 0 && (e.iridescenceIOR = r.iridescenceIor), e.iridescenceThicknessRange === void 0 && (e.iridescenceThicknessRange = [100, 400]), r.iridescenceThicknessMinimum !== void 0 && (e.iridescenceThicknessRange[0] = r.iridescenceThicknessMinimum), r.iridescenceThicknessMaximum !== void 0 && (e.iridescenceThicknessRange[1] = r.iridescenceThicknessMaximum), r.iridescenceThicknessTexture !== void 0 && s.push(i.assignTexture(e, "iridescenceThicknessMap", r.iridescenceThicknessTexture)), Promise.all(s);
+  }
+}
+class Wn {
+  constructor(n) {
+    this.parser = n, this.name = E.KHR_MATERIALS_SHEEN;
+  }
+  getMaterialType(n) {
+    const i = this.parser.json.materials[n];
+    return !i.extensions || !i.extensions[this.name] ? null : O;
+  }
+  extendMaterialParams(n, e) {
+    const i = this.parser, t = i.json.materials[n];
+    if (!t.extensions || !t.extensions[this.name])
+      return Promise.resolve();
+    const s = [];
+    e.sheenColor = new G(0, 0, 0), e.sheenRoughness = 0, e.sheen = 1;
+    const r = t.extensions[this.name];
+    if (r.sheenColorFactor !== void 0) {
+      const a = r.sheenColorFactor;
+      e.sheenColor.setRGB(a[0], a[1], a[2], F);
+    }
+    return r.sheenRoughnessFactor !== void 0 && (e.sheenRoughness = r.sheenRoughnessFactor), r.sheenColorTexture !== void 0 && s.push(i.assignTexture(e, "sheenColorMap", r.sheenColorTexture, Y)), r.sheenRoughnessTexture !== void 0 && s.push(i.assignTexture(e, "sheenRoughnessMap", r.sheenRoughnessTexture)), Promise.all(s);
+  }
+}
+class Yn {
+  constructor(n) {
+    this.parser = n, this.name = E.KHR_MATERIALS_TRANSMISSION;
+  }
+  getMaterialType(n) {
+    const i = this.parser.json.materials[n];
+    return !i.extensions || !i.extensions[this.name] ? null : O;
+  }
+  extendMaterialParams(n, e) {
+    const i = this.parser, t = i.json.materials[n];
+    if (!t.extensions || !t.extensions[this.name])
+      return Promise.resolve();
+    const s = [], r = t.extensions[this.name];
+    return r.transmissionFactor !== void 0 && (e.transmission = r.transmissionFactor), r.transmissionTexture !== void 0 && s.push(i.assignTexture(e, "transmissionMap", r.transmissionTexture)), Promise.all(s);
+  }
+}
+class $n {
+  constructor(n) {
+    this.parser = n, this.name = E.KHR_MATERIALS_VOLUME;
+  }
+  getMaterialType(n) {
+    const i = this.parser.json.materials[n];
+    return !i.extensions || !i.extensions[this.name] ? null : O;
+  }
+  extendMaterialParams(n, e) {
+    const i = this.parser, t = i.json.materials[n];
+    if (!t.extensions || !t.extensions[this.name])
+      return Promise.resolve();
+    const s = [], r = t.extensions[this.name];
+    e.thickness = r.thicknessFactor !== void 0 ? r.thicknessFactor : 0, r.thicknessTexture !== void 0 && s.push(i.assignTexture(e, "thicknessMap", r.thicknessTexture)), e.attenuationDistance = r.attenuationDistance || 1 / 0;
+    const a = r.attenuationColor || [1, 1, 1];
+    return e.attenuationColor = new G().setRGB(a[0], a[1], a[2], F), Promise.all(s);
+  }
+}
+class Jn {
+  constructor(n) {
+    this.parser = n, this.name = E.KHR_MATERIALS_IOR;
+  }
+  getMaterialType(n) {
+    const i = this.parser.json.materials[n];
+    return !i.extensions || !i.extensions[this.name] ? null : O;
+  }
+  extendMaterialParams(n, e) {
+    const t = this.parser.json.materials[n];
+    if (!t.extensions || !t.extensions[this.name])
+      return Promise.resolve();
+    const s = t.extensions[this.name];
+    return e.ior = s.ior !== void 0 ? s.ior : 1.5, Promise.resolve();
+  }
+}
+class Qn {
+  constructor(n) {
+    this.parser = n, this.name = E.KHR_MATERIALS_SPECULAR;
+  }
+  getMaterialType(n) {
+    const i = this.parser.json.materials[n];
+    return !i.extensions || !i.extensions[this.name] ? null : O;
+  }
+  extendMaterialParams(n, e) {
+    const i = this.parser, t = i.json.materials[n];
+    if (!t.extensions || !t.extensions[this.name])
+      return Promise.resolve();
+    const s = [], r = t.extensions[this.name];
+    e.specularIntensity = r.specularFactor !== void 0 ? r.specularFactor : 1, r.specularTexture !== void 0 && s.push(i.assignTexture(e, "specularIntensityMap", r.specularTexture));
+    const a = r.specularColorFactor || [1, 1, 1];
+    return e.specularColor = new G().setRGB(a[0], a[1], a[2], F), r.specularColorTexture !== void 0 && s.push(i.assignTexture(e, "specularColorMap", r.specularColorTexture, Y)), Promise.all(s);
+  }
+}
+class Zn {
+  constructor(n) {
+    this.parser = n, this.name = E.EXT_MATERIALS_BUMP;
+  }
+  getMaterialType(n) {
+    const i = this.parser.json.materials[n];
+    return !i.extensions || !i.extensions[this.name] ? null : O;
+  }
+  extendMaterialParams(n, e) {
+    const i = this.parser, t = i.json.materials[n];
+    if (!t.extensions || !t.extensions[this.name])
+      return Promise.resolve();
+    const s = [], r = t.extensions[this.name];
+    return e.bumpScale = r.bumpFactor !== void 0 ? r.bumpFactor : 1, r.bumpTexture !== void 0 && s.push(i.assignTexture(e, "bumpMap", r.bumpTexture)), Promise.all(s);
+  }
+}
+class et {
+  constructor(n) {
+    this.parser = n, this.name = E.KHR_MATERIALS_ANISOTROPY;
+  }
+  getMaterialType(n) {
+    const i = this.parser.json.materials[n];
+    return !i.extensions || !i.extensions[this.name] ? null : O;
+  }
+  extendMaterialParams(n, e) {
+    const i = this.parser, t = i.json.materials[n];
+    if (!t.extensions || !t.extensions[this.name])
+      return Promise.resolve();
+    const s = [], r = t.extensions[this.name];
+    return r.anisotropyStrength !== void 0 && (e.anisotropy = r.anisotropyStrength), r.anisotropyRotation !== void 0 && (e.anisotropyRotation = r.anisotropyRotation), r.anisotropyTexture !== void 0 && s.push(i.assignTexture(e, "anisotropyMap", r.anisotropyTexture)), Promise.all(s);
+  }
+}
+class nt {
+  constructor(n) {
+    this.parser = n, this.name = E.KHR_TEXTURE_BASISU;
+  }
+  loadTexture(n) {
+    const e = this.parser, i = e.json, t = i.textures[n];
+    if (!t.extensions || !t.extensions[this.name])
+      return null;
+    const s = t.extensions[this.name], r = e.options.ktx2Loader;
+    if (!r) {
+      if (i.extensionsRequired && i.extensionsRequired.indexOf(this.name) >= 0)
+        throw new Error("THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures");
+      return null;
+    }
+    return e.loadTextureImage(n, s.source, r);
+  }
+}
+class tt {
+  constructor(n) {
+    this.parser = n, this.name = E.EXT_TEXTURE_WEBP;
+  }
+  loadTexture(n) {
+    const e = this.name, i = this.parser, t = i.json, s = t.textures[n];
+    if (!s.extensions || !s.extensions[e])
+      return null;
+    const r = s.extensions[e], a = t.images[r.source];
+    let o = i.textureLoader;
+    if (a.uri) {
+      const c = i.options.manager.getHandler(a.uri);
+      c !== null && (o = c);
+    }
+    return i.loadTextureImage(n, r.source, o);
+  }
+}
+class st {
+  constructor(n) {
+    this.parser = n, this.name = E.EXT_TEXTURE_AVIF;
+  }
+  loadTexture(n) {
+    const e = this.name, i = this.parser, t = i.json, s = t.textures[n];
+    if (!s.extensions || !s.extensions[e])
+      return null;
+    const r = s.extensions[e], a = t.images[r.source];
+    let o = i.textureLoader;
+    if (a.uri) {
+      const c = i.options.manager.getHandler(a.uri);
+      c !== null && (o = c);
+    }
+    return i.loadTextureImage(n, r.source, o);
+  }
+}
+class rt {
+  constructor(n) {
+    this.name = E.EXT_MESHOPT_COMPRESSION, this.parser = n;
+  }
+  loadBufferView(n) {
+    const e = this.parser.json, i = e.bufferViews[n];
+    if (i.extensions && i.extensions[this.name]) {
+      const t = i.extensions[this.name], s = this.parser.getDependency("buffer", t.buffer), r = this.parser.options.meshoptDecoder;
+      if (!r || !r.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 s.then(function(a) {
+        const o = t.byteOffset || 0, c = t.byteLength || 0, u = t.count, l = t.byteStride, f = new Uint8Array(a, o, c);
+        return r.decodeGltfBufferAsync ? r.decodeGltfBufferAsync(u, l, f, t.mode, t.filter).then(function(h) {
+          return h.buffer;
+        }) : r.ready.then(function() {
+          const h = new ArrayBuffer(u * l);
+          return r.decodeGltfBuffer(new Uint8Array(h), u, l, f, t.mode, t.filter), h;
+        });
+      });
+    } else
+      return null;
+  }
+}
+class it {
+  constructor(n) {
+    this.name = E.EXT_MESH_GPU_INSTANCING, this.parser = n;
+  }
+  createNodeMesh(n) {
+    const e = this.parser.json, i = e.nodes[n];
+    if (!i.extensions || !i.extensions[this.name] || i.mesh === void 0)
+      return null;
+    const t = e.meshes[i.mesh];
+    for (const c of t.primitives)
+      if (c.mode !== C.TRIANGLES && c.mode !== C.TRIANGLE_STRIP && c.mode !== C.TRIANGLE_FAN && c.mode !== void 0)
+        return null;
+    const r = i.extensions[this.name].attributes, a = [], o = {};
+    for (const c in r)
+      a.push(this.parser.getDependency("accessor", r[c]).then((u) => (o[c] = u, o[c])));
+    return a.length < 1 ? null : (a.push(this.parser.createNodeMesh(n)), Promise.all(a).then((c) => {
+      const u = c.pop(), l = u.isGroup ? u.children : [u], f = c[0].count, h = [];
+      for (const p of l) {
+        const R = new Q(), m = new B(), g = new Ne(), A = new B(1, 1, 1), M = new an(p.geometry, p.material, f);
+        for (let T = 0; T < f; T++)
+          o.TRANSLATION && m.fromBufferAttribute(o.TRANSLATION, T), o.ROTATION && g.fromBufferAttribute(o.ROTATION, T), o.SCALE && A.fromBufferAttribute(o.SCALE, T), M.setMatrixAt(T, R.compose(m, g, A));
+        for (const T in o)
+          if (T === "_COLOR_0") {
+            const S = o[T];
+            M.instanceColor = new cn(S.array, S.itemSize, S.normalized);
+          } else T !== "TRANSLATION" && T !== "ROTATION" && T !== "SCALE" && p.geometry.setAttribute(T, o[T]);
+        Ie.prototype.copy.call(M, p), this.parser.assignFinalMaterial(M), h.push(M);
+      }
+      return u.isGroup ? (u.clear(), u.add(...h), u) : h[0];
+    }));
+  }
+}
+const De = "glTF", X = 12, Le = { JSON: 1313821514, BIN: 5130562 };
+class ot {
+  constructor(n) {
+    this.name = E.KHR_BINARY_GLTF, this.content = null, this.body = null;
+    const e = new DataView(n, 0, X), i = new TextDecoder();
+    if (this.header = {
+      magic: i.decode(new Uint8Array(n.slice(0, 4))),
+      version: e.getUint32(4, !0),
+      length: e.getUint32(8, !0)
+    }, this.header.magic !== De)
+      throw new Error("THREE.GLTFLoader: Unsupported glTF-Binary header.");
+    if (this.header.version < 2)
+      throw new Error("THREE.GLTFLoader: Legacy binary file detected.");
+    const t = this.header.length - X, s = new DataView(n, X);
+    let r = 0;
+    for (; r < t; ) {
+      const a = s.getUint32(r, !0);
+      r += 4;
+      const o = s.getUint32(r, !0);
+      if (r += 4, o === Le.JSON) {
+        const c = new Uint8Array(n, X + r, a);
+        this.content = i.decode(c);
+      } else if (o === Le.BIN) {
+        const c = X + r;
+        this.body = n.slice(c, c + a);
+      }
+      r += a;
+    }
+    if (this.content === null)
+      throw new Error("THREE.GLTFLoader: JSON content not found.");
+  }
+}
+class at {
+  constructor(n, e) {
+    if (!e)
+      throw new Error("THREE.GLTFLoader: No DRACOLoader instance provided.");
+    this.name = E.KHR_DRACO_MESH_COMPRESSION, this.json = n, this.dracoLoader = e, this.dracoLoader.preload();
+  }
+  decodePrimitive(n, e) {
+    const i = this.json, t = this.dracoLoader, s = n.extensions[this.name].bufferView, r = n.extensions[this.name].attributes, a = {}, o = {}, c = {};
+    for (const u in r) {
+      const l = de[u] || u.toLowerCase();
+      a[l] = r[u];
+    }
+    for (const u in n.attributes) {
+      const l = de[u] || u.toLowerCase();
+      if (r[u] !== void 0) {
+        const f = i.accessors[n.attributes[u]], h = V[f.componentType];
+        c[l] = h.name, o[l] = f.normalized === !0;
+      }
+    }
+    return e.getDependency("bufferView", s).then(function(u) {
+      return new Promise(function(l, f) {
+        t.decodeDracoFile(u, function(h) {
+          for (const p in h.attributes) {
+            const R = h.attributes[p], m = o[p];
+            m !== void 0 && (R.normalized = m);
+          }
+          l(h);
+        }, a, c, F, f);
+      });
+    });
+  }
+}
+class ct {
+  constructor() {
+    this.name = E.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 lt {
+  constructor() {
+    this.name = E.KHR_MESH_QUANTIZATION;
+  }
+}
+class He extends Pn {
+  constructor(n, e, i, t) {
+    super(n, e, i, t);
+  }
+  copySampleValue_(n) {
+    const e = this.resultBuffer, i = this.sampleValues, t = this.valueSize, s = n * t * 3 + t;
+    for (let r = 0; r !== t; r++)
+      e[r] = i[s + r];
+    return e;
+  }
+  interpolate_(n, e, i, t) {
+    const s = this.resultBuffer, r = this.sampleValues, a = this.valueSize, o = a * 2, c = a * 3, u = t - e, l = (i - e) / u, f = l * l, h = f * l, p = n * c, R = p - c, m = -2 * h + 3 * f, g = h - f, A = 1 - m, M = g - f + l;
+    for (let T = 0; T !== a; T++) {
+      const S = r[R + T + a], I = r[R + T + o] * u, L = r[p + T + a], v = r[p + T] * u;
+      s[T] = A * S + M * I + m * L + g * v;
+    }
+    return s;
+  }
+}
+const ut = new Ne();
+class dt extends He {
+  interpolate_(n, e, i, t) {
+    const s = super.interpolate_(n, e, i, t);
+    return ut.fromArray(s).normalize().toArray(s), s;
+  }
+}
+const C = {
+  POINTS: 0,
+  LINES: 1,
+  LINE_LOOP: 2,
+  LINE_STRIP: 3,
+  TRIANGLES: 4,
+  TRIANGLE_STRIP: 5,
+  TRIANGLE_FAN: 6
+}, V = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5125: Uint32Array,
+  5126: Float32Array
+}, _e = {
+  9728: Oe,
+  9729: le,
+  9984: pn,
+  9985: hn,
+  9986: fn,
+  9987: Ce
+}, Me = {
+  33071: gn,
+  33648: mn,
+  10497: ue
+}, ie = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+}, de = {
+  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"
+}, D = {
+  scale: "scale",
+  translation: "position",
+  rotation: "quaternion",
+  weights: "morphTargetInfluences"
+}, ft = {
+  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: Fe,
+  STEP: vn
+}, oe = {
+  OPAQUE: "OPAQUE",
+  MASK: "MASK",
+  BLEND: "BLEND"
+};
+function ht(d) {
+  return d.DefaultMaterial === void 0 && (d.DefaultMaterial = new ve({
+    color: 16777215,
+    emissive: 0,
+    metalness: 1,
+    roughness: 1,
+    transparent: !1,
+    depthTest: !0,
+    side: Fn
+  })), d.DefaultMaterial;
+}
+function U(d, n, e) {
+  for (const i in e.extensions)
+    d[i] === void 0 && (n.userData.gltfExtensions = n.userData.gltfExtensions || {}, n.userData.gltfExtensions[i] = e.extensions[i]);
+}
+function k(d, n) {
+  n.extras !== void 0 && (typeof n.extras == "object" ? Object.assign(d.userData, n.extras) : console.warn("THREE.GLTFLoader: Ignoring primitive type .extras, " + n.extras));
+}
+function pt(d, n, e) {
+  let i = !1, t = !1, s = !1;
+  for (let c = 0, u = n.length; c < u; c++) {
+    const l = n[c];
+    if (l.POSITION !== void 0 && (i = !0), l.NORMAL !== void 0 && (t = !0), l.COLOR_0 !== void 0 && (s = !0), i && t && s) break;
+  }
+  if (!i && !t && !s) return Promise.resolve(d);
+  const r = [], a = [], o = [];
+  for (let c = 0, u = n.length; c < u; c++) {
+    const l = n[c];
+    if (i) {
+      const f = l.POSITION !== void 0 ? e.getDependency("accessor", l.POSITION) : d.attributes.position;
+      r.push(f);
+    }
+    if (t) {
+      const f = l.NORMAL !== void 0 ? e.getDependency("accessor", l.NORMAL) : d.attributes.normal;
+      a.push(f);
+    }
+    if (s) {
+      const f = l.COLOR_0 !== void 0 ? e.getDependency("accessor", l.COLOR_0) : d.attributes.color;
+      o.push(f);
+    }
+  }
+  return Promise.all([
+    Promise.all(r),
+    Promise.all(a),
+    Promise.all(o)
+  ]).then(function(c) {
+    const u = c[0], l = c[1], f = c[2];
+    return i && (d.morphAttributes.position = u), t && (d.morphAttributes.normal = l), s && (d.morphAttributes.color = f), d.morphTargetsRelative = !0, d;
+  });
+}
+function mt(d, n) {
+  if (d.updateMorphTargets(), n.weights !== void 0)
+    for (let e = 0, i = n.weights.length; e < i; e++)
+      d.morphTargetInfluences[e] = n.weights[e];
+  if (n.extras && Array.isArray(n.extras.targetNames)) {
+    const e = n.extras.targetNames;
+    if (d.morphTargetInfluences.length === e.length) {
+      d.morphTargetDictionary = {};
+      for (let i = 0, t = e.length; i < t; i++)
+        d.morphTargetDictionary[e[i]] = i;
+    } else
+      console.warn("THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.");
+  }
+}
+function gt(d) {
+  let n;
+  const e = d.extensions && d.extensions[E.KHR_DRACO_MESH_COMPRESSION];
+  if (e ? n = "draco:" + e.bufferView + ":" + e.indices + ":" + ae(e.attributes) : n = d.indices + ":" + ae(d.attributes) + ":" + d.mode, d.targets !== void 0)
+    for (let i = 0, t = d.targets.length; i < t; i++)
+      n += ":" + ae(d.targets[i]);
+  return n;
+}
+function ae(d) {
+  let n = "";
+  const e = Object.keys(d).sort();
+  for (let i = 0, t = e.length; i < t; i++)
+    n += e[i] + ":" + d[e[i]] + ";";
+  return n;
+}
+function fe(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 Tt(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 xt = new Q();
+class Rt {
+  constructor(n = {}, e = {}) {
+    this.json = n, this.extensions = {}, this.plugins = {}, this.options = e, this.cache = new jn(), 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 i = !1, t = -1, s = !1, r = -1;
+    if (typeof navigator < "u") {
+      const a = navigator.userAgent;
+      i = /^((?!chrome|android).)*safari/i.test(a) === !0;
+      const o = a.match(/Version\/(\d+)/);
+      t = i && o ? parseInt(o[1], 10) : -1, s = a.indexOf("Firefox") > -1, r = s ? a.match(/Firefox\/([0-9]+)\./)[1] : -1;
+    }
+    typeof createImageBitmap > "u" || i && t < 17 || s && r < 98 ? this.textureLoader = new ln(this.options.manager) : this.textureLoader = new un(this.options.manager), this.textureLoader.setCrossOrigin(this.options.crossOrigin), this.textureLoader.setRequestHeader(this.options.requestHeader), this.fileLoader = new be(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 i = this, t = this.json, s = this.extensions;
+    this.cache.removeAll(), this.nodeCache = {}, this._invokeAll(function(r) {
+      return r._markDefs && r._markDefs();
+    }), Promise.all(this._invokeAll(function(r) {
+      return r.beforeRoot && r.beforeRoot();
+    })).then(function() {
+      return Promise.all([
+        i.getDependencies("scene"),
+        i.getDependencies("animation"),
+        i.getDependencies("camera")
+      ]);
+    }).then(function(r) {
+      const a = {
+        scene: r[0][t.scene || 0],
+        scenes: r[0],
+        animations: r[1],
+        cameras: r[2],
+        asset: t.asset,
+        parser: i,
+        userData: {}
+      };
+      return U(s, a, t), k(a, t), Promise.all(i._invokeAll(function(o) {
+        return o.afterRoot && o.afterRoot(a);
+      })).then(function() {
+        for (const o of a.scenes)
+          o.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 || [], i = this.json.meshes || [];
+    for (let t = 0, s = e.length; t < s; t++) {
+      const r = e[t].joints;
+      for (let a = 0, o = r.length; a < o; a++)
+        n[r[a]].isBone = !0;
+    }
+    for (let t = 0, s = n.length; t < s; t++) {
+      const r = n[t];
+      r.mesh !== void 0 && (this._addNodeRef(this.meshCache, r.mesh), r.skin !== void 0 && (i[r.mesh].isSkinnedMesh = !0)), r.camera !== void 0 && this._addNodeRef(this.cameraCache, r.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, i) {
+    if (n.refs[e] <= 1) return i;
+    const t = i.clone(), s = (r, a) => {
+      const o = this.associations.get(r);
+      o != null && this.associations.set(a, o);
+      for (const [c, u] of r.children.entries())
+        s(u, a.children[c]);
+    };
+    return s(i, t), t.name += "_instance_" + n.uses[e]++, t;
+  }
+  _invokeOne(n) {
+    const e = Object.values(this.plugins);
+    e.push(this);
+    for (let i = 0; i < e.length; i++) {
+      const t = n(e[i]);
+      if (t) return t;
+    }
+    return null;
+  }
+  _invokeAll(n) {
+    const e = Object.values(this.plugins);
+    e.unshift(this);
+    const i = [];
+    for (let t = 0; t < e.length; t++) {
+      const s = n(e[t]);
+      s && i.push(s);
+    }
+    return i;
+  }
+  /**
+   * Requests the specified dependency asynchronously, with caching.
+   *
+   * @private
+   * @param {string} type
+   * @param {number} index
+   * @return {Promise<Object3D|Material|THREE.Texture|AnimationClip|ArrayBuffer|Object>}
+   */
+  getDependency(n, e) {
+    const i = n + ":" + e;
+    let t = this.cache.get(i);
+    if (!t) {
+      switch (n) {
+        case "scene":
+          t = this.loadScene(e);
+          break;
+        case "node":
+          t = this._invokeOne(function(s) {
+            return s.loadNode && s.loadNode(e);
+          });
+          break;
+        case "mesh":
+          t = this._invokeOne(function(s) {
+            return s.loadMesh && s.loadMesh(e);
+          });
+          break;
+        case "accessor":
+          t = this.loadAccessor(e);
+          break;
+        case "bufferView":
+          t = this._invokeOne(function(s) {
+            return s.loadBufferView && s.loadBufferView(e);
+          });
+          break;
+        case "buffer":
+          t = this.loadBuffer(e);
+          break;
+        case "material":
+          t = this._invokeOne(function(s) {
+            return s.loadMaterial && s.loadMaterial(e);
+          });
+          break;
+        case "texture":
+          t = this._invokeOne(function(s) {
+            return s.loadTexture && s.loadTexture(e);
+          });
+          break;
+        case "skin":
+          t = this.loadSkin(e);
+          break;
+        case "animation":
+          t = this._invokeOne(function(s) {
+            return s.loadAnimation && s.loadAnimation(e);
+          });
+          break;
+        case "camera":
+          t = this.loadCamera(e);
+          break;
+        default:
+          if (t = this._invokeOne(function(s) {
+            return s != this && s.getDependency && s.getDependency(n, e);
+          }), !t)
+            throw new Error("Unknown type: " + n);
+          break;
+      }
+      this.cache.add(i, t);
+    }
+    return t;
+  }
+  /**
+   * 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 i = this, t = this.json[n + (n === "mesh" ? "es" : "s")] || [];
+      e = Promise.all(t.map(function(s, r) {
+        return i.getDependency(n, r);
+      })), 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], i = 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[E.KHR_BINARY_GLTF].body);
+    const t = this.options;
+    return new Promise(function(s, r) {
+      i.load(W.resolveURL(e.uri, t.path), s, void 0, function() {
+        r(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(i) {
+      const t = e.byteLength || 0, s = e.byteOffset || 0;
+      return i.slice(s, s + t);
+    });
+  }
+  /**
+   * 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, i = this.json, t = this.json.accessors[n];
+    if (t.bufferView === void 0 && t.sparse === void 0) {
+      const r = ie[t.type], a = V[t.componentType], o = t.normalized === !0, c = new a(t.count * r);
+      return Promise.resolve(new te(c, r, o));
+    }
+    const s = [];
+    return t.bufferView !== void 0 ? s.push(this.getDependency("bufferView", t.bufferView)) : s.push(null), t.sparse !== void 0 && (s.push(this.getDependency("bufferView", t.sparse.indices.bufferView)), s.push(this.getDependency("bufferView", t.sparse.values.bufferView))), Promise.all(s).then(function(r) {
+      const a = r[0], o = ie[t.type], c = V[t.componentType], u = c.BYTES_PER_ELEMENT, l = u * o, f = t.byteOffset || 0, h = t.bufferView !== void 0 ? i.bufferViews[t.bufferView].byteStride : void 0, p = t.normalized === !0;
+      let R, m;
+      if (h && h !== l) {
+        const g = Math.floor(f / h), A = "InterleavedBuffer:" + t.bufferView + ":" + t.componentType + ":" + g + ":" + t.count;
+        let M = e.cache.get(A);
+        M || (R = new c(a, g * h, t.count * h / u), M = new dn(R, h / u), e.cache.add(A, M)), m = new kn(M, o, f % h / u, p);
+      } else
+        a === null ? R = new c(t.count * o) : R = new c(a, f, t.count * o), m = new te(R, o, p);
+      if (t.sparse !== void 0) {
+        const g = ie.SCALAR, A = V[t.sparse.indices.componentType], M = t.sparse.indices.byteOffset || 0, T = t.sparse.values.byteOffset || 0, S = new A(r[1], M, t.sparse.count * g), I = new c(r[2], T, t.sparse.count * o);
+        a !== null && (m = new te(m.array.slice(), m.itemSize, m.normalized)), m.normalized = !1;
+        for (let L = 0, v = S.length; L < v; L++) {
+          const w = S[L];
+          if (m.setX(w, I[L * o]), o >= 2 && m.setY(w, I[L * o + 1]), o >= 3 && m.setZ(w, I[L * o + 2]), o >= 4 && m.setW(w, I[L * o + 3]), o >= 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<THREE.Texture|null>}
+   */
+  loadTexture(n) {
+    const e = this.json, i = this.options, s = e.textures[n].source, r = e.images[s];
+    let a = this.textureLoader;
+    if (r.uri) {
+      const o = i.manager.getHandler(r.uri);
+      o !== null && (a = o);
+    }
+    return this.loadTextureImage(n, s, a);
+  }
+  loadTextureImage(n, e, i) {
+    const t = this, s = this.json, r = s.textures[n], a = s.images[e], o = (a.uri || a.bufferView) + ":" + r.sampler;
+    if (this.textureCache[o])
+      return this.textureCache[o];
+    const c = this.loadImageSource(e, i).then(function(u) {
+      u.flipY = !1, u.name = r.name || a.name || "", u.name === "" && typeof a.uri == "string" && a.uri.startsWith("data:image/") === !1 && (u.name = a.uri);
+      const f = (s.samplers || {})[r.sampler] || {};
+      return u.magFilter = _e[f.magFilter] || le, u.minFilter = _e[f.minFilter] || Ce, u.wrapS = Me[f.wrapS] || ue, u.wrapT = Me[f.wrapT] || ue, u.generateMipmaps = !u.isCompressedTexture && u.minFilter !== Oe && u.minFilter !== le, t.associations.set(u, { textures: n }), u;
+    }).catch(function() {
+      return null;
+    });
+    return this.textureCache[o] = c, c;
+  }
+  loadImageSource(n, e) {
+    const i = this, t = this.json, s = this.options;
+    if (this.sourceCache[n] !== void 0)
+      return this.sourceCache[n].then((l) => l.clone());
+    const r = t.images[n], a = self.URL || self.webkitURL;
+    let o = r.uri || "", c = !1;
+    if (r.bufferView !== void 0)
+      o = i.getDependency("bufferView", r.bufferView).then(function(l) {
+        c = !0;
+        const f = new Blob([l], { type: r.mimeType });
+        return o = a.createObjectURL(f), o;
+      });
+    else if (r.uri === void 0)
+      throw new Error("THREE.GLTFLoader: Image " + n + " is missing URI and bufferView");
+    const u = Promise.resolve(o).then(function(l) {
+      return new Promise(function(f, h) {
+        let p = f;
+        e.isImageBitmapLoader === !0 && (p = function(R) {
+          const m = new me(R);
+          m.needsUpdate = !0, f(m);
+        }), e.load(W.resolveURL(l, s.path), p, void 0, h);
+      });
+    }).then(function(l) {
+      return c === !0 && a.revokeObjectURL(o), k(l, r), l.userData.mimeType = r.mimeType || Tt(r.uri), l;
+    }).catch(function(l) {
+      throw console.error("THREE.GLTFLoader: Couldn't load texture", o), l;
+    });
+    return this.sourceCache[n] = 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(n, e, i, t) {
+    const s = this;
+    return this.getDependency("texture", i.index).then(function(r) {
+      if (!r) return null;
+      if (i.texCoord !== void 0 && i.texCoord > 0 && (r = r.clone(), r.channel = i.texCoord), s.extensions[E.KHR_TEXTURE_TRANSFORM]) {
+        const a = i.extensions !== void 0 ? i.extensions[E.KHR_TEXTURE_TRANSFORM] : void 0;
+        if (a) {
+          const o = s.associations.get(r);
+          r = s.extensions[E.KHR_TEXTURE_TRANSFORM].extendTexture(r, a), s.associations.set(r, o);
+        }
+      }
+      return t !== void 0 && (r.colorSpace = t), n[e] = r, r;
+    });
+  }
+  /**
+   * 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 i = n.material;
+    const t = e.attributes.tangent === void 0, s = e.attributes.color !== void 0, r = e.attributes.normal === void 0;
+    if (n.isPoints) {
+      const a = "PointsMaterial:" + i.uuid;
+      let o = this.cache.get(a);
+      o || (o = new Tn(), se.prototype.copy.call(o, i), o.color.copy(i.color), o.map = i.map, o.sizeAttenuation = !1, this.cache.add(a, o)), i = o;
+    } else if (n.isLine) {
+      const a = "LineBasicMaterial:" + i.uuid;
+      let o = this.cache.get(a);
+      o || (o = new xn(), se.prototype.copy.call(o, i), o.color.copy(i.color), o.map = i.map, this.cache.add(a, o)), i = o;
+    }
+    if (t || s || r) {
+      let a = "ClonedMaterial:" + i.uuid + ":";
+      t && (a += "derivative-tangents:"), s && (a += "vertex-colors:"), r && (a += "flat-shading:");
+      let o = this.cache.get(a);
+      o || (o = i.clone(), s && (o.vertexColors = !0), r && (o.flatShading = !0), t && (o.normalScale && (o.normalScale.y *= -1), o.clearcoatNormalScale && (o.clearcoatNormalScale.y *= -1)), this.cache.add(a, o), this.associations.set(o, this.associations.get(i))), i = o;
+    }
+    n.material = i;
+  }
+  getMaterialType() {
+    return ve;
+  }
+  /**
+   * 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, i = this.json, t = this.extensions, s = i.materials[n];
+    let r;
+    const a = {}, o = s.extensions || {}, c = [];
+    if (o[E.KHR_MATERIALS_UNLIT]) {
+      const l = t[E.KHR_MATERIALS_UNLIT];
+      r = l.getMaterialType(), c.push(l.extendParams(a, s, e));
+    } else {
+      const l = s.pbrMetallicRoughness || {};
+      if (a.color = new G(1, 1, 1), a.opacity = 1, Array.isArray(l.baseColorFactor)) {
+        const f = l.baseColorFactor;
+        a.color.setRGB(f[0], f[1], f[2], F), a.opacity = f[3];
+      }
+      l.baseColorTexture !== void 0 && c.push(e.assignTexture(a, "map", l.baseColorTexture, Y)), 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))), r = this._invokeOne(function(f) {
+        return f.getMaterialType && f.getMaterialType(n);
+      }), c.push(Promise.all(this._invokeAll(function(f) {
+        return f.extendMaterialParams && f.extendMaterialParams(n, a);
+      })));
+    }
+    s.doubleSided === !0 && (a.side = Rn);
+    const u = s.alphaMode || oe.OPAQUE;
+    if (u === oe.BLEND ? (a.transparent = !0, a.depthWrite = !1) : (a.transparent = !1, u === oe.MASK && (a.alphaTest = s.alphaCutoff !== void 0 ? s.alphaCutoff : 0.5)), s.normalTexture !== void 0 && r !== q && (c.push(e.assignTexture(a, "normalMap", s.normalTexture)), a.normalScale = new Se(1, 1), s.normalTexture.scale !== void 0)) {
+      const l = s.normalTexture.scale;
+      a.normalScale.set(l, l);
+    }
+    if (s.occlusionTexture !== void 0 && r !== q && (c.push(e.assignTexture(a, "aoMap", s.occlusionTexture)), s.occlusionTexture.strength !== void 0 && (a.aoMapIntensity = s.occlusionTexture.strength)), s.emissiveFactor !== void 0 && r !== q) {
+      const l = s.emissiveFactor;
+      a.emissive = new G().setRGB(l[0], l[1], l[2], F);
+    }
+    return s.emissiveTexture !== void 0 && r !== q && c.push(e.assignTexture(a, "emissiveMap", s.emissiveTexture, Y)), Promise.all(c).then(function() {
+      const l = new r(a);
+      return s.name && (l.name = s.name), k(l, s), e.associations.set(l, { materials: n }), s.extensions && U(t, l, s), l;
+    });
+  }
+  /**
+   * When Object3D instances are targeted by animation, they need unique names.
+   *
+   * @private
+   * @param {string} originalName
+   * @return {string}
+   */
+  createUniqueName(n) {
+    const e = En.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, i = this.extensions, t = this.primitiveCache;
+    function s(a) {
+      return i[E.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(a, e).then(function(o) {
+        return we(o, a, e);
+      });
+    }
+    const r = [];
+    for (let a = 0, o = n.length; a < o; a++) {
+      const c = n[a], u = gt(c), l = t[u];
+      if (l)
+        r.push(l.promise);
+      else {
+        let f;
+        c.extensions && c.extensions[E.KHR_DRACO_MESH_COMPRESSION] ? f = s(c) : f = we(new An(), c, e), t[u] = { primitive: c, promise: f }, r.push(f);
+      }
+    }
+    return Promise.all(r);
+  }
+  /**
+   * 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, i = this.json, t = this.extensions, s = i.meshes[n], r = s.primitives, a = [];
+    for (let o = 0, c = r.length; o < c; o++) {
+      const u = r[o].material === void 0 ? ht(this.cache) : this.getDependency("material", r[o].material);
+      a.push(u);
+    }
+    return a.push(e.loadGeometries(r)), Promise.all(a).then(function(o) {
+      const c = o.slice(0, o.length - 1), u = o[o.length - 1], l = [];
+      for (let h = 0, p = u.length; h < p; h++) {
+        const R = u[h], m = r[h];
+        let g;
+        const A = c[h];
+        if (m.mode === C.TRIANGLES || m.mode === C.TRIANGLE_STRIP || m.mode === C.TRIANGLE_FAN || m.mode === void 0)
+          g = s.isSkinnedMesh === !0 ? new Ln(R, A) : new ke(R, A), g.isSkinnedMesh === !0 && g.normalizeSkinWeights(), m.mode === C.TRIANGLE_STRIP ? g.geometry = Ae(g.geometry, ye) : m.mode === C.TRIANGLE_FAN && (g.geometry = Ae(g.geometry, ce));
+        else if (m.mode === C.LINES)
+          g = new _n(R, A);
+        else if (m.mode === C.LINE_STRIP)
+          g = new Mn(R, A);
+        else if (m.mode === C.LINE_LOOP)
+          g = new wn(R, A);
+        else if (m.mode === C.POINTS)
+          g = new yn(R, A);
+        else
+          throw new Error("THREE.GLTFLoader: Primitive mode unsupported: " + m.mode);
+        Object.keys(g.geometry.morphAttributes).length > 0 && mt(g, s), g.name = e.createUniqueName(s.name || "mesh_" + n), k(g, s), m.extensions && U(t, g, m), e.assignFinalMaterial(g), l.push(g);
+      }
+      for (let h = 0, p = l.length; h < p; h++)
+        e.associations.set(l[h], {
+          meshes: n,
+          primitives: h
+        });
+      if (l.length === 1)
+        return s.extensions && U(t, l[0], s), l[0];
+      const f = new re();
+      s.extensions && U(t, f, s), e.associations.set(f, { meshes: n });
+      for (let h = 0, p = l.length; h < p; 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<THREE.Camera>}
+   */
+  loadCamera(n) {
+    let e;
+    const i = this.json.cameras[n], t = i[i.type];
+    if (!t) {
+      console.warn("THREE.GLTFLoader: Missing camera parameters.");
+      return;
+    }
+    return i.type === "perspective" ? e = new bn(Sn.radToDeg(t.yfov), t.aspectRatio || 1, t.znear || 1, t.zfar || 2e6) : i.type === "orthographic" && (e = new Nn(-t.xmag, t.xmag, t.ymag, -t.ymag, t.znear, t.zfar)), i.name && (e.name = this.createUniqueName(i.name)), k(e, i), 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], i = [];
+    for (let t = 0, s = e.joints.length; t < s; t++)
+      i.push(this._loadNodeShallow(e.joints[t]));
+    return e.inverseBindMatrices !== void 0 ? i.push(this.getDependency("accessor", e.inverseBindMatrices)) : i.push(null), Promise.all(i).then(function(t) {
+      const s = t.pop(), r = t, a = [], o = [];
+      for (let c = 0, u = r.length; c < u; c++) {
+        const l = r[c];
+        if (l) {
+          a.push(l);
+          const f = new Q();
+          s !== null && f.fromArray(s.array, c * 16), o.push(f);
+        } else
+          console.warn('THREE.GLTFLoader: Joint "%s" could not be found.', e.joints[c]);
+      }
+      return new In(a, o);
+    });
+  }
+  /**
+   * 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, i = this, t = e.animations[n], s = t.name ? t.name : "animation_" + n, r = [], a = [], o = [], c = [], u = [];
+    for (let l = 0, f = t.channels.length; l < f; l++) {
+      const h = t.channels[l], p = t.samplers[h.sampler], R = h.target, m = R.node, g = t.parameters !== void 0 ? t.parameters[p.input] : p.input, A = t.parameters !== void 0 ? t.parameters[p.output] : p.output;
+      R.node !== void 0 && (r.push(this.getDependency("node", m)), a.push(this.getDependency("accessor", g)), o.push(this.getDependency("accessor", A)), c.push(p), u.push(R));
+    }
+    return Promise.all([
+      Promise.all(r),
+      Promise.all(a),
+      Promise.all(o),
+      Promise.all(c),
+      Promise.all(u)
+    ]).then(function(l) {
+      const f = l[0], h = l[1], p = l[2], R = l[3], m = l[4], g = [];
+      for (let A = 0, M = f.length; A < M; A++) {
+        const T = f[A], S = h[A], I = p[A], L = R[A], v = m[A];
+        if (T === void 0) continue;
+        T.updateMatrix && T.updateMatrix();
+        const w = i._createAnimationTracks(T, S, I, L, v);
+        if (w)
+          for (let P = 0; P < w.length; P++)
+            g.push(w[P]);
+      }
+      return new Cn(s, void 0, g);
+    });
+  }
+  createNodeMesh(n) {
+    const e = this.json, i = this, t = e.nodes[n];
+    return t.mesh === void 0 ? null : i.getDependency("mesh", t.mesh).then(function(s) {
+      const r = i._getNodeRef(i.meshCache, t.mesh, s);
+      return t.weights !== void 0 && r.traverse(function(a) {
+        if (a.isMesh)
+          for (let o = 0, c = t.weights.length; o < c; o++)
+            a.morphTargetInfluences[o] = t.weights[o];
+      }), r;
+    });
+  }
+  /**
+   * 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, i = this, t = e.nodes[n], s = i._loadNodeShallow(n), r = [], a = t.children || [];
+    for (let c = 0, u = a.length; c < u; c++)
+      r.push(i.getDependency("node", a[c]));
+    const o = t.skin === void 0 ? Promise.resolve(null) : i.getDependency("skin", t.skin);
+    return Promise.all([
+      s,
+      Promise.all(r),
+      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, xt);
+      });
+      for (let h = 0, p = l.length; h < p; 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(n) {
+    const e = this.json, i = this.extensions, t = this;
+    if (this.nodeCache[n] !== void 0)
+      return this.nodeCache[n];
+    const s = e.nodes[n], r = s.name ? t.createUniqueName(s.name) : "", a = [], o = t._invokeOne(function(c) {
+      return c.createNodeMesh && c.createNodeMesh(n);
+    });
+    return o && a.push(o), s.camera !== void 0 && a.push(t.getDependency("camera", s.camera).then(function(c) {
+      return t._getNodeRef(t.cameraCache, s.camera, c);
+    })), t._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 u;
+      if (s.isBone === !0 ? u = new On() : c.length > 1 ? u = new re() : c.length === 1 ? u = c[0] : u = new Ie(), u !== c[0])
+        for (let l = 0, f = c.length; l < f; l++)
+          u.add(c[l]);
+      if (s.name && (u.userData.name = s.name, u.name = r), k(u, s), s.extensions && U(i, u, s), s.matrix !== void 0) {
+        const l = new Q();
+        l.fromArray(s.matrix), u.applyMatrix4(l);
+      } else
+        s.translation !== void 0 && u.position.fromArray(s.translation), s.rotation !== void 0 && u.quaternion.fromArray(s.rotation), s.scale !== void 0 && u.scale.fromArray(s.scale);
+      if (!t.associations.has(u))
+        t.associations.set(u, {});
+      else if (s.mesh !== void 0 && t.meshCache.refs[s.mesh] > 1) {
+        const l = t.associations.get(u);
+        t.associations.set(u, { ...l });
+      }
+      return t.associations.get(u).nodes = n, u;
+    }), 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, i = this.json.scenes[n], t = this, s = new re();
+    i.name && (s.name = t.createUniqueName(i.name)), k(s, i), i.extensions && U(e, s, i);
+    const r = i.nodes || [], a = [];
+    for (let o = 0, c = r.length; o < c; o++)
+      a.push(t.getDependency("node", r[o]));
+    return Promise.all(a).then(function(o) {
+      for (let u = 0, l = o.length; u < l; u++)
+        s.add(o[u]);
+      const c = (u) => {
+        const l = /* @__PURE__ */ new Map();
+        for (const [f, h] of t.associations)
+          (f instanceof se || f instanceof me) && l.set(f, h);
+        return u.traverse((f) => {
+          const h = t.associations.get(f);
+          h != null && l.set(f, h);
+        }), l;
+      };
+      return t.associations = c(s), s;
+    });
+  }
+  _createAnimationTracks(n, e, i, t, s) {
+    const r = [], a = n.name ? n.name : n.uuid, o = [];
+    D[s.path] === D.weights ? n.traverse(function(f) {
+      f.morphTargetInfluences && o.push(f.name ? f.name : f.uuid);
+    }) : o.push(a);
+    let c;
+    switch (D[s.path]) {
+      case D.weights:
+        c = Te;
+        break;
+      case D.rotation:
+        c = xe;
+        break;
+      case D.translation:
+      case D.scale:
+        c = ge;
+        break;
+      default:
+        switch (i.itemSize) {
+          case 1:
+            c = Te;
+            break;
+          case 2:
+          case 3:
+          default:
+            c = ge;
+            break;
+        }
+        break;
+    }
+    const u = t.interpolation !== void 0 ? ft[t.interpolation] : Fe, l = this._getArrayFromAccessor(i);
+    for (let f = 0, h = o.length; f < h; f++) {
+      const p = new c(
+        o[f] + "." + D[s.path],
+        e.array,
+        l,
+        u
+      );
+      t.interpolation === "CUBICSPLINE" && this._createCubicSplineTrackInterpolant(p), r.push(p);
+    }
+    return r;
+  }
+  _getArrayFromAccessor(n) {
+    let e = n.array;
+    if (n.normalized) {
+      const i = fe(e.constructor), t = new Float32Array(e.length);
+      for (let s = 0, r = e.length; s < r; s++)
+        t[s] = e[s] * i;
+      e = t;
+    }
+    return e;
+  }
+  _createCubicSplineTrackInterpolant(n) {
+    n.createInterpolant = function(i) {
+      const t = this instanceof xe ? dt : He;
+      return new t(this.times, this.values, this.getValueSize() / 3, i);
+    }, n.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = !0;
+  }
+}
+function Et(d, n, e) {
+  const i = n.attributes, t = new Pe();
+  if (i.POSITION !== void 0) {
+    const a = e.json.accessors[i.POSITION], o = a.min, c = a.max;
+    if (o !== void 0 && c !== void 0) {
+      if (t.set(
+        new B(o[0], o[1], o[2]),
+        new B(c[0], c[1], c[2])
+      ), a.normalized) {
+        const u = fe(V[a.componentType]);
+        t.min.multiplyScalar(u), t.max.multiplyScalar(u);
+      }
+    } else {
+      console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      return;
+    }
+  } else
+    return;
+  const s = n.targets;
+  if (s !== void 0) {
+    const a = new B(), o = new B();
+    for (let c = 0, u = s.length; c < u; c++) {
+      const l = s[c];
+      if (l.POSITION !== void 0) {
+        const f = e.json.accessors[l.POSITION], h = f.min, p = f.max;
+        if (h !== void 0 && p !== void 0) {
+          if (o.setX(Math.max(Math.abs(h[0]), Math.abs(p[0]))), o.setY(Math.max(Math.abs(h[1]), Math.abs(p[1]))), o.setZ(Math.max(Math.abs(h[2]), Math.abs(p[2]))), f.normalized) {
+            const R = fe(V[f.componentType]);
+            o.multiplyScalar(R);
+          }
+          a.max(o);
+        } else
+          console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      }
+    }
+    t.expandByVector(a);
+  }
+  d.boundingBox = t;
+  const r = new Dn();
+  t.getCenter(r.center), r.radius = t.min.distanceTo(t.max) / 2, d.boundingSphere = r;
+}
+function we(d, n, e) {
+  const i = n.attributes, t = [];
+  function s(r, a) {
+    return e.getDependency("accessor", r).then(function(o) {
+      d.setAttribute(a, o);
+    });
+  }
+  for (const r in i) {
+    const a = de[r] || r.toLowerCase();
+    a in d.attributes || t.push(s(i[r], a));
+  }
+  if (n.indices !== void 0 && !d.index) {
+    const r = e.getDependency("accessor", n.indices).then(function(a) {
+      d.setIndex(a);
+    });
+    t.push(r);
+  }
+  return Re.workingColorSpace !== F && "COLOR_0" in i && console.warn(`THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${Re.workingColorSpace}" not supported.`), k(d, n), Et(d, n, e), Promise.all(t).then(function() {
+    return n.targets !== void 0 ? pt(d, n.targets, e) : d;
+  });
+}
+function At() {
+  const d = K(!1), n = K(""), e = je([]), i = K(null), t = new Qe(), s = new Ze(), r = new en(), a = new Gn();
+  return {
+    isLoading: d,
+    loadingProgress: n,
+    loadedModels: e,
+    error: i,
+    loadModelsFromBlobs: async (c) => {
+      var h;
+      if (!c || c.length === 0) {
+        console.warn("loadModelsFromBlobs 加载的文件数组为空！");
+        return;
+      }
+      d.value = !0, n.value = "准备加载...", e.value = [], i.value = null;
+      const u = /* @__PURE__ */ new Map();
+      c.forEach((p) => {
+        p instanceof File && u.set(p.name.toLowerCase(), p);
+      });
+      const l = [], f = [];
+      try {
+        for (const p of c) {
+          const R = p.name || "unknown_file", m = (h = R.split(".").pop()) == null ? void 0 : h.toLowerCase();
+          if (m === "mtl") continue;
+          const g = URL.createObjectURL(p);
+          l.push(g);
+          let A = null;
+          const M = (T) => {
+            const S = T.lengthComputable ? T.loaded / T.total * 100 : 0;
+            n.value = `正在加载 ${R}... ${Math.round(S)}%`;
+          };
+          switch (n.value = `正在加载 ${R}... 0%`, m) {
+            case "obj":
+              const T = R.replace(/\.obj$/i, ".mtl").toLowerCase();
+              if (u.has(T)) {
+                const v = u.get(T), w = URL.createObjectURL(v);
+                l.push(w);
+                const P = await t.loadAsync(w);
+                P.preload(), s.setMaterials(P);
+              } else
+                s.setMaterials(null);
+              A = await s.loadAsync(g, M);
+              break;
+            case "stl":
+              const S = await r.loadAsync(g, M), I = new Hn({ color: 11184810, specular: 1118481, shininess: 200 });
+              A = new ke(S, I);
+              break;
+            case "gltf":
+            case "glb":
+              A = (await a.loadAsync(g, M)).scene;
+              break;
+            default:
+              console.warn(`不支持的文件类型: .${m}`), n.value = `不支持的文件类型: ${R}`;
+              continue;
+          }
+          A && (A.userData.boundingBox = new Pe().setFromObject(A), f.push(A));
+        }
+        e.value = f, n.value = "加载完成！";
+      } catch (p) {
+        throw console.error("加载模型时出错:", p), i.value = `加载失败: ${p.message || "未知错误"}`, n.value = "加载失败！", e.value = [], p;
+      } finally {
+        d.value = !1, l.forEach((p) => URL.revokeObjectURL(p));
+      }
+    }
+  };
+}
+const Lt = { class: "obj-viewer-container" }, _t = { class: "buttonGroup-topLeft" }, Mt = { class: "buttonGroup-left" }, wt = { class: "left-panel" }, yt = { class: "panel-header" }, bt = {
+  key: 0,
+  class: "clipping-content"
+}, St = { class: "radio-group" }, Nt = { class: "radio-label" }, It = { class: "radio-label" }, Ct = { class: "radio-label" }, Ot = { class: "radio-label" }, vt = {
+  key: 0,
+  class: "loading-overlay"
+}, kt = /* @__PURE__ */ Be({
+  __name: "threePreview",
+  props: {
+    fileBlobs: { default: () => [] }
+  },
+  setup(d) {
+    const n = d, e = K(null), i = K(!1), t = K(""), {
+      currentModels: s,
+      resetView: r,
+      initThreeJS: a,
+      handleResize: o,
+      getThreeJSObjects: c,
+      cleanup: u,
+      setModels: l,
+      axesHelperVisible: f,
+      toggleAxesVisibility: h
+    } = Ye(e), {
+      isLoading: p,
+      loadingProgress: R,
+      loadedModels: m,
+      error: g,
+      loadModelsFromBlobs: A
+    } = At(), { isAnimating: M, toggleAnimation: T, stopAnimation: S } = $e(c, s), { isClipping: I, activeClippingAxis: L, toggleClipping: v, updateClippingPlanes: w } = Je(
+      c,
+      s
+    ), P = () => {
+      h();
+    };
+    Z(() => n.fileBlobs, (N) => {
+      N && N.length > 0 && A(N).catch((x) => {
+        console.error("加载错误:", x);
+      });
+    }, {
+      immediate: !0,
+      deep: !0
+    }), Z(m, (N) => {
+      N && N.length > 0 && l(N);
+    }), Z(g, (N) => {
+      N && Ee.error(`模型加载失败: ${N}`);
+    });
+    const Ue = (N) => {
+      i.value = !0, t.value = N, I.value || v();
+    };
+    return Ke(async () => {
+      await Ve();
+      try {
+        a(), window.addEventListener("resize", o);
+      } catch (N) {
+        console.error("Three.js 初始化失败:", N), Ee.error("渲染引擎初始化失败！");
+      }
+    }), ze(() => {
+      t.value = "", window.removeEventListener("resize", o), M.value && S(), u();
+    }), (N, x) => {
+      const Ge = Xe("el-scrollbar");
+      return ne(), ee("div", Lt, [
+        _("div", {
+          ref_key: "threejsContainer",
+          ref: e,
+          class: "threejs-container"
+        }, null, 512),
+        x[15] || (x[15] = _("div", { class: "buttonGroup-top" }, null, -1)),
+        _("div", _t, [
+          H(j, {
+            name: "viewReset",
+            size: "24",
+            onClick: y(r),
+            title: "重置"
+          }, null, 8, ["onClick"]),
+          H(j, {
+            name: "fangda",
+            size: "24",
+            title: "放大"
+          }),
+          H(j, {
+            name: "suoxiao",
+            size: "24",
+            title: "缩小"
+          }),
+          H(j, {
+            name: "lookAround",
+            size: "24",
+            onClick: y(T),
+            title: y(M) ? "停止动画" : "动画视图"
+          }, null, 8, ["onClick", "title"]),
+          H(j, {
+            name: "zuobiaoxi",
+            size: "24",
+            active: y(f),
+            onClick: P,
+            title: "显隐坐标轴"
+          }, null, 8, ["active"])
+        ]),
+        _("div", Mt, [
+          H(j, {
+            name: "clipping",
+            size: "24",
+            onClick: x[0] || (x[0] = (b) => Ue("剖面视图")),
+            active: i.value && t.value === "剖面视图",
+            title: "剖面视图"
+          }, null, 8, ["active"])
+        ]),
+        x[16] || (x[16] = _("div", { class: "buttonGroup-right" }, null, -1)),
+        x[17] || (x[17] = _("div", { class: "buttonGroup-bottom" }, null, -1)),
+        z(_("div", wt, [
+          _("div", yt, [
+            _("span", null, pe(t.value), 1),
+            _("span", {
+              class: "close",
+              onClick: x[1] || (x[1] = (b) => i.value = !1)
+            }, " X ")
+          ]),
+          H(Ge, { "max-height": "650px" }, {
+            default: qe(() => [
+              t.value === "剖面视图" ? (ne(), ee("div", bt, [
+                _("div", St, [
+                  _("label", Nt, [
+                    z(_("input", {
+                      type: "radio",
+                      name: "clipping-axis",
+                      value: "none",
+                      "onUpdate:modelValue": x[2] || (x[2] = (b) => $(L) ? L.value = b : null),
+                      onChange: x[3] || (x[3] = //@ts-ignore
+                      (...b) => y(w) && y(w)(...b))
+                    }, null, 544), [
+                      [J, y(L)]
+                    ]),
+                    x[10] || (x[10] = _("span", { class: "radio-text" }, "无切割", -1))
+                  ]),
+                  _("label", It, [
+                    z(_("input", {
+                      type: "radio",
+                      name: "clipping-axis",
+                      value: "x",
+                      "onUpdate:modelValue": x[4] || (x[4] = (b) => $(L) ? L.value = b : null),
+                      onChange: x[5] || (x[5] = //@ts-ignore
+                      (...b) => y(w) && y(w)(...b))
+                    }, null, 544), [
+                      [J, y(L)]
+                    ]),
+                    x[11] || (x[11] = _("span", { class: "radio-text" }, "X轴切割", -1))
+                  ]),
+                  _("label", Ct, [
+                    z(_("input", {
+                      type: "radio",
+                      name: "clipping-axis",
+                      value: "y",
+                      "onUpdate:modelValue": x[6] || (x[6] = (b) => $(L) ? L.value = b : null),
+                      onChange: x[7] || (x[7] = //@ts-ignore
+                      (...b) => y(w) && y(w)(...b))
+                    }, null, 544), [
+                      [J, y(L)]
+                    ]),
+                    x[12] || (x[12] = _("span", { class: "radio-text" }, "Y轴切割", -1))
+                  ]),
+                  _("label", Ot, [
+                    z(_("input", {
+                      type: "radio",
+                      name: "clipping-axis",
+                      value: "z",
+                      "onUpdate:modelValue": x[8] || (x[8] = (b) => $(L) ? L.value = b : null),
+                      onChange: x[9] || (x[9] = //@ts-ignore
+                      (...b) => y(w) && y(w)(...b))
+                    }, null, 544), [
+                      [J, y(L)]
+                    ]),
+                    x[13] || (x[13] = _("span", { class: "radio-text" }, "Z轴切割", -1))
+                  ])
+                ])
+              ])) : he("", !0)
+            ]),
+            _: 1
+          })
+        ], 512), [
+          [We, i.value]
+        ]),
+        y(p) ? (ne(), ee("div", vt, [
+          x[14] || (x[14] = _("div", { class: "loading-spinner" }, null, -1)),
+          _("p", null, pe(y(R)), 1)
+        ])) : he("", !0)
+      ]);
+    };
+  }
+}), jt = /* @__PURE__ */ Un(kt, [["__scopeId", "data-v-cdd00cd0"]]);
+export {
+  jt as default
+};