@ridp/threejs 1.2.2 → 1.3.1

package/dist/useGLTFLoader-kuE8ICl_.js

@@ -0,0 +1,2477 @@
+import { TrianglesDrawMode as lt, TriangleFanDrawMode as ye, TriangleStripDrawMode as Ve, Loader as Xe, FileLoader as le, SRGBColorSpace as V, LinearSRGBColorSpace as F, BufferGeometry as qe, BufferAttribute as ie, Color as G, ColorManagement as Re, LoaderUtils as oe, MeshPhysicalMaterial as v, Vector2 as Se, SpotLight as ut, PointLight as dt, DirectionalLight as ht, Matrix4 as ee, Vector3 as _, Quaternion as We, InstancedMesh as ft, InstancedBufferAttribute as pt, Object3D as Ye, TextureLoader as mt, ImageBitmapLoader as gt, InterleavedBuffer as Tt, InterleavedBufferAttribute as xt, LinearMipmapLinearFilter as Je, NearestMipmapLinearFilter as yt, LinearMipmapNearestFilter as Rt, NearestMipmapNearestFilter as bt, LinearFilter as be, NearestFilter as Qe, RepeatWrapping as Ae, MirroredRepeatWrapping as At, ClampToEdgeWrapping as wt, PointsMaterial as _t, Material as he, LineBasicMaterial as Et, MeshStandardMaterial as Ze, DoubleSide as St, MeshBasicMaterial as re, PropertyBinding as Lt, SkinnedMesh as Mt, Mesh as It, LineSegments as Ct, Line as Nt, LineLoop as Ot, Points as Dt, Group as fe, PerspectiveCamera as $e, MathUtils as Z, OrthographicCamera as Pt, Skeleton as kt, AnimationClip as Ft, Bone as vt, InterpolateDiscrete as Ht, InterpolateLinear as et, Texture as Ce, VectorKeyframeTrack as Ne, NumberKeyframeTrack as Oe, QuaternionKeyframeTrack as De, FrontSide as Ut, Interpolant as Gt, Box3 as ue, Sphere as Bt, Matrix3 as tt, Ray as jt, WebGLRenderer as zt, Scene as Kt, Raycaster as Vt } from "three";
+import { ref as pe, shallowRef as Xt, onMounted as qt, onUnmounted as Wt, nextTick as Pe } from "vue";
+import { d as Yt, j as Jt, S as Qt, C as Zt, l as $t, o as en } from "./modelSerialize-5oJb1ka7.js";
+import tn from "dexie";
+function ke(h, e) {
+  if (e === lt)
+    return console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles."), h;
+  if (e === ye || e === Ve) {
+    let t = h.getIndex();
+    if (t === null) {
+      const i = [], a = h.getAttribute("position");
+      if (a !== void 0) {
+        for (let o = 0; o < a.count; o++)
+          i.push(o);
+        h.setIndex(i), t = h.getIndex();
+      } else
+        return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible."), h;
+    }
+    const r = t.count - 2, n = [];
+    if (e === ye)
+      for (let i = 1; i <= r; i++)
+        n.push(t.getX(0)), n.push(t.getX(i)), n.push(t.getX(i + 1));
+    else
+      for (let i = 0; i < r; i++)
+        i % 2 === 0 ? (n.push(t.getX(i)), n.push(t.getX(i + 1)), n.push(t.getX(i + 2))) : (n.push(t.getX(i + 2)), n.push(t.getX(i + 1)), n.push(t.getX(i)));
+    n.length / 3 !== r && console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unable to generate correct amount of triangles.");
+    const s = h.clone();
+    return s.setIndex(n), s.clearGroups(), s;
+  } else
+    return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unknown draw mode:", e), h;
+}
+const me = /* @__PURE__ */ new WeakMap();
+class nn extends Xe {
+  /**
+   * Constructs a new Draco loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
+  constructor(e) {
+    super(e), this.decoderPath = "", this.decoderConfig = {}, this.decoderBinary = null, this.decoderPending = null, this.workerLimit = 4, this.workerPool = [], this.workerNextTaskID = 1, this.workerSourceURL = "", this.defaultAttributeIDs = {
+      position: "POSITION",
+      normal: "NORMAL",
+      color: "COLOR",
+      uv: "TEX_COORD"
+    }, this.defaultAttributeTypes = {
+      position: "Float32Array",
+      normal: "Float32Array",
+      color: "Float32Array",
+      uv: "Float32Array"
+    };
+  }
+  /**
+   * Provides configuration for the decoder libraries. Configuration cannot be changed after decoding begins.
+   *
+   * @param {string} path - The decoder path.
+   * @return {DRACOLoader} A reference to this loader.
+   */
+  setDecoderPath(e) {
+    return this.decoderPath = e, this;
+  }
+  /**
+   * Provides configuration for the decoder libraries. Configuration cannot be changed after decoding begins.
+   *
+   * @param {{type:('js'|'wasm')}} config - The decoder config.
+   * @return {DRACOLoader} A reference to this loader.
+   */
+  setDecoderConfig(e) {
+    return this.decoderConfig = e, this;
+  }
+  /**
+   * Sets the maximum number of Web Workers to be used during decoding.
+   * A lower limit may be preferable if workers are also for other tasks in the application.
+   *
+   * @param {number} workerLimit - The worker limit.
+   * @return {DRACOLoader} A reference to this loader.
+   */
+  setWorkerLimit(e) {
+    return this.workerLimit = e, this;
+  }
+  /**
+   * Starts loading from the given URL and passes the loaded Draco 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(BufferGeometry)} 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(e, t, r, n) {
+    const s = new le(this.manager);
+    s.setPath(this.path), s.setResponseType("arraybuffer"), s.setRequestHeader(this.requestHeader), s.setWithCredentials(this.withCredentials), s.load(e, (i) => {
+      this.parse(i, t, n);
+    }, r, n);
+  }
+  /**
+   * Parses the given Draco data.
+   *
+   * @param {ArrayBuffer} buffer - The raw Draco data as an array buffer.
+   * @param {function(BufferGeometry)} onLoad - Executed when the loading/parsing process has been finished.
+   * @param {onErrorCallback} onError - Executed when errors occur.
+   */
+  parse(e, t, r = () => {
+  }) {
+    this.decodeDracoFile(e, t, null, null, V, r).catch(r);
+  }
+  //
+  decodeDracoFile(e, t, r, n, s = F, i = () => {
+  }) {
+    const a = {
+      attributeIDs: r || this.defaultAttributeIDs,
+      attributeTypes: n || this.defaultAttributeTypes,
+      useUniqueIDs: !!r,
+      vertexColorSpace: s
+    };
+    return this.decodeGeometry(e, a).then(t).catch(i);
+  }
+  decodeGeometry(e, t) {
+    const r = JSON.stringify(t);
+    if (me.has(e)) {
+      const o = me.get(e);
+      if (o.key === r)
+        return o.promise;
+      if (e.byteLength === 0)
+        throw new Error(
+          "THREE.DRACOLoader: Unable to re-decode a buffer with different settings. Buffer has already been transferred."
+        );
+    }
+    let n;
+    const s = this.workerNextTaskID++, i = e.byteLength, a = this._getWorker(s, i).then((o) => (n = o, new Promise((c, u) => {
+      n._callbacks[s] = { resolve: c, reject: u }, n.postMessage({ type: "decode", id: s, taskConfig: t, buffer: e }, [e]);
+    }))).then((o) => this._createGeometry(o.geometry));
+    return a.catch(() => !0).then(() => {
+      n && s && this._releaseTask(n, s);
+    }), me.set(e, {
+      key: r,
+      promise: a
+    }), a;
+  }
+  _createGeometry(e) {
+    const t = new qe();
+    e.index && t.setIndex(new ie(e.index.array, 1));
+    for (let r = 0; r < e.attributes.length; r++) {
+      const n = e.attributes[r], s = n.name, i = n.array, a = n.itemSize, o = new ie(i, a);
+      s === "color" && (this._assignVertexColorSpace(o, n.vertexColorSpace), o.normalized = !(i instanceof Float32Array)), t.setAttribute(s, o);
+    }
+    return t;
+  }
+  _assignVertexColorSpace(e, t) {
+    if (t !== V) return;
+    const r = new G();
+    for (let n = 0, s = e.count; n < s; n++)
+      r.fromBufferAttribute(e, n), Re.colorSpaceToWorking(r, V), e.setXYZ(n, r.r, r.g, r.b);
+  }
+  _loadLibrary(e, t) {
+    const r = new le(this.manager);
+    return r.setPath(this.decoderPath), r.setResponseType(t), r.setWithCredentials(this.withCredentials), new Promise((n, s) => {
+      r.load(e, n, void 0, s);
+    });
+  }
+  preload() {
+    return this._initDecoder(), this;
+  }
+  _initDecoder() {
+    if (this.decoderPending) return this.decoderPending;
+    const e = typeof WebAssembly != "object" || this.decoderConfig.type === "js", t = [];
+    return e ? t.push(this._loadLibrary("draco_decoder.js", "text")) : (t.push(this._loadLibrary("draco_wasm_wrapper.js", "text")), t.push(this._loadLibrary("draco_decoder.wasm", "arraybuffer"))), this.decoderPending = Promise.all(t).then((r) => {
+      const n = r[0];
+      e || (this.decoderConfig.wasmBinary = r[1]);
+      const s = sn.toString(), i = [
+        "/* draco decoder */",
+        n,
+        "",
+        "/* worker */",
+        s.substring(s.indexOf("{") + 1, s.lastIndexOf("}"))
+      ].join(`
+`);
+      this.workerSourceURL = URL.createObjectURL(new Blob([i]));
+    }), this.decoderPending;
+  }
+  _getWorker(e, t) {
+    return this._initDecoder().then(() => {
+      if (this.workerPool.length < this.workerLimit) {
+        const n = new Worker(this.workerSourceURL);
+        n._callbacks = {}, n._taskCosts = {}, n._taskLoad = 0, n.postMessage({ type: "init", decoderConfig: this.decoderConfig }), n.onmessage = function(s) {
+          const i = s.data;
+          switch (i.type) {
+            case "decode":
+              n._callbacks[i.id].resolve(i);
+              break;
+            case "error":
+              n._callbacks[i.id].reject(i);
+              break;
+            default:
+              console.error('THREE.DRACOLoader: Unexpected message, "' + i.type + '"');
+          }
+        }, this.workerPool.push(n);
+      } else
+        this.workerPool.sort(function(n, s) {
+          return n._taskLoad > s._taskLoad ? -1 : 1;
+        });
+      const r = this.workerPool[this.workerPool.length - 1];
+      return r._taskCosts[e] = t, r._taskLoad += t, r;
+    });
+  }
+  _releaseTask(e, t) {
+    e._taskLoad -= e._taskCosts[t], delete e._callbacks[t], delete e._taskCosts[t];
+  }
+  debug() {
+    console.log("Task load: ", this.workerPool.map((e) => e._taskLoad));
+  }
+  dispose() {
+    for (let e = 0; e < this.workerPool.length; ++e)
+      this.workerPool[e].terminate();
+    return this.workerPool.length = 0, this.workerSourceURL !== "" && URL.revokeObjectURL(this.workerSourceURL), this;
+  }
+}
+function sn() {
+  let h, e;
+  onmessage = function(i) {
+    const a = i.data;
+    switch (a.type) {
+      case "init":
+        h = a.decoderConfig, e = new Promise(function(u) {
+          h.onModuleLoaded = function(l) {
+            u({ draco: l });
+          }, DracoDecoderModule(h);
+        });
+        break;
+      case "decode":
+        const o = a.buffer, c = a.taskConfig;
+        e.then((u) => {
+          const l = u.draco, d = new l.Decoder();
+          try {
+            const f = t(l, d, new Int8Array(o), c), p = f.attributes.map((T) => T.array.buffer);
+            f.index && p.push(f.index.array.buffer), self.postMessage({ type: "decode", id: a.id, geometry: f }, p);
+          } catch (f) {
+            console.error(f), self.postMessage({ type: "error", id: a.id, error: f.message });
+          } finally {
+            l.destroy(d);
+          }
+        });
+        break;
+    }
+  };
+  function t(i, a, o, c) {
+    const u = c.attributeIDs, l = c.attributeTypes;
+    let d, f;
+    const p = a.GetEncodedGeometryType(o);
+    if (p === i.TRIANGULAR_MESH)
+      d = new i.Mesh(), f = a.DecodeArrayToMesh(o, o.byteLength, d);
+    else if (p === i.POINT_CLOUD)
+      d = new i.PointCloud(), f = a.DecodeArrayToPointCloud(o, o.byteLength, d);
+    else
+      throw new Error("THREE.DRACOLoader: Unexpected geometry type.");
+    if (!f.ok() || d.ptr === 0)
+      throw new Error("THREE.DRACOLoader: Decoding failed: " + f.error_msg());
+    const T = { index: null, attributes: [] };
+    for (const m in u) {
+      const g = self[l[m]];
+      let b, S;
+      if (c.useUniqueIDs)
+        S = u[m], b = a.GetAttributeByUniqueId(d, S);
+      else {
+        if (S = a.GetAttributeId(d, i[u[m]]), S === -1) continue;
+        b = a.GetAttribute(d, S);
+      }
+      const y = n(i, a, d, m, g, b);
+      m === "color" && (y.vertexColorSpace = c.vertexColorSpace), T.attributes.push(y);
+    }
+    return p === i.TRIANGULAR_MESH && (T.index = r(i, a, d)), i.destroy(d), T;
+  }
+  function r(i, a, o) {
+    const u = o.num_faces() * 3, l = u * 4, d = i._malloc(l);
+    a.GetTrianglesUInt32Array(o, l, d);
+    const f = new Uint32Array(i.HEAPF32.buffer, d, u).slice();
+    return i._free(d), { array: f, itemSize: 1 };
+  }
+  function n(i, a, o, c, u, l) {
+    const d = l.num_components(), p = o.num_points() * d, T = p * u.BYTES_PER_ELEMENT, m = s(i, u), g = i._malloc(T);
+    a.GetAttributeDataArrayForAllPoints(o, l, m, T, g);
+    const b = new u(i.HEAPF32.buffer, g, p).slice();
+    return i._free(g), {
+      name: c,
+      array: b,
+      itemSize: d
+    };
+  }
+  function s(i, a) {
+    switch (a) {
+      case Float32Array:
+        return i.DT_FLOAT32;
+      case Int8Array:
+        return i.DT_INT8;
+      case Int16Array:
+        return i.DT_INT16;
+      case Int32Array:
+        return i.DT_INT32;
+      case Uint8Array:
+        return i.DT_UINT8;
+      case Uint16Array:
+        return i.DT_UINT16;
+      case Uint32Array:
+        return i.DT_UINT32;
+    }
+  }
+}
+class rn extends Xe {
+  /**
+   * Constructs a new glTF loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
+  constructor(e) {
+    super(e), this.dracoLoader = null, this.ktx2Loader = null, this.meshoptDecoder = null, this.pluginCallbacks = [], this.register(function(t) {
+      return new un(t);
+    }), this.register(function(t) {
+      return new dn(t);
+    }), this.register(function(t) {
+      return new Rn(t);
+    }), this.register(function(t) {
+      return new bn(t);
+    }), this.register(function(t) {
+      return new An(t);
+    }), this.register(function(t) {
+      return new fn(t);
+    }), this.register(function(t) {
+      return new pn(t);
+    }), this.register(function(t) {
+      return new mn(t);
+    }), this.register(function(t) {
+      return new gn(t);
+    }), this.register(function(t) {
+      return new ln(t);
+    }), this.register(function(t) {
+      return new Tn(t);
+    }), this.register(function(t) {
+      return new hn(t);
+    }), this.register(function(t) {
+      return new yn(t);
+    }), this.register(function(t) {
+      return new xn(t);
+    }), this.register(function(t) {
+      return new an(t);
+    }), this.register(function(t) {
+      return new wn(t);
+    }), this.register(function(t) {
+      return new _n(t);
+    });
+  }
+  /**
+   * 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(e, t, r, n) {
+    const s = this;
+    let i;
+    if (this.resourcePath !== "")
+      i = this.resourcePath;
+    else if (this.path !== "") {
+      const c = oe.extractUrlBase(e);
+      i = oe.resolveURL(c, this.path);
+    } else
+      i = oe.extractUrlBase(e);
+    this.manager.itemStart(e);
+    const a = function(c) {
+      n ? n(c) : console.error(c), s.manager.itemError(e), s.manager.itemEnd(e);
+    }, o = new le(this.manager);
+    o.setPath(this.path), o.setResponseType("arraybuffer"), o.setRequestHeader(this.requestHeader), o.setWithCredentials(this.withCredentials), o.load(e, function(c) {
+      try {
+        s.parse(c, i, function(u) {
+          t(u), s.manager.itemEnd(e);
+        }, a);
+      } catch (u) {
+        a(u);
+      }
+    }, r, a);
+  }
+  /**
+   * Sets the given Draco loader to this loader. Required for decoding assets
+   * compressed with the `KHR_draco_mesh_compression` extension.
+   *
+   * @param {DRACOLoader} dracoLoader - The Draco loader to set.
+   * @return {GLTFLoader} A reference to this loader.
+   */
+  setDRACOLoader(e) {
+    return this.dracoLoader = e, 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(e) {
+    return this.ktx2Loader = e, 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(e) {
+    return this.meshoptDecoder = e, 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(e) {
+    return this.pluginCallbacks.indexOf(e) === -1 && this.pluginCallbacks.push(e), this;
+  }
+  /**
+   * Unregisters a plugin callback.
+   *
+   * @param {Function} callback - The callback function to unregister.
+   * @return {GLTFLoader} A reference to this loader.
+   */
+  unregister(e) {
+    return this.pluginCallbacks.indexOf(e) !== -1 && this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(e), 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(e, t, r, n) {
+    let s;
+    const i = {}, a = {}, o = new TextDecoder();
+    if (typeof e == "string")
+      s = JSON.parse(e);
+    else if (e instanceof ArrayBuffer)
+      if (o.decode(new Uint8Array(e, 0, 4)) === nt) {
+        try {
+          i[R.KHR_BINARY_GLTF] = new En(e);
+        } catch (l) {
+          n && n(l);
+          return;
+        }
+        s = JSON.parse(i[R.KHR_BINARY_GLTF].content);
+      } else
+        s = JSON.parse(o.decode(e));
+    else
+      s = e;
+    if (s.asset === void 0 || s.asset.version[0] < 2) {
+      n && n(new Error("THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported."));
+      return;
+    }
+    const c = new Hn(s, {
+      path: t || 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, i[l.name] = !0;
+    }
+    if (s.extensionsUsed)
+      for (let u = 0; u < s.extensionsUsed.length; ++u) {
+        const l = s.extensionsUsed[u], d = s.extensionsRequired || [];
+        switch (l) {
+          case R.KHR_MATERIALS_UNLIT:
+            i[l] = new cn();
+            break;
+          case R.KHR_DRACO_MESH_COMPRESSION:
+            i[l] = new Sn(s, this.dracoLoader);
+            break;
+          case R.KHR_TEXTURE_TRANSFORM:
+            i[l] = new Ln();
+            break;
+          case R.KHR_MESH_QUANTIZATION:
+            i[l] = new Mn();
+            break;
+          default:
+            d.indexOf(l) >= 0 && a[l] === void 0 && console.warn('THREE.GLTFLoader: Unknown extension "' + l + '".');
+        }
+      }
+    c.setExtensions(i), c.setPlugins(a), c.parse(r, n);
+  }
+  /**
+   * Async version of {@link GLTFLoader#parse}.
+   *
+   * @async
+   * @param {string|ArrayBuffer} data - The raw glTF data.
+   * @param {string} path - The URL base path.
+   * @return {Promise<GLTFLoader~LoadObject>} A Promise that resolves with the loaded glTF when the parsing has been finished.
+   */
+  parseAsync(e, t) {
+    const r = this;
+    return new Promise(function(n, s) {
+      r.parse(e, t, n, s);
+    });
+  }
+}
+function on() {
+  let h = {};
+  return {
+    get: function(e) {
+      return h[e];
+    },
+    add: function(e, t) {
+      h[e] = t;
+    },
+    remove: function(e) {
+      delete h[e];
+    },
+    removeAll: function() {
+      h = {};
+    }
+  };
+}
+const R = {
+  KHR_BINARY_GLTF: "KHR_binary_glTF",
+  KHR_DRACO_MESH_COMPRESSION: "KHR_draco_mesh_compression",
+  KHR_LIGHTS_PUNCTUAL: "KHR_lights_punctual",
+  KHR_MATERIALS_CLEARCOAT: "KHR_materials_clearcoat",
+  KHR_MATERIALS_DISPERSION: "KHR_materials_dispersion",
+  KHR_MATERIALS_IOR: "KHR_materials_ior",
+  KHR_MATERIALS_SHEEN: "KHR_materials_sheen",
+  KHR_MATERIALS_SPECULAR: "KHR_materials_specular",
+  KHR_MATERIALS_TRANSMISSION: "KHR_materials_transmission",
+  KHR_MATERIALS_IRIDESCENCE: "KHR_materials_iridescence",
+  KHR_MATERIALS_ANISOTROPY: "KHR_materials_anisotropy",
+  KHR_MATERIALS_UNLIT: "KHR_materials_unlit",
+  KHR_MATERIALS_VOLUME: "KHR_materials_volume",
+  KHR_TEXTURE_BASISU: "KHR_texture_basisu",
+  KHR_TEXTURE_TRANSFORM: "KHR_texture_transform",
+  KHR_MESH_QUANTIZATION: "KHR_mesh_quantization",
+  KHR_MATERIALS_EMISSIVE_STRENGTH: "KHR_materials_emissive_strength",
+  EXT_MATERIALS_BUMP: "EXT_materials_bump",
+  EXT_TEXTURE_WEBP: "EXT_texture_webp",
+  EXT_TEXTURE_AVIF: "EXT_texture_avif",
+  EXT_MESHOPT_COMPRESSION: "EXT_meshopt_compression",
+  EXT_MESH_GPU_INSTANCING: "EXT_mesh_gpu_instancing"
+};
+class an {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_LIGHTS_PUNCTUAL, this.cache = { refs: {}, uses: {} };
+  }
+  _markDefs() {
+    const e = this.parser, t = this.parser.json.nodes || [];
+    for (let r = 0, n = t.length; r < n; r++) {
+      const s = t[r];
+      s.extensions && s.extensions[this.name] && s.extensions[this.name].light !== void 0 && e._addNodeRef(this.cache, s.extensions[this.name].light);
+    }
+  }
+  _loadLight(e) {
+    const t = this.parser, r = "light:" + e;
+    let n = t.cache.get(r);
+    if (n) return n;
+    const s = t.json, o = ((s.extensions && s.extensions[this.name] || {}).lights || [])[e];
+    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 ht(u), c.target.position.set(0, 0, -1), c.add(c.target);
+        break;
+      case "point":
+        c = new dt(u), c.distance = l;
+        break;
+      case "spot":
+        c = new ut(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), U(c, o), o.intensity !== void 0 && (c.intensity = o.intensity), c.name = t.createUniqueName(o.name || "light_" + e), n = Promise.resolve(c), t.cache.add(r, n), n;
+  }
+  getDependency(e, t) {
+    if (e === "light")
+      return this._loadLight(t);
+  }
+  createNodeAttachment(e) {
+    const t = this, r = this.parser, s = r.json.nodes[e], a = (s.extensions && s.extensions[this.name] || {}).light;
+    return a === void 0 ? null : this._loadLight(a).then(function(o) {
+      return r._getNodeRef(t.cache, a, o);
+    });
+  }
+}
+class cn {
+  constructor() {
+    this.name = R.KHR_MATERIALS_UNLIT;
+  }
+  getMaterialType() {
+    return re;
+  }
+  extendParams(e, t, r) {
+    const n = [];
+    e.color = new G(1, 1, 1), e.opacity = 1;
+    const s = t.pbrMetallicRoughness;
+    if (s) {
+      if (Array.isArray(s.baseColorFactor)) {
+        const i = s.baseColorFactor;
+        e.color.setRGB(i[0], i[1], i[2], F), e.opacity = i[3];
+      }
+      s.baseColorTexture !== void 0 && n.push(r.assignTexture(e, "map", s.baseColorTexture, V));
+    }
+    return Promise.all(n);
+  }
+}
+class ln {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_EMISSIVE_STRENGTH;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const s = n.extensions[this.name].emissiveStrength;
+    return s !== void 0 && (t.emissiveIntensity = s), Promise.resolve();
+  }
+}
+class un {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_CLEARCOAT;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const s = [], i = n.extensions[this.name];
+    if (i.clearcoatFactor !== void 0 && (t.clearcoat = i.clearcoatFactor), i.clearcoatTexture !== void 0 && s.push(r.assignTexture(t, "clearcoatMap", i.clearcoatTexture)), i.clearcoatRoughnessFactor !== void 0 && (t.clearcoatRoughness = i.clearcoatRoughnessFactor), i.clearcoatRoughnessTexture !== void 0 && s.push(r.assignTexture(t, "clearcoatRoughnessMap", i.clearcoatRoughnessTexture)), i.clearcoatNormalTexture !== void 0 && (s.push(r.assignTexture(t, "clearcoatNormalMap", i.clearcoatNormalTexture)), i.clearcoatNormalTexture.scale !== void 0)) {
+      const a = i.clearcoatNormalTexture.scale;
+      t.clearcoatNormalScale = new Se(a, a);
+    }
+    return Promise.all(s);
+  }
+}
+class dn {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_DISPERSION;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const s = n.extensions[this.name];
+    return t.dispersion = s.dispersion !== void 0 ? s.dispersion : 0, Promise.resolve();
+  }
+}
+class hn {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_IRIDESCENCE;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const s = [], i = n.extensions[this.name];
+    return i.iridescenceFactor !== void 0 && (t.iridescence = i.iridescenceFactor), i.iridescenceTexture !== void 0 && s.push(r.assignTexture(t, "iridescenceMap", i.iridescenceTexture)), i.iridescenceIor !== void 0 && (t.iridescenceIOR = i.iridescenceIor), t.iridescenceThicknessRange === void 0 && (t.iridescenceThicknessRange = [100, 400]), i.iridescenceThicknessMinimum !== void 0 && (t.iridescenceThicknessRange[0] = i.iridescenceThicknessMinimum), i.iridescenceThicknessMaximum !== void 0 && (t.iridescenceThicknessRange[1] = i.iridescenceThicknessMaximum), i.iridescenceThicknessTexture !== void 0 && s.push(r.assignTexture(t, "iridescenceThicknessMap", i.iridescenceThicknessTexture)), Promise.all(s);
+  }
+}
+class fn {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_SHEEN;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const s = [];
+    t.sheenColor = new G(0, 0, 0), t.sheenRoughness = 0, t.sheen = 1;
+    const i = n.extensions[this.name];
+    if (i.sheenColorFactor !== void 0) {
+      const a = i.sheenColorFactor;
+      t.sheenColor.setRGB(a[0], a[1], a[2], F);
+    }
+    return i.sheenRoughnessFactor !== void 0 && (t.sheenRoughness = i.sheenRoughnessFactor), i.sheenColorTexture !== void 0 && s.push(r.assignTexture(t, "sheenColorMap", i.sheenColorTexture, V)), i.sheenRoughnessTexture !== void 0 && s.push(r.assignTexture(t, "sheenRoughnessMap", i.sheenRoughnessTexture)), Promise.all(s);
+  }
+}
+class pn {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_TRANSMISSION;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const s = [], i = n.extensions[this.name];
+    return i.transmissionFactor !== void 0 && (t.transmission = i.transmissionFactor), i.transmissionTexture !== void 0 && s.push(r.assignTexture(t, "transmissionMap", i.transmissionTexture)), Promise.all(s);
+  }
+}
+class mn {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_VOLUME;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const s = [], i = n.extensions[this.name];
+    t.thickness = i.thicknessFactor !== void 0 ? i.thicknessFactor : 0, i.thicknessTexture !== void 0 && s.push(r.assignTexture(t, "thicknessMap", i.thicknessTexture)), t.attenuationDistance = i.attenuationDistance || 1 / 0;
+    const a = i.attenuationColor || [1, 1, 1];
+    return t.attenuationColor = new G().setRGB(a[0], a[1], a[2], F), Promise.all(s);
+  }
+}
+class gn {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_IOR;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const s = n.extensions[this.name];
+    return t.ior = s.ior !== void 0 ? s.ior : 1.5, Promise.resolve();
+  }
+}
+class Tn {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_SPECULAR;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const s = [], i = n.extensions[this.name];
+    t.specularIntensity = i.specularFactor !== void 0 ? i.specularFactor : 1, i.specularTexture !== void 0 && s.push(r.assignTexture(t, "specularIntensityMap", i.specularTexture));
+    const a = i.specularColorFactor || [1, 1, 1];
+    return t.specularColor = new G().setRGB(a[0], a[1], a[2], F), i.specularColorTexture !== void 0 && s.push(r.assignTexture(t, "specularColorMap", i.specularColorTexture, V)), Promise.all(s);
+  }
+}
+class xn {
+  constructor(e) {
+    this.parser = e, this.name = R.EXT_MATERIALS_BUMP;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const s = [], i = n.extensions[this.name];
+    return t.bumpScale = i.bumpFactor !== void 0 ? i.bumpFactor : 1, i.bumpTexture !== void 0 && s.push(r.assignTexture(t, "bumpMap", i.bumpTexture)), Promise.all(s);
+  }
+}
+class yn {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_MATERIALS_ANISOTROPY;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const s = [], i = n.extensions[this.name];
+    return i.anisotropyStrength !== void 0 && (t.anisotropy = i.anisotropyStrength), i.anisotropyRotation !== void 0 && (t.anisotropyRotation = i.anisotropyRotation), i.anisotropyTexture !== void 0 && s.push(r.assignTexture(t, "anisotropyMap", i.anisotropyTexture)), Promise.all(s);
+  }
+}
+class Rn {
+  constructor(e) {
+    this.parser = e, this.name = R.KHR_TEXTURE_BASISU;
+  }
+  loadTexture(e) {
+    const t = this.parser, r = t.json, n = r.textures[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return null;
+    const s = n.extensions[this.name], i = t.options.ktx2Loader;
+    if (!i) {
+      if (r.extensionsRequired && r.extensionsRequired.indexOf(this.name) >= 0)
+        throw new Error("THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures");
+      return null;
+    }
+    return t.loadTextureImage(e, s.source, i);
+  }
+}
+class bn {
+  constructor(e) {
+    this.parser = e, this.name = R.EXT_TEXTURE_WEBP;
+  }
+  loadTexture(e) {
+    const t = this.name, r = this.parser, n = r.json, s = n.textures[e];
+    if (!s.extensions || !s.extensions[t])
+      return null;
+    const i = s.extensions[t], a = n.images[i.source];
+    let o = r.textureLoader;
+    if (a.uri) {
+      const c = r.options.manager.getHandler(a.uri);
+      c !== null && (o = c);
+    }
+    return r.loadTextureImage(e, i.source, o);
+  }
+}
+class An {
+  constructor(e) {
+    this.parser = e, this.name = R.EXT_TEXTURE_AVIF;
+  }
+  loadTexture(e) {
+    const t = this.name, r = this.parser, n = r.json, s = n.textures[e];
+    if (!s.extensions || !s.extensions[t])
+      return null;
+    const i = s.extensions[t], a = n.images[i.source];
+    let o = r.textureLoader;
+    if (a.uri) {
+      const c = r.options.manager.getHandler(a.uri);
+      c !== null && (o = c);
+    }
+    return r.loadTextureImage(e, i.source, o);
+  }
+}
+class wn {
+  constructor(e) {
+    this.name = R.EXT_MESHOPT_COMPRESSION, this.parser = e;
+  }
+  loadBufferView(e) {
+    const t = this.parser.json, r = t.bufferViews[e];
+    if (r.extensions && r.extensions[this.name]) {
+      const n = r.extensions[this.name], s = this.parser.getDependency("buffer", n.buffer), i = this.parser.options.meshoptDecoder;
+      if (!i || !i.supported) {
+        if (t.extensionsRequired && t.extensionsRequired.indexOf(this.name) >= 0)
+          throw new Error("THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files");
+        return null;
+      }
+      return s.then(function(a) {
+        const o = n.byteOffset || 0, c = n.byteLength || 0, u = n.count, l = n.byteStride, d = new Uint8Array(a, o, c);
+        return i.decodeGltfBufferAsync ? i.decodeGltfBufferAsync(u, l, d, n.mode, n.filter).then(function(f) {
+          return f.buffer;
+        }) : i.ready.then(function() {
+          const f = new ArrayBuffer(u * l);
+          return i.decodeGltfBuffer(new Uint8Array(f), u, l, d, n.mode, n.filter), f;
+        });
+      });
+    } else
+      return null;
+  }
+}
+class _n {
+  constructor(e) {
+    this.name = R.EXT_MESH_GPU_INSTANCING, this.parser = e;
+  }
+  createNodeMesh(e) {
+    const t = this.parser.json, r = t.nodes[e];
+    if (!r.extensions || !r.extensions[this.name] || r.mesh === void 0)
+      return null;
+    const n = t.meshes[r.mesh];
+    for (const c of n.primitives)
+      if (c.mode !== O.TRIANGLES && c.mode !== O.TRIANGLE_STRIP && c.mode !== O.TRIANGLE_FAN && c.mode !== void 0)
+        return null;
+    const i = r.extensions[this.name].attributes, a = [], o = {};
+    for (const c in i)
+      a.push(this.parser.getDependency("accessor", i[c]).then((u) => (o[c] = u, o[c])));
+    return a.length < 1 ? null : (a.push(this.parser.createNodeMesh(e)), Promise.all(a).then((c) => {
+      const u = c.pop(), l = u.isGroup ? u.children : [u], d = c[0].count, f = [];
+      for (const p of l) {
+        const T = new ee(), m = new _(), g = new We(), b = new _(1, 1, 1), S = new ft(p.geometry, p.material, d);
+        for (let y = 0; y < d; y++)
+          o.TRANSLATION && m.fromBufferAttribute(o.TRANSLATION, y), o.ROTATION && g.fromBufferAttribute(o.ROTATION, y), o.SCALE && b.fromBufferAttribute(o.SCALE, y), S.setMatrixAt(y, T.compose(m, g, b));
+        for (const y in o)
+          if (y === "_COLOR_0") {
+            const I = o[y];
+            S.instanceColor = new pt(I.array, I.itemSize, I.normalized);
+          } else y !== "TRANSLATION" && y !== "ROTATION" && y !== "SCALE" && p.geometry.setAttribute(y, o[y]);
+        Ye.prototype.copy.call(S, p), this.parser.assignFinalMaterial(S), f.push(S);
+      }
+      return u.isGroup ? (u.clear(), u.add(...f), u) : f[0];
+    }));
+  }
+}
+const nt = "glTF", se = 12, Fe = { JSON: 1313821514, BIN: 5130562 };
+class En {
+  constructor(e) {
+    this.name = R.KHR_BINARY_GLTF, this.content = null, this.body = null;
+    const t = new DataView(e, 0, se), r = new TextDecoder();
+    if (this.header = {
+      magic: r.decode(new Uint8Array(e.slice(0, 4))),
+      version: t.getUint32(4, !0),
+      length: t.getUint32(8, !0)
+    }, this.header.magic !== nt)
+      throw new Error("THREE.GLTFLoader: Unsupported glTF-Binary header.");
+    if (this.header.version < 2)
+      throw new Error("THREE.GLTFLoader: Legacy binary file detected.");
+    const n = this.header.length - se, s = new DataView(e, se);
+    let i = 0;
+    for (; i < n; ) {
+      const a = s.getUint32(i, !0);
+      i += 4;
+      const o = s.getUint32(i, !0);
+      if (i += 4, o === Fe.JSON) {
+        const c = new Uint8Array(e, se + i, a);
+        this.content = r.decode(c);
+      } else if (o === Fe.BIN) {
+        const c = se + i;
+        this.body = e.slice(c, c + a);
+      }
+      i += a;
+    }
+    if (this.content === null)
+      throw new Error("THREE.GLTFLoader: JSON content not found.");
+  }
+}
+class Sn {
+  constructor(e, t) {
+    if (!t)
+      throw new Error("THREE.GLTFLoader: No DRACOLoader instance provided.");
+    this.name = R.KHR_DRACO_MESH_COMPRESSION, this.json = e, this.dracoLoader = t, this.dracoLoader.preload();
+  }
+  decodePrimitive(e, t) {
+    const r = this.json, n = this.dracoLoader, s = e.extensions[this.name].bufferView, i = e.extensions[this.name].attributes, a = {}, o = {}, c = {};
+    for (const u in i) {
+      const l = we[u] || u.toLowerCase();
+      a[l] = i[u];
+    }
+    for (const u in e.attributes) {
+      const l = we[u] || u.toLowerCase();
+      if (i[u] !== void 0) {
+        const d = r.accessors[e.attributes[u]], f = $[d.componentType];
+        c[l] = f.name, o[l] = d.normalized === !0;
+      }
+    }
+    return t.getDependency("bufferView", s).then(function(u) {
+      return new Promise(function(l, d) {
+        n.decodeDracoFile(u, function(f) {
+          for (const p in f.attributes) {
+            const T = f.attributes[p], m = o[p];
+            m !== void 0 && (T.normalized = m);
+          }
+          l(f);
+        }, a, c, F, d);
+      });
+    });
+  }
+}
+class Ln {
+  constructor() {
+    this.name = R.KHR_TEXTURE_TRANSFORM;
+  }
+  extendTexture(e, t) {
+    return (t.texCoord === void 0 || t.texCoord === e.channel) && t.offset === void 0 && t.rotation === void 0 && t.scale === void 0 || (e = e.clone(), t.texCoord !== void 0 && (e.channel = t.texCoord), t.offset !== void 0 && e.offset.fromArray(t.offset), t.rotation !== void 0 && (e.rotation = t.rotation), t.scale !== void 0 && e.repeat.fromArray(t.scale), e.needsUpdate = !0), e;
+  }
+}
+class Mn {
+  constructor() {
+    this.name = R.KHR_MESH_QUANTIZATION;
+  }
+}
+class st extends Gt {
+  constructor(e, t, r, n) {
+    super(e, t, r, n);
+  }
+  copySampleValue_(e) {
+    const t = this.resultBuffer, r = this.sampleValues, n = this.valueSize, s = e * n * 3 + n;
+    for (let i = 0; i !== n; i++)
+      t[i] = r[s + i];
+    return t;
+  }
+  interpolate_(e, t, r, n) {
+    const s = this.resultBuffer, i = this.sampleValues, a = this.valueSize, o = a * 2, c = a * 3, u = n - t, l = (r - t) / u, d = l * l, f = d * l, p = e * c, T = p - c, m = -2 * f + 3 * d, g = f - d, b = 1 - m, S = g - d + l;
+    for (let y = 0; y !== a; y++) {
+      const I = i[T + y + a], P = i[T + y + o] * u, C = i[p + y + a], B = i[p + y] * u;
+      s[y] = b * I + S * P + m * C + g * B;
+    }
+    return s;
+  }
+}
+const In = new We();
+class Cn extends st {
+  interpolate_(e, t, r, n) {
+    const s = super.interpolate_(e, t, r, n);
+    return In.fromArray(s).normalize().toArray(s), s;
+  }
+}
+const O = {
+  POINTS: 0,
+  LINES: 1,
+  LINE_LOOP: 2,
+  LINE_STRIP: 3,
+  TRIANGLES: 4,
+  TRIANGLE_STRIP: 5,
+  TRIANGLE_FAN: 6
+}, $ = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5125: Uint32Array,
+  5126: Float32Array
+}, ve = {
+  9728: Qe,
+  9729: be,
+  9984: bt,
+  9985: Rt,
+  9986: yt,
+  9987: Je
+}, He = {
+  33071: wt,
+  33648: At,
+  10497: Ae
+}, ge = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+}, we = {
+  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"
+}, K = {
+  scale: "scale",
+  translation: "position",
+  rotation: "quaternion",
+  weights: "morphTargetInfluences"
+}, Nn = {
+  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: et,
+  STEP: Ht
+}, Te = {
+  OPAQUE: "OPAQUE",
+  MASK: "MASK",
+  BLEND: "BLEND"
+};
+function On(h) {
+  return h.DefaultMaterial === void 0 && (h.DefaultMaterial = new Ze({
+    color: 16777215,
+    emissive: 0,
+    metalness: 1,
+    roughness: 1,
+    transparent: !1,
+    depthTest: !0,
+    side: Ut
+  })), h.DefaultMaterial;
+}
+function q(h, e, t) {
+  for (const r in t.extensions)
+    h[r] === void 0 && (e.userData.gltfExtensions = e.userData.gltfExtensions || {}, e.userData.gltfExtensions[r] = t.extensions[r]);
+}
+function U(h, e) {
+  e.extras !== void 0 && (typeof e.extras == "object" ? Object.assign(h.userData, e.extras) : console.warn("THREE.GLTFLoader: Ignoring primitive type .extras, " + e.extras));
+}
+function Dn(h, e, t) {
+  let r = !1, n = !1, s = !1;
+  for (let c = 0, u = e.length; c < u; c++) {
+    const l = e[c];
+    if (l.POSITION !== void 0 && (r = !0), l.NORMAL !== void 0 && (n = !0), l.COLOR_0 !== void 0 && (s = !0), r && n && s) break;
+  }
+  if (!r && !n && !s) return Promise.resolve(h);
+  const i = [], a = [], o = [];
+  for (let c = 0, u = e.length; c < u; c++) {
+    const l = e[c];
+    if (r) {
+      const d = l.POSITION !== void 0 ? t.getDependency("accessor", l.POSITION) : h.attributes.position;
+      i.push(d);
+    }
+    if (n) {
+      const d = l.NORMAL !== void 0 ? t.getDependency("accessor", l.NORMAL) : h.attributes.normal;
+      a.push(d);
+    }
+    if (s) {
+      const d = l.COLOR_0 !== void 0 ? t.getDependency("accessor", l.COLOR_0) : h.attributes.color;
+      o.push(d);
+    }
+  }
+  return Promise.all([
+    Promise.all(i),
+    Promise.all(a),
+    Promise.all(o)
+  ]).then(function(c) {
+    const u = c[0], l = c[1], d = c[2];
+    return r && (h.morphAttributes.position = u), n && (h.morphAttributes.normal = l), s && (h.morphAttributes.color = d), h.morphTargetsRelative = !0, h;
+  });
+}
+function Pn(h, e) {
+  if (h.updateMorphTargets(), e.weights !== void 0)
+    for (let t = 0, r = e.weights.length; t < r; t++)
+      h.morphTargetInfluences[t] = e.weights[t];
+  if (e.extras && Array.isArray(e.extras.targetNames)) {
+    const t = e.extras.targetNames;
+    if (h.morphTargetInfluences.length === t.length) {
+      h.morphTargetDictionary = {};
+      for (let r = 0, n = t.length; r < n; r++)
+        h.morphTargetDictionary[t[r]] = r;
+    } else
+      console.warn("THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.");
+  }
+}
+function kn(h) {
+  let e;
+  const t = h.extensions && h.extensions[R.KHR_DRACO_MESH_COMPRESSION];
+  if (t ? e = "draco:" + t.bufferView + ":" + t.indices + ":" + xe(t.attributes) : e = h.indices + ":" + xe(h.attributes) + ":" + h.mode, h.targets !== void 0)
+    for (let r = 0, n = h.targets.length; r < n; r++)
+      e += ":" + xe(h.targets[r]);
+  return e;
+}
+function xe(h) {
+  let e = "";
+  const t = Object.keys(h).sort();
+  for (let r = 0, n = t.length; r < n; r++)
+    e += t[r] + ":" + h[t[r]] + ";";
+  return e;
+}
+function _e(h) {
+  switch (h) {
+    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 Fn(h) {
+  return h.search(/\.jpe?g($|\?)/i) > 0 || h.search(/^data\:image\/jpeg/) === 0 ? "image/jpeg" : h.search(/\.webp($|\?)/i) > 0 || h.search(/^data\:image\/webp/) === 0 ? "image/webp" : h.search(/\.ktx2($|\?)/i) > 0 || h.search(/^data\:image\/ktx2/) === 0 ? "image/ktx2" : "image/png";
+}
+const vn = new ee();
+class Hn {
+  constructor(e = {}, t = {}) {
+    this.json = e, this.extensions = {}, this.plugins = {}, this.options = t, this.cache = new on(), this.associations = /* @__PURE__ */ new Map(), this.primitiveCache = {}, this.nodeCache = {}, this.meshCache = { refs: {}, uses: {} }, this.cameraCache = { refs: {}, uses: {} }, this.lightCache = { refs: {}, uses: {} }, this.sourceCache = {}, this.textureCache = {}, this.nodeNamesUsed = {};
+    let r = !1, n = -1, s = !1, i = -1;
+    if (typeof navigator < "u") {
+      const a = navigator.userAgent;
+      r = /^((?!chrome|android).)*safari/i.test(a) === !0;
+      const o = a.match(/Version\/(\d+)/);
+      n = r && o ? parseInt(o[1], 10) : -1, s = a.indexOf("Firefox") > -1, i = s ? a.match(/Firefox\/([0-9]+)\./)[1] : -1;
+    }
+    typeof createImageBitmap > "u" || r && n < 17 || s && i < 98 ? this.textureLoader = new mt(this.options.manager) : this.textureLoader = new gt(this.options.manager), this.textureLoader.setCrossOrigin(this.options.crossOrigin), this.textureLoader.setRequestHeader(this.options.requestHeader), this.fileLoader = new le(this.options.manager), this.fileLoader.setResponseType("arraybuffer"), this.options.crossOrigin === "use-credentials" && this.fileLoader.setWithCredentials(!0);
+  }
+  setExtensions(e) {
+    this.extensions = e;
+  }
+  setPlugins(e) {
+    this.plugins = e;
+  }
+  parse(e, t) {
+    const r = this, n = this.json, s = this.extensions;
+    this.cache.removeAll(), this.nodeCache = {}, this._invokeAll(function(i) {
+      return i._markDefs && i._markDefs();
+    }), Promise.all(this._invokeAll(function(i) {
+      return i.beforeRoot && i.beforeRoot();
+    })).then(function() {
+      return Promise.all([
+        r.getDependencies("scene"),
+        r.getDependencies("animation"),
+        r.getDependencies("camera")
+      ]);
+    }).then(function(i) {
+      const a = {
+        scene: i[0][n.scene || 0],
+        scenes: i[0],
+        animations: i[1],
+        cameras: i[2],
+        asset: n.asset,
+        parser: r,
+        userData: {}
+      };
+      return q(s, a, n), U(a, n), Promise.all(r._invokeAll(function(o) {
+        return o.afterRoot && o.afterRoot(a);
+      })).then(function() {
+        for (const o of a.scenes)
+          o.updateMatrixWorld();
+        e(a);
+      });
+    }).catch(t);
+  }
+  /**
+   * Marks the special nodes/meshes in json for efficient parse.
+   *
+   * @private
+   */
+  _markDefs() {
+    const e = this.json.nodes || [], t = this.json.skins || [], r = this.json.meshes || [];
+    for (let n = 0, s = t.length; n < s; n++) {
+      const i = t[n].joints;
+      for (let a = 0, o = i.length; a < o; a++)
+        e[i[a]].isBone = !0;
+    }
+    for (let n = 0, s = e.length; n < s; n++) {
+      const i = e[n];
+      i.mesh !== void 0 && (this._addNodeRef(this.meshCache, i.mesh), i.skin !== void 0 && (r[i.mesh].isSkinnedMesh = !0)), i.camera !== void 0 && this._addNodeRef(this.cameraCache, i.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(e, t) {
+    t !== void 0 && (e.refs[t] === void 0 && (e.refs[t] = e.uses[t] = 0), e.refs[t]++);
+  }
+  /**
+   * Returns a reference to a shared resource, cloning it if necessary.
+   *
+   * @private
+   * @param {Object} cache
+   * @param {number} index
+   * @param {Object} object
+   * @return {Object}
+   */
+  _getNodeRef(e, t, r) {
+    if (e.refs[t] <= 1) return r;
+    const n = r.clone(), s = (i, a) => {
+      const o = this.associations.get(i);
+      o != null && this.associations.set(a, o);
+      for (const [c, u] of i.children.entries())
+        s(u, a.children[c]);
+    };
+    return s(r, n), n.name += "_instance_" + e.uses[t]++, n;
+  }
+  _invokeOne(e) {
+    const t = Object.values(this.plugins);
+    t.push(this);
+    for (let r = 0; r < t.length; r++) {
+      const n = e(t[r]);
+      if (n) return n;
+    }
+    return null;
+  }
+  _invokeAll(e) {
+    const t = Object.values(this.plugins);
+    t.unshift(this);
+    const r = [];
+    for (let n = 0; n < t.length; n++) {
+      const s = e(t[n]);
+      s && r.push(s);
+    }
+    return r;
+  }
+  /**
+   * Requests the specified dependency asynchronously, with caching.
+   *
+   * @private
+   * @param {string} type
+   * @param {number} index
+   * @return {Promise<Object3D|Material|THREE.Texture|AnimationClip|ArrayBuffer|Object>}
+   */
+  getDependency(e, t) {
+    const r = e + ":" + t;
+    let n = this.cache.get(r);
+    if (!n) {
+      switch (e) {
+        case "scene":
+          n = this.loadScene(t);
+          break;
+        case "node":
+          n = this._invokeOne(function(s) {
+            return s.loadNode && s.loadNode(t);
+          });
+          break;
+        case "mesh":
+          n = this._invokeOne(function(s) {
+            return s.loadMesh && s.loadMesh(t);
+          });
+          break;
+        case "accessor":
+          n = this.loadAccessor(t);
+          break;
+        case "bufferView":
+          n = this._invokeOne(function(s) {
+            return s.loadBufferView && s.loadBufferView(t);
+          });
+          break;
+        case "buffer":
+          n = this.loadBuffer(t);
+          break;
+        case "material":
+          n = this._invokeOne(function(s) {
+            return s.loadMaterial && s.loadMaterial(t);
+          });
+          break;
+        case "texture":
+          n = this._invokeOne(function(s) {
+            return s.loadTexture && s.loadTexture(t);
+          });
+          break;
+        case "skin":
+          n = this.loadSkin(t);
+          break;
+        case "animation":
+          n = this._invokeOne(function(s) {
+            return s.loadAnimation && s.loadAnimation(t);
+          });
+          break;
+        case "camera":
+          n = this.loadCamera(t);
+          break;
+        default:
+          if (n = this._invokeOne(function(s) {
+            return s != this && s.getDependency && s.getDependency(e, t);
+          }), !n)
+            throw new Error("Unknown type: " + e);
+          break;
+      }
+      this.cache.add(r, n);
+    }
+    return n;
+  }
+  /**
+   * Requests all dependencies of the specified type asynchronously, with caching.
+   *
+   * @private
+   * @param {string} type
+   * @return {Promise<Array<Object>>}
+   */
+  getDependencies(e) {
+    let t = this.cache.get(e);
+    if (!t) {
+      const r = this, n = this.json[e + (e === "mesh" ? "es" : "s")] || [];
+      t = Promise.all(n.map(function(s, i) {
+        return r.getDependency(e, i);
+      })), this.cache.add(e, t);
+    }
+    return t;
+  }
+  /**
+   * 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(e) {
+    const t = this.json.buffers[e], r = this.fileLoader;
+    if (t.type && t.type !== "arraybuffer")
+      throw new Error("THREE.GLTFLoader: " + t.type + " buffer type is not supported.");
+    if (t.uri === void 0 && e === 0)
+      return Promise.resolve(this.extensions[R.KHR_BINARY_GLTF].body);
+    const n = this.options;
+    return new Promise(function(s, i) {
+      r.load(oe.resolveURL(t.uri, n.path), s, void 0, function() {
+        i(new Error('THREE.GLTFLoader: Failed to load buffer "' + t.uri + '".'));
+      });
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
+   *
+   * @private
+   * @param {number} bufferViewIndex
+   * @return {Promise<ArrayBuffer>}
+   */
+  loadBufferView(e) {
+    const t = this.json.bufferViews[e];
+    return this.getDependency("buffer", t.buffer).then(function(r) {
+      const n = t.byteLength || 0, s = t.byteOffset || 0;
+      return r.slice(s, s + n);
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
+   *
+   * @private
+   * @param {number} accessorIndex
+   * @return {Promise<BufferAttribute|InterleavedBufferAttribute>}
+   */
+  loadAccessor(e) {
+    const t = this, r = this.json, n = this.json.accessors[e];
+    if (n.bufferView === void 0 && n.sparse === void 0) {
+      const i = ge[n.type], a = $[n.componentType], o = n.normalized === !0, c = new a(n.count * i);
+      return Promise.resolve(new ie(c, i, o));
+    }
+    const s = [];
+    return n.bufferView !== void 0 ? s.push(this.getDependency("bufferView", n.bufferView)) : s.push(null), n.sparse !== void 0 && (s.push(this.getDependency("bufferView", n.sparse.indices.bufferView)), s.push(this.getDependency("bufferView", n.sparse.values.bufferView))), Promise.all(s).then(function(i) {
+      const a = i[0], o = ge[n.type], c = $[n.componentType], u = c.BYTES_PER_ELEMENT, l = u * o, d = n.byteOffset || 0, f = n.bufferView !== void 0 ? r.bufferViews[n.bufferView].byteStride : void 0, p = n.normalized === !0;
+      let T, m;
+      if (f && f !== l) {
+        const g = Math.floor(d / f), b = "InterleavedBuffer:" + n.bufferView + ":" + n.componentType + ":" + g + ":" + n.count;
+        let S = t.cache.get(b);
+        S || (T = new c(a, g * f, n.count * f / u), S = new Tt(T, f / u), t.cache.add(b, S)), m = new xt(S, o, d % f / u, p);
+      } else
+        a === null ? T = new c(n.count * o) : T = new c(a, d, n.count * o), m = new ie(T, o, p);
+      if (n.sparse !== void 0) {
+        const g = ge.SCALAR, b = $[n.sparse.indices.componentType], S = n.sparse.indices.byteOffset || 0, y = n.sparse.values.byteOffset || 0, I = new b(i[1], S, n.sparse.count * g), P = new c(i[2], y, n.sparse.count * o);
+        a !== null && (m = new ie(m.array.slice(), m.itemSize, m.normalized)), m.normalized = !1;
+        for (let C = 0, B = I.length; C < B; C++) {
+          const k = I[C];
+          if (m.setX(k, P[C * o]), o >= 2 && m.setY(k, P[C * o + 1]), o >= 3 && m.setZ(k, P[C * o + 2]), o >= 4 && m.setW(k, P[C * 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(e) {
+    const t = this.json, r = this.options, s = t.textures[e].source, i = t.images[s];
+    let a = this.textureLoader;
+    if (i.uri) {
+      const o = r.manager.getHandler(i.uri);
+      o !== null && (a = o);
+    }
+    return this.loadTextureImage(e, s, a);
+  }
+  loadTextureImage(e, t, r) {
+    const n = this, s = this.json, i = s.textures[e], a = s.images[t], o = (a.uri || a.bufferView) + ":" + i.sampler;
+    if (this.textureCache[o])
+      return this.textureCache[o];
+    const c = this.loadImageSource(t, r).then(function(u) {
+      u.flipY = !1, u.name = i.name || a.name || "", u.name === "" && typeof a.uri == "string" && a.uri.startsWith("data:image/") === !1 && (u.name = a.uri);
+      const d = (s.samplers || {})[i.sampler] || {};
+      return u.magFilter = ve[d.magFilter] || be, u.minFilter = ve[d.minFilter] || Je, u.wrapS = He[d.wrapS] || Ae, u.wrapT = He[d.wrapT] || Ae, u.generateMipmaps = !u.isCompressedTexture && u.minFilter !== Qe && u.minFilter !== be, n.associations.set(u, { textures: e }), u;
+    }).catch(function() {
+      return null;
+    });
+    return this.textureCache[o] = c, c;
+  }
+  loadImageSource(e, t) {
+    const r = this, n = this.json, s = this.options;
+    if (this.sourceCache[e] !== void 0)
+      return this.sourceCache[e].then((l) => l.clone());
+    const i = n.images[e], a = self.URL || self.webkitURL;
+    let o = i.uri || "", c = !1;
+    if (i.bufferView !== void 0)
+      o = r.getDependency("bufferView", i.bufferView).then(function(l) {
+        c = !0;
+        const d = new Blob([l], { type: i.mimeType });
+        return o = a.createObjectURL(d), o;
+      });
+    else if (i.uri === void 0)
+      throw new Error("THREE.GLTFLoader: Image " + e + " is missing URI and bufferView");
+    const u = Promise.resolve(o).then(function(l) {
+      return new Promise(function(d, f) {
+        let p = d;
+        t.isImageBitmapLoader === !0 && (p = function(T) {
+          const m = new Ce(T);
+          m.needsUpdate = !0, d(m);
+        }), t.load(oe.resolveURL(l, s.path), p, void 0, f);
+      });
+    }).then(function(l) {
+      return c === !0 && a.revokeObjectURL(o), U(l, i), l.userData.mimeType = i.mimeType || Fn(i.uri), l;
+    }).catch(function(l) {
+      throw console.error("THREE.GLTFLoader: Couldn't load texture", o), l;
+    });
+    return this.sourceCache[e] = 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(e, t, r, n) {
+    const s = this;
+    return this.getDependency("texture", r.index).then(function(i) {
+      if (!i) return null;
+      if (r.texCoord !== void 0 && r.texCoord > 0 && (i = i.clone(), i.channel = r.texCoord), s.extensions[R.KHR_TEXTURE_TRANSFORM]) {
+        const a = r.extensions !== void 0 ? r.extensions[R.KHR_TEXTURE_TRANSFORM] : void 0;
+        if (a) {
+          const o = s.associations.get(i);
+          i = s.extensions[R.KHR_TEXTURE_TRANSFORM].extendTexture(i, a), s.associations.set(i, o);
+        }
+      }
+      return n !== void 0 && (i.colorSpace = n), e[t] = i, i;
+    });
+  }
+  /**
+   * 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(e) {
+    const t = e.geometry;
+    let r = e.material;
+    const n = t.attributes.tangent === void 0, s = t.attributes.color !== void 0, i = t.attributes.normal === void 0;
+    if (e.isPoints) {
+      const a = "PointsMaterial:" + r.uuid;
+      let o = this.cache.get(a);
+      o || (o = new _t(), he.prototype.copy.call(o, r), o.color.copy(r.color), o.map = r.map, o.sizeAttenuation = !1, this.cache.add(a, o)), r = o;
+    } else if (e.isLine) {
+      const a = "LineBasicMaterial:" + r.uuid;
+      let o = this.cache.get(a);
+      o || (o = new Et(), he.prototype.copy.call(o, r), o.color.copy(r.color), o.map = r.map, this.cache.add(a, o)), r = o;
+    }
+    if (n || s || i) {
+      let a = "ClonedMaterial:" + r.uuid + ":";
+      n && (a += "derivative-tangents:"), s && (a += "vertex-colors:"), i && (a += "flat-shading:");
+      let o = this.cache.get(a);
+      o || (o = r.clone(), s && (o.vertexColors = !0), i && (o.flatShading = !0), n && (o.normalScale && (o.normalScale.y *= -1), o.clearcoatNormalScale && (o.clearcoatNormalScale.y *= -1)), this.cache.add(a, o), this.associations.set(o, this.associations.get(r))), r = o;
+    }
+    e.material = r;
+  }
+  getMaterialType() {
+    return Ze;
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
+   *
+   * @private
+   * @param {number} materialIndex
+   * @return {Promise<Material>}
+   */
+  loadMaterial(e) {
+    const t = this, r = this.json, n = this.extensions, s = r.materials[e];
+    let i;
+    const a = {}, o = s.extensions || {}, c = [];
+    if (o[R.KHR_MATERIALS_UNLIT]) {
+      const l = n[R.KHR_MATERIALS_UNLIT];
+      i = l.getMaterialType(), c.push(l.extendParams(a, s, t));
+    } else {
+      const l = s.pbrMetallicRoughness || {};
+      if (a.color = new G(1, 1, 1), a.opacity = 1, Array.isArray(l.baseColorFactor)) {
+        const d = l.baseColorFactor;
+        a.color.setRGB(d[0], d[1], d[2], F), a.opacity = d[3];
+      }
+      l.baseColorTexture !== void 0 && c.push(t.assignTexture(a, "map", l.baseColorTexture, V)), a.metalness = l.metallicFactor !== void 0 ? l.metallicFactor : 1, a.roughness = l.roughnessFactor !== void 0 ? l.roughnessFactor : 1, l.metallicRoughnessTexture !== void 0 && (c.push(t.assignTexture(a, "metalnessMap", l.metallicRoughnessTexture)), c.push(t.assignTexture(a, "roughnessMap", l.metallicRoughnessTexture))), i = this._invokeOne(function(d) {
+        return d.getMaterialType && d.getMaterialType(e);
+      }), c.push(Promise.all(this._invokeAll(function(d) {
+        return d.extendMaterialParams && d.extendMaterialParams(e, a);
+      })));
+    }
+    s.doubleSided === !0 && (a.side = St);
+    const u = s.alphaMode || Te.OPAQUE;
+    if (u === Te.BLEND ? (a.transparent = !0, a.depthWrite = !1) : (a.transparent = !1, u === Te.MASK && (a.alphaTest = s.alphaCutoff !== void 0 ? s.alphaCutoff : 0.5)), s.normalTexture !== void 0 && i !== re && (c.push(t.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 && i !== re && (c.push(t.assignTexture(a, "aoMap", s.occlusionTexture)), s.occlusionTexture.strength !== void 0 && (a.aoMapIntensity = s.occlusionTexture.strength)), s.emissiveFactor !== void 0 && i !== re) {
+      const l = s.emissiveFactor;
+      a.emissive = new G().setRGB(l[0], l[1], l[2], F);
+    }
+    return s.emissiveTexture !== void 0 && i !== re && c.push(t.assignTexture(a, "emissiveMap", s.emissiveTexture, V)), Promise.all(c).then(function() {
+      const l = new i(a);
+      return s.name && (l.name = s.name), U(l, s), t.associations.set(l, { materials: e }), s.extensions && q(n, l, s), l;
+    });
+  }
+  /**
+   * When Object3D instances are targeted by animation, they need unique names.
+   *
+   * @private
+   * @param {string} originalName
+   * @return {string}
+   */
+  createUniqueName(e) {
+    const t = Lt.sanitizeNodeName(e || "");
+    return t in this.nodeNamesUsed ? t + "_" + ++this.nodeNamesUsed[t] : (this.nodeNamesUsed[t] = 0, t);
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#geometry
+   *
+   * Creates BufferGeometries from primitives.
+   *
+   * @private
+   * @param {Array<GLTF.Primitive>} primitives
+   * @return {Promise<Array<BufferGeometry>>}
+   */
+  loadGeometries(e) {
+    const t = this, r = this.extensions, n = this.primitiveCache;
+    function s(a) {
+      return r[R.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(a, t).then(function(o) {
+        return Ue(o, a, t);
+      });
+    }
+    const i = [];
+    for (let a = 0, o = e.length; a < o; a++) {
+      const c = e[a], u = kn(c), l = n[u];
+      if (l)
+        i.push(l.promise);
+      else {
+        let d;
+        c.extensions && c.extensions[R.KHR_DRACO_MESH_COMPRESSION] ? d = s(c) : d = Ue(new qe(), c, t), n[u] = { primitive: c, promise: d }, i.push(d);
+      }
+    }
+    return Promise.all(i);
+  }
+  /**
+   * 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(e) {
+    const t = this, r = this.json, n = this.extensions, s = r.meshes[e], i = s.primitives, a = [];
+    for (let o = 0, c = i.length; o < c; o++) {
+      const u = i[o].material === void 0 ? On(this.cache) : this.getDependency("material", i[o].material);
+      a.push(u);
+    }
+    return a.push(t.loadGeometries(i)), Promise.all(a).then(function(o) {
+      const c = o.slice(0, o.length - 1), u = o[o.length - 1], l = [];
+      for (let f = 0, p = u.length; f < p; f++) {
+        const T = u[f], m = i[f];
+        let g;
+        const b = c[f];
+        if (m.mode === O.TRIANGLES || m.mode === O.TRIANGLE_STRIP || m.mode === O.TRIANGLE_FAN || m.mode === void 0)
+          g = s.isSkinnedMesh === !0 ? new Mt(T, b) : new It(T, b), g.isSkinnedMesh === !0 && g.normalizeSkinWeights(), m.mode === O.TRIANGLE_STRIP ? g.geometry = ke(g.geometry, Ve) : m.mode === O.TRIANGLE_FAN && (g.geometry = ke(g.geometry, ye));
+        else if (m.mode === O.LINES)
+          g = new Ct(T, b);
+        else if (m.mode === O.LINE_STRIP)
+          g = new Nt(T, b);
+        else if (m.mode === O.LINE_LOOP)
+          g = new Ot(T, b);
+        else if (m.mode === O.POINTS)
+          g = new Dt(T, b);
+        else
+          throw new Error("THREE.GLTFLoader: Primitive mode unsupported: " + m.mode);
+        Object.keys(g.geometry.morphAttributes).length > 0 && Pn(g, s), g.name = t.createUniqueName(s.name || "mesh_" + e), U(g, s), m.extensions && q(n, g, m), t.assignFinalMaterial(g), l.push(g);
+      }
+      for (let f = 0, p = l.length; f < p; f++)
+        t.associations.set(l[f], {
+          meshes: e,
+          primitives: f
+        });
+      if (l.length === 1)
+        return s.extensions && q(n, l[0], s), l[0];
+      const d = new fe();
+      s.extensions && q(n, d, s), t.associations.set(d, { meshes: e });
+      for (let f = 0, p = l.length; f < p; f++)
+        d.add(l[f]);
+      return d;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
+   *
+   * @private
+   * @param {number} cameraIndex
+   * @return {Promise<THREE.Camera>}
+   */
+  loadCamera(e) {
+    let t;
+    const r = this.json.cameras[e], n = r[r.type];
+    if (!n) {
+      console.warn("THREE.GLTFLoader: Missing camera parameters.");
+      return;
+    }
+    return r.type === "perspective" ? t = new $e(Z.radToDeg(n.yfov), n.aspectRatio || 1, n.znear || 1, n.zfar || 2e6) : r.type === "orthographic" && (t = new Pt(-n.xmag, n.xmag, n.ymag, -n.ymag, n.znear, n.zfar)), r.name && (t.name = this.createUniqueName(r.name)), U(t, r), Promise.resolve(t);
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
+   *
+   * @private
+   * @param {number} skinIndex
+   * @return {Promise<Skeleton>}
+   */
+  loadSkin(e) {
+    const t = this.json.skins[e], r = [];
+    for (let n = 0, s = t.joints.length; n < s; n++)
+      r.push(this._loadNodeShallow(t.joints[n]));
+    return t.inverseBindMatrices !== void 0 ? r.push(this.getDependency("accessor", t.inverseBindMatrices)) : r.push(null), Promise.all(r).then(function(n) {
+      const s = n.pop(), i = n, a = [], o = [];
+      for (let c = 0, u = i.length; c < u; c++) {
+        const l = i[c];
+        if (l) {
+          a.push(l);
+          const d = new ee();
+          s !== null && d.fromArray(s.array, c * 16), o.push(d);
+        } else
+          console.warn('THREE.GLTFLoader: Joint "%s" could not be found.', t.joints[c]);
+      }
+      return new kt(a, o);
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
+   *
+   * @private
+   * @param {number} animationIndex
+   * @return {Promise<AnimationClip>}
+   */
+  loadAnimation(e) {
+    const t = this.json, r = this, n = t.animations[e], s = n.name ? n.name : "animation_" + e, i = [], a = [], o = [], c = [], u = [];
+    for (let l = 0, d = n.channels.length; l < d; l++) {
+      const f = n.channels[l], p = n.samplers[f.sampler], T = f.target, m = T.node, g = n.parameters !== void 0 ? n.parameters[p.input] : p.input, b = n.parameters !== void 0 ? n.parameters[p.output] : p.output;
+      T.node !== void 0 && (i.push(this.getDependency("node", m)), a.push(this.getDependency("accessor", g)), o.push(this.getDependency("accessor", b)), c.push(p), u.push(T));
+    }
+    return Promise.all([
+      Promise.all(i),
+      Promise.all(a),
+      Promise.all(o),
+      Promise.all(c),
+      Promise.all(u)
+    ]).then(function(l) {
+      const d = l[0], f = l[1], p = l[2], T = l[3], m = l[4], g = [];
+      for (let b = 0, S = d.length; b < S; b++) {
+        const y = d[b], I = f[b], P = p[b], C = T[b], B = m[b];
+        if (y === void 0) continue;
+        y.updateMatrix && y.updateMatrix();
+        const k = r._createAnimationTracks(y, I, P, C, B);
+        if (k)
+          for (let te = 0; te < k.length; te++)
+            g.push(k[te]);
+      }
+      return new Ft(s, void 0, g);
+    });
+  }
+  createNodeMesh(e) {
+    const t = this.json, r = this, n = t.nodes[e];
+    return n.mesh === void 0 ? null : r.getDependency("mesh", n.mesh).then(function(s) {
+      const i = r._getNodeRef(r.meshCache, n.mesh, s);
+      return n.weights !== void 0 && i.traverse(function(a) {
+        if (a.isMesh)
+          for (let o = 0, c = n.weights.length; o < c; o++)
+            a.morphTargetInfluences[o] = n.weights[o];
+      }), i;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
+   *
+   * @private
+   * @param {number} nodeIndex
+   * @return {Promise<Object3D>}
+   */
+  loadNode(e) {
+    const t = this.json, r = this, n = t.nodes[e], s = r._loadNodeShallow(e), i = [], a = n.children || [];
+    for (let c = 0, u = a.length; c < u; c++)
+      i.push(r.getDependency("node", a[c]));
+    const o = n.skin === void 0 ? Promise.resolve(null) : r.getDependency("skin", n.skin);
+    return Promise.all([
+      s,
+      Promise.all(i),
+      o
+    ]).then(function(c) {
+      const u = c[0], l = c[1], d = c[2];
+      d !== null && u.traverse(function(f) {
+        f.isSkinnedMesh && f.bind(d, vn);
+      });
+      for (let f = 0, p = l.length; f < p; f++)
+        u.add(l[f]);
+      return u;
+    });
+  }
+  // ._loadNodeShallow() parses a single node.
+  // skin and child nodes are created and added in .loadNode() (no '_' prefix).
+  _loadNodeShallow(e) {
+    const t = this.json, r = this.extensions, n = this;
+    if (this.nodeCache[e] !== void 0)
+      return this.nodeCache[e];
+    const s = t.nodes[e], i = s.name ? n.createUniqueName(s.name) : "", a = [], o = n._invokeOne(function(c) {
+      return c.createNodeMesh && c.createNodeMesh(e);
+    });
+    return o && a.push(o), s.camera !== void 0 && a.push(n.getDependency("camera", s.camera).then(function(c) {
+      return n._getNodeRef(n.cameraCache, s.camera, c);
+    })), n._invokeAll(function(c) {
+      return c.createNodeAttachment && c.createNodeAttachment(e);
+    }).forEach(function(c) {
+      a.push(c);
+    }), this.nodeCache[e] = Promise.all(a).then(function(c) {
+      let u;
+      if (s.isBone === !0 ? u = new vt() : c.length > 1 ? u = new fe() : c.length === 1 ? u = c[0] : u = new Ye(), u !== c[0])
+        for (let l = 0, d = c.length; l < d; l++)
+          u.add(c[l]);
+      if (s.name && (u.userData.name = s.name, u.name = i), U(u, s), s.extensions && q(r, u, s), s.matrix !== void 0) {
+        const l = new ee();
+        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 (!n.associations.has(u))
+        n.associations.set(u, {});
+      else if (s.mesh !== void 0 && n.meshCache.refs[s.mesh] > 1) {
+        const l = n.associations.get(u);
+        n.associations.set(u, { ...l });
+      }
+      return n.associations.get(u).nodes = e, u;
+    }), this.nodeCache[e];
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes
+   *
+   * @private
+   * @param {number} sceneIndex
+   * @return {Promise<Group>}
+   */
+  loadScene(e) {
+    const t = this.extensions, r = this.json.scenes[e], n = this, s = new fe();
+    r.name && (s.name = n.createUniqueName(r.name)), U(s, r), r.extensions && q(t, s, r);
+    const i = r.nodes || [], a = [];
+    for (let o = 0, c = i.length; o < c; o++)
+      a.push(n.getDependency("node", i[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 [d, f] of n.associations)
+          (d instanceof he || d instanceof Ce) && l.set(d, f);
+        return u.traverse((d) => {
+          const f = n.associations.get(d);
+          f != null && l.set(d, f);
+        }), l;
+      };
+      return n.associations = c(s), s;
+    });
+  }
+  _createAnimationTracks(e, t, r, n, s) {
+    const i = [], a = e.name ? e.name : e.uuid, o = [];
+    K[s.path] === K.weights ? e.traverse(function(d) {
+      d.morphTargetInfluences && o.push(d.name ? d.name : d.uuid);
+    }) : o.push(a);
+    let c;
+    switch (K[s.path]) {
+      case K.weights:
+        c = Oe;
+        break;
+      case K.rotation:
+        c = De;
+        break;
+      case K.translation:
+      case K.scale:
+        c = Ne;
+        break;
+      default:
+        switch (r.itemSize) {
+          case 1:
+            c = Oe;
+            break;
+          case 2:
+          case 3:
+          default:
+            c = Ne;
+            break;
+        }
+        break;
+    }
+    const u = n.interpolation !== void 0 ? Nn[n.interpolation] : et, l = this._getArrayFromAccessor(r);
+    for (let d = 0, f = o.length; d < f; d++) {
+      const p = new c(
+        o[d] + "." + K[s.path],
+        t.array,
+        l,
+        u
+      );
+      n.interpolation === "CUBICSPLINE" && this._createCubicSplineTrackInterpolant(p), i.push(p);
+    }
+    return i;
+  }
+  _getArrayFromAccessor(e) {
+    let t = e.array;
+    if (e.normalized) {
+      const r = _e(t.constructor), n = new Float32Array(t.length);
+      for (let s = 0, i = t.length; s < i; s++)
+        n[s] = t[s] * r;
+      t = n;
+    }
+    return t;
+  }
+  _createCubicSplineTrackInterpolant(e) {
+    e.createInterpolant = function(r) {
+      const n = this instanceof De ? Cn : st;
+      return new n(this.times, this.values, this.getValueSize() / 3, r);
+    }, e.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = !0;
+  }
+}
+function Un(h, e, t) {
+  const r = e.attributes, n = new ue();
+  if (r.POSITION !== void 0) {
+    const a = t.json.accessors[r.POSITION], o = a.min, c = a.max;
+    if (o !== void 0 && c !== void 0) {
+      if (n.set(
+        new _(o[0], o[1], o[2]),
+        new _(c[0], c[1], c[2])
+      ), a.normalized) {
+        const u = _e($[a.componentType]);
+        n.min.multiplyScalar(u), n.max.multiplyScalar(u);
+      }
+    } else {
+      console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      return;
+    }
+  } else
+    return;
+  const s = e.targets;
+  if (s !== void 0) {
+    const a = new _(), o = new _();
+    for (let c = 0, u = s.length; c < u; c++) {
+      const l = s[c];
+      if (l.POSITION !== void 0) {
+        const d = t.json.accessors[l.POSITION], f = d.min, p = d.max;
+        if (f !== void 0 && p !== void 0) {
+          if (o.setX(Math.max(Math.abs(f[0]), Math.abs(p[0]))), o.setY(Math.max(Math.abs(f[1]), Math.abs(p[1]))), o.setZ(Math.max(Math.abs(f[2]), Math.abs(p[2]))), d.normalized) {
+            const T = _e($[d.componentType]);
+            o.multiplyScalar(T);
+          }
+          a.max(o);
+        } else
+          console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      }
+    }
+    n.expandByVector(a);
+  }
+  h.boundingBox = n;
+  const i = new Bt();
+  n.getCenter(i.center), i.radius = n.min.distanceTo(n.max) / 2, h.boundingSphere = i;
+}
+function Ue(h, e, t) {
+  const r = e.attributes, n = [];
+  function s(i, a) {
+    return t.getDependency("accessor", i).then(function(o) {
+      h.setAttribute(a, o);
+    });
+  }
+  for (const i in r) {
+    const a = we[i] || i.toLowerCase();
+    a in h.attributes || n.push(s(r[i], a));
+  }
+  if (e.indices !== void 0 && !h.index) {
+    const i = t.getDependency("accessor", e.indices).then(function(a) {
+      h.setIndex(a);
+    });
+    n.push(i);
+  }
+  return Re.workingColorSpace !== F && "COLOR_0" in r && console.warn(`THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${Re.workingColorSpace}" not supported.`), U(h, e), Un(h, e, t), Promise.all(n).then(function() {
+    return e.targets !== void 0 ? Dn(h, e.targets, t) : h;
+  });
+}
+const A = {
+  c: null,
+  // center
+  u: [new _(), new _(), new _()],
+  // basis vectors
+  e: []
+  // half width
+}, w = {
+  c: null,
+  // center
+  u: [new _(), new _(), new _()],
+  // basis vectors
+  e: []
+  // half width
+}, L = [[], [], []], x = [[], [], []], E = [], W = new _(), Y = new _(), J = new _(), M = new _(), Ge = new _(), Be = new _(), D = new tt(), je = new ue(), ae = new ee(), ze = new ee(), Ke = new jt();
+class Ee {
+  /**
+   * Constructs a new OBB.
+   *
+   * @param {Vector3} [center] - The center of the OBB.
+   * @param {Vector3} [halfSize] - Positive halfwidth extents of the OBB along each axis.
+   * @param {Matrix3} [rotation] - The rotation of the OBB.
+   */
+  constructor(e = new _(), t = new _(), r = new tt()) {
+    this.center = e, this.halfSize = t, this.rotation = r;
+  }
+  /**
+   * Sets the OBBs components to the given values.
+   *
+   * @param {Vector3} [center] - The center of the OBB.
+   * @param {Vector3} [halfSize] - Positive halfwidth extents of the OBB along each axis.
+   * @param {Matrix3} [rotation] - The rotation of the OBB.
+   * @return {OBB} A reference to this OBB.
+   */
+  set(e, t, r) {
+    return this.center = e, this.halfSize = t, this.rotation = r, this;
+  }
+  /**
+   * Copies the values of the given OBB to this instance.
+   *
+   * @param {OBB} obb - The OBB to copy.
+   * @return {OBB} A reference to this OBB.
+   */
+  copy(e) {
+    return this.center.copy(e.center), this.halfSize.copy(e.halfSize), this.rotation.copy(e.rotation), this;
+  }
+  /**
+   * Returns a new OBB with copied values from this instance.
+   *
+   * @return {OBB} A clone of this instance.
+   */
+  clone() {
+    return new this.constructor().copy(this);
+  }
+  /**
+   * Returns the size of this OBB.
+   *
+   * @param {Vector3} target - The target vector that is used to store the method's result.
+   * @return {Vector3} The size.
+   */
+  getSize(e) {
+    return e.copy(this.halfSize).multiplyScalar(2);
+  }
+  /**
+   * Clamps the given point within the bounds of this OBB.
+   *
+   * @param {Vector3} point - The point that should be clamped within the bounds of this OBB.
+   * @param {Vector3} target - The target vector that is used to store the method's result.
+   * @returns {Vector3} - The clamped point.
+   */
+  clampPoint(e, t) {
+    const r = this.halfSize;
+    M.subVectors(e, this.center), this.rotation.extractBasis(W, Y, J), t.copy(this.center);
+    const n = Z.clamp(M.dot(W), -r.x, r.x);
+    t.add(W.multiplyScalar(n));
+    const s = Z.clamp(M.dot(Y), -r.y, r.y);
+    t.add(Y.multiplyScalar(s));
+    const i = Z.clamp(M.dot(J), -r.z, r.z);
+    return t.add(J.multiplyScalar(i)), t;
+  }
+  /**
+   * Returns `true` if the given point lies within this OBB.
+   *
+   * @param {Vector3} point - The point to test.
+   * @returns {boolean} - Whether the given point lies within this OBB or not.
+   */
+  containsPoint(e) {
+    return M.subVectors(e, this.center), this.rotation.extractBasis(W, Y, J), Math.abs(M.dot(W)) <= this.halfSize.x && Math.abs(M.dot(Y)) <= this.halfSize.y && Math.abs(M.dot(J)) <= this.halfSize.z;
+  }
+  /**
+   * Returns `true` if the given AABB intersects this OBB.
+   *
+   * @param {Box3} box3 - The AABB to test.
+   * @returns {boolean} - Whether the given AABB intersects this OBB or not.
+   */
+  intersectsBox3(e) {
+    return this.intersectsOBB(Gn.fromBox3(e));
+  }
+  /**
+   * Returns `true` if the given bounding sphere intersects this OBB.
+   *
+   * @param {Sphere} sphere - The bounding sphere to test.
+   * @returns {boolean} - Whether the given bounding sphere intersects this OBB or not.
+   */
+  intersectsSphere(e) {
+    return this.clampPoint(e.center, Be), Be.distanceToSquared(e.center) <= e.radius * e.radius;
+  }
+  /**
+   * Returns `true` if the given OBB intersects this OBB.
+   *
+   * @param {OBB} obb - The OBB to test.
+   * @param {number} [epsilon=Number.EPSILON] - A small value to prevent arithmetic errors.
+   * @returns {boolean} - Whether the given OBB intersects this OBB or not.
+   */
+  intersectsOBB(e, t = Number.EPSILON) {
+    A.c = this.center, A.e[0] = this.halfSize.x, A.e[1] = this.halfSize.y, A.e[2] = this.halfSize.z, this.rotation.extractBasis(A.u[0], A.u[1], A.u[2]), w.c = e.center, w.e[0] = e.halfSize.x, w.e[1] = e.halfSize.y, w.e[2] = e.halfSize.z, e.rotation.extractBasis(w.u[0], w.u[1], w.u[2]);
+    for (let s = 0; s < 3; s++)
+      for (let i = 0; i < 3; i++)
+        L[s][i] = A.u[s].dot(w.u[i]);
+    M.subVectors(w.c, A.c), E[0] = M.dot(A.u[0]), E[1] = M.dot(A.u[1]), E[2] = M.dot(A.u[2]);
+    for (let s = 0; s < 3; s++)
+      for (let i = 0; i < 3; i++)
+        x[s][i] = Math.abs(L[s][i]) + t;
+    let r, n;
+    for (let s = 0; s < 3; s++)
+      if (r = A.e[s], n = w.e[0] * x[s][0] + w.e[1] * x[s][1] + w.e[2] * x[s][2], Math.abs(E[s]) > r + n) return !1;
+    for (let s = 0; s < 3; s++)
+      if (r = A.e[0] * x[0][s] + A.e[1] * x[1][s] + A.e[2] * x[2][s], n = w.e[s], Math.abs(E[0] * L[0][s] + E[1] * L[1][s] + E[2] * L[2][s]) > r + n) return !1;
+    return r = A.e[1] * x[2][0] + A.e[2] * x[1][0], n = w.e[1] * x[0][2] + w.e[2] * x[0][1], !(Math.abs(E[2] * L[1][0] - E[1] * L[2][0]) > r + n || (r = A.e[1] * x[2][1] + A.e[2] * x[1][1], n = w.e[0] * x[0][2] + w.e[2] * x[0][0], Math.abs(E[2] * L[1][1] - E[1] * L[2][1]) > r + n) || (r = A.e[1] * x[2][2] + A.e[2] * x[1][2], n = w.e[0] * x[0][1] + w.e[1] * x[0][0], Math.abs(E[2] * L[1][2] - E[1] * L[2][2]) > r + n) || (r = A.e[0] * x[2][0] + A.e[2] * x[0][0], n = w.e[1] * x[1][2] + w.e[2] * x[1][1], Math.abs(E[0] * L[2][0] - E[2] * L[0][0]) > r + n) || (r = A.e[0] * x[2][1] + A.e[2] * x[0][1], n = w.e[0] * x[1][2] + w.e[2] * x[1][0], Math.abs(E[0] * L[2][1] - E[2] * L[0][1]) > r + n) || (r = A.e[0] * x[2][2] + A.e[2] * x[0][2], n = w.e[0] * x[1][1] + w.e[1] * x[1][0], Math.abs(E[0] * L[2][2] - E[2] * L[0][2]) > r + n) || (r = A.e[0] * x[1][0] + A.e[1] * x[0][0], n = w.e[1] * x[2][2] + w.e[2] * x[2][1], Math.abs(E[1] * L[0][0] - E[0] * L[1][0]) > r + n) || (r = A.e[0] * x[1][1] + A.e[1] * x[0][1], n = w.e[0] * x[2][2] + w.e[2] * x[2][0], Math.abs(E[1] * L[0][1] - E[0] * L[1][1]) > r + n) || (r = A.e[0] * x[1][2] + A.e[1] * x[0][2], n = w.e[0] * x[2][1] + w.e[1] * x[2][0], Math.abs(E[1] * L[0][2] - E[0] * L[1][2]) > r + n));
+  }
+  /**
+   * Returns `true` if the given plane intersects this OBB.
+   *
+   * @param {Plane} plane - The plane to test.
+   * @returns {boolean} Whether the given plane intersects this OBB or not.
+   */
+  intersectsPlane(e) {
+    this.rotation.extractBasis(W, Y, J);
+    const t = this.halfSize.x * Math.abs(e.normal.dot(W)) + this.halfSize.y * Math.abs(e.normal.dot(Y)) + this.halfSize.z * Math.abs(e.normal.dot(J)), r = e.normal.dot(this.center) - e.constant;
+    return Math.abs(r) <= t;
+  }
+  /**
+   * Performs a ray/OBB intersection test and stores the intersection point
+   * in the given 3D vector.
+   *
+   * @param {Ray} ray - The ray to test.
+   * @param {Vector3} target - The target vector that is used to store the method's result.
+   * @return {?Vector3} The intersection point. If no intersection is detected, `null` is returned.
+   */
+  intersectRay(e, t) {
+    return this.getSize(Ge), je.setFromCenterAndSize(M.set(0, 0, 0), Ge), ae.setFromMatrix3(this.rotation), ae.setPosition(this.center), ze.copy(ae).invert(), Ke.copy(e).applyMatrix4(ze), Ke.intersectBox(je, t) ? t.applyMatrix4(ae) : null;
+  }
+  /**
+   * Returns `true` if the given ray intersects this OBB.
+   *
+   * @param {Ray} ray - The ray to test.
+   * @returns {boolean} Whether the given ray intersects this OBB or not.
+   */
+  intersectsRay(e) {
+    return this.intersectRay(e, M) !== null;
+  }
+  /**
+   * Defines an OBB based on the given AABB.
+   *
+   * @param {Box3} box3 - The AABB to setup the OBB from.
+   * @return {OBB} A reference of this OBB.
+   */
+  fromBox3(e) {
+    return e.getCenter(this.center), e.getSize(this.halfSize).multiplyScalar(0.5), this.rotation.identity(), this;
+  }
+  /**
+   * Returns `true` if the given OBB is equal to this OBB.
+   *
+   * @param {OBB} obb - The OBB to test.
+   * @returns {boolean} Whether the given OBB is equal to this OBB or not.
+   */
+  equals(e) {
+    return e.center.equals(this.center) && e.halfSize.equals(this.halfSize) && e.rotation.equals(this.rotation);
+  }
+  /**
+   * Applies the given transformation matrix to this OBB. This method can be
+   * used to transform the bounding volume with the world matrix of a 3D object
+   * in order to keep both entities in sync.
+   *
+   * @param {Matrix4} matrix - The matrix to apply.
+   * @return {OBB} A reference of this OBB.
+   */
+  applyMatrix4(e) {
+    const t = e.elements;
+    let r = M.set(t[0], t[1], t[2]).length();
+    const n = M.set(t[4], t[5], t[6]).length(), s = M.set(t[8], t[9], t[10]).length();
+    e.determinant() < 0 && (r = -r), D.setFromMatrix4(e);
+    const a = 1 / r, o = 1 / n, c = 1 / s;
+    return D.elements[0] *= a, D.elements[1] *= a, D.elements[2] *= a, D.elements[3] *= o, D.elements[4] *= o, D.elements[5] *= o, D.elements[6] *= c, D.elements[7] *= c, D.elements[8] *= c, this.rotation.multiply(D), this.halfSize.x *= r, this.halfSize.y *= n, this.halfSize.z *= s, M.setFromMatrixPosition(e), this.center.add(M), this;
+  }
+}
+const Gn = new Ee(), Bn = {
+  enableDamping: !0,
+  dampingFactor: 0.25,
+  screenSpacePanning: !1,
+  minDistance: 0.1,
+  maxDistance: 1e3,
+  maxPolarAngle: Z.degToRad(60)
+};
+function Yn(h, e) {
+  const t = Object.assign(
+    {
+      css3d: !1,
+      stats: !1,
+      renderType: "change",
+      control: {
+        init: !0,
+        options: {}
+      }
+    },
+    e || {}
+  );
+  let r, n, s, i = [];
+  const a = pe(!1), o = Xt(), c = pe(0), u = pe(0), l = new zt({
+    antialias: !0,
+    alpha: !0,
+    precision: "mediump",
+    logarithmicDepthBuffer: !0
+  }), d = new Kt({}), f = new $e(50, 1, 0.1, 2e3), p = Math.tan(Math.PI / 180 * f.fov / 2);
+  let T = !1;
+  l.setPixelRatio(window.devicePixelRatio);
+  function m() {
+    a.value = !1;
+    const N = B();
+    c.value = N[0], u.value = N[1], f.aspect = c.value / u.value, f.position.set(47, 39, 100), f.fov = 360 / Math.PI * Math.atan(p * (u.value / c.value)), f.lookAt(0, 0, 0), f.updateProjectionMatrix(), l.setSize(c.value, u.value), r.appendChild(l.domElement), t.stats && k(), t.css3d && rt();
+    let j;
+    if (t.control && t.control.init) {
+      j = Yt(f, l.domElement);
+      const z = Object.assign(
+        Bn,
+        t.control.options || {}
+      );
+      Object.keys(z).forEach((ne) => {
+        j[ne] = z[ne];
+      });
+    }
+    return Pe(() => a.value = !0), j;
+  }
+  function g(N) {
+    N.preventDefault(), cancelAnimationFrame(y);
+  }
+  function b(N) {
+    N.preventDefault(), m(), y();
+  }
+  function S(N) {
+    i.push(N);
+  }
+  function y(N) {
+    i && i.length && i.forEach((j) => {
+      typeof j == "function" && j();
+    }), t.renderType === "loop" && I(), requestAnimationFrame(y);
+  }
+  function I() {
+    T = !1, n && n.update(), o.value && o.value.update(), l.render(d, f), s && s.render(d, f);
+  }
+  function P() {
+    T || (T = !0, requestAnimationFrame(I));
+  }
+  function C() {
+    Pe(() => {
+      const N = B();
+      c.value = N[0], u.value = N[1], f.aspect = c.value / u.value, f.fov = 360 / Math.PI * Math.atan(p * (u.value / c.value)), f.updateProjectionMatrix(), f.lookAt(d.position), l.setSize(c.value, u.value), s && s.setSize(c.value, u.value), I();
+    });
+  }
+  function B() {
+    return r = document.querySelector(h), r ? [r.clientWidth, r.clientHeight] : [0, 0];
+  }
+  function k() {
+    n = new Qt(), n.dom.style.cssText = "position:absolute;top:0;left:0;cursor:pointer;opacity:0.9;z-index:10000", r.appendChild(n.dom);
+  }
+  function te(N, j, z, ne, Le) {
+    const Me = new ue().setFromObject(N), Ie = Me.getSize(new _()).length(), X = Me.getCenter(new _());
+    Le && X.add(Le);
+    const ot = Ie * j * 0.5, at = Z.degToRad(z.fov * 0.5), ct = ot / Math.tan(at), de = new _().subVectors(z.position, X).multiply(new _(1, 1, 1)).normalize().multiplyScalar(ct).add(X), Q = {
+      x: de.x,
+      y: de.y,
+      z: de.z,
+      lookAt_x: X.x,
+      lookAt_y: X.y,
+      lookAt_z: X.z
+    };
+    return z.position.set(Q.x, Q.y, Q.z), z.lookAt(
+      Q.lookAt_x,
+      Q.lookAt_y,
+      Q.lookAt_z
+    ), z.updateProjectionMatrix(), ne.target.copy(X), ne.update(), Ie;
+  }
+  function rt() {
+    s = new Zt(), s.setSize(c.value, u.value), s.domElement.style.position = "absolute", s.domElement.style.top = 0, s.domElement.style.left = 0, s.domElement.style.pointerEvents = "none", r.appendChild(s.domElement);
+  }
+  function it() {
+    Jt(d);
+  }
+  return qt(() => {
+    o.value = m(), window.addEventListener("resize", C, !1), l.domElement.addEventListener(
+      "webglcontextlost",
+      g,
+      !1
+    ), l.domElement.addEventListener(
+      "webglcontextrestored",
+      b,
+      !1
+    ), t.renderType === "loop" ? requestAnimationFrame(y) : t.renderType === "change" && o.value && o.value.addEventListener("change", P);
+  }), Wt(() => {
+    cancelAnimationFrame(y), l.domElement.removeEventListener("resize", C, !1), l.domElement.removeEventListener(
+      "webglcontextlost",
+      g,
+      !1
+    ), l.domElement.removeEventListener(
+      "webglcontextrestored",
+      b,
+      !1
+    ), it();
+  }), {
+    addAnimate: S,
+    frameArea: te,
+    onRender: I,
+    css3dRenderer: s,
+    scene: d,
+    camera: f,
+    control: o,
+    renderer: l,
+    domWidth: c,
+    domHeight: u,
+    isReady: a
+  };
+}
+const Jn = (h = "app") => {
+  const e = new Vt();
+  e.params.Line.threshold = 8;
+  const t = new Se(), r = document.getElementById(h);
+  function n(a, o) {
+    const { scaleX: c, scaleY: u } = i(r), { clientWidth: l, clientHeight: d } = o, f = o.getBoundingClientRect(), p = l * c, T = d * u, m = a.clientX - f.left, g = a.clientY - f.top;
+    return t.x = (a.clientX - f.left) / p * 2 - 1, t.y = -((a.clientY - f.top) / T) * 2 + 1, { pointer: t, x: m, y: g };
+  }
+  function s(a, o, c, u) {
+    const { pointer: l, x: d, y: f } = n(a, o);
+    return e.setFromCamera(l, c), { intersects: e.intersectObjects(u), pointer: l, x: d, y: f };
+  }
+  function i(a) {
+    const o = window.getComputedStyle(a), c = o.transform || o.webkitTransform || o.mozTransform;
+    if (c && c !== "none") {
+      const u = c.match(/^matrix\((.+)\)$/);
+      if (u) {
+        const l = u[1].split(", "), d = parseFloat(l[0]), f = parseFloat(l[3]);
+        return { scaleX: d, scaleY: f };
+      }
+    }
+    return { scaleX: 1, scaleY: 1 };
+  }
+  return {
+    raycaster: e,
+    pointer: t,
+    getPointer: n,
+    getScale: i,
+    getIntersects: s
+  };
+}, H = [], Qn = new G(16711680), Zn = () => {
+  const h = () => {
+    H.splice(0);
+  }, e = (a, o) => {
+    o.traverse((c) => {
+      c && t(a, c);
+    });
+  }, t = (a, o) => {
+    if (o.userData.needCheck && (o.autoUpdateMatrix = !1, o.updateMatrix(), o.updateMatrixWorld(), o.isMesh)) {
+      const c = new ue(new _()).setFromObject(o);
+      o.geometry.userData.obb = new Ee(), o.geometry.userData.obb.halfSize.copy(c.getSize(new _())).multiplyScalar(0.5).multiplyScalar(0.88), o.userData.obb = new Ee(), o.userData.originColor = o.material.color.clone(), o.userData.parentUid = a, H.push({
+        object: o,
+        parentUid: a
+      });
+    }
+  };
+  return {
+    resetObbs: h,
+    initObb: e,
+    getObbObjectByParentUid: (a) => H.filter((o) => o.parentUid === a),
+    addObbFromArray: (a, o) => {
+      for (let c = 0, u = o.length; c < u; c++)
+        t(a, o[c]);
+    },
+    removeObbFromArray: (a) => {
+      const o = H.filter((c) => !a.includes(c.object));
+      H.splice(0, H.length, ...o);
+    },
+    removeUidObb: (a) => {
+      for (let o = H.length - 1; o >= 0; o--)
+        H[o].parentUid === a && H.splice(o, 1);
+    }
+  };
+};
+class jn {
+  /**
+   * 构造函数
+   * @param {string} dbName - 数据库名称
+   * @param {Object} tableDefinitions - 表定义对象，例如 { models: "&path, data" }
+   * @param {number} version - 数据库版本号
+   */
+  constructor(e = "threeJsIDBCache", t = 3) {
+    this.version = t, this.dbName = e, this.dbInit();
+  }
+  dbInit() {
+    this.db = new tn(this.dbName), this.materialMap = {}, this.db.version(this.version).stores({ models: "&path, version, data" });
+  }
+  /**
+   * 获取 Dexie 数据库实例
+   * @returns {Dexie} Dexie 实例
+   */
+  getDatabase() {
+    return this.db;
+  }
+  /**
+   * 缓存模型到 IndexedDB
+   * @param {string} path - 主键值
+   * @param {THREE.Object3D} model - 要缓存的模型
+   * @param {string} [version] - 缓存模型版本
+   */
+  async cacheModel(e, t, r) {
+    try {
+      this.db.table("models").put({ version: r, path: e, data: t }).then(() => {
+        console.log(`Model "${e}" cached successfully in table models`);
+      });
+    } catch {
+      console.log(" 缓存模型失败 =====> ");
+    }
+    return t;
+  }
+  /**
+   * 从 IndexedDB 加载缓存的模型
+   * @param {string} path - 主键值
+   * @returns {THREE.Object3D | null} 加载的模型
+   */
+  async loadCachedModel(e, t) {
+    let r = null;
+    try {
+      if (r = await this.db.table("models").get(e), !r)
+        return console.warn(`Model "${t}" not found in table models`), null;
+      if (r.version !== t)
+        return console.log(" =====> 模型版本不一致, 清除当前记录"), await this.db.table("models").delete(e), null;
+    } catch {
+      return console.log("  =====> 查询表中模型失败"), this.db.delete().then(() => {
+        this.init();
+      }), null;
+    }
+    return r.data;
+  }
+}
+let ce;
+const $n = () => {
+  const h = new rn(), e = new nn();
+  e.setDecoderPath("/draco/"), h.setDRACOLoader(e);
+  function t(s, i, a, o) {
+    return h.load(s, i, a, o);
+  }
+  function r(s, i) {
+    return new Promise((a, o) => {
+      h.load(s, a, i, o);
+    });
+  }
+  async function n(s, i, a = !0, o) {
+    ce || (ce = new jn());
+    const c = await ce.loadCachedModel(s, i);
+    return c ? a ? $t(c) : c : new Promise((u, l) => {
+      h.load(s, u, o, l);
+    }).then(async (u) => {
+      const l = en(u);
+      return ce.cacheModel(s, u.scene, i), a ? u.scene : l;
+    });
+  }
+  return {
+    load: t,
+    asyncLoad: r,
+    asyncCacheLoad: n
+  };
+};
+export {
+  jn as I,
+  Jn as a,
+  Zn as b,
+  $n as c,
+  Qn as i,
+  H as o,
+  Yn as u
+};