@ridp/threejs 0.0.1

package/dist/useGLTFLoader-CoqckCZO.js

@@ -0,0 +1,2641 @@
+import { TrianglesDrawMode as ht, TriangleFanDrawMode as Ie, TriangleStripDrawMode as Je, Loader as Ze, FileLoader as ye, SRGBColorSpace as te, LinearSRGBColorSpace as K, BufferGeometry as $e, BufferAttribute as ue, Color as V, ColorManagement as Ne, LoaderUtils as de, MeshPhysicalMaterial as X, Vector2 as De, SpotLight as et, PointLight as ft, DirectionalLight as pt, Matrix4 as ae, Vector3 as O, Quaternion as tt, InstancedMesh as mt, InstancedBufferAttribute as gt, Object3D as nt, TextureLoader as At, ImageBitmapLoader as Tt, InterleavedBuffer as yt, InterleavedBufferAttribute as Rt, LinearMipmapLinearFilter as st, NearestMipmapLinearFilter as xt, LinearMipmapNearestFilter as _t, NearestMipmapNearestFilter as Et, LinearFilter as pe, NearestFilter as rt, RepeatWrapping as Ce, MirroredRepeatWrapping as wt, ClampToEdgeWrapping as bt, PointsMaterial as St, Material as _e, LineBasicMaterial as Lt, MeshStandardMaterial as it, DoubleSide as Mt, MeshBasicMaterial as le, PropertyBinding as It, SkinnedMesh as Nt, Mesh as Ct, LineSegments as Ot, Line as Pt, LineLoop as kt, Points as Dt, Group as Te, PerspectiveCamera as ot, MathUtils as he, OrthographicCamera as Ft, Skeleton as Ht, AnimationClip as vt, Bone as Bt, InterpolateDiscrete as Gt, InterpolateLinear as at, Texture as He, VectorKeyframeTrack as ve, NumberKeyframeTrack as Be, QuaternionKeyframeTrack as Ge, FrontSide as Ut, Interpolant as jt, Box3 as Re, Sphere as zt, DataTextureLoader as Kt, HalfFloatType as me, FloatType as Ee, DataUtils as ge, Matrix3 as ct, Ray as Vt, WebGLRenderer as Xt, Scene as Wt, EquirectangularReflectionMapping as qt, Raycaster as Yt, AmbientLight as Qt } from "three";
+import { i as Jt, g as Zt, a as $t, d as en, j as tn } from "./disposeObject-CmFSSgi7.js";
+var fe = function() {
+  var h = 0, e = document.createElement("div");
+  e.style.cssText = "position:fixed;top:0;left:0;cursor:pointer;opacity:0.9;z-index:10000", e.addEventListener("click", function(l) {
+    l.preventDefault(), r(++h % e.children.length);
+  }, !1);
+  function t(l) {
+    return e.appendChild(l.dom), l;
+  }
+  function r(l) {
+    for (var u = 0; u < e.children.length; u++)
+      e.children[u].style.display = u === l ? "block" : "none";
+    h = l;
+  }
+  var n = (performance || Date).now(), i = n, s = 0, a = t(new fe.Panel("FPS", "#0ff", "#002")), o = t(new fe.Panel("MS", "#0f0", "#020"));
+  if (self.performance && self.performance.memory)
+    var c = t(new fe.Panel("MB", "#f08", "#201"));
+  return r(0), {
+    REVISION: 16,
+    dom: e,
+    addPanel: t,
+    showPanel: r,
+    begin: function() {
+      n = (performance || Date).now();
+    },
+    end: function() {
+      s++;
+      var l = (performance || Date).now();
+      if (o.update(l - n, 200), l >= i + 1e3 && (a.update(s * 1e3 / (l - i), 100), i = l, s = 0, c)) {
+        var u = performance.memory;
+        c.update(u.usedJSHeapSize / 1048576, u.jsHeapSizeLimit / 1048576);
+      }
+      return l;
+    },
+    update: function() {
+      n = this.end();
+    },
+    // Backwards Compatibility
+    domElement: e,
+    setMode: r
+  };
+};
+fe.Panel = function(h, e, t) {
+  var r = 1 / 0, n = 0, i = Math.round, s = i(window.devicePixelRatio || 1), a = 80 * s, o = 48 * s, c = 3 * s, l = 2 * s, u = 3 * s, d = 15 * s, f = 74 * s, m = 30 * s, T = document.createElement("canvas");
+  T.width = a, T.height = o, T.style.cssText = "width:80px;height:48px";
+  var p = T.getContext("2d");
+  return p.font = "bold " + 9 * s + "px Helvetica,Arial,sans-serif", p.textBaseline = "top", p.fillStyle = t, p.fillRect(0, 0, a, o), p.fillStyle = e, p.fillText(h, c, l), p.fillRect(u, d, f, m), p.fillStyle = t, p.globalAlpha = 0.9, p.fillRect(u, d, f, m), {
+    dom: T,
+    update: function(A, x) {
+      r = Math.min(r, A), n = Math.max(n, A), p.fillStyle = t, p.globalAlpha = 1, p.fillRect(0, 0, a, d), p.fillStyle = e, p.fillText(i(A) + " " + h + " (" + i(r) + "-" + i(n) + ")", c, l), p.drawImage(T, u + s, d, f - s, m, u, d, f - s, m), p.fillRect(u + f - s, d, s, m), p.fillStyle = t, p.globalAlpha = 0.9, p.fillRect(u + f - s, d, s, i((1 - A / x) * m));
+    }
+  };
+};
+function Ue(h, e) {
+  if (e === ht)
+    return console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles."), h;
+  if (e === Ie || e === Je) {
+    let t = h.getIndex();
+    if (t === null) {
+      const s = [], a = h.getAttribute("position");
+      if (a !== void 0) {
+        for (let o = 0; o < a.count; o++)
+          s.push(o);
+        h.setIndex(s), 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 === Ie)
+      for (let s = 1; s <= r; s++)
+        n.push(t.getX(0)), n.push(t.getX(s)), n.push(t.getX(s + 1));
+    else
+      for (let s = 0; s < r; s++)
+        s % 2 === 0 ? (n.push(t.getX(s)), n.push(t.getX(s + 1)), n.push(t.getX(s + 2))) : (n.push(t.getX(s + 2)), n.push(t.getX(s + 1)), n.push(t.getX(s)));
+    n.length / 3 !== r && console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unable to generate correct amount of triangles.");
+    const i = h.clone();
+    return i.setIndex(n), i.clearGroups(), i;
+  } else
+    return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unknown draw mode:", e), h;
+}
+const we = /* @__PURE__ */ new WeakMap();
+class nn extends Ze {
+  /**
+   * 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 i = new ye(this.manager);
+    i.setPath(this.path), i.setResponseType("arraybuffer"), i.setRequestHeader(this.requestHeader), i.setWithCredentials(this.withCredentials), i.load(e, (s) => {
+      this.parse(s, 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, te, r).catch(r);
+  }
+  //
+  decodeDracoFile(e, t, r, n, i = K, s = () => {
+  }) {
+    const a = {
+      attributeIDs: r || this.defaultAttributeIDs,
+      attributeTypes: n || this.defaultAttributeTypes,
+      useUniqueIDs: !!r,
+      vertexColorSpace: i
+    };
+    return this.decodeGeometry(e, a).then(t).catch(s);
+  }
+  decodeGeometry(e, t) {
+    const r = JSON.stringify(t);
+    if (we.has(e)) {
+      const o = we.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 i = this.workerNextTaskID++, s = e.byteLength, a = this._getWorker(i, s).then((o) => (n = o, new Promise((c, l) => {
+      n._callbacks[i] = { resolve: c, reject: l }, n.postMessage({ type: "decode", id: i, taskConfig: t, buffer: e }, [e]);
+    }))).then((o) => this._createGeometry(o.geometry));
+    return a.catch(() => !0).then(() => {
+      n && i && this._releaseTask(n, i);
+    }), we.set(e, {
+      key: r,
+      promise: a
+    }), a;
+  }
+  _createGeometry(e) {
+    const t = new $e();
+    e.index && t.setIndex(new ue(e.index.array, 1));
+    for (let r = 0; r < e.attributes.length; r++) {
+      const n = e.attributes[r], i = n.name, s = n.array, a = n.itemSize, o = new ue(s, a);
+      i === "color" && (this._assignVertexColorSpace(o, n.vertexColorSpace), o.normalized = !(s instanceof Float32Array)), t.setAttribute(i, o);
+    }
+    return t;
+  }
+  _assignVertexColorSpace(e, t) {
+    if (t !== te) return;
+    const r = new V();
+    for (let n = 0, i = e.count; n < i; n++)
+      r.fromBufferAttribute(e, n), Ne.toWorkingColorSpace(r, te), e.setXYZ(n, r.r, r.g, r.b);
+  }
+  _loadLibrary(e, t) {
+    const r = new ye(this.manager);
+    return r.setPath(this.decoderPath), r.setResponseType(t), r.setWithCredentials(this.withCredentials), new Promise((n, i) => {
+      r.load(e, n, void 0, i);
+    });
+  }
+  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 i = sn.toString(), s = [
+        "/* draco decoder */",
+        n,
+        "",
+        "/* worker */",
+        i.substring(i.indexOf("{") + 1, i.lastIndexOf("}"))
+      ].join(`
+`);
+      this.workerSourceURL = URL.createObjectURL(new Blob([s]));
+    }), 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(i) {
+          const s = i.data;
+          switch (s.type) {
+            case "decode":
+              n._callbacks[s.id].resolve(s);
+              break;
+            case "error":
+              n._callbacks[s.id].reject(s);
+              break;
+            default:
+              console.error('THREE.DRACOLoader: Unexpected message, "' + s.type + '"');
+          }
+        }, this.workerPool.push(n);
+      } else
+        this.workerPool.sort(function(n, i) {
+          return n._taskLoad > i._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(s) {
+    const a = s.data;
+    switch (a.type) {
+      case "init":
+        h = a.decoderConfig, e = new Promise(function(l) {
+          h.onModuleLoaded = function(u) {
+            l({ draco: u });
+          }, DracoDecoderModule(h);
+        });
+        break;
+      case "decode":
+        const o = a.buffer, c = a.taskConfig;
+        e.then((l) => {
+          const u = l.draco, d = new u.Decoder();
+          try {
+            const f = t(u, d, new Int8Array(o), c), m = f.attributes.map((T) => T.array.buffer);
+            f.index && m.push(f.index.array.buffer), self.postMessage({ type: "decode", id: a.id, geometry: f }, m);
+          } catch (f) {
+            console.error(f), self.postMessage({ type: "error", id: a.id, error: f.message });
+          } finally {
+            u.destroy(d);
+          }
+        });
+        break;
+    }
+  };
+  function t(s, a, o, c) {
+    const l = c.attributeIDs, u = c.attributeTypes;
+    let d, f;
+    const m = a.GetEncodedGeometryType(o);
+    if (m === s.TRIANGULAR_MESH)
+      d = new s.Mesh(), f = a.DecodeArrayToMesh(o, o.byteLength, d);
+    else if (m === s.POINT_CLOUD)
+      d = new s.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 p in l) {
+      const A = self[u[p]];
+      let x, N;
+      if (c.useUniqueIDs)
+        N = l[p], x = a.GetAttributeByUniqueId(d, N);
+      else {
+        if (N = a.GetAttributeId(d, s[l[p]]), N === -1) continue;
+        x = a.GetAttribute(d, N);
+      }
+      const _ = n(s, a, d, p, A, x);
+      p === "color" && (_.vertexColorSpace = c.vertexColorSpace), T.attributes.push(_);
+    }
+    return m === s.TRIANGULAR_MESH && (T.index = r(s, a, d)), s.destroy(d), T;
+  }
+  function r(s, a, o) {
+    const l = o.num_faces() * 3, u = l * 4, d = s._malloc(u);
+    a.GetTrianglesUInt32Array(o, u, d);
+    const f = new Uint32Array(s.HEAPF32.buffer, d, l).slice();
+    return s._free(d), { array: f, itemSize: 1 };
+  }
+  function n(s, a, o, c, l, u) {
+    const d = u.num_components(), m = o.num_points() * d, T = m * l.BYTES_PER_ELEMENT, p = i(s, l), A = s._malloc(T);
+    a.GetAttributeDataArrayForAllPoints(o, u, p, T, A);
+    const x = new l(s.HEAPF32.buffer, A, m).slice();
+    return s._free(A), {
+      name: c,
+      array: x,
+      itemSize: d
+    };
+  }
+  function i(s, a) {
+    switch (a) {
+      case Float32Array:
+        return s.DT_FLOAT32;
+      case Int8Array:
+        return s.DT_INT8;
+      case Int16Array:
+        return s.DT_INT16;
+      case Int32Array:
+        return s.DT_INT32;
+      case Uint8Array:
+        return s.DT_UINT8;
+      case Uint16Array:
+        return s.DT_UINT16;
+      case Uint32Array:
+        return s.DT_UINT32;
+    }
+  }
+}
+class rn extends Ze {
+  /**
+   * 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 xn(t);
+    }), this.register(function(t) {
+      return new _n(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 An(t);
+    }), this.register(function(t) {
+      return new hn(t);
+    }), this.register(function(t) {
+      return new yn(t);
+    }), this.register(function(t) {
+      return new Tn(t);
+    }), this.register(function(t) {
+      return new an(t);
+    }), this.register(function(t) {
+      return new En(t);
+    }), this.register(function(t) {
+      return new wn(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 i = this;
+    let s;
+    if (this.resourcePath !== "")
+      s = this.resourcePath;
+    else if (this.path !== "") {
+      const c = de.extractUrlBase(e);
+      s = de.resolveURL(c, this.path);
+    } else
+      s = de.extractUrlBase(e);
+    this.manager.itemStart(e);
+    const a = function(c) {
+      n ? n(c) : console.error(c), i.manager.itemError(e), i.manager.itemEnd(e);
+    }, o = new ye(this.manager);
+    o.setPath(this.path), o.setResponseType("arraybuffer"), o.setRequestHeader(this.requestHeader), o.setWithCredentials(this.withCredentials), o.load(e, function(c) {
+      try {
+        i.parse(c, s, function(l) {
+          t(l), i.manager.itemEnd(e);
+        }, a);
+      } catch (l) {
+        a(l);
+      }
+    }, 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 i;
+    const s = {}, a = {}, o = new TextDecoder();
+    if (typeof e == "string")
+      i = JSON.parse(e);
+    else if (e instanceof ArrayBuffer)
+      if (o.decode(new Uint8Array(e, 0, 4)) === lt) {
+        try {
+          s[E.KHR_BINARY_GLTF] = new bn(e);
+        } catch (u) {
+          n && n(u);
+          return;
+        }
+        i = JSON.parse(s[E.KHR_BINARY_GLTF].content);
+      } else
+        i = JSON.parse(o.decode(e));
+    else
+      i = e;
+    if (i.asset === void 0 || i.asset.version[0] < 2) {
+      n && n(new Error("THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported."));
+      return;
+    }
+    const c = new vn(i, {
+      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 l = 0; l < this.pluginCallbacks.length; l++) {
+      const u = this.pluginCallbacks[l](c);
+      u.name || console.error("THREE.GLTFLoader: Invalid plugin found: missing name"), a[u.name] = u, s[u.name] = !0;
+    }
+    if (i.extensionsUsed)
+      for (let l = 0; l < i.extensionsUsed.length; ++l) {
+        const u = i.extensionsUsed[l], d = i.extensionsRequired || [];
+        switch (u) {
+          case E.KHR_MATERIALS_UNLIT:
+            s[u] = new cn();
+            break;
+          case E.KHR_DRACO_MESH_COMPRESSION:
+            s[u] = new Sn(i, this.dracoLoader);
+            break;
+          case E.KHR_TEXTURE_TRANSFORM:
+            s[u] = new Ln();
+            break;
+          case E.KHR_MESH_QUANTIZATION:
+            s[u] = new Mn();
+            break;
+          default:
+            d.indexOf(u) >= 0 && a[u] === void 0 && console.warn('THREE.GLTFLoader: Unknown extension "' + u + '".');
+        }
+      }
+    c.setExtensions(s), c.setPlugins(a), c.parse(r, n);
+  }
+  /**
+   * Async version of {@link GLTFLoader#parse}.
+   *
+   * @async
+   * @param {string|ArrayBuffer} data - The raw glTF data.
+   * @param {string} path - The URL base path.
+   * @return {Promise<GLTFLoader~LoadObject>} A Promise that resolves with the loaded glTF when the parsing has been finished.
+   */
+  parseAsync(e, t) {
+    const r = this;
+    return new Promise(function(n, i) {
+      r.parse(e, t, n, i);
+    });
+  }
+}
+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 E = {
+  KHR_BINARY_GLTF: "KHR_binary_glTF",
+  KHR_DRACO_MESH_COMPRESSION: "KHR_draco_mesh_compression",
+  KHR_LIGHTS_PUNCTUAL: "KHR_lights_punctual",
+  KHR_MATERIALS_CLEARCOAT: "KHR_materials_clearcoat",
+  KHR_MATERIALS_DISPERSION: "KHR_materials_dispersion",
+  KHR_MATERIALS_IOR: "KHR_materials_ior",
+  KHR_MATERIALS_SHEEN: "KHR_materials_sheen",
+  KHR_MATERIALS_SPECULAR: "KHR_materials_specular",
+  KHR_MATERIALS_TRANSMISSION: "KHR_materials_transmission",
+  KHR_MATERIALS_IRIDESCENCE: "KHR_materials_iridescence",
+  KHR_MATERIALS_ANISOTROPY: "KHR_materials_anisotropy",
+  KHR_MATERIALS_UNLIT: "KHR_materials_unlit",
+  KHR_MATERIALS_VOLUME: "KHR_materials_volume",
+  KHR_TEXTURE_BASISU: "KHR_texture_basisu",
+  KHR_TEXTURE_TRANSFORM: "KHR_texture_transform",
+  KHR_MESH_QUANTIZATION: "KHR_mesh_quantization",
+  KHR_MATERIALS_EMISSIVE_STRENGTH: "KHR_materials_emissive_strength",
+  EXT_MATERIALS_BUMP: "EXT_materials_bump",
+  EXT_TEXTURE_WEBP: "EXT_texture_webp",
+  EXT_TEXTURE_AVIF: "EXT_texture_avif",
+  EXT_MESHOPT_COMPRESSION: "EXT_meshopt_compression",
+  EXT_MESH_GPU_INSTANCING: "EXT_mesh_gpu_instancing"
+};
+class an {
+  constructor(e) {
+    this.parser = e, this.name = E.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 i = t[r];
+      i.extensions && i.extensions[this.name] && i.extensions[this.name].light !== void 0 && e._addNodeRef(this.cache, i.extensions[this.name].light);
+    }
+  }
+  _loadLight(e) {
+    const t = this.parser, r = "light:" + e;
+    let n = t.cache.get(r);
+    if (n) return n;
+    const i = t.json, o = ((i.extensions && i.extensions[this.name] || {}).lights || [])[e];
+    let c;
+    const l = new V(16777215);
+    o.color !== void 0 && l.setRGB(o.color[0], o.color[1], o.color[2], K);
+    const u = o.range !== void 0 ? o.range : 0;
+    switch (o.type) {
+      case "directional":
+        c = new pt(l), c.target.position.set(0, 0, -1), c.add(c.target);
+        break;
+      case "point":
+        c = new ft(l), c.distance = u;
+        break;
+      case "spot":
+        c = new et(l), c.distance = u, 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), Z(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, i = r.json.nodes[e], a = (i.extensions && i.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 = E.KHR_MATERIALS_UNLIT;
+  }
+  getMaterialType() {
+    return le;
+  }
+  extendParams(e, t, r) {
+    const n = [];
+    e.color = new V(1, 1, 1), e.opacity = 1;
+    const i = t.pbrMetallicRoughness;
+    if (i) {
+      if (Array.isArray(i.baseColorFactor)) {
+        const s = i.baseColorFactor;
+        e.color.setRGB(s[0], s[1], s[2], K), e.opacity = s[3];
+      }
+      i.baseColorTexture !== void 0 && n.push(r.assignTexture(e, "map", i.baseColorTexture, te));
+    }
+    return Promise.all(n);
+  }
+}
+class ln {
+  constructor(e) {
+    this.parser = e, this.name = E.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 i = n.extensions[this.name].emissiveStrength;
+    return i !== void 0 && (t.emissiveIntensity = i), Promise.resolve();
+  }
+}
+class un {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_CLEARCOAT;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], s = n.extensions[this.name];
+    if (s.clearcoatFactor !== void 0 && (t.clearcoat = s.clearcoatFactor), s.clearcoatTexture !== void 0 && i.push(r.assignTexture(t, "clearcoatMap", s.clearcoatTexture)), s.clearcoatRoughnessFactor !== void 0 && (t.clearcoatRoughness = s.clearcoatRoughnessFactor), s.clearcoatRoughnessTexture !== void 0 && i.push(r.assignTexture(t, "clearcoatRoughnessMap", s.clearcoatRoughnessTexture)), s.clearcoatNormalTexture !== void 0 && (i.push(r.assignTexture(t, "clearcoatNormalMap", s.clearcoatNormalTexture)), s.clearcoatNormalTexture.scale !== void 0)) {
+      const a = s.clearcoatNormalTexture.scale;
+      t.clearcoatNormalScale = new De(a, a);
+    }
+    return Promise.all(i);
+  }
+}
+class dn {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_DISPERSION;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = n.extensions[this.name];
+    return t.dispersion = i.dispersion !== void 0 ? i.dispersion : 0, Promise.resolve();
+  }
+}
+class hn {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_IRIDESCENCE;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], s = n.extensions[this.name];
+    return s.iridescenceFactor !== void 0 && (t.iridescence = s.iridescenceFactor), s.iridescenceTexture !== void 0 && i.push(r.assignTexture(t, "iridescenceMap", s.iridescenceTexture)), s.iridescenceIor !== void 0 && (t.iridescenceIOR = s.iridescenceIor), t.iridescenceThicknessRange === void 0 && (t.iridescenceThicknessRange = [100, 400]), s.iridescenceThicknessMinimum !== void 0 && (t.iridescenceThicknessRange[0] = s.iridescenceThicknessMinimum), s.iridescenceThicknessMaximum !== void 0 && (t.iridescenceThicknessRange[1] = s.iridescenceThicknessMaximum), s.iridescenceThicknessTexture !== void 0 && i.push(r.assignTexture(t, "iridescenceThicknessMap", s.iridescenceThicknessTexture)), Promise.all(i);
+  }
+}
+class fn {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_SHEEN;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [];
+    t.sheenColor = new V(0, 0, 0), t.sheenRoughness = 0, t.sheen = 1;
+    const s = n.extensions[this.name];
+    if (s.sheenColorFactor !== void 0) {
+      const a = s.sheenColorFactor;
+      t.sheenColor.setRGB(a[0], a[1], a[2], K);
+    }
+    return s.sheenRoughnessFactor !== void 0 && (t.sheenRoughness = s.sheenRoughnessFactor), s.sheenColorTexture !== void 0 && i.push(r.assignTexture(t, "sheenColorMap", s.sheenColorTexture, te)), s.sheenRoughnessTexture !== void 0 && i.push(r.assignTexture(t, "sheenRoughnessMap", s.sheenRoughnessTexture)), Promise.all(i);
+  }
+}
+class pn {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_TRANSMISSION;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], s = n.extensions[this.name];
+    return s.transmissionFactor !== void 0 && (t.transmission = s.transmissionFactor), s.transmissionTexture !== void 0 && i.push(r.assignTexture(t, "transmissionMap", s.transmissionTexture)), Promise.all(i);
+  }
+}
+class mn {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_VOLUME;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], s = n.extensions[this.name];
+    t.thickness = s.thicknessFactor !== void 0 ? s.thicknessFactor : 0, s.thicknessTexture !== void 0 && i.push(r.assignTexture(t, "thicknessMap", s.thicknessTexture)), t.attenuationDistance = s.attenuationDistance || 1 / 0;
+    const a = s.attenuationColor || [1, 1, 1];
+    return t.attenuationColor = new V().setRGB(a[0], a[1], a[2], K), Promise.all(i);
+  }
+}
+class gn {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_IOR;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = n.extensions[this.name];
+    return t.ior = i.ior !== void 0 ? i.ior : 1.5, Promise.resolve();
+  }
+}
+class An {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_SPECULAR;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], s = n.extensions[this.name];
+    t.specularIntensity = s.specularFactor !== void 0 ? s.specularFactor : 1, s.specularTexture !== void 0 && i.push(r.assignTexture(t, "specularIntensityMap", s.specularTexture));
+    const a = s.specularColorFactor || [1, 1, 1];
+    return t.specularColor = new V().setRGB(a[0], a[1], a[2], K), s.specularColorTexture !== void 0 && i.push(r.assignTexture(t, "specularColorMap", s.specularColorTexture, te)), Promise.all(i);
+  }
+}
+class Tn {
+  constructor(e) {
+    this.parser = e, this.name = E.EXT_MATERIALS_BUMP;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], s = n.extensions[this.name];
+    return t.bumpScale = s.bumpFactor !== void 0 ? s.bumpFactor : 1, s.bumpTexture !== void 0 && i.push(r.assignTexture(t, "bumpMap", s.bumpTexture)), Promise.all(i);
+  }
+}
+class yn {
+  constructor(e) {
+    this.parser = e, this.name = E.KHR_MATERIALS_ANISOTROPY;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : X;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [], s = n.extensions[this.name];
+    return s.anisotropyStrength !== void 0 && (t.anisotropy = s.anisotropyStrength), s.anisotropyRotation !== void 0 && (t.anisotropyRotation = s.anisotropyRotation), s.anisotropyTexture !== void 0 && i.push(r.assignTexture(t, "anisotropyMap", s.anisotropyTexture)), Promise.all(i);
+  }
+}
+class Rn {
+  constructor(e) {
+    this.parser = e, this.name = E.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 i = n.extensions[this.name], s = t.options.ktx2Loader;
+    if (!s) {
+      if (r.extensionsRequired && r.extensionsRequired.indexOf(this.name) >= 0)
+        throw new Error("THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures");
+      return null;
+    }
+    return t.loadTextureImage(e, i.source, s);
+  }
+}
+class xn {
+  constructor(e) {
+    this.parser = e, this.name = E.EXT_TEXTURE_WEBP, this.isSupported = null;
+  }
+  loadTexture(e) {
+    const t = this.name, r = this.parser, n = r.json, i = n.textures[e];
+    if (!i.extensions || !i.extensions[t])
+      return null;
+    const s = i.extensions[t], a = n.images[s.source];
+    let o = r.textureLoader;
+    if (a.uri) {
+      const c = r.options.manager.getHandler(a.uri);
+      c !== null && (o = c);
+    }
+    return this.detectSupport().then(function(c) {
+      if (c) return r.loadTextureImage(e, s.source, o);
+      if (n.extensionsRequired && n.extensionsRequired.indexOf(t) >= 0)
+        throw new Error("THREE.GLTFLoader: WebP required by asset but unsupported.");
+      return r.loadTexture(e);
+    });
+  }
+  detectSupport() {
+    return this.isSupported || (this.isSupported = new Promise(function(e) {
+      const t = new Image();
+      t.src = "data:image/webp;base64,UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA", t.onload = t.onerror = function() {
+        e(t.height === 1);
+      };
+    })), this.isSupported;
+  }
+}
+class _n {
+  constructor(e) {
+    this.parser = e, this.name = E.EXT_TEXTURE_AVIF, this.isSupported = null;
+  }
+  loadTexture(e) {
+    const t = this.name, r = this.parser, n = r.json, i = n.textures[e];
+    if (!i.extensions || !i.extensions[t])
+      return null;
+    const s = i.extensions[t], a = n.images[s.source];
+    let o = r.textureLoader;
+    if (a.uri) {
+      const c = r.options.manager.getHandler(a.uri);
+      c !== null && (o = c);
+    }
+    return this.detectSupport().then(function(c) {
+      if (c) return r.loadTextureImage(e, s.source, o);
+      if (n.extensionsRequired && n.extensionsRequired.indexOf(t) >= 0)
+        throw new Error("THREE.GLTFLoader: AVIF required by asset but unsupported.");
+      return r.loadTexture(e);
+    });
+  }
+  detectSupport() {
+    return this.isSupported || (this.isSupported = new Promise(function(e) {
+      const t = new Image();
+      t.src = "data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAABcAAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAEAAAABAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQAMAAAAABNjb2xybmNseAACAAIABoAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAAB9tZGF0EgAKCBgABogQEDQgMgkQAAAAB8dSLfI=", t.onload = t.onerror = function() {
+        e(t.height === 1);
+      };
+    })), this.isSupported;
+  }
+}
+class En {
+  constructor(e) {
+    this.name = E.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], i = this.parser.getDependency("buffer", n.buffer), s = this.parser.options.meshoptDecoder;
+      if (!s || !s.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 i.then(function(a) {
+        const o = n.byteOffset || 0, c = n.byteLength || 0, l = n.count, u = n.byteStride, d = new Uint8Array(a, o, c);
+        return s.decodeGltfBufferAsync ? s.decodeGltfBufferAsync(l, u, d, n.mode, n.filter).then(function(f) {
+          return f.buffer;
+        }) : s.ready.then(function() {
+          const f = new ArrayBuffer(l * u);
+          return s.decodeGltfBuffer(new Uint8Array(f), l, u, d, n.mode, n.filter), f;
+        });
+      });
+    } else
+      return null;
+  }
+}
+class wn {
+  constructor(e) {
+    this.name = E.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 !== j.TRIANGLES && c.mode !== j.TRIANGLE_STRIP && c.mode !== j.TRIANGLE_FAN && c.mode !== void 0)
+        return null;
+    const s = r.extensions[this.name].attributes, a = [], o = {};
+    for (const c in s)
+      a.push(this.parser.getDependency("accessor", s[c]).then((l) => (o[c] = l, o[c])));
+    return a.length < 1 ? null : (a.push(this.parser.createNodeMesh(e)), Promise.all(a).then((c) => {
+      const l = c.pop(), u = l.isGroup ? l.children : [l], d = c[0].count, f = [];
+      for (const m of u) {
+        const T = new ae(), p = new O(), A = new tt(), x = new O(1, 1, 1), N = new mt(m.geometry, m.material, d);
+        for (let _ = 0; _ < d; _++)
+          o.TRANSLATION && p.fromBufferAttribute(o.TRANSLATION, _), o.ROTATION && A.fromBufferAttribute(o.ROTATION, _), o.SCALE && x.fromBufferAttribute(o.SCALE, _), N.setMatrixAt(_, T.compose(p, A, x));
+        for (const _ in o)
+          if (_ === "_COLOR_0") {
+            const B = o[_];
+            N.instanceColor = new gt(B.array, B.itemSize, B.normalized);
+          } else _ !== "TRANSLATION" && _ !== "ROTATION" && _ !== "SCALE" && m.geometry.setAttribute(_, o[_]);
+        nt.prototype.copy.call(N, m), this.parser.assignFinalMaterial(N), f.push(N);
+      }
+      return l.isGroup ? (l.clear(), l.add(...f), l) : f[0];
+    }));
+  }
+}
+const lt = "glTF", ce = 12, je = { JSON: 1313821514, BIN: 5130562 };
+class bn {
+  constructor(e) {
+    this.name = E.KHR_BINARY_GLTF, this.content = null, this.body = null;
+    const t = new DataView(e, 0, ce), 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 !== lt)
+      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 - ce, i = new DataView(e, ce);
+    let s = 0;
+    for (; s < n; ) {
+      const a = i.getUint32(s, !0);
+      s += 4;
+      const o = i.getUint32(s, !0);
+      if (s += 4, o === je.JSON) {
+        const c = new Uint8Array(e, ce + s, a);
+        this.content = r.decode(c);
+      } else if (o === je.BIN) {
+        const c = ce + s;
+        this.body = e.slice(c, c + a);
+      }
+      s += 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 = E.KHR_DRACO_MESH_COMPRESSION, this.json = e, this.dracoLoader = t, this.dracoLoader.preload();
+  }
+  decodePrimitive(e, t) {
+    const r = this.json, n = this.dracoLoader, i = e.extensions[this.name].bufferView, s = e.extensions[this.name].attributes, a = {}, o = {}, c = {};
+    for (const l in s) {
+      const u = Oe[l] || l.toLowerCase();
+      a[u] = s[l];
+    }
+    for (const l in e.attributes) {
+      const u = Oe[l] || l.toLowerCase();
+      if (s[l] !== void 0) {
+        const d = r.accessors[e.attributes[l]], f = oe[d.componentType];
+        c[u] = f.name, o[u] = d.normalized === !0;
+      }
+    }
+    return t.getDependency("bufferView", i).then(function(l) {
+      return new Promise(function(u, d) {
+        n.decodeDracoFile(l, function(f) {
+          for (const m in f.attributes) {
+            const T = f.attributes[m], p = o[m];
+            p !== void 0 && (T.normalized = p);
+          }
+          u(f);
+        }, a, c, K, d);
+      });
+    });
+  }
+}
+class Ln {
+  constructor() {
+    this.name = E.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 = E.KHR_MESH_QUANTIZATION;
+  }
+}
+class ut extends jt {
+  constructor(e, t, r, n) {
+    super(e, t, r, n);
+  }
+  copySampleValue_(e) {
+    const t = this.resultBuffer, r = this.sampleValues, n = this.valueSize, i = e * n * 3 + n;
+    for (let s = 0; s !== n; s++)
+      t[s] = r[i + s];
+    return t;
+  }
+  interpolate_(e, t, r, n) {
+    const i = this.resultBuffer, s = this.sampleValues, a = this.valueSize, o = a * 2, c = a * 3, l = n - t, u = (r - t) / l, d = u * u, f = d * u, m = e * c, T = m - c, p = -2 * f + 3 * d, A = f - d, x = 1 - p, N = A - d + u;
+    for (let _ = 0; _ !== a; _++) {
+      const B = s[T + _ + a], U = s[T + _ + o] * l, M = s[m + _ + a], g = s[m + _] * l;
+      i[_] = x * B + N * U + p * M + A * g;
+    }
+    return i;
+  }
+}
+const In = new tt();
+class Nn extends ut {
+  interpolate_(e, t, r, n) {
+    const i = super.interpolate_(e, t, r, n);
+    return In.fromArray(i).normalize().toArray(i), i;
+  }
+}
+const j = {
+  POINTS: 0,
+  LINES: 1,
+  LINE_LOOP: 2,
+  LINE_STRIP: 3,
+  TRIANGLES: 4,
+  TRIANGLE_STRIP: 5,
+  TRIANGLE_FAN: 6
+}, oe = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5125: Uint32Array,
+  5126: Float32Array
+}, ze = {
+  9728: rt,
+  9729: pe,
+  9984: Et,
+  9985: _t,
+  9986: xt,
+  9987: st
+}, Ke = {
+  33071: bt,
+  33648: wt,
+  10497: Ce
+}, be = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+}, Oe = {
+  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"
+}, ee = {
+  scale: "scale",
+  translation: "position",
+  rotation: "quaternion",
+  weights: "morphTargetInfluences"
+}, Cn = {
+  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: at,
+  STEP: Gt
+}, Se = {
+  OPAQUE: "OPAQUE",
+  MASK: "MASK",
+  BLEND: "BLEND"
+};
+function On(h) {
+  return h.DefaultMaterial === void 0 && (h.DefaultMaterial = new it({
+    color: 16777215,
+    emissive: 0,
+    metalness: 1,
+    roughness: 1,
+    transparent: !1,
+    depthTest: !0,
+    side: Ut
+  })), h.DefaultMaterial;
+}
+function ne(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 Z(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 Pn(h, e, t) {
+  let r = !1, n = !1, i = !1;
+  for (let c = 0, l = e.length; c < l; c++) {
+    const u = e[c];
+    if (u.POSITION !== void 0 && (r = !0), u.NORMAL !== void 0 && (n = !0), u.COLOR_0 !== void 0 && (i = !0), r && n && i) break;
+  }
+  if (!r && !n && !i) return Promise.resolve(h);
+  const s = [], a = [], o = [];
+  for (let c = 0, l = e.length; c < l; c++) {
+    const u = e[c];
+    if (r) {
+      const d = u.POSITION !== void 0 ? t.getDependency("accessor", u.POSITION) : h.attributes.position;
+      s.push(d);
+    }
+    if (n) {
+      const d = u.NORMAL !== void 0 ? t.getDependency("accessor", u.NORMAL) : h.attributes.normal;
+      a.push(d);
+    }
+    if (i) {
+      const d = u.COLOR_0 !== void 0 ? t.getDependency("accessor", u.COLOR_0) : h.attributes.color;
+      o.push(d);
+    }
+  }
+  return Promise.all([
+    Promise.all(s),
+    Promise.all(a),
+    Promise.all(o)
+  ]).then(function(c) {
+    const l = c[0], u = c[1], d = c[2];
+    return r && (h.morphAttributes.position = l), n && (h.morphAttributes.normal = u), i && (h.morphAttributes.color = d), h.morphTargetsRelative = !0, h;
+  });
+}
+function kn(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 Dn(h) {
+  let e;
+  const t = h.extensions && h.extensions[E.KHR_DRACO_MESH_COMPRESSION];
+  if (t ? e = "draco:" + t.bufferView + ":" + t.indices + ":" + Le(t.attributes) : e = h.indices + ":" + Le(h.attributes) + ":" + h.mode, h.targets !== void 0)
+    for (let r = 0, n = h.targets.length; r < n; r++)
+      e += ":" + Le(h.targets[r]);
+  return e;
+}
+function Le(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 Pe(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 Hn = new ae();
+class vn {
+  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, i = !1, s = -1;
+    if (typeof navigator < "u") {
+      const a = navigator.userAgent;
+      r = /^((?!chrome|android).)*safari/i.test(a) === !0;
+      const o = a.match(/Version\/(\d+)/);
+      n = r && o ? parseInt(o[1], 10) : -1, i = a.indexOf("Firefox") > -1, s = i ? a.match(/Firefox\/([0-9]+)\./)[1] : -1;
+    }
+    typeof createImageBitmap > "u" || r && n < 17 || i && s < 98 ? this.textureLoader = new At(this.options.manager) : this.textureLoader = new Tt(this.options.manager), this.textureLoader.setCrossOrigin(this.options.crossOrigin), this.textureLoader.setRequestHeader(this.options.requestHeader), this.fileLoader = new ye(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, i = this.extensions;
+    this.cache.removeAll(), this.nodeCache = {}, this._invokeAll(function(s) {
+      return s._markDefs && s._markDefs();
+    }), Promise.all(this._invokeAll(function(s) {
+      return s.beforeRoot && s.beforeRoot();
+    })).then(function() {
+      return Promise.all([
+        r.getDependencies("scene"),
+        r.getDependencies("animation"),
+        r.getDependencies("camera")
+      ]);
+    }).then(function(s) {
+      const a = {
+        scene: s[0][n.scene || 0],
+        scenes: s[0],
+        animations: s[1],
+        cameras: s[2],
+        asset: n.asset,
+        parser: r,
+        userData: {}
+      };
+      return ne(i, a, n), Z(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, i = t.length; n < i; n++) {
+      const s = t[n].joints;
+      for (let a = 0, o = s.length; a < o; a++)
+        e[s[a]].isBone = !0;
+    }
+    for (let n = 0, i = e.length; n < i; n++) {
+      const s = e[n];
+      s.mesh !== void 0 && (this._addNodeRef(this.meshCache, s.mesh), s.skin !== void 0 && (r[s.mesh].isSkinnedMesh = !0)), s.camera !== void 0 && this._addNodeRef(this.cameraCache, s.camera);
+    }
+  }
+  /**
+   * Counts references to shared node / Object3D resources. These resources
+   * can be reused, or "instantiated", at multiple nodes in the scene
+   * hierarchy. Mesh, Camera, and Light instances are instantiated and must
+   * be marked. Non-scenegraph resources (like Materials, Geometries, and
+   * Textures) can be reused directly and are not marked here.
+   *
+   * Example: CesiumMilkTruck sample model reuses "Wheel" meshes.
+   *
+   * @private
+   * @param {Object} cache
+   * @param {Object3D} index
+   */
+  _addNodeRef(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(), i = (s, a) => {
+      const o = this.associations.get(s);
+      o != null && this.associations.set(a, o);
+      for (const [c, l] of s.children.entries())
+        i(l, a.children[c]);
+    };
+    return i(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 i = e(t[n]);
+      i && r.push(i);
+    }
+    return r;
+  }
+  /**
+   * Requests the specified dependency asynchronously, with caching.
+   *
+   * @private
+   * @param {string} type
+   * @param {number} index
+   * @return {Promise<Object3D|Material|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(i) {
+            return i.loadNode && i.loadNode(t);
+          });
+          break;
+        case "mesh":
+          n = this._invokeOne(function(i) {
+            return i.loadMesh && i.loadMesh(t);
+          });
+          break;
+        case "accessor":
+          n = this.loadAccessor(t);
+          break;
+        case "bufferView":
+          n = this._invokeOne(function(i) {
+            return i.loadBufferView && i.loadBufferView(t);
+          });
+          break;
+        case "buffer":
+          n = this.loadBuffer(t);
+          break;
+        case "material":
+          n = this._invokeOne(function(i) {
+            return i.loadMaterial && i.loadMaterial(t);
+          });
+          break;
+        case "texture":
+          n = this._invokeOne(function(i) {
+            return i.loadTexture && i.loadTexture(t);
+          });
+          break;
+        case "skin":
+          n = this.loadSkin(t);
+          break;
+        case "animation":
+          n = this._invokeOne(function(i) {
+            return i.loadAnimation && i.loadAnimation(t);
+          });
+          break;
+        case "camera":
+          n = this.loadCamera(t);
+          break;
+        default:
+          if (n = this._invokeOne(function(i) {
+            return i != this && i.getDependency && i.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(i, s) {
+        return r.getDependency(e, s);
+      })), 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[E.KHR_BINARY_GLTF].body);
+    const n = this.options;
+    return new Promise(function(i, s) {
+      r.load(de.resolveURL(t.uri, n.path), i, void 0, function() {
+        s(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, i = t.byteOffset || 0;
+      return r.slice(i, i + n);
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
+   *
+   * @private
+   * @param {number} accessorIndex
+   * @return {Promise<BufferAttribute|InterleavedBufferAttribute>}
+   */
+  loadAccessor(e) {
+    const t = this, r = this.json, n = this.json.accessors[e];
+    if (n.bufferView === void 0 && n.sparse === void 0) {
+      const s = be[n.type], a = oe[n.componentType], o = n.normalized === !0, c = new a(n.count * s);
+      return Promise.resolve(new ue(c, s, o));
+    }
+    const i = [];
+    return n.bufferView !== void 0 ? i.push(this.getDependency("bufferView", n.bufferView)) : i.push(null), n.sparse !== void 0 && (i.push(this.getDependency("bufferView", n.sparse.indices.bufferView)), i.push(this.getDependency("bufferView", n.sparse.values.bufferView))), Promise.all(i).then(function(s) {
+      const a = s[0], o = be[n.type], c = oe[n.componentType], l = c.BYTES_PER_ELEMENT, u = l * o, d = n.byteOffset || 0, f = n.bufferView !== void 0 ? r.bufferViews[n.bufferView].byteStride : void 0, m = n.normalized === !0;
+      let T, p;
+      if (f && f !== u) {
+        const A = Math.floor(d / f), x = "InterleavedBuffer:" + n.bufferView + ":" + n.componentType + ":" + A + ":" + n.count;
+        let N = t.cache.get(x);
+        N || (T = new c(a, A * f, n.count * f / l), N = new yt(T, f / l), t.cache.add(x, N)), p = new Rt(N, o, d % f / l, m);
+      } else
+        a === null ? T = new c(n.count * o) : T = new c(a, d, n.count * o), p = new ue(T, o, m);
+      if (n.sparse !== void 0) {
+        const A = be.SCALAR, x = oe[n.sparse.indices.componentType], N = n.sparse.indices.byteOffset || 0, _ = n.sparse.values.byteOffset || 0, B = new x(s[1], N, n.sparse.count * A), U = new c(s[2], _, n.sparse.count * o);
+        a !== null && (p = new ue(p.array.slice(), p.itemSize, p.normalized)), p.normalized = !1;
+        for (let M = 0, g = B.length; M < g; M++) {
+          const y = B[M];
+          if (p.setX(y, U[M * o]), o >= 2 && p.setY(y, U[M * o + 1]), o >= 3 && p.setZ(y, U[M * o + 2]), o >= 4 && p.setW(y, U[M * o + 3]), o >= 5) throw new Error("THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.");
+        }
+        p.normalized = m;
+      }
+      return p;
+    });
+  }
+  /**
+   * 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, i = t.textures[e].source, s = t.images[i];
+    let a = this.textureLoader;
+    if (s.uri) {
+      const o = r.manager.getHandler(s.uri);
+      o !== null && (a = o);
+    }
+    return this.loadTextureImage(e, i, a);
+  }
+  loadTextureImage(e, t, r) {
+    const n = this, i = this.json, s = i.textures[e], a = i.images[t], o = (a.uri || a.bufferView) + ":" + s.sampler;
+    if (this.textureCache[o])
+      return this.textureCache[o];
+    const c = this.loadImageSource(t, r).then(function(l) {
+      l.flipY = !1, l.name = s.name || a.name || "", l.name === "" && typeof a.uri == "string" && a.uri.startsWith("data:image/") === !1 && (l.name = a.uri);
+      const d = (i.samplers || {})[s.sampler] || {};
+      return l.magFilter = ze[d.magFilter] || pe, l.minFilter = ze[d.minFilter] || st, l.wrapS = Ke[d.wrapS] || Ce, l.wrapT = Ke[d.wrapT] || Ce, l.generateMipmaps = !l.isCompressedTexture && l.minFilter !== rt && l.minFilter !== pe, n.associations.set(l, { textures: e }), l;
+    }).catch(function() {
+      return null;
+    });
+    return this.textureCache[o] = c, c;
+  }
+  loadImageSource(e, t) {
+    const r = this, n = this.json, i = this.options;
+    if (this.sourceCache[e] !== void 0)
+      return this.sourceCache[e].then((u) => u.clone());
+    const s = n.images[e], a = self.URL || self.webkitURL;
+    let o = s.uri || "", c = !1;
+    if (s.bufferView !== void 0)
+      o = r.getDependency("bufferView", s.bufferView).then(function(u) {
+        c = !0;
+        const d = new Blob([u], { type: s.mimeType });
+        return o = a.createObjectURL(d), o;
+      });
+    else if (s.uri === void 0)
+      throw new Error("THREE.GLTFLoader: Image " + e + " is missing URI and bufferView");
+    const l = Promise.resolve(o).then(function(u) {
+      return new Promise(function(d, f) {
+        let m = d;
+        t.isImageBitmapLoader === !0 && (m = function(T) {
+          const p = new He(T);
+          p.needsUpdate = !0, d(p);
+        }), t.load(de.resolveURL(u, i.path), m, void 0, f);
+      });
+    }).then(function(u) {
+      return c === !0 && a.revokeObjectURL(o), Z(u, s), u.userData.mimeType = s.mimeType || Fn(s.uri), u;
+    }).catch(function(u) {
+      throw console.error("THREE.GLTFLoader: Couldn't load texture", o), u;
+    });
+    return this.sourceCache[e] = l, l;
+  }
+  /**
+   * Asynchronously assigns a texture to the given material parameters.
+   *
+   * @private
+   * @param {Object} materialParams
+   * @param {string} mapName
+   * @param {Object} mapDef
+   * @param {string} [colorSpace]
+   * @return {Promise<Texture>}
+   */
+  assignTexture(e, t, r, n) {
+    const i = this;
+    return this.getDependency("texture", r.index).then(function(s) {
+      if (!s) return null;
+      if (r.texCoord !== void 0 && r.texCoord > 0 && (s = s.clone(), s.channel = r.texCoord), i.extensions[E.KHR_TEXTURE_TRANSFORM]) {
+        const a = r.extensions !== void 0 ? r.extensions[E.KHR_TEXTURE_TRANSFORM] : void 0;
+        if (a) {
+          const o = i.associations.get(s);
+          s = i.extensions[E.KHR_TEXTURE_TRANSFORM].extendTexture(s, a), i.associations.set(s, o);
+        }
+      }
+      return n !== void 0 && (s.colorSpace = n), e[t] = s, s;
+    });
+  }
+  /**
+   * Assigns final material to a Mesh, Line, or Points instance. The instance
+   * already has a material (generated from the glTF material options alone)
+   * but reuse of the same glTF material may require multiple threejs materials
+   * to accommodate different primitive types, defines, etc. New materials will
+   * be created if necessary, and reused from a cache.
+   *
+   * @private
+   * @param {Object3D} mesh Mesh, Line, or Points instance.
+   */
+  assignFinalMaterial(e) {
+    const t = e.geometry;
+    let r = e.material;
+    const n = t.attributes.tangent === void 0, i = t.attributes.color !== void 0, s = t.attributes.normal === void 0;
+    if (e.isPoints) {
+      const a = "PointsMaterial:" + r.uuid;
+      let o = this.cache.get(a);
+      o || (o = new St(), _e.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 Lt(), _e.prototype.copy.call(o, r), o.color.copy(r.color), o.map = r.map, this.cache.add(a, o)), r = o;
+    }
+    if (n || i || s) {
+      let a = "ClonedMaterial:" + r.uuid + ":";
+      n && (a += "derivative-tangents:"), i && (a += "vertex-colors:"), s && (a += "flat-shading:");
+      let o = this.cache.get(a);
+      o || (o = r.clone(), i && (o.vertexColors = !0), s && (o.flatShading = !0), n && (o.normalScale && (o.normalScale.y *= -1), o.clearcoatNormalScale && (o.clearcoatNormalScale.y *= -1)), this.cache.add(a, o), this.associations.set(o, this.associations.get(r))), r = o;
+    }
+    e.material = r;
+  }
+  getMaterialType() {
+    return it;
+  }
+  /**
+   * 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, i = r.materials[e];
+    let s;
+    const a = {}, o = i.extensions || {}, c = [];
+    if (o[E.KHR_MATERIALS_UNLIT]) {
+      const u = n[E.KHR_MATERIALS_UNLIT];
+      s = u.getMaterialType(), c.push(u.extendParams(a, i, t));
+    } else {
+      const u = i.pbrMetallicRoughness || {};
+      if (a.color = new V(1, 1, 1), a.opacity = 1, Array.isArray(u.baseColorFactor)) {
+        const d = u.baseColorFactor;
+        a.color.setRGB(d[0], d[1], d[2], K), a.opacity = d[3];
+      }
+      u.baseColorTexture !== void 0 && c.push(t.assignTexture(a, "map", u.baseColorTexture, te)), a.metalness = u.metallicFactor !== void 0 ? u.metallicFactor : 1, a.roughness = u.roughnessFactor !== void 0 ? u.roughnessFactor : 1, u.metallicRoughnessTexture !== void 0 && (c.push(t.assignTexture(a, "metalnessMap", u.metallicRoughnessTexture)), c.push(t.assignTexture(a, "roughnessMap", u.metallicRoughnessTexture))), s = 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);
+      })));
+    }
+    i.doubleSided === !0 && (a.side = Mt);
+    const l = i.alphaMode || Se.OPAQUE;
+    if (l === Se.BLEND ? (a.transparent = !0, a.depthWrite = !1) : (a.transparent = !1, l === Se.MASK && (a.alphaTest = i.alphaCutoff !== void 0 ? i.alphaCutoff : 0.5)), i.normalTexture !== void 0 && s !== le && (c.push(t.assignTexture(a, "normalMap", i.normalTexture)), a.normalScale = new De(1, 1), i.normalTexture.scale !== void 0)) {
+      const u = i.normalTexture.scale;
+      a.normalScale.set(u, u);
+    }
+    if (i.occlusionTexture !== void 0 && s !== le && (c.push(t.assignTexture(a, "aoMap", i.occlusionTexture)), i.occlusionTexture.strength !== void 0 && (a.aoMapIntensity = i.occlusionTexture.strength)), i.emissiveFactor !== void 0 && s !== le) {
+      const u = i.emissiveFactor;
+      a.emissive = new V().setRGB(u[0], u[1], u[2], K);
+    }
+    return i.emissiveTexture !== void 0 && s !== le && c.push(t.assignTexture(a, "emissiveMap", i.emissiveTexture, te)), Promise.all(c).then(function() {
+      const u = new s(a);
+      return i.name && (u.name = i.name), Z(u, i), t.associations.set(u, { materials: e }), i.extensions && ne(n, u, i), u;
+    });
+  }
+  /**
+   * When Object3D instances are targeted by animation, they need unique names.
+   *
+   * @private
+   * @param {string} originalName
+   * @return {string}
+   */
+  createUniqueName(e) {
+    const t = It.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 i(a) {
+      return r[E.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(a, t).then(function(o) {
+        return Ve(o, a, t);
+      });
+    }
+    const s = [];
+    for (let a = 0, o = e.length; a < o; a++) {
+      const c = e[a], l = Dn(c), u = n[l];
+      if (u)
+        s.push(u.promise);
+      else {
+        let d;
+        c.extensions && c.extensions[E.KHR_DRACO_MESH_COMPRESSION] ? d = i(c) : d = Ve(new $e(), c, t), n[l] = { primitive: c, promise: d }, s.push(d);
+      }
+    }
+    return Promise.all(s);
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes
+   *
+   * @private
+   * @param {number} meshIndex
+   * @return {Promise<Group|Mesh|SkinnedMesh|Line|Points>}
+   */
+  loadMesh(e) {
+    const t = this, r = this.json, n = this.extensions, i = r.meshes[e], s = i.primitives, a = [];
+    for (let o = 0, c = s.length; o < c; o++) {
+      const l = s[o].material === void 0 ? On(this.cache) : this.getDependency("material", s[o].material);
+      a.push(l);
+    }
+    return a.push(t.loadGeometries(s)), Promise.all(a).then(function(o) {
+      const c = o.slice(0, o.length - 1), l = o[o.length - 1], u = [];
+      for (let f = 0, m = l.length; f < m; f++) {
+        const T = l[f], p = s[f];
+        let A;
+        const x = c[f];
+        if (p.mode === j.TRIANGLES || p.mode === j.TRIANGLE_STRIP || p.mode === j.TRIANGLE_FAN || p.mode === void 0)
+          A = i.isSkinnedMesh === !0 ? new Nt(T, x) : new Ct(T, x), A.isSkinnedMesh === !0 && A.normalizeSkinWeights(), p.mode === j.TRIANGLE_STRIP ? A.geometry = Ue(A.geometry, Je) : p.mode === j.TRIANGLE_FAN && (A.geometry = Ue(A.geometry, Ie));
+        else if (p.mode === j.LINES)
+          A = new Ot(T, x);
+        else if (p.mode === j.LINE_STRIP)
+          A = new Pt(T, x);
+        else if (p.mode === j.LINE_LOOP)
+          A = new kt(T, x);
+        else if (p.mode === j.POINTS)
+          A = new Dt(T, x);
+        else
+          throw new Error("THREE.GLTFLoader: Primitive mode unsupported: " + p.mode);
+        Object.keys(A.geometry.morphAttributes).length > 0 && kn(A, i), A.name = t.createUniqueName(i.name || "mesh_" + e), Z(A, i), p.extensions && ne(n, A, p), t.assignFinalMaterial(A), u.push(A);
+      }
+      for (let f = 0, m = u.length; f < m; f++)
+        t.associations.set(u[f], {
+          meshes: e,
+          primitives: f
+        });
+      if (u.length === 1)
+        return i.extensions && ne(n, u[0], i), u[0];
+      const d = new Te();
+      i.extensions && ne(n, d, i), t.associations.set(d, { meshes: e });
+      for (let f = 0, m = u.length; f < m; f++)
+        d.add(u[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 ot(he.radToDeg(n.yfov), n.aspectRatio || 1, n.znear || 1, n.zfar || 2e6) : r.type === "orthographic" && (t = new Ft(-n.xmag, n.xmag, n.ymag, -n.ymag, n.znear, n.zfar)), r.name && (t.name = this.createUniqueName(r.name)), Z(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, i = t.joints.length; n < i; 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 i = n.pop(), s = n, a = [], o = [];
+      for (let c = 0, l = s.length; c < l; c++) {
+        const u = s[c];
+        if (u) {
+          a.push(u);
+          const d = new ae();
+          i !== null && d.fromArray(i.array, c * 16), o.push(d);
+        } else
+          console.warn('THREE.GLTFLoader: Joint "%s" could not be found.', t.joints[c]);
+      }
+      return new Ht(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], i = n.name ? n.name : "animation_" + e, s = [], a = [], o = [], c = [], l = [];
+    for (let u = 0, d = n.channels.length; u < d; u++) {
+      const f = n.channels[u], m = n.samplers[f.sampler], T = f.target, p = T.node, A = n.parameters !== void 0 ? n.parameters[m.input] : m.input, x = n.parameters !== void 0 ? n.parameters[m.output] : m.output;
+      T.node !== void 0 && (s.push(this.getDependency("node", p)), a.push(this.getDependency("accessor", A)), o.push(this.getDependency("accessor", x)), c.push(m), l.push(T));
+    }
+    return Promise.all([
+      Promise.all(s),
+      Promise.all(a),
+      Promise.all(o),
+      Promise.all(c),
+      Promise.all(l)
+    ]).then(function(u) {
+      const d = u[0], f = u[1], m = u[2], T = u[3], p = u[4], A = [];
+      for (let x = 0, N = d.length; x < N; x++) {
+        const _ = d[x], B = f[x], U = m[x], M = T[x], g = p[x];
+        if (_ === void 0) continue;
+        _.updateMatrix && _.updateMatrix();
+        const y = r._createAnimationTracks(_, B, U, M, g);
+        if (y)
+          for (let S = 0; S < y.length; S++)
+            A.push(y[S]);
+      }
+      return new vt(i, void 0, A);
+    });
+  }
+  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(i) {
+      const s = r._getNodeRef(r.meshCache, n.mesh, i);
+      return n.weights !== void 0 && s.traverse(function(a) {
+        if (a.isMesh)
+          for (let o = 0, c = n.weights.length; o < c; o++)
+            a.morphTargetInfluences[o] = n.weights[o];
+      }), s;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
+   *
+   * @private
+   * @param {number} nodeIndex
+   * @return {Promise<Object3D>}
+   */
+  loadNode(e) {
+    const t = this.json, r = this, n = t.nodes[e], i = r._loadNodeShallow(e), s = [], a = n.children || [];
+    for (let c = 0, l = a.length; c < l; c++)
+      s.push(r.getDependency("node", a[c]));
+    const o = n.skin === void 0 ? Promise.resolve(null) : r.getDependency("skin", n.skin);
+    return Promise.all([
+      i,
+      Promise.all(s),
+      o
+    ]).then(function(c) {
+      const l = c[0], u = c[1], d = c[2];
+      d !== null && l.traverse(function(f) {
+        f.isSkinnedMesh && f.bind(d, Hn);
+      });
+      for (let f = 0, m = u.length; f < m; f++)
+        l.add(u[f]);
+      return l;
+    });
+  }
+  // ._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 i = t.nodes[e], s = i.name ? n.createUniqueName(i.name) : "", a = [], o = n._invokeOne(function(c) {
+      return c.createNodeMesh && c.createNodeMesh(e);
+    });
+    return o && a.push(o), i.camera !== void 0 && a.push(n.getDependency("camera", i.camera).then(function(c) {
+      return n._getNodeRef(n.cameraCache, i.camera, c);
+    })), n._invokeAll(function(c) {
+      return c.createNodeAttachment && c.createNodeAttachment(e);
+    }).forEach(function(c) {
+      a.push(c);
+    }), this.nodeCache[e] = Promise.all(a).then(function(c) {
+      let l;
+      if (i.isBone === !0 ? l = new Bt() : c.length > 1 ? l = new Te() : c.length === 1 ? l = c[0] : l = new nt(), l !== c[0])
+        for (let u = 0, d = c.length; u < d; u++)
+          l.add(c[u]);
+      if (i.name && (l.userData.name = i.name, l.name = s), Z(l, i), i.extensions && ne(r, l, i), i.matrix !== void 0) {
+        const u = new ae();
+        u.fromArray(i.matrix), l.applyMatrix4(u);
+      } else
+        i.translation !== void 0 && l.position.fromArray(i.translation), i.rotation !== void 0 && l.quaternion.fromArray(i.rotation), i.scale !== void 0 && l.scale.fromArray(i.scale);
+      return n.associations.has(l) || n.associations.set(l, {}), n.associations.get(l).nodes = e, l;
+    }), 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, i = new Te();
+    r.name && (i.name = n.createUniqueName(r.name)), Z(i, r), r.extensions && ne(t, i, r);
+    const s = r.nodes || [], a = [];
+    for (let o = 0, c = s.length; o < c; o++)
+      a.push(n.getDependency("node", s[o]));
+    return Promise.all(a).then(function(o) {
+      for (let l = 0, u = o.length; l < u; l++)
+        i.add(o[l]);
+      const c = (l) => {
+        const u = /* @__PURE__ */ new Map();
+        for (const [d, f] of n.associations)
+          (d instanceof _e || d instanceof He) && u.set(d, f);
+        return l.traverse((d) => {
+          const f = n.associations.get(d);
+          f != null && u.set(d, f);
+        }), u;
+      };
+      return n.associations = c(i), i;
+    });
+  }
+  _createAnimationTracks(e, t, r, n, i) {
+    const s = [], a = e.name ? e.name : e.uuid, o = [];
+    ee[i.path] === ee.weights ? e.traverse(function(d) {
+      d.morphTargetInfluences && o.push(d.name ? d.name : d.uuid);
+    }) : o.push(a);
+    let c;
+    switch (ee[i.path]) {
+      case ee.weights:
+        c = Be;
+        break;
+      case ee.rotation:
+        c = Ge;
+        break;
+      case ee.translation:
+      case ee.scale:
+        c = ve;
+        break;
+      default:
+        switch (r.itemSize) {
+          case 1:
+            c = Be;
+            break;
+          case 2:
+          case 3:
+          default:
+            c = ve;
+            break;
+        }
+        break;
+    }
+    const l = n.interpolation !== void 0 ? Cn[n.interpolation] : at, u = this._getArrayFromAccessor(r);
+    for (let d = 0, f = o.length; d < f; d++) {
+      const m = new c(
+        o[d] + "." + ee[i.path],
+        t.array,
+        u,
+        l
+      );
+      n.interpolation === "CUBICSPLINE" && this._createCubicSplineTrackInterpolant(m), s.push(m);
+    }
+    return s;
+  }
+  _getArrayFromAccessor(e) {
+    let t = e.array;
+    if (e.normalized) {
+      const r = Pe(t.constructor), n = new Float32Array(t.length);
+      for (let i = 0, s = t.length; i < s; i++)
+        n[i] = t[i] * r;
+      t = n;
+    }
+    return t;
+  }
+  _createCubicSplineTrackInterpolant(e) {
+    e.createInterpolant = function(r) {
+      const n = this instanceof Ge ? Nn : ut;
+      return new n(this.times, this.values, this.getValueSize() / 3, r);
+    }, e.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = !0;
+  }
+}
+function Bn(h, e, t) {
+  const r = e.attributes, n = new Re();
+  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(o[0], o[1], o[2]),
+        new O(c[0], c[1], c[2])
+      ), a.normalized) {
+        const l = Pe(oe[a.componentType]);
+        n.min.multiplyScalar(l), n.max.multiplyScalar(l);
+      }
+    } else {
+      console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      return;
+    }
+  } else
+    return;
+  const i = e.targets;
+  if (i !== void 0) {
+    const a = new O(), o = new O();
+    for (let c = 0, l = i.length; c < l; c++) {
+      const u = i[c];
+      if (u.POSITION !== void 0) {
+        const d = t.json.accessors[u.POSITION], f = d.min, m = d.max;
+        if (f !== void 0 && m !== void 0) {
+          if (o.setX(Math.max(Math.abs(f[0]), Math.abs(m[0]))), o.setY(Math.max(Math.abs(f[1]), Math.abs(m[1]))), o.setZ(Math.max(Math.abs(f[2]), Math.abs(m[2]))), d.normalized) {
+            const T = Pe(oe[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 s = new zt();
+  n.getCenter(s.center), s.radius = n.min.distanceTo(n.max) / 2, h.boundingSphere = s;
+}
+function Ve(h, e, t) {
+  const r = e.attributes, n = [];
+  function i(s, a) {
+    return t.getDependency("accessor", s).then(function(o) {
+      h.setAttribute(a, o);
+    });
+  }
+  for (const s in r) {
+    const a = Oe[s] || s.toLowerCase();
+    a in h.attributes || n.push(i(r[s], a));
+  }
+  if (e.indices !== void 0 && !h.index) {
+    const s = t.getDependency("accessor", e.indices).then(function(a) {
+      h.setIndex(a);
+    });
+    n.push(s);
+  }
+  return Ne.workingColorSpace !== K && "COLOR_0" in r && console.warn(`THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${Ne.workingColorSpace}" not supported.`), Z(h, e), Bn(h, e, t), Promise.all(n).then(function() {
+    return e.targets !== void 0 ? Pn(h, e.targets, t) : h;
+  });
+}
+class Gn extends Kt {
+  /**
+   * Constructs a new RGBE loader.
+   *
+   * @param {LoadingManager} [manager] - The loading manager.
+   */
+  constructor(e) {
+    super(e), this.type = me;
+  }
+  /**
+   * Parses the given RGBE texture data.
+   *
+   * @param {ArrayBuffer} buffer - The raw texture data.
+   * @return {DataTextureLoader~TexData} An object representing the parsed texture data.
+   */
+  parse(e) {
+    const s = function(g, y) {
+      switch (g) {
+        case 1:
+          throw new Error("THREE.RGBELoader: Read Error: " + (y || ""));
+        case 2:
+          throw new Error("THREE.RGBELoader: Write Error: " + (y || ""));
+        case 3:
+          throw new Error("THREE.RGBELoader: Bad File Format: " + (y || ""));
+        default:
+        case 4:
+          throw new Error("THREE.RGBELoader: Memory Error: " + (y || ""));
+      }
+    }, l = `
+`, u = function(g, y, S) {
+      y = y || 1024;
+      let F = g.pos, C = -1, w = 0, H = "", I = String.fromCharCode.apply(null, new Uint16Array(g.subarray(F, F + 128)));
+      for (; 0 > (C = I.indexOf(l)) && w < y && F < g.byteLength; )
+        H += I, w += I.length, F += 128, I += String.fromCharCode.apply(null, new Uint16Array(g.subarray(F, F + 128)));
+      return -1 < C ? (g.pos += w + C + 1, H + I.slice(0, C)) : !1;
+    }, d = function(g) {
+      const y = /^#\?(\S+)/, S = /^\s*GAMMA\s*=\s*(\d+(\.\d+)?)\s*$/, P = /^\s*EXPOSURE\s*=\s*(\d+(\.\d+)?)\s*$/, F = /^\s*FORMAT=(\S+)\s*$/, C = /^\s*\-Y\s+(\d+)\s+\+X\s+(\d+)\s*$/, w = {
+        valid: 0,
+        /* indicate which fields are valid */
+        string: "",
+        /* the actual header string */
+        comments: "",
+        /* comments found in header */
+        programtype: "RGBE",
+        /* listed at beginning of file to identify it after "#?". defaults to "RGBE" */
+        format: "",
+        /* RGBE format, default 32-bit_rle_rgbe */
+        gamma: 1,
+        /* image has already been gamma corrected with given gamma. defaults to 1.0 (no correction) */
+        exposure: 1,
+        /* a value of 1.0 in an image corresponds to <exposure> watts/steradian/m^2. defaults to 1.0 */
+        width: 0,
+        height: 0
+        /* image dimensions, width/height */
+      };
+      let H, I;
+      for ((g.pos >= g.byteLength || !(H = u(g))) && s(1, "no header found"), (I = H.match(y)) || s(3, "bad initial token"), w.valid |= 1, w.programtype = I[1], w.string += H + `
+`; H = u(g), H !== !1; ) {
+        if (w.string += H + `
+`, H.charAt(0) === "#") {
+          w.comments += H + `
+`;
+          continue;
+        }
+        if ((I = H.match(S)) && (w.gamma = parseFloat(I[1])), (I = H.match(P)) && (w.exposure = parseFloat(I[1])), (I = H.match(F)) && (w.valid |= 2, w.format = I[1]), (I = H.match(C)) && (w.valid |= 4, w.height = parseInt(I[1], 10), w.width = parseInt(I[2], 10)), w.valid & 2 && w.valid & 4) break;
+      }
+      return w.valid & 2 || s(3, "missing format specifier"), w.valid & 4 || s(3, "missing image size specifier"), w;
+    }, f = function(g, y, S) {
+      const P = y;
+      if (
+        // run length encoding is not allowed so read flat
+        P < 8 || P > 32767 || // this file is not run length encoded
+        g[0] !== 2 || g[1] !== 2 || g[2] & 128
+      )
+        return new Uint8Array(g);
+      P !== (g[2] << 8 | g[3]) && s(3, "wrong scanline width");
+      const F = new Uint8Array(4 * y * S);
+      F.length || s(4, "unable to allocate buffer space");
+      let C = 0, w = 0;
+      const H = 4 * P, I = new Uint8Array(4), $ = new Uint8Array(H);
+      let xe = S;
+      for (; xe > 0 && w < g.byteLength; ) {
+        w + 4 > g.byteLength && s(1), I[0] = g[w++], I[1] = g[w++], I[2] = g[w++], I[3] = g[w++], (I[0] != 2 || I[1] != 2 || (I[2] << 8 | I[3]) != P) && s(3, "bad rgbe scanline format");
+        let W = 0, G;
+        for (; W < H && w < g.byteLength; ) {
+          G = g[w++];
+          const q = G > 128;
+          if (q && (G -= 128), (G === 0 || W + G > H) && s(3, "bad scanline data"), q) {
+            const Y = g[w++];
+            for (let Fe = 0; Fe < G; Fe++)
+              $[W++] = Y;
+          } else
+            $.set(g.subarray(w, w + G), W), W += G, w += G;
+        }
+        const dt = P;
+        for (let q = 0; q < dt; q++) {
+          let Y = 0;
+          F[C] = $[q + Y], Y += P, F[C + 1] = $[q + Y], Y += P, F[C + 2] = $[q + Y], Y += P, F[C + 3] = $[q + Y], C += 4;
+        }
+        xe--;
+      }
+      return F;
+    }, m = function(g, y, S, P) {
+      const F = g[y + 3], C = Math.pow(2, F - 128) / 255;
+      S[P + 0] = g[y + 0] * C, S[P + 1] = g[y + 1] * C, S[P + 2] = g[y + 2] * C, S[P + 3] = 1;
+    }, T = function(g, y, S, P) {
+      const F = g[y + 3], C = Math.pow(2, F - 128) / 255;
+      S[P + 0] = ge.toHalfFloat(Math.min(g[y + 0] * C, 65504)), S[P + 1] = ge.toHalfFloat(Math.min(g[y + 1] * C, 65504)), S[P + 2] = ge.toHalfFloat(Math.min(g[y + 2] * C, 65504)), S[P + 3] = ge.toHalfFloat(1);
+    }, p = new Uint8Array(e);
+    p.pos = 0;
+    const A = d(p), x = A.width, N = A.height, _ = f(p.subarray(p.pos), x, N);
+    let B, U, M;
+    switch (this.type) {
+      case Ee:
+        M = _.length / 4;
+        const g = new Float32Array(M * 4);
+        for (let S = 0; S < M; S++)
+          m(_, S * 4, g, S * 4);
+        B = g, U = Ee;
+        break;
+      case me:
+        M = _.length / 4;
+        const y = new Uint16Array(M * 4);
+        for (let S = 0; S < M; S++)
+          T(_, S * 4, y, S * 4);
+        B = y, U = me;
+        break;
+      default:
+        throw new Error("THREE.RGBELoader: Unsupported type: " + this.type);
+    }
+    return {
+      width: x,
+      height: N,
+      data: B,
+      header: A.string,
+      gamma: A.gamma,
+      exposure: A.exposure,
+      type: U
+    };
+  }
+  /**
+   * Sets the texture type.
+   *
+   * @param {(HalfFloatType|FloatType)} value - The texture type to set.
+   * @return {RGBELoader} A reference to this loader.
+   */
+  setDataType(e) {
+    return this.type = e, this;
+  }
+  load(e, t, r, n) {
+    function i(s, a) {
+      switch (s.type) {
+        case Ee:
+        case me:
+          s.colorSpace = K, s.minFilter = pe, s.magFilter = pe, s.generateMipmaps = !1, s.flipY = !0;
+          break;
+      }
+      t && t(s, a);
+    }
+    return super.load(e, i, r, n);
+  }
+}
+const b = {
+  c: null,
+  // center
+  u: [new O(), new O(), new O()],
+  // basis vectors
+  e: []
+  // half width
+}, L = {
+  c: null,
+  // center
+  u: [new O(), new O(), new O()],
+  // basis vectors
+  e: []
+  // half width
+}, D = [[], [], []], R = [[], [], []], k = [], se = new O(), re = new O(), ie = new O(), v = new O(), Xe = new O(), We = new O(), z = new ct(), qe = new Re(), Ae = new ae(), Ye = new ae(), Qe = new Vt();
+class ke {
+  /**
+   * 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 O(), t = new O(), r = new ct()) {
+    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;
+    v.subVectors(e, this.center), this.rotation.extractBasis(se, re, ie), t.copy(this.center);
+    const n = he.clamp(v.dot(se), -r.x, r.x);
+    t.add(se.multiplyScalar(n));
+    const i = he.clamp(v.dot(re), -r.y, r.y);
+    t.add(re.multiplyScalar(i));
+    const s = he.clamp(v.dot(ie), -r.z, r.z);
+    return t.add(ie.multiplyScalar(s)), 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 v.subVectors(e, this.center), this.rotation.extractBasis(se, re, ie), Math.abs(v.dot(se)) <= this.halfSize.x && Math.abs(v.dot(re)) <= this.halfSize.y && Math.abs(v.dot(ie)) <= 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(Un.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, We), We.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) {
+    b.c = this.center, b.e[0] = this.halfSize.x, b.e[1] = this.halfSize.y, b.e[2] = this.halfSize.z, this.rotation.extractBasis(b.u[0], b.u[1], b.u[2]), L.c = e.center, L.e[0] = e.halfSize.x, L.e[1] = e.halfSize.y, L.e[2] = e.halfSize.z, e.rotation.extractBasis(L.u[0], L.u[1], L.u[2]);
+    for (let i = 0; i < 3; i++)
+      for (let s = 0; s < 3; s++)
+        D[i][s] = b.u[i].dot(L.u[s]);
+    v.subVectors(L.c, b.c), k[0] = v.dot(b.u[0]), k[1] = v.dot(b.u[1]), k[2] = v.dot(b.u[2]);
+    for (let i = 0; i < 3; i++)
+      for (let s = 0; s < 3; s++)
+        R[i][s] = Math.abs(D[i][s]) + t;
+    let r, n;
+    for (let i = 0; i < 3; i++)
+      if (r = b.e[i], n = L.e[0] * R[i][0] + L.e[1] * R[i][1] + L.e[2] * R[i][2], Math.abs(k[i]) > r + n) return !1;
+    for (let i = 0; i < 3; i++)
+      if (r = b.e[0] * R[0][i] + b.e[1] * R[1][i] + b.e[2] * R[2][i], n = L.e[i], Math.abs(k[0] * D[0][i] + k[1] * D[1][i] + k[2] * D[2][i]) > r + n) return !1;
+    return r = b.e[1] * R[2][0] + b.e[2] * R[1][0], n = L.e[1] * R[0][2] + L.e[2] * R[0][1], !(Math.abs(k[2] * D[1][0] - k[1] * D[2][0]) > r + n || (r = b.e[1] * R[2][1] + b.e[2] * R[1][1], n = L.e[0] * R[0][2] + L.e[2] * R[0][0], Math.abs(k[2] * D[1][1] - k[1] * D[2][1]) > r + n) || (r = b.e[1] * R[2][2] + b.e[2] * R[1][2], n = L.e[0] * R[0][1] + L.e[1] * R[0][0], Math.abs(k[2] * D[1][2] - k[1] * D[2][2]) > r + n) || (r = b.e[0] * R[2][0] + b.e[2] * R[0][0], n = L.e[1] * R[1][2] + L.e[2] * R[1][1], Math.abs(k[0] * D[2][0] - k[2] * D[0][0]) > r + n) || (r = b.e[0] * R[2][1] + b.e[2] * R[0][1], n = L.e[0] * R[1][2] + L.e[2] * R[1][0], Math.abs(k[0] * D[2][1] - k[2] * D[0][1]) > r + n) || (r = b.e[0] * R[2][2] + b.e[2] * R[0][2], n = L.e[0] * R[1][1] + L.e[1] * R[1][0], Math.abs(k[0] * D[2][2] - k[2] * D[0][2]) > r + n) || (r = b.e[0] * R[1][0] + b.e[1] * R[0][0], n = L.e[1] * R[2][2] + L.e[2] * R[2][1], Math.abs(k[1] * D[0][0] - k[0] * D[1][0]) > r + n) || (r = b.e[0] * R[1][1] + b.e[1] * R[0][1], n = L.e[0] * R[2][2] + L.e[2] * R[2][0], Math.abs(k[1] * D[0][1] - k[0] * D[1][1]) > r + n) || (r = b.e[0] * R[1][2] + b.e[1] * R[0][2], n = L.e[0] * R[2][1] + L.e[1] * R[2][0], Math.abs(k[1] * D[0][2] - k[0] * D[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(se, re, ie);
+    const t = this.halfSize.x * Math.abs(e.normal.dot(se)) + this.halfSize.y * Math.abs(e.normal.dot(re)) + this.halfSize.z * Math.abs(e.normal.dot(ie)), 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(Xe), qe.setFromCenterAndSize(v.set(0, 0, 0), Xe), Ae.setFromMatrix3(this.rotation), Ae.setPosition(this.center), Ye.copy(Ae).invert(), Qe.copy(e).applyMatrix4(Ye), Qe.intersectBox(qe, 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, v) !== 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 = v.set(t[0], t[1], t[2]).length();
+    const n = v.set(t[4], t[5], t[6]).length(), i = v.set(t[8], t[9], t[10]).length();
+    e.determinant() < 0 && (r = -r), z.setFromMatrix4(e);
+    const a = 1 / r, o = 1 / n, c = 1 / i;
+    return z.elements[0] *= a, z.elements[1] *= a, z.elements[2] *= a, z.elements[3] *= o, z.elements[4] *= o, z.elements[5] *= o, z.elements[6] *= c, z.elements[7] *= c, z.elements[8] *= c, this.rotation.multiply(z), this.halfSize.x *= r, this.halfSize.y *= n, this.halfSize.z *= i, v.setFromMatrixPosition(e), this.center.add(v), this;
+  }
+}
+const Un = new ke(), jn = new URL("/hdr/slightly_overcast_sky_dome_1k.hdr", import.meta.url).href, zn = new Gn(), Me = {}, Kn = {
+  enableDamping: !0,
+  dampingFactor: 0.25,
+  screenSpacePanning: !1,
+  minDistance: 0.1,
+  maxDistance: 1e3,
+  maxPolarAngle: Math.PI / 2
+}, Q = new Xt({
+  antialias: !0,
+  alpha: !0,
+  precision: "mediump"
+});
+function qn(h, e) {
+  const t = Object.assign(
+    {
+      css3d: !1,
+      stats: !1,
+      axesHelper: {
+        init: !1,
+        size: 10
+      },
+      gridHelper: {
+        init: !1
+      },
+      control: {
+        init: !0,
+        options: {}
+      },
+      envImage: !0
+    },
+    e || {}
+  );
+  let r, n, i, s, a = [];
+  const o = ref(0), c = ref(0), l = new Wt({});
+  l.background = new V("#222b38");
+  const u = new Te();
+  l.add(u), Q.setPixelRatio(window.devicePixelRatio);
+  const d = new ot(50, 1, 0.1, 2e3), f = Math.tan(Math.PI / 180 * d.fov / 2);
+  function m() {
+    const M = x();
+    if (o.value = M[0], c.value = M[1], d.aspect = o.value / c.value, d.position.set(47, 39, 100), d.fov = 360 / Math.PI * Math.atan(f * (c.value / o.value)), d.updateProjectionMatrix(), Q.setSize(o.value, c.value), r.appendChild(Q.domElement), t.envImage && Vn(l), t.stats && N(), t.css3d && B(), t.axesHelper && t.axesHelper.init) {
+      const g = Zt(t.axesHelper.size || 10);
+      l.add(g);
+    }
+    if (t.gridHelper && t.gridHelper.init) {
+      const g = $t(
+        t.gridHelper.size || 150,
+        t.gridHelper.options || {}
+      );
+      l.add(g);
+    }
+    if (t.control && t.control.init) {
+      s = en(d, Q.domElement);
+      const g = t.control.options || Kn;
+      Object.keys(g).forEach((y) => {
+        s[y] = g[y];
+      });
+    }
+    return { control: s, scene: l, camera: d, renderer: Q };
+  }
+  function T(M) {
+    a.push(M);
+  }
+  function p(M) {
+    a && a.length && a.forEach((g) => {
+      typeof g == "function" && g();
+    }), s && s.update(), Q.render(l, d), n && n.update(), i && i.render(l, d), requestAnimationFrame(p);
+  }
+  function A() {
+    nextTick(() => {
+      const M = x();
+      o.value = M[0], c.value = M[1], d.aspect = o.value / c.value, d.fov = 360 / Math.PI * Math.atan(f * (c.value / o.value)), d.updateProjectionMatrix(), d.lookAt(l.position), Q.render(l, d), Q.setSize(o.value, c.value), i && i.setSize(o.value, c.value);
+    });
+  }
+  function x() {
+    return r = document.querySelector(h), [r.clientWidth, r.clientHeight];
+  }
+  function N() {
+    n = new fe(), n.dom.style.cssText = "position:absolute;top:0;left:0;cursor:pointer;opacity:0.9;z-index:10000", r.appendChild(n.dom);
+  }
+  function _(M, g, y, S) {
+    const P = new Re().setFromObject(M), F = P.getSize(new O()).length(), C = P.getCenter(new O()), H = F * g * 0.5, I = he.degToRad(y.fov * 0.5), $ = H / Math.tan(I), W = new O().subVectors(y.position, C).multiply(new O(1, 1, 1)).normalize().multiplyScalar($).add(C), G = {
+      x: W.x,
+      y: W.y,
+      z: W.z,
+      lookAt_x: C.x,
+      lookAt_y: C.y,
+      lookAt_z: C.z
+    };
+    return y.position.set(G.x, G.y, G.z), y.lookAt(
+      G.lookAt_x,
+      G.lookAt_y,
+      G.lookAt_z
+    ), y.updateProjectionMatrix(), S.target.copy(C), S.update(), F;
+  }
+  function B() {
+    i = new tn(), i.setSize(o.value, c.value), i.domElement.style.position = "absolute", i.domElement.style.top = 0, i.domElement.style.left = 0, i.domElement.style.pointerEvents = "none", r.appendChild(i.domElement);
+  }
+  function U() {
+    Jt(l);
+  }
+  return {
+    init: m,
+    dispose: U,
+    animate: p,
+    onResize: A,
+    addAnimate: T,
+    frameArea: _,
+    objectGroup: u,
+    scene: l,
+    camera: d,
+    control: s,
+    renderer: Q,
+    domWidth: o,
+    domHeight: c
+  };
+}
+async function Vn(h, e = jn) {
+  if (console.log("  =====> hdrImg:", e), Me[e]) {
+    const t = Me[e];
+    h.environment = t;
+    return;
+  }
+  return new Promise((t, r) => {
+    zn.load(e, t, void 0, r);
+  }).then((t) => {
+    t.mapping = qt, h.environment = t, Me[e] = t;
+  }).catch((t) => {
+    console.log("  =====> e:", t);
+  });
+}
+const Yn = (h = "app") => {
+  const e = new Yt();
+  e.params.Line.threshold = 8;
+  const t = new De(), r = document.getElementById(h);
+  function n(a, o) {
+    const { scaleX: c, scaleY: l } = s(r), { clientWidth: u, clientHeight: d } = o, f = o.getBoundingClientRect(), m = u * c, T = d * l, p = a.clientX - f.left, A = a.clientY - f.top;
+    return t.x = (a.clientX - f.left) / m * 2 - 1, t.y = -((a.clientY - f.top) / T) * 2 + 1, { pointer: t, x: p, y: A };
+  }
+  function i(a, o, c, l) {
+    const { pointer: u, x: d, y: f } = n(a, o);
+    return e.setFromCamera(u, c), { intersects: e.intersectObjects(l), pointer: u, x: d, y: f };
+  }
+  function s(a) {
+    const o = window.getComputedStyle(a), c = o.transform || o.webkitTransform || o.mozTransform;
+    if (c && c !== "none") {
+      const l = c.match(/^matrix\((.+)\)$/);
+      if (l) {
+        const u = l[1].split(", "), d = parseFloat(u[0]), f = parseFloat(u[3]);
+        return { scaleX: d, scaleY: f };
+      }
+    }
+    return { scaleX: 1, scaleY: 1 };
+  }
+  return {
+    raycaster: e,
+    pointer: t,
+    getPointer: n,
+    getScale: s,
+    getIntersects: i
+  };
+}, J = [], Qn = new V(16711680), Jn = () => {
+  const h = () => {
+    J.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 Re(new O()).setFromObject(o);
+      o.geometry.userData.obb = new ke(), o.geometry.userData.obb.halfSize.copy(c.getSize(new O())).multiplyScalar(0.5).multiplyScalar(0.88), o.userData.obb = new ke(), o.userData.originColor = o.material.color.clone(), o.userData.parentUid = a, J.push({
+        object: o,
+        parentUid: a
+      });
+    }
+  };
+  return {
+    resetObbs: h,
+    initObb: e,
+    getObbObjectByParentUid: (a) => J.filter((o) => o.parentUid === a),
+    addObbFromArray: (a, o) => {
+      for (let c = 0, l = o.length; c < l; c++)
+        t(a, o[c]);
+    },
+    removeObbFromArray: (a) => {
+      const o = J.filter((c) => !a.includes(c.object));
+      J.splice(0, J.length, ...o);
+    },
+    removeUidObb: (a) => {
+      for (let o = J.length - 1; o >= 0; o--)
+        J[o].parentUid === a && J.splice(o, 1);
+    }
+  };
+}, Zn = () => {
+  const h = new Qt(16777215, 1), e = new et(16777215, 1, 0);
+  e.position.set(0, 50, 100), e.angle = Math.PI / 8, e.penumbra = 1, e.decay = 0, e.distance = 0;
+  const t = e.clone();
+  return t.position.set(-100, 50, -100), t.angle = Math.PI / 8, t.penumbra = 1, t.decay = 0, t.distance = 0, [h, e, t];
+}, $n = () => {
+  const h = new rn(), e = new nn();
+  e.setDecoderPath("/draco/"), h.setDRACOLoader(e);
+  function t(n, i, s, a) {
+    return h.load(n, i, s, a);
+  }
+  function r(n, i) {
+    return new Promise((s, a) => {
+      h.load(n, s, i, a);
+    });
+  }
+  return {
+    load: t,
+    asyncLoad: r
+  };
+};
+export {
+  Yn as a,
+  Qn as b,
+  Jn as c,
+  Zn as d,
+  $n as e,
+  Vn as i,
+  J as o,
+  qn as u
+};