@quick-threejs/reactive 0.1.23 → 0.1.25

package/dist/main.mjs

@@ -0,0 +1,2485 @@
+var et = Object.defineProperty;
+var tt = (c, e, t) => e in c ? et(c, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : c[e] = t;
+var T = (c, e, t) => tt(c, typeof e != "symbol" ? e + "" : e, t);
+import { m as Te, _ as nt, a as Ne, c as ye, i as _e, b as N, o as st, d as rt, O as it, s as Y, L as Q, S as ot, f as Pe, e as De, g as k, h as ke, z as at, P as ct, j as Fe, U as Z, K as lt, $ as ut, C as He, k as V, J as z, D as we, l as dt } from "./app.module-BeaCiPyy.mjs";
+import { A as ys, n as ws, p as Es, q as Rs } from "./app.module-BeaCiPyy.mjs";
+import { Loader as Ue, FileLoader as X, SRGBColorSpace as O, LinearSRGBColorSpace as b, BufferGeometry as Ge, BufferAttribute as j, Color as P, ColorManagement as oe, TrianglesDrawMode as ht, TriangleFanDrawMode as ae, TriangleStripDrawMode as Be, LoaderUtils as K, SpotLight as ft, PointLight as pt, DirectionalLight as mt, MeshBasicMaterial as B, MeshPhysicalMaterial as v, Vector2 as je, Matrix4 as W, Vector3 as F, Quaternion as Ke, InstancedMesh as gt, InstancedBufferAttribute as At, Object3D as Ve, TextureLoader as Tt, ImageBitmapLoader as ze, InterleavedBuffer as _t, InterleavedBufferAttribute as yt, LinearFilter as ce, LinearMipmapLinearFilter as $e, RepeatWrapping as le, NearestFilter as Xe, PointsMaterial as wt, Material as ee, LineBasicMaterial as Et, MeshStandardMaterial as We, DoubleSide as Rt, PropertyBinding as xt, SkinnedMesh as Lt, Mesh as bt, LineSegments as vt, Line as St, LineLoop as Mt, Points as Ct, Group as te, PerspectiveCamera as It, MathUtils as Ot, OrthographicCamera as Nt, Skeleton as Pt, AnimationClip as Dt, Bone as kt, InterpolateLinear as qe, NearestMipmapNearestFilter as Ft, LinearMipmapNearestFilter as Ht, NearestMipmapLinearFilter as Ut, ClampToEdgeWrapping as Gt, MirroredRepeatWrapping as Bt, InterpolateDiscrete as jt, FrontSide as Kt, Texture as Ee, VectorKeyframeTrack as Re, NumberKeyframeTrack as xe, QuaternionKeyframeTrack as Le, Box3 as Vt, Sphere as zt, Interpolant as $t, LoadingManager as Xt, CubeTextureLoader as Wt, AudioLoader as qt, VideoTexture as Yt, CanvasTexture as Qt } from "three";
+class ms {
+  constructor() {
+    /** @description Handler triggered when the app is ready. */
+    T(this, "onReady");
+  }
+}
+class Ye {
+  constructor() {
+    /**
+     * @description The app worker logic location.
+     *
+     * @required
+     */
+    T(this, "location");
+    /**
+     * @description Initialize the app on construct.
+     *
+     * @default true
+     */
+    T(this, "initOnConstruct");
+    /**
+     * @description App `canvas` element reference.
+     *
+     * @default undefined
+     */
+    T(this, "canvas");
+    /**
+     * @description Set the `canvas` view in fullscreen and auto-resize it.
+     *
+     * @default true
+     */
+    T(this, "fullScreen");
+    /**
+     * Default used camera.
+     *
+     * @see {@link DefaultCameraType}
+     *
+     * @default DefaultCameraType.PERSPECTIVE
+     */
+    T(this, "defaultCamera");
+    /**
+     * @description Start timer update on launch.
+     *
+     * @default true
+     */
+    T(this, "startTimer");
+    /**
+     * Enable the debug mode
+     *
+     * @default undefined
+     */
+    T(this, "enableDebug");
+    /**
+     * Define the {@link THREE.AxesHelper} sizes.
+     *
+     * @remark __Deactivated if the value is `0` or `undefined`__
+     * @remark __This property depends on {@link RegisterPropsModel.enableDebug}__
+     *
+     * @default undefined
+     */
+    T(this, "axesSizes");
+    /**
+     * Define the {@link THREE.GridHelper} sizes.
+     *
+     * @remark __Deactivated if the value is `0` or `undefined`__
+     * @remark __This property depends on {@link RegisterPropsModel.enableDebug}__
+     *
+     * @default undefined
+     */
+    T(this, "gridSizes");
+    /**
+     * Display a mini perfective camera at the top right corner of the screen.
+     *
+     * @remark __This property depends on {@link RegisterPropsModel.enableDebug}__
+     *
+     * @default false
+     */
+    T(this, "withMiniCamera");
+    /**
+     * @description Handler called when the app is ready.
+     *
+     * @default undefined
+     */
+    T(this, "onReady");
+  }
+}
+class Jt {
+  constructor() {
+    T(this, "contextmenu$");
+    T(this, "resize$");
+    T(this, "mousedown$");
+    T(this, "mousemove$");
+    T(this, "mouseup$");
+    T(this, "pointerdown$");
+    T(this, "pointermove$");
+    T(this, "pointercancel$");
+    T(this, "pointerup$");
+    T(this, "touchstart$");
+    T(this, "touchmove$");
+    T(this, "touchend$");
+    T(this, "wheel$");
+    T(this, "keydown$");
+  }
+}
+var Zt = Array.isArray;
+function en(c, e) {
+  return Zt(e) ? c.apply(void 0, nt([], Ne(e))) : c(e);
+}
+function tn(c) {
+  return Te(function(e) {
+    return en(c, e);
+  });
+}
+function nn(c, e, t, r, n, i, s, a) {
+  var o = [], l = 0, u = 0, d = !1, h = function() {
+    d && !o.length && !l && e.complete();
+  }, f = function(g) {
+    return l < r ? p(g) : o.push(g);
+  }, p = function(g) {
+    l++;
+    var m = !1;
+    _e(t(g, u++)).subscribe(ye(e, function(A) {
+      e.next(A);
+    }, function() {
+      m = !0;
+    }, void 0, function() {
+      if (m)
+        try {
+          l--;
+          for (var A = function() {
+            var y = o.shift();
+            s || p(y);
+          }; o.length && l < r; )
+            A();
+          h();
+        } catch (y) {
+          e.error(y);
+        }
+    }));
+  };
+  return c.subscribe(ye(e, f, function() {
+    d = !0, h();
+  })), function() {
+  };
+}
+function Qe(c, e, t) {
+  return t === void 0 && (t = 1 / 0), N(e) ? Qe(function(r, n) {
+    return Te(function(i, s) {
+      return e(r, i, n, s);
+    })(_e(c(r, n)));
+  }, t) : (typeof e == "number" && (t = e), st(function(r, n) {
+    return nn(r, n, c, t);
+  }));
+}
+var sn = ["addListener", "removeListener"], rn = ["addEventListener", "removeEventListener"], on = ["on", "off"];
+function ue(c, e, t, r) {
+  if (N(t) && (r = t, t = void 0), r)
+    return ue(c, e, t).pipe(tn(r));
+  var n = Ne(ln(c) ? rn.map(function(a) {
+    return function(o) {
+      return c[a](e, o, t);
+    };
+  }) : an(c) ? sn.map(be(c, e)) : cn(c) ? on.map(be(c, e)) : [], 2), i = n[0], s = n[1];
+  if (!i && rt(c))
+    return Qe(function(a) {
+      return ue(a, e, t);
+    })(_e(c));
+  if (!i)
+    throw new TypeError("Invalid event target");
+  return new it(function(a) {
+    var o = function() {
+      for (var l = [], u = 0; u < arguments.length; u++)
+        l[u] = arguments[u];
+      return a.next(1 < l.length ? l : l[0]);
+    };
+    return i(o), function() {
+      return s(o);
+    };
+  });
+}
+function be(c, e) {
+  return function(t) {
+    return function(r) {
+      return c[t](e, r);
+    };
+  };
+}
+function an(c) {
+  return N(c.addListener) && N(c.removeListener);
+}
+function cn(c) {
+  return N(c.on) && N(c.off);
+}
+function ln(c) {
+  return N(c.addEventListener) && N(c.removeEventListener);
+}
+const ne = /* @__PURE__ */ new WeakMap();
+class un extends Ue {
+  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"
+    };
+  }
+  setDecoderPath(e) {
+    return this.decoderPath = e, this;
+  }
+  setDecoderConfig(e) {
+    return this.decoderConfig = e, this;
+  }
+  setWorkerLimit(e) {
+    return this.workerLimit = e, this;
+  }
+  load(e, t, r, n) {
+    const i = new X(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);
+  }
+  parse(e, t, r = () => {
+  }) {
+    this.decodeDracoFile(e, t, null, null, O, r).catch(r);
+  }
+  decodeDracoFile(e, t, r, n, i = b, 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 (ne.has(e)) {
+      const o = ne.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((l, u) => {
+      n._callbacks[i] = { resolve: l, reject: u }, 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);
+    }), ne.set(e, {
+      key: r,
+      promise: a
+    }), a;
+  }
+  _createGeometry(e) {
+    const t = new Ge();
+    e.index && t.setIndex(new j(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 j(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 !== O) return;
+    const r = new P();
+    for (let n = 0, i = e.count; n < i; n++)
+      r.fromBufferAttribute(e, n), oe.toWorkingColorSpace(r, O), e.setXYZ(n, r.r, r.g, r.b);
+  }
+  _loadLibrary(e, t) {
+    const r = new X(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 = dn.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 dn() {
+  let c, e;
+  onmessage = function(s) {
+    const a = s.data;
+    switch (a.type) {
+      case "init":
+        c = a.decoderConfig, e = new Promise(function(u) {
+          c.onModuleLoaded = function(d) {
+            u({ draco: d });
+          }, DracoDecoderModule(c);
+        });
+        break;
+      case "decode":
+        const o = a.buffer, l = a.taskConfig;
+        e.then((u) => {
+          const d = u.draco, h = new d.Decoder();
+          try {
+            const f = t(d, h, new Int8Array(o), l), p = f.attributes.map((g) => g.array.buffer);
+            f.index && p.push(f.index.array.buffer), self.postMessage({ type: "decode", id: a.id, geometry: f }, p);
+          } catch (f) {
+            console.error(f), self.postMessage({ type: "error", id: a.id, error: f.message });
+          } finally {
+            d.destroy(h);
+          }
+        });
+        break;
+    }
+  };
+  function t(s, a, o, l) {
+    const u = l.attributeIDs, d = l.attributeTypes;
+    let h, f;
+    const p = a.GetEncodedGeometryType(o);
+    if (p === s.TRIANGULAR_MESH)
+      h = new s.Mesh(), f = a.DecodeArrayToMesh(o, o.byteLength, h);
+    else if (p === s.POINT_CLOUD)
+      h = new s.PointCloud(), f = a.DecodeArrayToPointCloud(o, o.byteLength, h);
+    else
+      throw new Error("THREE.DRACOLoader: Unexpected geometry type.");
+    if (!f.ok() || h.ptr === 0)
+      throw new Error("THREE.DRACOLoader: Decoding failed: " + f.error_msg());
+    const g = { index: null, attributes: [] };
+    for (const m in u) {
+      const A = self[d[m]];
+      let y, E;
+      if (l.useUniqueIDs)
+        E = u[m], y = a.GetAttributeByUniqueId(h, E);
+      else {
+        if (E = a.GetAttributeId(h, s[u[m]]), E === -1) continue;
+        y = a.GetAttribute(h, E);
+      }
+      const w = n(s, a, h, m, A, y);
+      m === "color" && (w.vertexColorSpace = l.vertexColorSpace), g.attributes.push(w);
+    }
+    return p === s.TRIANGULAR_MESH && (g.index = r(s, a, h)), s.destroy(h), g;
+  }
+  function r(s, a, o) {
+    const u = o.num_faces() * 3, d = u * 4, h = s._malloc(d);
+    a.GetTrianglesUInt32Array(o, d, h);
+    const f = new Uint32Array(s.HEAPF32.buffer, h, u).slice();
+    return s._free(h), { array: f, itemSize: 1 };
+  }
+  function n(s, a, o, l, u, d) {
+    const h = d.num_components(), p = o.num_points() * h, g = p * u.BYTES_PER_ELEMENT, m = i(s, u), A = s._malloc(g);
+    a.GetAttributeDataArrayForAllPoints(o, d, m, g, A);
+    const y = new u(s.HEAPF32.buffer, A, p).slice();
+    return s._free(A), {
+      name: l,
+      array: y,
+      itemSize: h
+    };
+  }
+  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;
+    }
+  }
+}
+var hn = Object.defineProperty, fn = Object.getOwnPropertyDescriptor, pn = (c, e, t, r) => {
+  for (var n = r > 1 ? void 0 : r ? fn(e, t) : e, i = c.length - 1, s; i >= 0; i--)
+    (s = c[i]) && (n = (r ? s(e, t, n) : s(n)) || n);
+  return r && n && hn(e, t, n), n;
+};
+let de = class {
+  constructor() {
+    T(this, "progress$$", new ot());
+    T(this, "progress$", this.progress$$.pipe());
+    T(this, "progressCompleted$", this.progress$.pipe(
+      Pe((c) => c.toLoad === c.loaded)
+    ));
+  }
+};
+de = pn([
+  Y(Q.ResolutionScoped)
+], de);
+function ve(c, e) {
+  if (e === ht)
+    return console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles."), c;
+  if (e === ae || e === Be) {
+    let t = c.getIndex();
+    if (t === null) {
+      const s = [], a = c.getAttribute("position");
+      if (a !== void 0) {
+        for (let o = 0; o < a.count; o++)
+          s.push(o);
+        c.setIndex(s), t = c.getIndex();
+      } else
+        return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible."), c;
+    }
+    const r = t.count - 2, n = [];
+    if (e === ae)
+      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 = c.clone();
+    return i.setIndex(n), i.clearGroups(), i;
+  } else
+    return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unknown draw mode:", e), c;
+}
+class mn extends Ue {
+  constructor(e) {
+    super(e), this.dracoLoader = null, this.ktx2Loader = null, this.meshoptDecoder = null, this.pluginCallbacks = [], this.register(function(t) {
+      return new yn(t);
+    }), this.register(function(t) {
+      return new wn(t);
+    }), this.register(function(t) {
+      return new Cn(t);
+    }), this.register(function(t) {
+      return new In(t);
+    }), this.register(function(t) {
+      return new On(t);
+    }), this.register(function(t) {
+      return new Rn(t);
+    }), this.register(function(t) {
+      return new xn(t);
+    }), this.register(function(t) {
+      return new Ln(t);
+    }), this.register(function(t) {
+      return new bn(t);
+    }), this.register(function(t) {
+      return new _n(t);
+    }), this.register(function(t) {
+      return new vn(t);
+    }), this.register(function(t) {
+      return new En(t);
+    }), this.register(function(t) {
+      return new Mn(t);
+    }), this.register(function(t) {
+      return new Sn(t);
+    }), this.register(function(t) {
+      return new An(t);
+    }), this.register(function(t) {
+      return new Nn(t);
+    }), this.register(function(t) {
+      return new Pn(t);
+    });
+  }
+  load(e, t, r, n) {
+    const i = this;
+    let s;
+    if (this.resourcePath !== "")
+      s = this.resourcePath;
+    else if (this.path !== "") {
+      const l = K.extractUrlBase(e);
+      s = K.resolveURL(l, this.path);
+    } else
+      s = K.extractUrlBase(e);
+    this.manager.itemStart(e);
+    const a = function(l) {
+      n ? n(l) : console.error(l), i.manager.itemError(e), i.manager.itemEnd(e);
+    }, o = new X(this.manager);
+    o.setPath(this.path), o.setResponseType("arraybuffer"), o.setRequestHeader(this.requestHeader), o.setWithCredentials(this.withCredentials), o.load(e, function(l) {
+      try {
+        i.parse(l, s, function(u) {
+          t(u), i.manager.itemEnd(e);
+        }, a);
+      } catch (u) {
+        a(u);
+      }
+    }, r, a);
+  }
+  setDRACOLoader(e) {
+    return this.dracoLoader = e, this;
+  }
+  setKTX2Loader(e) {
+    return this.ktx2Loader = e, this;
+  }
+  setMeshoptDecoder(e) {
+    return this.meshoptDecoder = e, this;
+  }
+  register(e) {
+    return this.pluginCallbacks.indexOf(e) === -1 && this.pluginCallbacks.push(e), this;
+  }
+  unregister(e) {
+    return this.pluginCallbacks.indexOf(e) !== -1 && this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(e), 1), this;
+  }
+  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)) === Je) {
+        try {
+          s[_.KHR_BINARY_GLTF] = new Dn(e);
+        } catch (d) {
+          n && n(d);
+          return;
+        }
+        i = JSON.parse(s[_.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 l = new Wn(i, {
+      path: t || this.resourcePath || "",
+      crossOrigin: this.crossOrigin,
+      requestHeader: this.requestHeader,
+      manager: this.manager,
+      ktx2Loader: this.ktx2Loader,
+      meshoptDecoder: this.meshoptDecoder
+    });
+    l.fileLoader.setRequestHeader(this.requestHeader);
+    for (let u = 0; u < this.pluginCallbacks.length; u++) {
+      const d = this.pluginCallbacks[u](l);
+      d.name || console.error("THREE.GLTFLoader: Invalid plugin found: missing name"), a[d.name] = d, s[d.name] = !0;
+    }
+    if (i.extensionsUsed)
+      for (let u = 0; u < i.extensionsUsed.length; ++u) {
+        const d = i.extensionsUsed[u], h = i.extensionsRequired || [];
+        switch (d) {
+          case _.KHR_MATERIALS_UNLIT:
+            s[d] = new Tn();
+            break;
+          case _.KHR_DRACO_MESH_COMPRESSION:
+            s[d] = new kn(i, this.dracoLoader);
+            break;
+          case _.KHR_TEXTURE_TRANSFORM:
+            s[d] = new Fn();
+            break;
+          case _.KHR_MESH_QUANTIZATION:
+            s[d] = new Hn();
+            break;
+          default:
+            h.indexOf(d) >= 0 && a[d] === void 0 && console.warn('THREE.GLTFLoader: Unknown extension "' + d + '".');
+        }
+      }
+    l.setExtensions(s), l.setPlugins(a), l.parse(r, n);
+  }
+  parseAsync(e, t) {
+    const r = this;
+    return new Promise(function(n, i) {
+      r.parse(e, t, n, i);
+    });
+  }
+}
+function gn() {
+  let c = {};
+  return {
+    get: function(e) {
+      return c[e];
+    },
+    add: function(e, t) {
+      c[e] = t;
+    },
+    remove: function(e) {
+      delete c[e];
+    },
+    removeAll: function() {
+      c = {};
+    }
+  };
+}
+const _ = {
+  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 = _.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 l;
+    const u = new P(16777215);
+    o.color !== void 0 && u.setRGB(o.color[0], o.color[1], o.color[2], b);
+    const d = o.range !== void 0 ? o.range : 0;
+    switch (o.type) {
+      case "directional":
+        l = new mt(u), l.target.position.set(0, 0, -1), l.add(l.target);
+        break;
+      case "point":
+        l = new pt(u), l.distance = d;
+        break;
+      case "spot":
+        l = new ft(u), l.distance = d, 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, l.angle = o.spot.outerConeAngle, l.penumbra = 1 - o.spot.innerConeAngle / o.spot.outerConeAngle, l.target.position.set(0, 0, -1), l.add(l.target);
+        break;
+      default:
+        throw new Error("THREE.GLTFLoader: Unexpected light type: " + o.type);
+    }
+    return l.position.set(0, 0, 0), l.decay = 2, S(l, o), o.intensity !== void 0 && (l.intensity = o.intensity), l.name = t.createUniqueName(o.name || "light_" + e), n = Promise.resolve(l), 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 Tn {
+  constructor() {
+    this.name = _.KHR_MATERIALS_UNLIT;
+  }
+  getMaterialType() {
+    return B;
+  }
+  extendParams(e, t, r) {
+    const n = [];
+    e.color = new P(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], b), e.opacity = s[3];
+      }
+      i.baseColorTexture !== void 0 && n.push(r.assignTexture(e, "map", i.baseColorTexture, O));
+    }
+    return Promise.all(n);
+  }
+}
+class _n {
+  constructor(e) {
+    this.parser = e, this.name = _.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 yn {
+  constructor(e) {
+    this.parser = e, this.name = _.KHR_MATERIALS_CLEARCOAT;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const 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 je(a, a);
+    }
+    return Promise.all(i);
+  }
+}
+class wn {
+  constructor(e) {
+    this.parser = e, this.name = _.KHR_MATERIALS_DISPERSION;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = n.extensions[this.name];
+    return t.dispersion = i.dispersion !== void 0 ? i.dispersion : 0, Promise.resolve();
+  }
+}
+class En {
+  constructor(e) {
+    this.parser = e, this.name = _.KHR_MATERIALS_IRIDESCENCE;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const 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 Rn {
+  constructor(e) {
+    this.parser = e, this.name = _.KHR_MATERIALS_SHEEN;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = [];
+    t.sheenColor = new P(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], b);
+    }
+    return s.sheenRoughnessFactor !== void 0 && (t.sheenRoughness = s.sheenRoughnessFactor), s.sheenColorTexture !== void 0 && i.push(r.assignTexture(t, "sheenColorMap", s.sheenColorTexture, O)), s.sheenRoughnessTexture !== void 0 && i.push(r.assignTexture(t, "sheenRoughnessMap", s.sheenRoughnessTexture)), Promise.all(i);
+  }
+}
+class xn {
+  constructor(e) {
+    this.parser = e, this.name = _.KHR_MATERIALS_TRANSMISSION;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const 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 Ln {
+  constructor(e) {
+    this.parser = e, this.name = _.KHR_MATERIALS_VOLUME;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const 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 P().setRGB(a[0], a[1], a[2], b), Promise.all(i);
+  }
+}
+class bn {
+  constructor(e) {
+    this.parser = e, this.name = _.KHR_MATERIALS_IOR;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const i = n.extensions[this.name];
+    return t.ior = i.ior !== void 0 ? i.ior : 1.5, Promise.resolve();
+  }
+}
+class vn {
+  constructor(e) {
+    this.parser = e, this.name = _.KHR_MATERIALS_SPECULAR;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const 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 P().setRGB(a[0], a[1], a[2], b), s.specularColorTexture !== void 0 && i.push(r.assignTexture(t, "specularColorMap", s.specularColorTexture, O)), Promise.all(i);
+  }
+}
+class Sn {
+  constructor(e) {
+    this.parser = e, this.name = _.EXT_MATERIALS_BUMP;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const 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 Mn {
+  constructor(e) {
+    this.parser = e, this.name = _.KHR_MATERIALS_ANISOTROPY;
+  }
+  getMaterialType(e) {
+    const r = this.parser.json.materials[e];
+    return !r.extensions || !r.extensions[this.name] ? null : v;
+  }
+  extendMaterialParams(e, t) {
+    const r = this.parser, n = r.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const 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 Cn {
+  constructor(e) {
+    this.parser = e, this.name = _.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 In {
+  constructor(e) {
+    this.parser = e, this.name = _.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 l = r.options.manager.getHandler(a.uri);
+      l !== null && (o = l);
+    }
+    return this.detectSupport().then(function(l) {
+      if (l) 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 On {
+  constructor(e) {
+    this.parser = e, this.name = _.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 l = r.options.manager.getHandler(a.uri);
+      l !== null && (o = l);
+    }
+    return this.detectSupport().then(function(l) {
+      if (l) 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 Nn {
+  constructor(e) {
+    this.name = _.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, l = n.byteLength || 0, u = n.count, d = n.byteStride, h = new Uint8Array(a, o, l);
+        return s.decodeGltfBufferAsync ? s.decodeGltfBufferAsync(u, d, h, n.mode, n.filter).then(function(f) {
+          return f.buffer;
+        }) : s.ready.then(function() {
+          const f = new ArrayBuffer(u * d);
+          return s.decodeGltfBuffer(new Uint8Array(f), u, d, h, n.mode, n.filter), f;
+        });
+      });
+    } else
+      return null;
+  }
+}
+class Pn {
+  constructor(e) {
+    this.name = _.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 l of n.primitives)
+      if (l.mode !== R.TRIANGLES && l.mode !== R.TRIANGLE_STRIP && l.mode !== R.TRIANGLE_FAN && l.mode !== void 0)
+        return null;
+    const s = r.extensions[this.name].attributes, a = [], o = {};
+    for (const l in s)
+      a.push(this.parser.getDependency("accessor", s[l]).then((u) => (o[l] = u, o[l])));
+    return a.length < 1 ? null : (a.push(this.parser.createNodeMesh(e)), Promise.all(a).then((l) => {
+      const u = l.pop(), d = u.isGroup ? u.children : [u], h = l[0].count, f = [];
+      for (const p of d) {
+        const g = new W(), m = new F(), A = new Ke(), y = new F(1, 1, 1), E = new gt(p.geometry, p.material, h);
+        for (let w = 0; w < h; w++)
+          o.TRANSLATION && m.fromBufferAttribute(o.TRANSLATION, w), o.ROTATION && A.fromBufferAttribute(o.ROTATION, w), o.SCALE && y.fromBufferAttribute(o.SCALE, w), E.setMatrixAt(w, g.compose(m, A, y));
+        for (const w in o)
+          if (w === "_COLOR_0") {
+            const L = o[w];
+            E.instanceColor = new At(L.array, L.itemSize, L.normalized);
+          } else w !== "TRANSLATION" && w !== "ROTATION" && w !== "SCALE" && p.geometry.setAttribute(w, o[w]);
+        Ve.prototype.copy.call(E, p), this.parser.assignFinalMaterial(E), f.push(E);
+      }
+      return u.isGroup ? (u.clear(), u.add(...f), u) : f[0];
+    }));
+  }
+}
+const Je = "glTF", G = 12, Se = { JSON: 1313821514, BIN: 5130562 };
+class Dn {
+  constructor(e) {
+    this.name = _.KHR_BINARY_GLTF, this.content = null, this.body = null;
+    const t = new DataView(e, 0, G), 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 !== Je)
+      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 - G, i = new DataView(e, G);
+    let s = 0;
+    for (; s < n; ) {
+      const a = i.getUint32(s, !0);
+      s += 4;
+      const o = i.getUint32(s, !0);
+      if (s += 4, o === Se.JSON) {
+        const l = new Uint8Array(e, G + s, a);
+        this.content = r.decode(l);
+      } else if (o === Se.BIN) {
+        const l = G + s;
+        this.body = e.slice(l, l + a);
+      }
+      s += a;
+    }
+    if (this.content === null)
+      throw new Error("THREE.GLTFLoader: JSON content not found.");
+  }
+}
+class kn {
+  constructor(e, t) {
+    if (!t)
+      throw new Error("THREE.GLTFLoader: No DRACOLoader instance provided.");
+    this.name = _.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 = {}, l = {};
+    for (const u in s) {
+      const d = he[u] || u.toLowerCase();
+      a[d] = s[u];
+    }
+    for (const u in e.attributes) {
+      const d = he[u] || u.toLowerCase();
+      if (s[u] !== void 0) {
+        const h = r.accessors[e.attributes[u]], f = H[h.componentType];
+        l[d] = f.name, o[d] = h.normalized === !0;
+      }
+    }
+    return t.getDependency("bufferView", i).then(function(u) {
+      return new Promise(function(d, h) {
+        n.decodeDracoFile(u, function(f) {
+          for (const p in f.attributes) {
+            const g = f.attributes[p], m = o[p];
+            m !== void 0 && (g.normalized = m);
+          }
+          d(f);
+        }, a, l, b, h);
+      });
+    });
+  }
+}
+class Fn {
+  constructor() {
+    this.name = _.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 Hn {
+  constructor() {
+    this.name = _.KHR_MESH_QUANTIZATION;
+  }
+}
+class Ze extends $t {
+  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, l = a * 3, u = n - t, d = (r - t) / u, h = d * d, f = h * d, p = e * l, g = p - l, m = -2 * f + 3 * h, A = f - h, y = 1 - m, E = A - h + d;
+    for (let w = 0; w !== a; w++) {
+      const L = s[g + w + a], M = s[g + w + o] * u, x = s[p + w + a], U = s[p + w] * u;
+      i[w] = y * L + E * M + m * x + A * U;
+    }
+    return i;
+  }
+}
+const Un = new Ke();
+class Gn extends Ze {
+  interpolate_(e, t, r, n) {
+    const i = super.interpolate_(e, t, r, n);
+    return Un.fromArray(i).normalize().toArray(i), i;
+  }
+}
+const R = {
+  FLOAT: 5126,
+  //FLOAT_MAT2: 35674,
+  FLOAT_MAT3: 35675,
+  FLOAT_MAT4: 35676,
+  FLOAT_VEC2: 35664,
+  FLOAT_VEC3: 35665,
+  FLOAT_VEC4: 35666,
+  LINEAR: 9729,
+  REPEAT: 10497,
+  SAMPLER_2D: 35678,
+  POINTS: 0,
+  LINES: 1,
+  LINE_LOOP: 2,
+  LINE_STRIP: 3,
+  TRIANGLES: 4,
+  TRIANGLE_STRIP: 5,
+  TRIANGLE_FAN: 6,
+  UNSIGNED_BYTE: 5121,
+  UNSIGNED_SHORT: 5123
+}, H = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5125: Uint32Array,
+  5126: Float32Array
+}, Me = {
+  9728: Xe,
+  9729: ce,
+  9984: Ft,
+  9985: Ht,
+  9986: Ut,
+  9987: $e
+}, Ce = {
+  33071: Gt,
+  33648: Bt,
+  10497: le
+}, se = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+}, he = {
+  POSITION: "position",
+  NORMAL: "normal",
+  TANGENT: "tangent",
+  TEXCOORD_0: "uv",
+  TEXCOORD_1: "uv1",
+  TEXCOORD_2: "uv2",
+  TEXCOORD_3: "uv3",
+  COLOR_0: "color",
+  WEIGHTS_0: "skinWeight",
+  JOINTS_0: "skinIndex"
+}, I = {
+  scale: "scale",
+  translation: "position",
+  rotation: "quaternion",
+  weights: "morphTargetInfluences"
+}, Bn = {
+  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: qe,
+  STEP: jt
+}, re = {
+  OPAQUE: "OPAQUE",
+  MASK: "MASK",
+  BLEND: "BLEND"
+};
+function jn(c) {
+  return c.DefaultMaterial === void 0 && (c.DefaultMaterial = new We({
+    color: 16777215,
+    emissive: 0,
+    metalness: 1,
+    roughness: 1,
+    transparent: !1,
+    depthTest: !0,
+    side: Kt
+  })), c.DefaultMaterial;
+}
+function D(c, e, t) {
+  for (const r in t.extensions)
+    c[r] === void 0 && (e.userData.gltfExtensions = e.userData.gltfExtensions || {}, e.userData.gltfExtensions[r] = t.extensions[r]);
+}
+function S(c, e) {
+  e.extras !== void 0 && (typeof e.extras == "object" ? Object.assign(c.userData, e.extras) : console.warn("THREE.GLTFLoader: Ignoring primitive type .extras, " + e.extras));
+}
+function Kn(c, e, t) {
+  let r = !1, n = !1, i = !1;
+  for (let l = 0, u = e.length; l < u; l++) {
+    const d = e[l];
+    if (d.POSITION !== void 0 && (r = !0), d.NORMAL !== void 0 && (n = !0), d.COLOR_0 !== void 0 && (i = !0), r && n && i) break;
+  }
+  if (!r && !n && !i) return Promise.resolve(c);
+  const s = [], a = [], o = [];
+  for (let l = 0, u = e.length; l < u; l++) {
+    const d = e[l];
+    if (r) {
+      const h = d.POSITION !== void 0 ? t.getDependency("accessor", d.POSITION) : c.attributes.position;
+      s.push(h);
+    }
+    if (n) {
+      const h = d.NORMAL !== void 0 ? t.getDependency("accessor", d.NORMAL) : c.attributes.normal;
+      a.push(h);
+    }
+    if (i) {
+      const h = d.COLOR_0 !== void 0 ? t.getDependency("accessor", d.COLOR_0) : c.attributes.color;
+      o.push(h);
+    }
+  }
+  return Promise.all([
+    Promise.all(s),
+    Promise.all(a),
+    Promise.all(o)
+  ]).then(function(l) {
+    const u = l[0], d = l[1], h = l[2];
+    return r && (c.morphAttributes.position = u), n && (c.morphAttributes.normal = d), i && (c.morphAttributes.color = h), c.morphTargetsRelative = !0, c;
+  });
+}
+function Vn(c, e) {
+  if (c.updateMorphTargets(), e.weights !== void 0)
+    for (let t = 0, r = e.weights.length; t < r; t++)
+      c.morphTargetInfluences[t] = e.weights[t];
+  if (e.extras && Array.isArray(e.extras.targetNames)) {
+    const t = e.extras.targetNames;
+    if (c.morphTargetInfluences.length === t.length) {
+      c.morphTargetDictionary = {};
+      for (let r = 0, n = t.length; r < n; r++)
+        c.morphTargetDictionary[t[r]] = r;
+    } else
+      console.warn("THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.");
+  }
+}
+function zn(c) {
+  let e;
+  const t = c.extensions && c.extensions[_.KHR_DRACO_MESH_COMPRESSION];
+  if (t ? e = "draco:" + t.bufferView + ":" + t.indices + ":" + ie(t.attributes) : e = c.indices + ":" + ie(c.attributes) + ":" + c.mode, c.targets !== void 0)
+    for (let r = 0, n = c.targets.length; r < n; r++)
+      e += ":" + ie(c.targets[r]);
+  return e;
+}
+function ie(c) {
+  let e = "";
+  const t = Object.keys(c).sort();
+  for (let r = 0, n = t.length; r < n; r++)
+    e += t[r] + ":" + c[t[r]] + ";";
+  return e;
+}
+function fe(c) {
+  switch (c) {
+    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 $n(c) {
+  return c.search(/\.jpe?g($|\?)/i) > 0 || c.search(/^data\:image\/jpeg/) === 0 ? "image/jpeg" : c.search(/\.webp($|\?)/i) > 0 || c.search(/^data\:image\/webp/) === 0 ? "image/webp" : c.search(/\.ktx2($|\?)/i) > 0 || c.search(/^data\:image\/ktx2/) === 0 ? "image/ktx2" : "image/png";
+}
+const Xn = new W();
+class Wn {
+  constructor(e = {}, t = {}) {
+    this.json = e, this.extensions = {}, this.plugins = {}, this.options = t, this.cache = new gn(), 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 Tt(this.options.manager) : this.textureLoader = new ze(this.options.manager), this.textureLoader.setCrossOrigin(this.options.crossOrigin), this.textureLoader.setRequestHeader(this.options.requestHeader), this.fileLoader = new X(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 D(i, a, n), S(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.
+   */
+  _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.
+   */
+  _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. */
+  _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 [l, u] of s.children.entries())
+        i(u, a.children[l]);
+    };
+    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.
+   * @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.
+   * @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
+   * @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[_.KHR_BINARY_GLTF].body);
+    const n = this.options;
+    return new Promise(function(i, s) {
+      r.load(K.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
+   * @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
+   * @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 = se[n.type], a = H[n.componentType], o = n.normalized === !0, l = new a(n.count * s);
+      return Promise.resolve(new j(l, 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 = se[n.type], l = H[n.componentType], u = l.BYTES_PER_ELEMENT, d = u * o, h = n.byteOffset || 0, f = n.bufferView !== void 0 ? r.bufferViews[n.bufferView].byteStride : void 0, p = n.normalized === !0;
+      let g, m;
+      if (f && f !== d) {
+        const A = Math.floor(h / f), y = "InterleavedBuffer:" + n.bufferView + ":" + n.componentType + ":" + A + ":" + n.count;
+        let E = t.cache.get(y);
+        E || (g = new l(a, A * f, n.count * f / u), E = new _t(g, f / u), t.cache.add(y, E)), m = new yt(E, o, h % f / u, p);
+      } else
+        a === null ? g = new l(n.count * o) : g = new l(a, h, n.count * o), m = new j(g, o, p);
+      if (n.sparse !== void 0) {
+        const A = se.SCALAR, y = H[n.sparse.indices.componentType], E = n.sparse.indices.byteOffset || 0, w = n.sparse.values.byteOffset || 0, L = new y(s[1], E, n.sparse.count * A), M = new l(s[2], w, n.sparse.count * o);
+        a !== null && (m = new j(m.array.slice(), m.itemSize, m.normalized)), m.normalized = !1;
+        for (let x = 0, U = L.length; x < U; x++) {
+          const C = L[x];
+          if (m.setX(C, M[x * o]), o >= 2 && m.setY(C, M[x * o + 1]), o >= 3 && m.setZ(C, M[x * o + 2]), o >= 4 && m.setW(C, M[x * o + 3]), o >= 5) throw new Error("THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.");
+        }
+        m.normalized = p;
+      }
+      return m;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures
+   * @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 l = this.loadImageSource(t, r).then(function(u) {
+      u.flipY = !1, u.name = s.name || a.name || "", u.name === "" && typeof a.uri == "string" && a.uri.startsWith("data:image/") === !1 && (u.name = a.uri);
+      const h = (i.samplers || {})[s.sampler] || {};
+      return u.magFilter = Me[h.magFilter] || ce, u.minFilter = Me[h.minFilter] || $e, u.wrapS = Ce[h.wrapS] || le, u.wrapT = Ce[h.wrapT] || le, u.generateMipmaps = !u.isCompressedTexture && u.minFilter !== Xe && u.minFilter !== ce, n.associations.set(u, { textures: e }), u;
+    }).catch(function() {
+      return null;
+    });
+    return this.textureCache[o] = l, l;
+  }
+  loadImageSource(e, t) {
+    const r = this, n = this.json, i = this.options;
+    if (this.sourceCache[e] !== void 0)
+      return this.sourceCache[e].then((d) => d.clone());
+    const s = n.images[e], a = self.URL || self.webkitURL;
+    let o = s.uri || "", l = !1;
+    if (s.bufferView !== void 0)
+      o = r.getDependency("bufferView", s.bufferView).then(function(d) {
+        l = !0;
+        const h = new Blob([d], { type: s.mimeType });
+        return o = a.createObjectURL(h), o;
+      });
+    else if (s.uri === void 0)
+      throw new Error("THREE.GLTFLoader: Image " + e + " is missing URI and bufferView");
+    const u = Promise.resolve(o).then(function(d) {
+      return new Promise(function(h, f) {
+        let p = h;
+        t.isImageBitmapLoader === !0 && (p = function(g) {
+          const m = new Ee(g);
+          m.needsUpdate = !0, h(m);
+        }), t.load(K.resolveURL(d, i.path), p, void 0, f);
+      });
+    }).then(function(d) {
+      return l === !0 && a.revokeObjectURL(o), S(d, s), d.userData.mimeType = s.mimeType || $n(s.uri), d;
+    }).catch(function(d) {
+      throw console.error("THREE.GLTFLoader: Couldn't load texture", o), d;
+    });
+    return this.sourceCache[e] = u, u;
+  }
+  /**
+   * Asynchronously assigns a texture to the given material parameters.
+   * @param {Object} materialParams
+   * @param {string} mapName
+   * @param {Object} mapDef
+   * @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[_.KHR_TEXTURE_TRANSFORM]) {
+        const a = r.extensions !== void 0 ? r.extensions[_.KHR_TEXTURE_TRANSFORM] : void 0;
+        if (a) {
+          const o = i.associations.get(s);
+          s = i.extensions[_.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.
+   * @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 wt(), ee.prototype.copy.call(o, r), o.color.copy(r.color), o.map = r.map, o.sizeAttenuation = !1, this.cache.add(a, o)), r = o;
+    } else if (e.isLine) {
+      const a = "LineBasicMaterial:" + r.uuid;
+      let o = this.cache.get(a);
+      o || (o = new Et(), ee.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 We;
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
+   * @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 || {}, l = [];
+    if (o[_.KHR_MATERIALS_UNLIT]) {
+      const d = n[_.KHR_MATERIALS_UNLIT];
+      s = d.getMaterialType(), l.push(d.extendParams(a, i, t));
+    } else {
+      const d = i.pbrMetallicRoughness || {};
+      if (a.color = new P(1, 1, 1), a.opacity = 1, Array.isArray(d.baseColorFactor)) {
+        const h = d.baseColorFactor;
+        a.color.setRGB(h[0], h[1], h[2], b), a.opacity = h[3];
+      }
+      d.baseColorTexture !== void 0 && l.push(t.assignTexture(a, "map", d.baseColorTexture, O)), a.metalness = d.metallicFactor !== void 0 ? d.metallicFactor : 1, a.roughness = d.roughnessFactor !== void 0 ? d.roughnessFactor : 1, d.metallicRoughnessTexture !== void 0 && (l.push(t.assignTexture(a, "metalnessMap", d.metallicRoughnessTexture)), l.push(t.assignTexture(a, "roughnessMap", d.metallicRoughnessTexture))), s = this._invokeOne(function(h) {
+        return h.getMaterialType && h.getMaterialType(e);
+      }), l.push(Promise.all(this._invokeAll(function(h) {
+        return h.extendMaterialParams && h.extendMaterialParams(e, a);
+      })));
+    }
+    i.doubleSided === !0 && (a.side = Rt);
+    const u = i.alphaMode || re.OPAQUE;
+    if (u === re.BLEND ? (a.transparent = !0, a.depthWrite = !1) : (a.transparent = !1, u === re.MASK && (a.alphaTest = i.alphaCutoff !== void 0 ? i.alphaCutoff : 0.5)), i.normalTexture !== void 0 && s !== B && (l.push(t.assignTexture(a, "normalMap", i.normalTexture)), a.normalScale = new je(1, 1), i.normalTexture.scale !== void 0)) {
+      const d = i.normalTexture.scale;
+      a.normalScale.set(d, d);
+    }
+    if (i.occlusionTexture !== void 0 && s !== B && (l.push(t.assignTexture(a, "aoMap", i.occlusionTexture)), i.occlusionTexture.strength !== void 0 && (a.aoMapIntensity = i.occlusionTexture.strength)), i.emissiveFactor !== void 0 && s !== B) {
+      const d = i.emissiveFactor;
+      a.emissive = new P().setRGB(d[0], d[1], d[2], b);
+    }
+    return i.emissiveTexture !== void 0 && s !== B && l.push(t.assignTexture(a, "emissiveMap", i.emissiveTexture, O)), Promise.all(l).then(function() {
+      const d = new s(a);
+      return i.name && (d.name = i.name), S(d, i), t.associations.set(d, { materials: e }), i.extensions && D(n, d, i), d;
+    });
+  }
+  /** When Object3D instances are targeted by animation, they need unique names. */
+  createUniqueName(e) {
+    const t = xt.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.
+   *
+   * @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[_.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(a, t).then(function(o) {
+        return Ie(o, a, t);
+      });
+    }
+    const s = [];
+    for (let a = 0, o = e.length; a < o; a++) {
+      const l = e[a], u = zn(l), d = n[u];
+      if (d)
+        s.push(d.promise);
+      else {
+        let h;
+        l.extensions && l.extensions[_.KHR_DRACO_MESH_COMPRESSION] ? h = i(l) : h = Ie(new Ge(), l, t), n[u] = { primitive: l, promise: h }, s.push(h);
+      }
+    }
+    return Promise.all(s);
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes
+   * @param {number} meshIndex
+   * @return {Promise<Group|Mesh|SkinnedMesh>}
+   */
+  loadMesh(e) {
+    const t = this, r = this.json, n = this.extensions, i = r.meshes[e], s = i.primitives, a = [];
+    for (let o = 0, l = s.length; o < l; o++) {
+      const u = s[o].material === void 0 ? jn(this.cache) : this.getDependency("material", s[o].material);
+      a.push(u);
+    }
+    return a.push(t.loadGeometries(s)), Promise.all(a).then(function(o) {
+      const l = o.slice(0, o.length - 1), u = o[o.length - 1], d = [];
+      for (let f = 0, p = u.length; f < p; f++) {
+        const g = u[f], m = s[f];
+        let A;
+        const y = l[f];
+        if (m.mode === R.TRIANGLES || m.mode === R.TRIANGLE_STRIP || m.mode === R.TRIANGLE_FAN || m.mode === void 0)
+          A = i.isSkinnedMesh === !0 ? new Lt(g, y) : new bt(g, y), A.isSkinnedMesh === !0 && A.normalizeSkinWeights(), m.mode === R.TRIANGLE_STRIP ? A.geometry = ve(A.geometry, Be) : m.mode === R.TRIANGLE_FAN && (A.geometry = ve(A.geometry, ae));
+        else if (m.mode === R.LINES)
+          A = new vt(g, y);
+        else if (m.mode === R.LINE_STRIP)
+          A = new St(g, y);
+        else if (m.mode === R.LINE_LOOP)
+          A = new Mt(g, y);
+        else if (m.mode === R.POINTS)
+          A = new Ct(g, y);
+        else
+          throw new Error("THREE.GLTFLoader: Primitive mode unsupported: " + m.mode);
+        Object.keys(A.geometry.morphAttributes).length > 0 && Vn(A, i), A.name = t.createUniqueName(i.name || "mesh_" + e), S(A, i), m.extensions && D(n, A, m), t.assignFinalMaterial(A), d.push(A);
+      }
+      for (let f = 0, p = d.length; f < p; f++)
+        t.associations.set(d[f], {
+          meshes: e,
+          primitives: f
+        });
+      if (d.length === 1)
+        return i.extensions && D(n, d[0], i), d[0];
+      const h = new te();
+      i.extensions && D(n, h, i), t.associations.set(h, { meshes: e });
+      for (let f = 0, p = d.length; f < p; f++)
+        h.add(d[f]);
+      return h;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
+   * @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 It(Ot.radToDeg(n.yfov), n.aspectRatio || 1, n.znear || 1, n.zfar || 2e6) : r.type === "orthographic" && (t = new Nt(-n.xmag, n.xmag, n.ymag, -n.ymag, n.znear, n.zfar)), r.name && (t.name = this.createUniqueName(r.name)), S(t, r), Promise.resolve(t);
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
+   * @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 l = 0, u = s.length; l < u; l++) {
+        const d = s[l];
+        if (d) {
+          a.push(d);
+          const h = new W();
+          i !== null && h.fromArray(i.array, l * 16), o.push(h);
+        } else
+          console.warn('THREE.GLTFLoader: Joint "%s" could not be found.', t.joints[l]);
+      }
+      return new Pt(a, o);
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
+   * @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 = [], l = [], u = [];
+    for (let d = 0, h = n.channels.length; d < h; d++) {
+      const f = n.channels[d], p = n.samplers[f.sampler], g = f.target, m = g.node, A = n.parameters !== void 0 ? n.parameters[p.input] : p.input, y = n.parameters !== void 0 ? n.parameters[p.output] : p.output;
+      g.node !== void 0 && (s.push(this.getDependency("node", m)), a.push(this.getDependency("accessor", A)), o.push(this.getDependency("accessor", y)), l.push(p), u.push(g));
+    }
+    return Promise.all([
+      Promise.all(s),
+      Promise.all(a),
+      Promise.all(o),
+      Promise.all(l),
+      Promise.all(u)
+    ]).then(function(d) {
+      const h = d[0], f = d[1], p = d[2], g = d[3], m = d[4], A = [];
+      for (let y = 0, E = h.length; y < E; y++) {
+        const w = h[y], L = f[y], M = p[y], x = g[y], U = m[y];
+        if (w === void 0) continue;
+        w.updateMatrix && w.updateMatrix();
+        const C = r._createAnimationTracks(w, L, M, x, U);
+        if (C)
+          for (let J = 0; J < C.length; J++)
+            A.push(C[J]);
+      }
+      return new Dt(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, l = n.weights.length; o < l; o++)
+            a.morphTargetInfluences[o] = n.weights[o];
+      }), s;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
+   * @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 l = 0, u = a.length; l < u; l++)
+      s.push(r.getDependency("node", a[l]));
+    const o = n.skin === void 0 ? Promise.resolve(null) : r.getDependency("skin", n.skin);
+    return Promise.all([
+      i,
+      Promise.all(s),
+      o
+    ]).then(function(l) {
+      const u = l[0], d = l[1], h = l[2];
+      h !== null && u.traverse(function(f) {
+        f.isSkinnedMesh && f.bind(h, Xn);
+      });
+      for (let f = 0, p = d.length; f < p; f++)
+        u.add(d[f]);
+      return u;
+    });
+  }
+  // ._loadNodeShallow() parses a single node.
+  // skin and child nodes are created and added in .loadNode() (no '_' prefix).
+  _loadNodeShallow(e) {
+    const t = this.json, r = this.extensions, n = this;
+    if (this.nodeCache[e] !== void 0)
+      return this.nodeCache[e];
+    const i = t.nodes[e], s = i.name ? n.createUniqueName(i.name) : "", a = [], o = n._invokeOne(function(l) {
+      return l.createNodeMesh && l.createNodeMesh(e);
+    });
+    return o && a.push(o), i.camera !== void 0 && a.push(n.getDependency("camera", i.camera).then(function(l) {
+      return n._getNodeRef(n.cameraCache, i.camera, l);
+    })), n._invokeAll(function(l) {
+      return l.createNodeAttachment && l.createNodeAttachment(e);
+    }).forEach(function(l) {
+      a.push(l);
+    }), this.nodeCache[e] = Promise.all(a).then(function(l) {
+      let u;
+      if (i.isBone === !0 ? u = new kt() : l.length > 1 ? u = new te() : l.length === 1 ? u = l[0] : u = new Ve(), u !== l[0])
+        for (let d = 0, h = l.length; d < h; d++)
+          u.add(l[d]);
+      if (i.name && (u.userData.name = i.name, u.name = s), S(u, i), i.extensions && D(r, u, i), i.matrix !== void 0) {
+        const d = new W();
+        d.fromArray(i.matrix), u.applyMatrix4(d);
+      } else
+        i.translation !== void 0 && u.position.fromArray(i.translation), i.rotation !== void 0 && u.quaternion.fromArray(i.rotation), i.scale !== void 0 && u.scale.fromArray(i.scale);
+      return n.associations.has(u) || n.associations.set(u, {}), n.associations.get(u).nodes = e, u;
+    }), this.nodeCache[e];
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes
+   * @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)), S(i, r), r.extensions && D(t, i, r);
+    const s = r.nodes || [], a = [];
+    for (let o = 0, l = s.length; o < l; o++)
+      a.push(n.getDependency("node", s[o]));
+    return Promise.all(a).then(function(o) {
+      for (let u = 0, d = o.length; u < d; u++)
+        i.add(o[u]);
+      const l = (u) => {
+        const d = /* @__PURE__ */ new Map();
+        for (const [h, f] of n.associations)
+          (h instanceof ee || h instanceof Ee) && d.set(h, f);
+        return u.traverse((h) => {
+          const f = n.associations.get(h);
+          f != null && d.set(h, f);
+        }), d;
+      };
+      return n.associations = l(i), i;
+    });
+  }
+  _createAnimationTracks(e, t, r, n, i) {
+    const s = [], a = e.name ? e.name : e.uuid, o = [];
+    I[i.path] === I.weights ? e.traverse(function(h) {
+      h.morphTargetInfluences && o.push(h.name ? h.name : h.uuid);
+    }) : o.push(a);
+    let l;
+    switch (I[i.path]) {
+      case I.weights:
+        l = xe;
+        break;
+      case I.rotation:
+        l = Le;
+        break;
+      case I.position:
+      case I.scale:
+        l = Re;
+        break;
+      default:
+        switch (r.itemSize) {
+          case 1:
+            l = xe;
+            break;
+          case 2:
+          case 3:
+          default:
+            l = Re;
+            break;
+        }
+        break;
+    }
+    const u = n.interpolation !== void 0 ? Bn[n.interpolation] : qe, d = this._getArrayFromAccessor(r);
+    for (let h = 0, f = o.length; h < f; h++) {
+      const p = new l(
+        o[h] + "." + I[i.path],
+        t.array,
+        d,
+        u
+      );
+      n.interpolation === "CUBICSPLINE" && this._createCubicSplineTrackInterpolant(p), s.push(p);
+    }
+    return s;
+  }
+  _getArrayFromAccessor(e) {
+    let t = e.array;
+    if (e.normalized) {
+      const r = fe(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 Le ? Gn : Ze;
+      return new n(this.times, this.values, this.getValueSize() / 3, r);
+    }, e.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = !0;
+  }
+}
+function qn(c, e, t) {
+  const r = e.attributes, n = new Vt();
+  if (r.POSITION !== void 0) {
+    const a = t.json.accessors[r.POSITION], o = a.min, l = a.max;
+    if (o !== void 0 && l !== void 0) {
+      if (n.set(
+        new F(o[0], o[1], o[2]),
+        new F(l[0], l[1], l[2])
+      ), a.normalized) {
+        const u = fe(H[a.componentType]);
+        n.min.multiplyScalar(u), n.max.multiplyScalar(u);
+      }
+    } else {
+      console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      return;
+    }
+  } else
+    return;
+  const i = e.targets;
+  if (i !== void 0) {
+    const a = new F(), o = new F();
+    for (let l = 0, u = i.length; l < u; l++) {
+      const d = i[l];
+      if (d.POSITION !== void 0) {
+        const h = t.json.accessors[d.POSITION], f = h.min, p = h.max;
+        if (f !== void 0 && p !== void 0) {
+          if (o.setX(Math.max(Math.abs(f[0]), Math.abs(p[0]))), o.setY(Math.max(Math.abs(f[1]), Math.abs(p[1]))), o.setZ(Math.max(Math.abs(f[2]), Math.abs(p[2]))), h.normalized) {
+            const g = fe(H[h.componentType]);
+            o.multiplyScalar(g);
+          }
+          a.max(o);
+        } else
+          console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      }
+    }
+    n.expandByVector(a);
+  }
+  c.boundingBox = n;
+  const s = new zt();
+  n.getCenter(s.center), s.radius = n.min.distanceTo(n.max) / 2, c.boundingSphere = s;
+}
+function Ie(c, e, t) {
+  const r = e.attributes, n = [];
+  function i(s, a) {
+    return t.getDependency("accessor", s).then(function(o) {
+      c.setAttribute(a, o);
+    });
+  }
+  for (const s in r) {
+    const a = he[s] || s.toLowerCase();
+    a in c.attributes || n.push(i(r[s], a));
+  }
+  if (e.indices !== void 0 && !c.index) {
+    const s = t.getDependency("accessor", e.indices).then(function(a) {
+      c.setIndex(a);
+    });
+    n.push(s);
+  }
+  return oe.workingColorSpace !== b && "COLOR_0" in r && console.warn(`THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${oe.workingColorSpace}" not supported.`), S(c, e), qn(c, e, t), Promise.all(n).then(function() {
+    return e.targets !== void 0 ? Kn(c, e.targets, t) : c;
+  });
+}
+var Yn = Object.defineProperty, Qn = Object.getOwnPropertyDescriptor, Jn = (c, e, t, r) => {
+  for (var n = r > 1 ? void 0 : r ? Qn(e, t) : e, i = c.length - 1, s; i >= 0; i--)
+    (s = c[i]) && (n = (r ? s(e, t, n) : s(n)) || n);
+  return r && n && Yn(e, t, n), n;
+};
+let pe = class {
+  constructor() {
+    T(this, "loadingManager", new Xt());
+    T(this, "loaders", {});
+    T(this, "resources", []);
+    T(this, "items", {});
+    T(this, "toLoad", 0);
+    T(this, "loaded", 0);
+  }
+  get videoLoader() {
+    return {
+      load: (c, e) => {
+        let t = document.createElement("video");
+        t.muted = !0, t.loop = !0, t.controls = !1, t.playsInline = !0, t.src = c, t.autoplay = !0;
+        const r = () => {
+          if (!t) return;
+          t.play();
+          const n = new Yt(t), i = n.dispose.bind(n);
+          n.dispose = () => {
+            n.userData.element = void 0, t == null || t.remove(), t = void 0, i();
+          }, e(n), n.userData.element = t, t.removeEventListener("canplaythrough", r);
+        };
+        t.addEventListener("canplaythrough", r);
+      }
+    };
+  }
+  _setLoaders() {
+    this.loaders.gltfLoader = new mn(this.loadingManager), this.loaders.textureLoader = new ze(this.loadingManager), this.loaders.cubeTextureLoader = new Wt(this.loadingManager), this.loaders.audioLoader = new qt(this.loadingManager), this.loaders.videoLoader = this.videoLoader;
+  }
+  setResources(c) {
+    this.resources = c, this.toLoad = this.resources.length, this.loaded = 0;
+  }
+  init(c = []) {
+    this.resources = c, this._setLoaders();
+  }
+};
+pe = Jn([
+  Y(Q.ResolutionScoped)
+], pe);
+var Zn = Object.defineProperty, es = Object.getOwnPropertyDescriptor, ts = (c, e, t, r) => {
+  for (var n = r > 1 ? void 0 : r ? es(e, t) : e, i = c.length - 1, s; i >= 0; i--)
+    (s = c[i]) && (n = (r ? s(e, t, n) : s(n)) || n);
+  return r && n && Zn(e, t, n), n;
+}, Oe = (c, e) => (t, r) => e(t, r, c);
+let me = class {
+  constructor(c, e) {
+    this.controller = c, this.component = e, typeof self < "u" && (self.onmessage = (t) => {
+      var n;
+      const r = (n = t == null ? void 0 : t.data) == null ? void 0 : n.resources;
+      r && this.init(r);
+    });
+  }
+  _handleLoadedResource(c, e) {
+    this.component.items[c.name] = e, this.component.loaded++, this.controller.progress$$.next({
+      file: e,
+      resource: c,
+      loaded: this.component.loaded,
+      toLoad: this.component.toLoad
+    });
+  }
+  setDracoLoader(c, e = !0) {
+    this.component.loaders.dracoLoader = new un(
+      this.component.loadingManager
+    ), this.component.loaders.dracoLoader.setDecoderPath(c), e && this.component.loaders.gltfLoader && this.component.loaders.gltfLoader.setDRACOLoader(
+      this.component.loaders.dracoLoader
+    );
+  }
+  load() {
+    var e, t, r, n, i;
+    const c = this.component.resources[0];
+    if (c) {
+      this.controller.progress$$.next({
+        resource: c,
+        loaded: this.component.loaded,
+        toLoad: this.component.toLoad
+      });
+      for (const s of this.component.resources)
+        this.component.items[s.name] || (s.type === "gltfModel" && typeof s.path == "string" && ((e = this.component.loaders.gltfLoader) == null || e.load(
+          s.path,
+          (a) => this._handleLoadedResource(s, a)
+        )), s.type === "texture" && typeof s.path == "string" && ((t = this.component.loaders.textureLoader) == null || t.load(s.path, (a) => {
+          this._handleLoadedResource(s, new Qt(a));
+        })), s.type === "cubeTexture" && typeof s.path == "object" && ((r = this.component.loaders.cubeTextureLoader) == null || r.load(
+          s.path,
+          (a) => this._handleLoadedResource(s, a)
+        )), s.type === "video" && typeof s.path == "string" && ((n = this.component.loaders.videoLoader) == null || n.load(
+          s.path,
+          (a) => this._handleLoadedResource(s, a)
+        )), s.type === "audio" && typeof s.path == "string" && ((i = this.component.loaders.audioLoader) == null || i.load(
+          s.path,
+          (a) => {
+            this._handleLoadedResource(s, a);
+          }
+        )));
+    }
+  }
+  items() {
+    return this.component.items;
+  }
+  loaders() {
+    return this.component.loaders;
+  }
+  resources() {
+    return this.component.resources;
+  }
+  loaded() {
+    return this.component.loaded;
+  }
+  toLoad() {
+    return this.component.toLoad;
+  }
+  init(c = []) {
+    this.component.init(c);
+  }
+  dispose() {
+    this.controller.progress$$.complete();
+  }
+  progress$() {
+    return this.controller.progress$;
+  }
+  progressCompleted$() {
+    return this.controller.progressCompleted$;
+  }
+};
+me = ts([
+  Y(Q.ResolutionScoped),
+  Oe(0, k(de)),
+  Oe(1, k(pe))
+], me);
+const gs = De.resolve(me);
+var ns = Object.defineProperty, ss = Object.getOwnPropertyDescriptor, rs = (c, e, t, r) => {
+  for (var n = r > 1 ? void 0 : r ? ss(e, t) : e, i = c.length - 1, s; i >= 0; i--)
+    (s = c[i]) && (n = (r ? s(e, t, n) : s(n)) || n);
+  return r && n && ns(e, t, n), n;
+};
+let q = class {
+  constructor() {
+    T(this, "workerPool", at(void 0, !0));
+    T(this, "canvas");
+    T(this, "worker");
+    T(this, "thread");
+  }
+  init(c) {
+    this.worker = c.worker, this.thread = c.thread;
+  }
+};
+q = rs([
+  ke()
+], q);
+var is = Object.defineProperty, os = Object.getOwnPropertyDescriptor, as = (c, e, t, r) => {
+  for (var n = r > 1 ? void 0 : r ? os(e, t) : e, i = c.length - 1, s; i >= 0; i--)
+    (s = c[i]) && (n = (r ? s(e, t, n) : s(n)) || n);
+  return r && n && is(e, t, n), n;
+}, cs = (c, e) => (t, r) => e(t, r, c);
+let ge = class extends ct {
+  constructor(e) {
+    super();
+    T(this, "canvas");
+    this._service = e;
+  }
+  init(e) {
+    this.canvas = e;
+    for (const t of Fe) {
+      const r = t.startsWith("mouse") || t.startsWith("pointer") || t.startsWith("touch") ? this.mouseEventHandler : t.startsWith("key") ? this.keyEventHandler : t === "resize" ? this.uiEventHandler : t === "wheel" ? this.wheelEventHandler : this.preventDefaultHandler;
+      this[`${t}$`] = ue(
+        t === "resize" ? window : e,
+        t
+      ).pipe(
+        // @ts-ignore
+        Te(r.bind(this)),
+        Pe((n) => !(t === "keydown" && !n))
+      ), this[`${t}$`].subscribe((n) => {
+        var i, s;
+        (s = (i = this._service.thread) == null ? void 0 : i[t]) == null || s.call(i, n);
+      });
+    }
+  }
+  preventDefaultHandler(e) {
+    return e.preventDefault(), {
+      type: e.type
+    };
+  }
+  getScreenSizes() {
+    return {
+      width: this.canvas.width,
+      height: this.canvas.height,
+      windowWidth: (window == null ? void 0 : window.innerWidth) ?? 0,
+      windowHeight: (window == null ? void 0 : window.innerHeight) ?? 0
+    };
+  }
+  uiEventHandler(e) {
+    const t = this.canvas.getBoundingClientRect();
+    return {
+      ...this.getScreenSizes(),
+      type: e.type,
+      top: t.top,
+      left: t.left
+    };
+  }
+  mouseEventHandler(e) {
+    return {
+      ...this.getScreenSizes(),
+      ...Z(e, [
+        "ctrlKey",
+        "metaKey",
+        "shiftKey",
+        "button",
+        "pointerType",
+        "clientX",
+        "clientY",
+        "pageX",
+        "pageY"
+      ])
+    };
+  }
+  touchEventHandler(e) {
+    const t = [], r = { type: e.type, touches: t };
+    for (let n = 0; n < e.touches.length; ++n) {
+      const i = e.touches[n];
+      t.push({
+        pageX: (i == null ? void 0 : i.pageX) ?? 0,
+        pageY: (i == null ? void 0 : i.pageY) ?? 0
+      });
+    }
+    return { ...this.getScreenSizes(), ...r };
+  }
+  wheelEventHandler(e) {
+    return e.preventDefault(), {
+      ...this.getScreenSizes(),
+      ...Z(e, ["deltaX", "deltaY"])
+    };
+  }
+  keyEventHandler(e) {
+    if (lt.includes(e.code))
+      return e.preventDefault(), {
+        ...this.getScreenSizes(),
+        ...Z(e, ["ctrlKey", "metaKey", "shiftKey", "keyCode"])
+      };
+  }
+};
+ge = as([
+  ke(),
+  cs(0, k(q))
+], ge);
+var ls = Object.defineProperty, us = Object.getOwnPropertyDescriptor, ds = (c, e, t, r) => {
+  for (var n = r > 1 ? void 0 : r ? us(e, t) : e, i = c.length - 1, s; i >= 0; i--)
+    (s = c[i]) && (n = (r ? s(e, t, n) : s(n)) || n);
+  return r && n && ls(e, t, n), n;
+}, $ = (c, e) => (t, r) => e(t, r, c);
+let Ae = class extends Jt {
+  constructor(e, t, r, n) {
+    super();
+    T(this, "initialized", !1);
+    this._container = e, this._service = t, this._controller = r, this.registerProps = n, this.registerProps.initOnConstruct && this.init();
+  }
+  async _initCanvas() {
+    try {
+      if (this.registerProps.canvas instanceof HTMLCanvasElement && (this._service.canvas = this.registerProps.canvas), typeof this.registerProps.canvas == "string") {
+        const e = document.querySelector(
+          this.registerProps.canvas
+        );
+        e instanceof HTMLCanvasElement && (this._service.canvas = e);
+      }
+      this._service.canvas || (this._service.canvas = document.createElement("canvas"), this._service.canvas.dataset.reactive = "true", document.body.appendChild(this._service.canvas));
+    } catch (e) {
+      console.error(
+        `🛑 Unable to initialize the canvas:
+${e instanceof Error ? e.message : "Something went wrong"}`
+      );
+    }
+  }
+  async _initComponent() {
+    this._service.init({
+      worker: this._service.worker,
+      thread: this._service.thread
+    });
+  }
+  async _initController() {
+    var e, t;
+    if (!this._service.canvas)
+      throw new Error("Canvas element is not initialized.");
+    this._controller.init(this._service.canvas), !(!this._service.thread || !this._service.worker) && ((t = (e = this._service.thread) == null ? void 0 : e.resize) == null || t.call(e, {
+      ...this._controller.uiEventHandler({ type: "resize" })
+    }));
+  }
+  async _initWorkerThread() {
+    if (!this._service.canvas)
+      throw new Error("Canvas element is not initialized.");
+    const e = this._service.canvas.transferControlToOffscreen();
+    e.width = this._service.canvas.clientWidth, e.height = this._service.canvas.clientHeight;
+    const [t, r] = await this._service.workerPool.run({
+      payload: {
+        path: this.registerProps.location,
+        subject: {
+          ...ut(this.registerProps, [
+            "canvas",
+            "location",
+            "onReady"
+          ]),
+          canvas: e
+        },
+        transferSubject: [e]
+      }
+    });
+    if (!t || r)
+      throw new Error("Unable to retrieve the worker-thread info.");
+    this._service.worker = t.worker, this._service.thread = t.thread;
+  }
+  async _initObservableProxyEvents() {
+    Fe.forEach(
+      (e) => this[`${e}$`] = () => {
+        var t;
+        return (t = this._controller) == null ? void 0 : t[`${e}$`];
+      }
+    );
+  }
+  async init() {
+    var e, t;
+    await this._initCanvas(), await this._initWorkerThread(), await this._initComponent(), await this._initController(), await this._initObservableProxyEvents(), (t = (e = this.registerProps).onReady) == null || t.call(e, { module: this, container: this._container });
+  }
+  async loadResources(e) {
+    var n, i, s, a, o, l, u, d, h;
+    const [t, r] = await this._service.workerPool.run({
+      payload: {
+        path: "../loader/loader.module-worker.ts",
+        subject: {
+          resources: e.resources
+        }
+      }
+    });
+    if (!t || r)
+      throw new Error("Unable to retrieve worker thread info.");
+    return (n = t.thread) == null || n.progress$().subscribe((f) => {
+      var p;
+      (p = e.onProgress) == null || p.call(e, f);
+    }), (i = t.thread) == null || i.progressCompleted$().subscribe((f) => {
+      var p, g;
+      (p = e.onProgressComplete) == null || p.call(e, f), (e.disposeOnComplete || e.disposeOnComplete === void 0) && ((g = t.thread) == null || g.dispose());
+    }), (e.immediateLoad || e.immediateLoad === void 0) && await ((s = t.thread) == null ? void 0 : s.load()), {
+      ...t,
+      load: await ((a = t.thread) == null ? void 0 : a.load),
+      items: await ((o = t.thread) == null ? void 0 : o.items()),
+      loaders: await ((l = t.thread) == null ? void 0 : l.items()),
+      toLoad: await ((u = t.thread) == null ? void 0 : u.toLoad()),
+      loaded: await ((d = t.thread) == null ? void 0 : d.loaded()),
+      resources: await ((h = t.thread) == null ? void 0 : h.resources())
+    };
+  }
+  workerPool() {
+    return this._service.workerPool;
+  }
+  canvas() {
+    return this._service.canvas;
+  }
+  worker() {
+    return this._service.worker;
+  }
+  thread() {
+    return this._service.thread;
+  }
+  async dispose() {
+    var e;
+    await this._service.workerPool.terminateAll(), ((e = this._service.canvas) == null ? void 0 : e.dataset.reactive) === "true" && (this._service.canvas.remove(), this._service.canvas = void 0);
+  }
+};
+Ae = ds([
+  Y(Q.ContainerScoped),
+  $(0, k(He)),
+  $(1, k(q)),
+  $(2, k(ge)),
+  $(3, k(Ye))
+], Ae);
+const As = (c) => {
+  if (typeof (c == null ? void 0 : c.location) != "string" && !((c == null ? void 0 : c.location) instanceof URL))
+    throw new Error(
+      "Invalid register props detected. location path is required"
+    );
+  const e = De.createChildContainer();
+  c.initOnConstruct = V(c.initOnConstruct) || !z(c.initOnConstruct) ? !0 : c.initOnConstruct, c.defaultCamera = c != null && c.defaultCamera && c.defaultCamera in we ? c.defaultCamera : we.PERSPECTIVE, c.withMiniCamera = V(c.withMiniCamera) || !z(c.withMiniCamera) ? !1 : c.withMiniCamera, c.startTimer = V(c.startTimer) || !z(c.startTimer) ? !0 : c.startTimer, c.fullScreen = V(c.fullScreen) || !z(c.fullScreen) ? !0 : c.fullScreen, c.onReady = dt(c.onReady) ? c.onReady : void 0, e.register(He, { useValue: e }), e.register(Ye, { useValue: c });
+  const t = e.resolve(Ae);
+  return t.initialized = !0, {
+    container: e,
+    module: t
+  };
+};
+export {
+  ys as AppModule,
+  ws as AppProxyEventHandlersModel,
+  He as CONTAINER_TOKEN,
+  we as DefaultCameraType,
+  lt as KEYBOARD_EVENT_CODES,
+  ms as LaunchAppProps,
+  me as LoaderModule,
+  Fe as PROXY_EVENT_LISTENERS,
+  ct as ProxyEventHandlersModel,
+  Es as ProxyEventObservablesModel,
+  Rs as ProxyEventSubjectsModel,
+  Ae as RegisterModule,
+  Ye as RegisterPropsModel,
+  Jt as RegisterProxyEventHandlersModel,
+  gs as loaderModule,
+  As as register
+};