@quick-threejs/reactive 0.1.22 → 0.1.24

package/dist/main.mjs

@@ -0,0 +1,2834 @@
+var et = Object.defineProperty;
+var tt = (o, e, t) => e in o ? et(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
+var g = (o, e, t) => tt(o, typeof e != "symbol" ? e + "" : e, t);
+import { i as nt, a as K, L as we, b as $, s as ye, P as st, c as Fe, K as it, A as xe, R as Ee, D as ve } from "./app.module-Dg_0i25D.mjs";
+import { d as _s, f as Ts, g as xs, h as Es, e as vs } from "./app.module-Dg_0i25D.mjs";
+import { Loader as He, FileLoader as z, SRGBColorSpace as D, LinearSRGBColorSpace as R, BufferGeometry as Be, BufferAttribute as j, Color as O, ColorManagement as ae, TrianglesDrawMode as rt, TriangleFanDrawMode as le, TriangleStripDrawMode as Ge, LoaderUtils as U, SpotLight as ot, PointLight as at, DirectionalLight as lt, MeshBasicMaterial as G, MeshPhysicalMaterial as S, Vector2 as je, Matrix4 as X, Vector3 as N, Quaternion as Ue, InstancedMesh as ct, InstancedBufferAttribute as ht, Object3D as Ve, TextureLoader as dt, ImageBitmapLoader as Ke, InterleavedBuffer as ut, InterleavedBufferAttribute as pt, LinearFilter as ze, LinearMipmapLinearFilter as Xe, RepeatWrapping as ce, PointsMaterial as ft, Material as q, LineBasicMaterial as mt, MeshStandardMaterial as We, DoubleSide as gt, PropertyBinding as At, SkinnedMesh as bt, Mesh as wt, LineSegments as yt, Line as _t, LineLoop as Tt, Points as xt, Group as J, PerspectiveCamera as Et, MathUtils as vt, OrthographicCamera as Lt, Skeleton as Rt, AnimationClip as St, Bone as Ct, InterpolateLinear as Ye, NearestFilter as Mt, NearestMipmapNearestFilter as It, LinearMipmapNearestFilter as kt, NearestMipmapLinearFilter as Dt, ClampToEdgeWrapping as Ot, MirroredRepeatWrapping as Pt, InterpolateDiscrete as Nt, FrontSide as $t, Texture as Le, VectorKeyframeTrack as Re, NumberKeyframeTrack as Se, QuaternionKeyframeTrack as Ce, Box3 as Ft, Sphere as Ht, Interpolant as Bt, LoadingManager as Gt, CubeTextureLoader as jt, AudioLoader as Ut, VideoTexture as Vt, CanvasTexture as Kt } from "three";
+import { Subject as he, filter as qe, fromEvent as zt, map as Xt } from "rxjs";
+import { createWorkerPool as Wt, copyProperties as Q, excludeProperties as Yt, isUndefined as Z, isBoolean as ee, isFunction as qt } from "@quick-threejs/utils";
+import Me from "stats.js";
+function _e(o, e) {
+  return function(t) {
+    nt()(t), K.register(t, t, {
+      lifecycle: o
+    });
+  };
+}
+const te = /* @__PURE__ */ new WeakMap();
+class Jt extends He {
+  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, s, n) {
+    const r = new z(this.manager);
+    r.setPath(this.path), r.setResponseType("arraybuffer"), r.setRequestHeader(this.requestHeader), r.setWithCredentials(this.withCredentials), r.load(e, (i) => {
+      this.parse(i, t, n);
+    }, s, n);
+  }
+  parse(e, t, s = () => {
+  }) {
+    this.decodeDracoFile(e, t, null, null, D, s).catch(s);
+  }
+  decodeDracoFile(e, t, s, n, r = R, i = () => {
+  }) {
+    const l = {
+      attributeIDs: s || this.defaultAttributeIDs,
+      attributeTypes: n || this.defaultAttributeTypes,
+      useUniqueIDs: !!s,
+      vertexColorSpace: r
+    };
+    return this.decodeGeometry(e, l).then(t).catch(i);
+  }
+  decodeGeometry(e, t) {
+    const s = JSON.stringify(t);
+    if (te.has(e)) {
+      const a = te.get(e);
+      if (a.key === s)
+        return a.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 r = this.workerNextTaskID++, i = e.byteLength, l = this._getWorker(r, i).then((a) => (n = a, new Promise((c, h) => {
+      n._callbacks[r] = { resolve: c, reject: h }, n.postMessage({ type: "decode", id: r, taskConfig: t, buffer: e }, [e]);
+    }))).then((a) => this._createGeometry(a.geometry));
+    return l.catch(() => !0).then(() => {
+      n && r && this._releaseTask(n, r);
+    }), te.set(e, {
+      key: s,
+      promise: l
+    }), l;
+  }
+  _createGeometry(e) {
+    const t = new Be();
+    e.index && t.setIndex(new j(e.index.array, 1));
+    for (let s = 0; s < e.attributes.length; s++) {
+      const n = e.attributes[s], r = n.name, i = n.array, l = n.itemSize, a = new j(i, l);
+      r === "color" && (this._assignVertexColorSpace(a, n.vertexColorSpace), a.normalized = !(i instanceof Float32Array)), t.setAttribute(r, a);
+    }
+    return t;
+  }
+  _assignVertexColorSpace(e, t) {
+    if (t !== D) return;
+    const s = new O();
+    for (let n = 0, r = e.count; n < r; n++)
+      s.fromBufferAttribute(e, n), ae.toWorkingColorSpace(s, D), e.setXYZ(n, s.r, s.g, s.b);
+  }
+  _loadLibrary(e, t) {
+    const s = new z(this.manager);
+    return s.setPath(this.decoderPath), s.setResponseType(t), s.setWithCredentials(this.withCredentials), new Promise((n, r) => {
+      s.load(e, n, void 0, r);
+    });
+  }
+  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((s) => {
+      const n = s[0];
+      e || (this.decoderConfig.wasmBinary = s[1]);
+      const r = Qt.toString(), i = [
+        "/* draco decoder */",
+        n,
+        "",
+        "/* worker */",
+        r.substring(r.indexOf("{") + 1, r.lastIndexOf("}"))
+      ].join(`
+`);
+      this.workerSourceURL = URL.createObjectURL(new Blob([i]));
+    }), this.decoderPending;
+  }
+  _getWorker(e, t) {
+    return this._initDecoder().then(() => {
+      if (this.workerPool.length < this.workerLimit) {
+        const n = new Worker(this.workerSourceURL);
+        n._callbacks = {}, n._taskCosts = {}, n._taskLoad = 0, n.postMessage({ type: "init", decoderConfig: this.decoderConfig }), n.onmessage = function(r) {
+          const i = r.data;
+          switch (i.type) {
+            case "decode":
+              n._callbacks[i.id].resolve(i);
+              break;
+            case "error":
+              n._callbacks[i.id].reject(i);
+              break;
+            default:
+              console.error('THREE.DRACOLoader: Unexpected message, "' + i.type + '"');
+          }
+        }, this.workerPool.push(n);
+      } else
+        this.workerPool.sort(function(n, r) {
+          return n._taskLoad > r._taskLoad ? -1 : 1;
+        });
+      const s = this.workerPool[this.workerPool.length - 1];
+      return s._taskCosts[e] = t, s._taskLoad += t, s;
+    });
+  }
+  _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 Qt() {
+  let o, e;
+  onmessage = function(i) {
+    const l = i.data;
+    switch (l.type) {
+      case "init":
+        o = l.decoderConfig, e = new Promise(function(h) {
+          o.onModuleLoaded = function(d) {
+            h({ draco: d });
+          }, DracoDecoderModule(o);
+        });
+        break;
+      case "decode":
+        const a = l.buffer, c = l.taskConfig;
+        e.then((h) => {
+          const d = h.draco, u = new d.Decoder();
+          try {
+            const p = t(d, u, new Int8Array(a), c), f = p.attributes.map((b) => b.array.buffer);
+            p.index && f.push(p.index.array.buffer), self.postMessage({ type: "decode", id: l.id, geometry: p }, f);
+          } catch (p) {
+            console.error(p), self.postMessage({ type: "error", id: l.id, error: p.message });
+          } finally {
+            d.destroy(u);
+          }
+        });
+        break;
+    }
+  };
+  function t(i, l, a, c) {
+    const h = c.attributeIDs, d = c.attributeTypes;
+    let u, p;
+    const f = l.GetEncodedGeometryType(a);
+    if (f === i.TRIANGULAR_MESH)
+      u = new i.Mesh(), p = l.DecodeArrayToMesh(a, a.byteLength, u);
+    else if (f === i.POINT_CLOUD)
+      u = new i.PointCloud(), p = l.DecodeArrayToPointCloud(a, a.byteLength, u);
+    else
+      throw new Error("THREE.DRACOLoader: Unexpected geometry type.");
+    if (!p.ok() || u.ptr === 0)
+      throw new Error("THREE.DRACOLoader: Decoding failed: " + p.error_msg());
+    const b = { index: null, attributes: [] };
+    for (const m in h) {
+      const A = self[d[m]];
+      let y, T;
+      if (c.useUniqueIDs)
+        T = h[m], y = l.GetAttributeByUniqueId(u, T);
+      else {
+        if (T = l.GetAttributeId(u, i[h[m]]), T === -1) continue;
+        y = l.GetAttribute(u, T);
+      }
+      const _ = n(i, l, u, m, A, y);
+      m === "color" && (_.vertexColorSpace = c.vertexColorSpace), b.attributes.push(_);
+    }
+    return f === i.TRIANGULAR_MESH && (b.index = s(i, l, u)), i.destroy(u), b;
+  }
+  function s(i, l, a) {
+    const h = a.num_faces() * 3, d = h * 4, u = i._malloc(d);
+    l.GetTrianglesUInt32Array(a, d, u);
+    const p = new Uint32Array(i.HEAPF32.buffer, u, h).slice();
+    return i._free(u), { array: p, itemSize: 1 };
+  }
+  function n(i, l, a, c, h, d) {
+    const u = d.num_components(), f = a.num_points() * u, b = f * h.BYTES_PER_ELEMENT, m = r(i, h), A = i._malloc(b);
+    l.GetAttributeDataArrayForAllPoints(a, d, m, b, A);
+    const y = new h(i.HEAPF32.buffer, A, f).slice();
+    return i._free(A), {
+      name: c,
+      array: y,
+      itemSize: u
+    };
+  }
+  function r(i, l) {
+    switch (l) {
+      case Float32Array:
+        return i.DT_FLOAT32;
+      case Int8Array:
+        return i.DT_INT8;
+      case Int16Array:
+        return i.DT_INT16;
+      case Int32Array:
+        return i.DT_INT32;
+      case Uint8Array:
+        return i.DT_UINT8;
+      case Uint16Array:
+        return i.DT_UINT16;
+      case Uint32Array:
+        return i.DT_UINT32;
+    }
+  }
+}
+var Zt = Object.defineProperty, en = Object.getOwnPropertyDescriptor, tn = (o, e, t, s) => {
+  for (var n = s > 1 ? void 0 : s ? en(e, t) : e, r = o.length - 1, i; r >= 0; r--)
+    (i = o[r]) && (n = (s ? i(e, t, n) : i(n)) || n);
+  return s && n && Zt(e, t, n), n;
+};
+let de = class {
+  constructor() {
+    g(this, "lifecycle$$", new he());
+    g(this, "progress$$", new he());
+    g(this, "progress$", this.progress$$.pipe());
+    g(this, "lifecycle$", this.lifecycle$$.pipe());
+    g(this, "progressCompleted$", this.progress$.pipe(
+      qe((o) => o.toLoad === o.loaded)
+    ));
+  }
+};
+de = tn([
+  _e(we.ResolutionScoped)
+], de);
+function Ie(o, e) {
+  if (e === rt)
+    return console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles."), o;
+  if (e === le || e === Ge) {
+    let t = o.getIndex();
+    if (t === null) {
+      const i = [], l = o.getAttribute("position");
+      if (l !== void 0) {
+        for (let a = 0; a < l.count; a++)
+          i.push(a);
+        o.setIndex(i), t = o.getIndex();
+      } else
+        return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible."), o;
+    }
+    const s = t.count - 2, n = [];
+    if (e === le)
+      for (let i = 1; i <= s; i++)
+        n.push(t.getX(0)), n.push(t.getX(i)), n.push(t.getX(i + 1));
+    else
+      for (let i = 0; i < s; i++)
+        i % 2 === 0 ? (n.push(t.getX(i)), n.push(t.getX(i + 1)), n.push(t.getX(i + 2))) : (n.push(t.getX(i + 2)), n.push(t.getX(i + 1)), n.push(t.getX(i)));
+    n.length / 3 !== s && console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unable to generate correct amount of triangles.");
+    const r = o.clone();
+    return r.setIndex(n), r.clearGroups(), r;
+  } else
+    return console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unknown draw mode:", e), o;
+}
+class nn extends He {
+  constructor(e) {
+    super(e), this.dracoLoader = null, this.ktx2Loader = null, this.meshoptDecoder = null, this.pluginCallbacks = [], this.register(function(t) {
+      return new ln(t);
+    }), this.register(function(t) {
+      return new cn(t);
+    }), this.register(function(t) {
+      return new bn(t);
+    }), this.register(function(t) {
+      return new wn(t);
+    }), this.register(function(t) {
+      return new yn(t);
+    }), this.register(function(t) {
+      return new dn(t);
+    }), this.register(function(t) {
+      return new un(t);
+    }), this.register(function(t) {
+      return new pn(t);
+    }), this.register(function(t) {
+      return new fn(t);
+    }), this.register(function(t) {
+      return new an(t);
+    }), this.register(function(t) {
+      return new mn(t);
+    }), this.register(function(t) {
+      return new hn(t);
+    }), this.register(function(t) {
+      return new An(t);
+    }), this.register(function(t) {
+      return new gn(t);
+    }), this.register(function(t) {
+      return new rn(t);
+    }), this.register(function(t) {
+      return new _n(t);
+    }), this.register(function(t) {
+      return new Tn(t);
+    });
+  }
+  load(e, t, s, n) {
+    const r = this;
+    let i;
+    if (this.resourcePath !== "")
+      i = this.resourcePath;
+    else if (this.path !== "") {
+      const c = U.extractUrlBase(e);
+      i = U.resolveURL(c, this.path);
+    } else
+      i = U.extractUrlBase(e);
+    this.manager.itemStart(e);
+    const l = function(c) {
+      n ? n(c) : console.error(c), r.manager.itemError(e), r.manager.itemEnd(e);
+    }, a = new z(this.manager);
+    a.setPath(this.path), a.setResponseType("arraybuffer"), a.setRequestHeader(this.requestHeader), a.setWithCredentials(this.withCredentials), a.load(e, function(c) {
+      try {
+        r.parse(c, i, function(h) {
+          t(h), r.manager.itemEnd(e);
+        }, l);
+      } catch (h) {
+        l(h);
+      }
+    }, s, l);
+  }
+  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, s, n) {
+    let r;
+    const i = {}, l = {}, a = new TextDecoder();
+    if (typeof e == "string")
+      r = JSON.parse(e);
+    else if (e instanceof ArrayBuffer)
+      if (a.decode(new Uint8Array(e, 0, 4)) === Je) {
+        try {
+          i[w.KHR_BINARY_GLTF] = new xn(e);
+        } catch (d) {
+          n && n(d);
+          return;
+        }
+        r = JSON.parse(i[w.KHR_BINARY_GLTF].content);
+      } else
+        r = JSON.parse(a.decode(e));
+    else
+      r = e;
+    if (r.asset === void 0 || r.asset.version[0] < 2) {
+      n && n(new Error("THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported."));
+      return;
+    }
+    const c = new Nn(r, {
+      path: t || this.resourcePath || "",
+      crossOrigin: this.crossOrigin,
+      requestHeader: this.requestHeader,
+      manager: this.manager,
+      ktx2Loader: this.ktx2Loader,
+      meshoptDecoder: this.meshoptDecoder
+    });
+    c.fileLoader.setRequestHeader(this.requestHeader);
+    for (let h = 0; h < this.pluginCallbacks.length; h++) {
+      const d = this.pluginCallbacks[h](c);
+      d.name || console.error("THREE.GLTFLoader: Invalid plugin found: missing name"), l[d.name] = d, i[d.name] = !0;
+    }
+    if (r.extensionsUsed)
+      for (let h = 0; h < r.extensionsUsed.length; ++h) {
+        const d = r.extensionsUsed[h], u = r.extensionsRequired || [];
+        switch (d) {
+          case w.KHR_MATERIALS_UNLIT:
+            i[d] = new on();
+            break;
+          case w.KHR_DRACO_MESH_COMPRESSION:
+            i[d] = new En(r, this.dracoLoader);
+            break;
+          case w.KHR_TEXTURE_TRANSFORM:
+            i[d] = new vn();
+            break;
+          case w.KHR_MESH_QUANTIZATION:
+            i[d] = new Ln();
+            break;
+          default:
+            u.indexOf(d) >= 0 && l[d] === void 0 && console.warn('THREE.GLTFLoader: Unknown extension "' + d + '".');
+        }
+      }
+    c.setExtensions(i), c.setPlugins(l), c.parse(s, n);
+  }
+  parseAsync(e, t) {
+    const s = this;
+    return new Promise(function(n, r) {
+      s.parse(e, t, n, r);
+    });
+  }
+}
+function sn() {
+  let o = {};
+  return {
+    get: function(e) {
+      return o[e];
+    },
+    add: function(e, t) {
+      o[e] = t;
+    },
+    remove: function(e) {
+      delete o[e];
+    },
+    removeAll: function() {
+      o = {};
+    }
+  };
+}
+const w = {
+  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 rn {
+  constructor(e) {
+    this.parser = e, this.name = w.KHR_LIGHTS_PUNCTUAL, this.cache = { refs: {}, uses: {} };
+  }
+  _markDefs() {
+    const e = this.parser, t = this.parser.json.nodes || [];
+    for (let s = 0, n = t.length; s < n; s++) {
+      const r = t[s];
+      r.extensions && r.extensions[this.name] && r.extensions[this.name].light !== void 0 && e._addNodeRef(this.cache, r.extensions[this.name].light);
+    }
+  }
+  _loadLight(e) {
+    const t = this.parser, s = "light:" + e;
+    let n = t.cache.get(s);
+    if (n) return n;
+    const r = t.json, a = ((r.extensions && r.extensions[this.name] || {}).lights || [])[e];
+    let c;
+    const h = new O(16777215);
+    a.color !== void 0 && h.setRGB(a.color[0], a.color[1], a.color[2], R);
+    const d = a.range !== void 0 ? a.range : 0;
+    switch (a.type) {
+      case "directional":
+        c = new lt(h), c.target.position.set(0, 0, -1), c.add(c.target);
+        break;
+      case "point":
+        c = new at(h), c.distance = d;
+        break;
+      case "spot":
+        c = new ot(h), c.distance = d, a.spot = a.spot || {}, a.spot.innerConeAngle = a.spot.innerConeAngle !== void 0 ? a.spot.innerConeAngle : 0, a.spot.outerConeAngle = a.spot.outerConeAngle !== void 0 ? a.spot.outerConeAngle : Math.PI / 4, c.angle = a.spot.outerConeAngle, c.penumbra = 1 - a.spot.innerConeAngle / a.spot.outerConeAngle, c.target.position.set(0, 0, -1), c.add(c.target);
+        break;
+      default:
+        throw new Error("THREE.GLTFLoader: Unexpected light type: " + a.type);
+    }
+    return c.position.set(0, 0, 0), c.decay = 2, C(c, a), a.intensity !== void 0 && (c.intensity = a.intensity), c.name = t.createUniqueName(a.name || "light_" + e), n = Promise.resolve(c), t.cache.add(s, n), n;
+  }
+  getDependency(e, t) {
+    if (e === "light")
+      return this._loadLight(t);
+  }
+  createNodeAttachment(e) {
+    const t = this, s = this.parser, r = s.json.nodes[e], l = (r.extensions && r.extensions[this.name] || {}).light;
+    return l === void 0 ? null : this._loadLight(l).then(function(a) {
+      return s._getNodeRef(t.cache, l, a);
+    });
+  }
+}
+class on {
+  constructor() {
+    this.name = w.KHR_MATERIALS_UNLIT;
+  }
+  getMaterialType() {
+    return G;
+  }
+  extendParams(e, t, s) {
+    const n = [];
+    e.color = new O(1, 1, 1), e.opacity = 1;
+    const r = t.pbrMetallicRoughness;
+    if (r) {
+      if (Array.isArray(r.baseColorFactor)) {
+        const i = r.baseColorFactor;
+        e.color.setRGB(i[0], i[1], i[2], R), e.opacity = i[3];
+      }
+      r.baseColorTexture !== void 0 && n.push(s.assignTexture(e, "map", r.baseColorTexture, D));
+    }
+    return Promise.all(n);
+  }
+}
+class an {
+  constructor(e) {
+    this.parser = e, this.name = w.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 r = n.extensions[this.name].emissiveStrength;
+    return r !== void 0 && (t.emissiveIntensity = r), Promise.resolve();
+  }
+}
+class ln {
+  constructor(e) {
+    this.parser = e, this.name = w.KHR_MATERIALS_CLEARCOAT;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : S;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser, n = s.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = [], i = n.extensions[this.name];
+    if (i.clearcoatFactor !== void 0 && (t.clearcoat = i.clearcoatFactor), i.clearcoatTexture !== void 0 && r.push(s.assignTexture(t, "clearcoatMap", i.clearcoatTexture)), i.clearcoatRoughnessFactor !== void 0 && (t.clearcoatRoughness = i.clearcoatRoughnessFactor), i.clearcoatRoughnessTexture !== void 0 && r.push(s.assignTexture(t, "clearcoatRoughnessMap", i.clearcoatRoughnessTexture)), i.clearcoatNormalTexture !== void 0 && (r.push(s.assignTexture(t, "clearcoatNormalMap", i.clearcoatNormalTexture)), i.clearcoatNormalTexture.scale !== void 0)) {
+      const l = i.clearcoatNormalTexture.scale;
+      t.clearcoatNormalScale = new je(l, l);
+    }
+    return Promise.all(r);
+  }
+}
+class cn {
+  constructor(e) {
+    this.parser = e, this.name = w.KHR_MATERIALS_DISPERSION;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : S;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = n.extensions[this.name];
+    return t.dispersion = r.dispersion !== void 0 ? r.dispersion : 0, Promise.resolve();
+  }
+}
+class hn {
+  constructor(e) {
+    this.parser = e, this.name = w.KHR_MATERIALS_IRIDESCENCE;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : S;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser, n = s.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = [], i = n.extensions[this.name];
+    return i.iridescenceFactor !== void 0 && (t.iridescence = i.iridescenceFactor), i.iridescenceTexture !== void 0 && r.push(s.assignTexture(t, "iridescenceMap", i.iridescenceTexture)), i.iridescenceIor !== void 0 && (t.iridescenceIOR = i.iridescenceIor), t.iridescenceThicknessRange === void 0 && (t.iridescenceThicknessRange = [100, 400]), i.iridescenceThicknessMinimum !== void 0 && (t.iridescenceThicknessRange[0] = i.iridescenceThicknessMinimum), i.iridescenceThicknessMaximum !== void 0 && (t.iridescenceThicknessRange[1] = i.iridescenceThicknessMaximum), i.iridescenceThicknessTexture !== void 0 && r.push(s.assignTexture(t, "iridescenceThicknessMap", i.iridescenceThicknessTexture)), Promise.all(r);
+  }
+}
+class dn {
+  constructor(e) {
+    this.parser = e, this.name = w.KHR_MATERIALS_SHEEN;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : S;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser, n = s.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = [];
+    t.sheenColor = new O(0, 0, 0), t.sheenRoughness = 0, t.sheen = 1;
+    const i = n.extensions[this.name];
+    if (i.sheenColorFactor !== void 0) {
+      const l = i.sheenColorFactor;
+      t.sheenColor.setRGB(l[0], l[1], l[2], R);
+    }
+    return i.sheenRoughnessFactor !== void 0 && (t.sheenRoughness = i.sheenRoughnessFactor), i.sheenColorTexture !== void 0 && r.push(s.assignTexture(t, "sheenColorMap", i.sheenColorTexture, D)), i.sheenRoughnessTexture !== void 0 && r.push(s.assignTexture(t, "sheenRoughnessMap", i.sheenRoughnessTexture)), Promise.all(r);
+  }
+}
+class un {
+  constructor(e) {
+    this.parser = e, this.name = w.KHR_MATERIALS_TRANSMISSION;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : S;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser, n = s.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = [], i = n.extensions[this.name];
+    return i.transmissionFactor !== void 0 && (t.transmission = i.transmissionFactor), i.transmissionTexture !== void 0 && r.push(s.assignTexture(t, "transmissionMap", i.transmissionTexture)), Promise.all(r);
+  }
+}
+class pn {
+  constructor(e) {
+    this.parser = e, this.name = w.KHR_MATERIALS_VOLUME;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : S;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser, n = s.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = [], i = n.extensions[this.name];
+    t.thickness = i.thicknessFactor !== void 0 ? i.thicknessFactor : 0, i.thicknessTexture !== void 0 && r.push(s.assignTexture(t, "thicknessMap", i.thicknessTexture)), t.attenuationDistance = i.attenuationDistance || 1 / 0;
+    const l = i.attenuationColor || [1, 1, 1];
+    return t.attenuationColor = new O().setRGB(l[0], l[1], l[2], R), Promise.all(r);
+  }
+}
+class fn {
+  constructor(e) {
+    this.parser = e, this.name = w.KHR_MATERIALS_IOR;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : S;
+  }
+  extendMaterialParams(e, t) {
+    const n = this.parser.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = n.extensions[this.name];
+    return t.ior = r.ior !== void 0 ? r.ior : 1.5, Promise.resolve();
+  }
+}
+class mn {
+  constructor(e) {
+    this.parser = e, this.name = w.KHR_MATERIALS_SPECULAR;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : S;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser, n = s.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = [], i = n.extensions[this.name];
+    t.specularIntensity = i.specularFactor !== void 0 ? i.specularFactor : 1, i.specularTexture !== void 0 && r.push(s.assignTexture(t, "specularIntensityMap", i.specularTexture));
+    const l = i.specularColorFactor || [1, 1, 1];
+    return t.specularColor = new O().setRGB(l[0], l[1], l[2], R), i.specularColorTexture !== void 0 && r.push(s.assignTexture(t, "specularColorMap", i.specularColorTexture, D)), Promise.all(r);
+  }
+}
+class gn {
+  constructor(e) {
+    this.parser = e, this.name = w.EXT_MATERIALS_BUMP;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : S;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser, n = s.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = [], i = n.extensions[this.name];
+    return t.bumpScale = i.bumpFactor !== void 0 ? i.bumpFactor : 1, i.bumpTexture !== void 0 && r.push(s.assignTexture(t, "bumpMap", i.bumpTexture)), Promise.all(r);
+  }
+}
+class An {
+  constructor(e) {
+    this.parser = e, this.name = w.KHR_MATERIALS_ANISOTROPY;
+  }
+  getMaterialType(e) {
+    const s = this.parser.json.materials[e];
+    return !s.extensions || !s.extensions[this.name] ? null : S;
+  }
+  extendMaterialParams(e, t) {
+    const s = this.parser, n = s.json.materials[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return Promise.resolve();
+    const r = [], i = n.extensions[this.name];
+    return i.anisotropyStrength !== void 0 && (t.anisotropy = i.anisotropyStrength), i.anisotropyRotation !== void 0 && (t.anisotropyRotation = i.anisotropyRotation), i.anisotropyTexture !== void 0 && r.push(s.assignTexture(t, "anisotropyMap", i.anisotropyTexture)), Promise.all(r);
+  }
+}
+class bn {
+  constructor(e) {
+    this.parser = e, this.name = w.KHR_TEXTURE_BASISU;
+  }
+  loadTexture(e) {
+    const t = this.parser, s = t.json, n = s.textures[e];
+    if (!n.extensions || !n.extensions[this.name])
+      return null;
+    const r = n.extensions[this.name], i = t.options.ktx2Loader;
+    if (!i) {
+      if (s.extensionsRequired && s.extensionsRequired.indexOf(this.name) >= 0)
+        throw new Error("THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures");
+      return null;
+    }
+    return t.loadTextureImage(e, r.source, i);
+  }
+}
+class wn {
+  constructor(e) {
+    this.parser = e, this.name = w.EXT_TEXTURE_WEBP, this.isSupported = null;
+  }
+  loadTexture(e) {
+    const t = this.name, s = this.parser, n = s.json, r = n.textures[e];
+    if (!r.extensions || !r.extensions[t])
+      return null;
+    const i = r.extensions[t], l = n.images[i.source];
+    let a = s.textureLoader;
+    if (l.uri) {
+      const c = s.options.manager.getHandler(l.uri);
+      c !== null && (a = c);
+    }
+    return this.detectSupport().then(function(c) {
+      if (c) return s.loadTextureImage(e, i.source, a);
+      if (n.extensionsRequired && n.extensionsRequired.indexOf(t) >= 0)
+        throw new Error("THREE.GLTFLoader: WebP required by asset but unsupported.");
+      return s.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 yn {
+  constructor(e) {
+    this.parser = e, this.name = w.EXT_TEXTURE_AVIF, this.isSupported = null;
+  }
+  loadTexture(e) {
+    const t = this.name, s = this.parser, n = s.json, r = n.textures[e];
+    if (!r.extensions || !r.extensions[t])
+      return null;
+    const i = r.extensions[t], l = n.images[i.source];
+    let a = s.textureLoader;
+    if (l.uri) {
+      const c = s.options.manager.getHandler(l.uri);
+      c !== null && (a = c);
+    }
+    return this.detectSupport().then(function(c) {
+      if (c) return s.loadTextureImage(e, i.source, a);
+      if (n.extensionsRequired && n.extensionsRequired.indexOf(t) >= 0)
+        throw new Error("THREE.GLTFLoader: AVIF required by asset but unsupported.");
+      return s.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 _n {
+  constructor(e) {
+    this.name = w.EXT_MESHOPT_COMPRESSION, this.parser = e;
+  }
+  loadBufferView(e) {
+    const t = this.parser.json, s = t.bufferViews[e];
+    if (s.extensions && s.extensions[this.name]) {
+      const n = s.extensions[this.name], r = this.parser.getDependency("buffer", n.buffer), i = this.parser.options.meshoptDecoder;
+      if (!i || !i.supported) {
+        if (t.extensionsRequired && t.extensionsRequired.indexOf(this.name) >= 0)
+          throw new Error("THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files");
+        return null;
+      }
+      return r.then(function(l) {
+        const a = n.byteOffset || 0, c = n.byteLength || 0, h = n.count, d = n.byteStride, u = new Uint8Array(l, a, c);
+        return i.decodeGltfBufferAsync ? i.decodeGltfBufferAsync(h, d, u, n.mode, n.filter).then(function(p) {
+          return p.buffer;
+        }) : i.ready.then(function() {
+          const p = new ArrayBuffer(h * d);
+          return i.decodeGltfBuffer(new Uint8Array(p), h, d, u, n.mode, n.filter), p;
+        });
+      });
+    } else
+      return null;
+  }
+}
+class Tn {
+  constructor(e) {
+    this.name = w.EXT_MESH_GPU_INSTANCING, this.parser = e;
+  }
+  createNodeMesh(e) {
+    const t = this.parser.json, s = t.nodes[e];
+    if (!s.extensions || !s.extensions[this.name] || s.mesh === void 0)
+      return null;
+    const n = t.meshes[s.mesh];
+    for (const c of n.primitives)
+      if (c.mode !== x.TRIANGLES && c.mode !== x.TRIANGLE_STRIP && c.mode !== x.TRIANGLE_FAN && c.mode !== void 0)
+        return null;
+    const i = s.extensions[this.name].attributes, l = [], a = {};
+    for (const c in i)
+      l.push(this.parser.getDependency("accessor", i[c]).then((h) => (a[c] = h, a[c])));
+    return l.length < 1 ? null : (l.push(this.parser.createNodeMesh(e)), Promise.all(l).then((c) => {
+      const h = c.pop(), d = h.isGroup ? h.children : [h], u = c[0].count, p = [];
+      for (const f of d) {
+        const b = new X(), m = new N(), A = new Ue(), y = new N(1, 1, 1), T = new ct(f.geometry, f.material, u);
+        for (let _ = 0; _ < u; _++)
+          a.TRANSLATION && m.fromBufferAttribute(a.TRANSLATION, _), a.ROTATION && A.fromBufferAttribute(a.ROTATION, _), a.SCALE && y.fromBufferAttribute(a.SCALE, _), T.setMatrixAt(_, b.compose(m, A, y));
+        for (const _ in a)
+          if (_ === "_COLOR_0") {
+            const v = a[_];
+            T.instanceColor = new ht(v.array, v.itemSize, v.normalized);
+          } else _ !== "TRANSLATION" && _ !== "ROTATION" && _ !== "SCALE" && f.geometry.setAttribute(_, a[_]);
+        Ve.prototype.copy.call(T, f), this.parser.assignFinalMaterial(T), p.push(T);
+      }
+      return h.isGroup ? (h.clear(), h.add(...p), h) : p[0];
+    }));
+  }
+}
+const Je = "glTF", B = 12, ke = { JSON: 1313821514, BIN: 5130562 };
+class xn {
+  constructor(e) {
+    this.name = w.KHR_BINARY_GLTF, this.content = null, this.body = null;
+    const t = new DataView(e, 0, B), s = new TextDecoder();
+    if (this.header = {
+      magic: s.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 - B, r = new DataView(e, B);
+    let i = 0;
+    for (; i < n; ) {
+      const l = r.getUint32(i, !0);
+      i += 4;
+      const a = r.getUint32(i, !0);
+      if (i += 4, a === ke.JSON) {
+        const c = new Uint8Array(e, B + i, l);
+        this.content = s.decode(c);
+      } else if (a === ke.BIN) {
+        const c = B + i;
+        this.body = e.slice(c, c + l);
+      }
+      i += l;
+    }
+    if (this.content === null)
+      throw new Error("THREE.GLTFLoader: JSON content not found.");
+  }
+}
+class En {
+  constructor(e, t) {
+    if (!t)
+      throw new Error("THREE.GLTFLoader: No DRACOLoader instance provided.");
+    this.name = w.KHR_DRACO_MESH_COMPRESSION, this.json = e, this.dracoLoader = t, this.dracoLoader.preload();
+  }
+  decodePrimitive(e, t) {
+    const s = this.json, n = this.dracoLoader, r = e.extensions[this.name].bufferView, i = e.extensions[this.name].attributes, l = {}, a = {}, c = {};
+    for (const h in i) {
+      const d = ue[h] || h.toLowerCase();
+      l[d] = i[h];
+    }
+    for (const h in e.attributes) {
+      const d = ue[h] || h.toLowerCase();
+      if (i[h] !== void 0) {
+        const u = s.accessors[e.attributes[h]], p = F[u.componentType];
+        c[d] = p.name, a[d] = u.normalized === !0;
+      }
+    }
+    return t.getDependency("bufferView", r).then(function(h) {
+      return new Promise(function(d, u) {
+        n.decodeDracoFile(h, function(p) {
+          for (const f in p.attributes) {
+            const b = p.attributes[f], m = a[f];
+            m !== void 0 && (b.normalized = m);
+          }
+          d(p);
+        }, l, c, R, u);
+      });
+    });
+  }
+}
+class vn {
+  constructor() {
+    this.name = w.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 Ln {
+  constructor() {
+    this.name = w.KHR_MESH_QUANTIZATION;
+  }
+}
+class Qe extends Bt {
+  constructor(e, t, s, n) {
+    super(e, t, s, n);
+  }
+  copySampleValue_(e) {
+    const t = this.resultBuffer, s = this.sampleValues, n = this.valueSize, r = e * n * 3 + n;
+    for (let i = 0; i !== n; i++)
+      t[i] = s[r + i];
+    return t;
+  }
+  interpolate_(e, t, s, n) {
+    const r = this.resultBuffer, i = this.sampleValues, l = this.valueSize, a = l * 2, c = l * 3, h = n - t, d = (s - t) / h, u = d * d, p = u * d, f = e * c, b = f - c, m = -2 * p + 3 * u, A = p - u, y = 1 - m, T = A - u + d;
+    for (let _ = 0; _ !== l; _++) {
+      const v = i[b + _ + l], M = i[b + _ + a] * h, E = i[f + _ + l], H = i[f + _] * h;
+      r[_] = y * v + T * M + m * E + A * H;
+    }
+    return r;
+  }
+}
+const Rn = new Ue();
+class Sn extends Qe {
+  interpolate_(e, t, s, n) {
+    const r = super.interpolate_(e, t, s, n);
+    return Rn.fromArray(r).normalize().toArray(r), r;
+  }
+}
+const x = {
+  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
+}, F = {
+  5120: Int8Array,
+  5121: Uint8Array,
+  5122: Int16Array,
+  5123: Uint16Array,
+  5125: Uint32Array,
+  5126: Float32Array
+}, De = {
+  9728: Mt,
+  9729: ze,
+  9984: It,
+  9985: kt,
+  9986: Dt,
+  9987: Xe
+}, Oe = {
+  33071: Ot,
+  33648: Pt,
+  10497: ce
+}, ne = {
+  SCALAR: 1,
+  VEC2: 2,
+  VEC3: 3,
+  VEC4: 4,
+  MAT2: 4,
+  MAT3: 9,
+  MAT4: 16
+}, ue = {
+  POSITION: "position",
+  NORMAL: "normal",
+  TANGENT: "tangent",
+  TEXCOORD_0: "uv",
+  TEXCOORD_1: "uv1",
+  TEXCOORD_2: "uv2",
+  TEXCOORD_3: "uv3",
+  COLOR_0: "color",
+  WEIGHTS_0: "skinWeight",
+  JOINTS_0: "skinIndex"
+}, k = {
+  scale: "scale",
+  translation: "position",
+  rotation: "quaternion",
+  weights: "morphTargetInfluences"
+}, Cn = {
+  CUBICSPLINE: void 0,
+  // We use a custom interpolant (GLTFCubicSplineInterpolation) for CUBICSPLINE tracks. Each
+  // keyframe track will be initialized with a default interpolation type, then modified.
+  LINEAR: Ye,
+  STEP: Nt
+}, se = {
+  OPAQUE: "OPAQUE",
+  MASK: "MASK",
+  BLEND: "BLEND"
+};
+function Mn(o) {
+  return o.DefaultMaterial === void 0 && (o.DefaultMaterial = new We({
+    color: 16777215,
+    emissive: 0,
+    metalness: 1,
+    roughness: 1,
+    transparent: !1,
+    depthTest: !0,
+    side: $t
+  })), o.DefaultMaterial;
+}
+function P(o, e, t) {
+  for (const s in t.extensions)
+    o[s] === void 0 && (e.userData.gltfExtensions = e.userData.gltfExtensions || {}, e.userData.gltfExtensions[s] = t.extensions[s]);
+}
+function C(o, e) {
+  e.extras !== void 0 && (typeof e.extras == "object" ? Object.assign(o.userData, e.extras) : console.warn("THREE.GLTFLoader: Ignoring primitive type .extras, " + e.extras));
+}
+function In(o, e, t) {
+  let s = !1, n = !1, r = !1;
+  for (let c = 0, h = e.length; c < h; c++) {
+    const d = e[c];
+    if (d.POSITION !== void 0 && (s = !0), d.NORMAL !== void 0 && (n = !0), d.COLOR_0 !== void 0 && (r = !0), s && n && r) break;
+  }
+  if (!s && !n && !r) return Promise.resolve(o);
+  const i = [], l = [], a = [];
+  for (let c = 0, h = e.length; c < h; c++) {
+    const d = e[c];
+    if (s) {
+      const u = d.POSITION !== void 0 ? t.getDependency("accessor", d.POSITION) : o.attributes.position;
+      i.push(u);
+    }
+    if (n) {
+      const u = d.NORMAL !== void 0 ? t.getDependency("accessor", d.NORMAL) : o.attributes.normal;
+      l.push(u);
+    }
+    if (r) {
+      const u = d.COLOR_0 !== void 0 ? t.getDependency("accessor", d.COLOR_0) : o.attributes.color;
+      a.push(u);
+    }
+  }
+  return Promise.all([
+    Promise.all(i),
+    Promise.all(l),
+    Promise.all(a)
+  ]).then(function(c) {
+    const h = c[0], d = c[1], u = c[2];
+    return s && (o.morphAttributes.position = h), n && (o.morphAttributes.normal = d), r && (o.morphAttributes.color = u), o.morphTargetsRelative = !0, o;
+  });
+}
+function kn(o, e) {
+  if (o.updateMorphTargets(), e.weights !== void 0)
+    for (let t = 0, s = e.weights.length; t < s; t++)
+      o.morphTargetInfluences[t] = e.weights[t];
+  if (e.extras && Array.isArray(e.extras.targetNames)) {
+    const t = e.extras.targetNames;
+    if (o.morphTargetInfluences.length === t.length) {
+      o.morphTargetDictionary = {};
+      for (let s = 0, n = t.length; s < n; s++)
+        o.morphTargetDictionary[t[s]] = s;
+    } else
+      console.warn("THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.");
+  }
+}
+function Dn(o) {
+  let e;
+  const t = o.extensions && o.extensions[w.KHR_DRACO_MESH_COMPRESSION];
+  if (t ? e = "draco:" + t.bufferView + ":" + t.indices + ":" + ie(t.attributes) : e = o.indices + ":" + ie(o.attributes) + ":" + o.mode, o.targets !== void 0)
+    for (let s = 0, n = o.targets.length; s < n; s++)
+      e += ":" + ie(o.targets[s]);
+  return e;
+}
+function ie(o) {
+  let e = "";
+  const t = Object.keys(o).sort();
+  for (let s = 0, n = t.length; s < n; s++)
+    e += t[s] + ":" + o[t[s]] + ";";
+  return e;
+}
+function pe(o) {
+  switch (o) {
+    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 On(o) {
+  return o.search(/\.jpe?g($|\?)/i) > 0 || o.search(/^data\:image\/jpeg/) === 0 ? "image/jpeg" : o.search(/\.webp($|\?)/i) > 0 || o.search(/^data\:image\/webp/) === 0 ? "image/webp" : "image/png";
+}
+const Pn = new X();
+class Nn {
+  constructor(e = {}, t = {}) {
+    this.json = e, this.extensions = {}, this.plugins = {}, this.options = t, this.cache = new sn(), 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 s = !1, n = -1, r = !1, i = -1;
+    if (typeof navigator < "u") {
+      const l = navigator.userAgent;
+      s = /^((?!chrome|android).)*safari/i.test(l) === !0;
+      const a = l.match(/Version\/(\d+)/);
+      n = s && a ? parseInt(a[1], 10) : -1, r = l.indexOf("Firefox") > -1, i = r ? l.match(/Firefox\/([0-9]+)\./)[1] : -1;
+    }
+    typeof createImageBitmap > "u" || s && n < 17 || r && i < 98 ? this.textureLoader = new dt(this.options.manager) : this.textureLoader = new Ke(this.options.manager), this.textureLoader.setCrossOrigin(this.options.crossOrigin), this.textureLoader.setRequestHeader(this.options.requestHeader), this.fileLoader = new z(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 s = this, n = this.json, r = this.extensions;
+    this.cache.removeAll(), this.nodeCache = {}, this._invokeAll(function(i) {
+      return i._markDefs && i._markDefs();
+    }), Promise.all(this._invokeAll(function(i) {
+      return i.beforeRoot && i.beforeRoot();
+    })).then(function() {
+      return Promise.all([
+        s.getDependencies("scene"),
+        s.getDependencies("animation"),
+        s.getDependencies("camera")
+      ]);
+    }).then(function(i) {
+      const l = {
+        scene: i[0][n.scene || 0],
+        scenes: i[0],
+        animations: i[1],
+        cameras: i[2],
+        asset: n.asset,
+        parser: s,
+        userData: {}
+      };
+      return P(r, l, n), C(l, n), Promise.all(s._invokeAll(function(a) {
+        return a.afterRoot && a.afterRoot(l);
+      })).then(function() {
+        for (const a of l.scenes)
+          a.updateMatrixWorld();
+        e(l);
+      });
+    }).catch(t);
+  }
+  /**
+   * Marks the special nodes/meshes in json for efficient parse.
+   */
+  _markDefs() {
+    const e = this.json.nodes || [], t = this.json.skins || [], s = this.json.meshes || [];
+    for (let n = 0, r = t.length; n < r; n++) {
+      const i = t[n].joints;
+      for (let l = 0, a = i.length; l < a; l++)
+        e[i[l]].isBone = !0;
+    }
+    for (let n = 0, r = e.length; n < r; n++) {
+      const i = e[n];
+      i.mesh !== void 0 && (this._addNodeRef(this.meshCache, i.mesh), i.skin !== void 0 && (s[i.mesh].isSkinnedMesh = !0)), i.camera !== void 0 && this._addNodeRef(this.cameraCache, i.camera);
+    }
+  }
+  /**
+   * Counts references to shared node / Object3D resources. These resources
+   * can be reused, or "instantiated", at multiple nodes in the scene
+   * hierarchy. Mesh, Camera, and Light instances are instantiated and must
+   * be marked. Non-scenegraph resources (like Materials, Geometries, and
+   * Textures) can be reused directly and are not marked here.
+   *
+   * Example: CesiumMilkTruck sample model reuses "Wheel" meshes.
+   */
+  _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, s) {
+    if (e.refs[t] <= 1) return s;
+    const n = s.clone(), r = (i, l) => {
+      const a = this.associations.get(i);
+      a != null && this.associations.set(l, a);
+      for (const [c, h] of i.children.entries())
+        r(h, l.children[c]);
+    };
+    return r(s, n), n.name += "_instance_" + e.uses[t]++, n;
+  }
+  _invokeOne(e) {
+    const t = Object.values(this.plugins);
+    t.push(this);
+    for (let s = 0; s < t.length; s++) {
+      const n = e(t[s]);
+      if (n) return n;
+    }
+    return null;
+  }
+  _invokeAll(e) {
+    const t = Object.values(this.plugins);
+    t.unshift(this);
+    const s = [];
+    for (let n = 0; n < t.length; n++) {
+      const r = e(t[n]);
+      r && s.push(r);
+    }
+    return s;
+  }
+  /**
+   * 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 s = e + ":" + t;
+    let n = this.cache.get(s);
+    if (!n) {
+      switch (e) {
+        case "scene":
+          n = this.loadScene(t);
+          break;
+        case "node":
+          n = this._invokeOne(function(r) {
+            return r.loadNode && r.loadNode(t);
+          });
+          break;
+        case "mesh":
+          n = this._invokeOne(function(r) {
+            return r.loadMesh && r.loadMesh(t);
+          });
+          break;
+        case "accessor":
+          n = this.loadAccessor(t);
+          break;
+        case "bufferView":
+          n = this._invokeOne(function(r) {
+            return r.loadBufferView && r.loadBufferView(t);
+          });
+          break;
+        case "buffer":
+          n = this.loadBuffer(t);
+          break;
+        case "material":
+          n = this._invokeOne(function(r) {
+            return r.loadMaterial && r.loadMaterial(t);
+          });
+          break;
+        case "texture":
+          n = this._invokeOne(function(r) {
+            return r.loadTexture && r.loadTexture(t);
+          });
+          break;
+        case "skin":
+          n = this.loadSkin(t);
+          break;
+        case "animation":
+          n = this._invokeOne(function(r) {
+            return r.loadAnimation && r.loadAnimation(t);
+          });
+          break;
+        case "camera":
+          n = this.loadCamera(t);
+          break;
+        default:
+          if (n = this._invokeOne(function(r) {
+            return r != this && r.getDependency && r.getDependency(e, t);
+          }), !n)
+            throw new Error("Unknown type: " + e);
+          break;
+      }
+      this.cache.add(s, 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 s = this, n = this.json[e + (e === "mesh" ? "es" : "s")] || [];
+      t = Promise.all(n.map(function(r, i) {
+        return s.getDependency(e, i);
+      })), this.cache.add(e, t);
+    }
+    return t;
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
+   * @param {number} bufferIndex
+   * @return {Promise<ArrayBuffer>}
+   */
+  loadBuffer(e) {
+    const t = this.json.buffers[e], s = 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[w.KHR_BINARY_GLTF].body);
+    const n = this.options;
+    return new Promise(function(r, i) {
+      s.load(U.resolveURL(t.uri, n.path), r, void 0, function() {
+        i(new Error('THREE.GLTFLoader: Failed to load buffer "' + t.uri + '".'));
+      });
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
+   * @param {number} bufferViewIndex
+   * @return {Promise<ArrayBuffer>}
+   */
+  loadBufferView(e) {
+    const t = this.json.bufferViews[e];
+    return this.getDependency("buffer", t.buffer).then(function(s) {
+      const n = t.byteLength || 0, r = t.byteOffset || 0;
+      return s.slice(r, r + 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, s = this.json, n = this.json.accessors[e];
+    if (n.bufferView === void 0 && n.sparse === void 0) {
+      const i = ne[n.type], l = F[n.componentType], a = n.normalized === !0, c = new l(n.count * i);
+      return Promise.resolve(new j(c, i, a));
+    }
+    const r = [];
+    return n.bufferView !== void 0 ? r.push(this.getDependency("bufferView", n.bufferView)) : r.push(null), n.sparse !== void 0 && (r.push(this.getDependency("bufferView", n.sparse.indices.bufferView)), r.push(this.getDependency("bufferView", n.sparse.values.bufferView))), Promise.all(r).then(function(i) {
+      const l = i[0], a = ne[n.type], c = F[n.componentType], h = c.BYTES_PER_ELEMENT, d = h * a, u = n.byteOffset || 0, p = n.bufferView !== void 0 ? s.bufferViews[n.bufferView].byteStride : void 0, f = n.normalized === !0;
+      let b, m;
+      if (p && p !== d) {
+        const A = Math.floor(u / p), y = "InterleavedBuffer:" + n.bufferView + ":" + n.componentType + ":" + A + ":" + n.count;
+        let T = t.cache.get(y);
+        T || (b = new c(l, A * p, n.count * p / h), T = new ut(b, p / h), t.cache.add(y, T)), m = new pt(T, a, u % p / h, f);
+      } else
+        l === null ? b = new c(n.count * a) : b = new c(l, u, n.count * a), m = new j(b, a, f);
+      if (n.sparse !== void 0) {
+        const A = ne.SCALAR, y = F[n.sparse.indices.componentType], T = n.sparse.indices.byteOffset || 0, _ = n.sparse.values.byteOffset || 0, v = new y(i[1], T, n.sparse.count * A), M = new c(i[2], _, n.sparse.count * a);
+        l !== null && (m = new j(m.array.slice(), m.itemSize, m.normalized)), m.normalized = !1;
+        for (let E = 0, H = v.length; E < H; E++) {
+          const I = v[E];
+          if (m.setX(I, M[E * a]), a >= 2 && m.setY(I, M[E * a + 1]), a >= 3 && m.setZ(I, M[E * a + 2]), a >= 4 && m.setW(I, M[E * a + 3]), a >= 5) throw new Error("THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.");
+        }
+        m.normalized = f;
+      }
+      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, s = this.options, r = t.textures[e].source, i = t.images[r];
+    let l = this.textureLoader;
+    if (i.uri) {
+      const a = s.manager.getHandler(i.uri);
+      a !== null && (l = a);
+    }
+    return this.loadTextureImage(e, r, l);
+  }
+  loadTextureImage(e, t, s) {
+    const n = this, r = this.json, i = r.textures[e], l = r.images[t], a = (l.uri || l.bufferView) + ":" + i.sampler;
+    if (this.textureCache[a])
+      return this.textureCache[a];
+    const c = this.loadImageSource(t, s).then(function(h) {
+      h.flipY = !1, h.name = i.name || l.name || "", h.name === "" && typeof l.uri == "string" && l.uri.startsWith("data:image/") === !1 && (h.name = l.uri);
+      const u = (r.samplers || {})[i.sampler] || {};
+      return h.magFilter = De[u.magFilter] || ze, h.minFilter = De[u.minFilter] || Xe, h.wrapS = Oe[u.wrapS] || ce, h.wrapT = Oe[u.wrapT] || ce, n.associations.set(h, { textures: e }), h;
+    }).catch(function() {
+      return null;
+    });
+    return this.textureCache[a] = c, c;
+  }
+  loadImageSource(e, t) {
+    const s = this, n = this.json, r = this.options;
+    if (this.sourceCache[e] !== void 0)
+      return this.sourceCache[e].then((d) => d.clone());
+    const i = n.images[e], l = self.URL || self.webkitURL;
+    let a = i.uri || "", c = !1;
+    if (i.bufferView !== void 0)
+      a = s.getDependency("bufferView", i.bufferView).then(function(d) {
+        c = !0;
+        const u = new Blob([d], { type: i.mimeType });
+        return a = l.createObjectURL(u), a;
+      });
+    else if (i.uri === void 0)
+      throw new Error("THREE.GLTFLoader: Image " + e + " is missing URI and bufferView");
+    const h = Promise.resolve(a).then(function(d) {
+      return new Promise(function(u, p) {
+        let f = u;
+        t.isImageBitmapLoader === !0 && (f = function(b) {
+          const m = new Le(b);
+          m.needsUpdate = !0, u(m);
+        }), t.load(U.resolveURL(d, r.path), f, void 0, p);
+      });
+    }).then(function(d) {
+      return c === !0 && l.revokeObjectURL(a), C(d, i), d.userData.mimeType = i.mimeType || On(i.uri), d;
+    }).catch(function(d) {
+      throw console.error("THREE.GLTFLoader: Couldn't load texture", a), d;
+    });
+    return this.sourceCache[e] = h, h;
+  }
+  /**
+   * Asynchronously assigns a texture to the given material parameters.
+   * @param {Object} materialParams
+   * @param {string} mapName
+   * @param {Object} mapDef
+   * @return {Promise<Texture>}
+   */
+  assignTexture(e, t, s, n) {
+    const r = this;
+    return this.getDependency("texture", s.index).then(function(i) {
+      if (!i) return null;
+      if (s.texCoord !== void 0 && s.texCoord > 0 && (i = i.clone(), i.channel = s.texCoord), r.extensions[w.KHR_TEXTURE_TRANSFORM]) {
+        const l = s.extensions !== void 0 ? s.extensions[w.KHR_TEXTURE_TRANSFORM] : void 0;
+        if (l) {
+          const a = r.associations.get(i);
+          i = r.extensions[w.KHR_TEXTURE_TRANSFORM].extendTexture(i, l), r.associations.set(i, a);
+        }
+      }
+      return n !== void 0 && (i.colorSpace = n), e[t] = i, i;
+    });
+  }
+  /**
+   * Assigns final material to a Mesh, Line, or Points instance. The instance
+   * already has a material (generated from the glTF material options alone)
+   * but reuse of the same glTF material may require multiple threejs materials
+   * to accommodate different primitive types, defines, etc. New materials will
+   * be created if necessary, and reused from a cache.
+   * @param  {Object3D} mesh Mesh, Line, or Points instance.
+   */
+  assignFinalMaterial(e) {
+    const t = e.geometry;
+    let s = e.material;
+    const n = t.attributes.tangent === void 0, r = t.attributes.color !== void 0, i = t.attributes.normal === void 0;
+    if (e.isPoints) {
+      const l = "PointsMaterial:" + s.uuid;
+      let a = this.cache.get(l);
+      a || (a = new ft(), q.prototype.copy.call(a, s), a.color.copy(s.color), a.map = s.map, a.sizeAttenuation = !1, this.cache.add(l, a)), s = a;
+    } else if (e.isLine) {
+      const l = "LineBasicMaterial:" + s.uuid;
+      let a = this.cache.get(l);
+      a || (a = new mt(), q.prototype.copy.call(a, s), a.color.copy(s.color), a.map = s.map, this.cache.add(l, a)), s = a;
+    }
+    if (n || r || i) {
+      let l = "ClonedMaterial:" + s.uuid + ":";
+      n && (l += "derivative-tangents:"), r && (l += "vertex-colors:"), i && (l += "flat-shading:");
+      let a = this.cache.get(l);
+      a || (a = s.clone(), r && (a.vertexColors = !0), i && (a.flatShading = !0), n && (a.normalScale && (a.normalScale.y *= -1), a.clearcoatNormalScale && (a.clearcoatNormalScale.y *= -1)), this.cache.add(l, a), this.associations.set(a, this.associations.get(s))), s = a;
+    }
+    e.material = s;
+  }
+  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, s = this.json, n = this.extensions, r = s.materials[e];
+    let i;
+    const l = {}, a = r.extensions || {}, c = [];
+    if (a[w.KHR_MATERIALS_UNLIT]) {
+      const d = n[w.KHR_MATERIALS_UNLIT];
+      i = d.getMaterialType(), c.push(d.extendParams(l, r, t));
+    } else {
+      const d = r.pbrMetallicRoughness || {};
+      if (l.color = new O(1, 1, 1), l.opacity = 1, Array.isArray(d.baseColorFactor)) {
+        const u = d.baseColorFactor;
+        l.color.setRGB(u[0], u[1], u[2], R), l.opacity = u[3];
+      }
+      d.baseColorTexture !== void 0 && c.push(t.assignTexture(l, "map", d.baseColorTexture, D)), l.metalness = d.metallicFactor !== void 0 ? d.metallicFactor : 1, l.roughness = d.roughnessFactor !== void 0 ? d.roughnessFactor : 1, d.metallicRoughnessTexture !== void 0 && (c.push(t.assignTexture(l, "metalnessMap", d.metallicRoughnessTexture)), c.push(t.assignTexture(l, "roughnessMap", d.metallicRoughnessTexture))), i = this._invokeOne(function(u) {
+        return u.getMaterialType && u.getMaterialType(e);
+      }), c.push(Promise.all(this._invokeAll(function(u) {
+        return u.extendMaterialParams && u.extendMaterialParams(e, l);
+      })));
+    }
+    r.doubleSided === !0 && (l.side = gt);
+    const h = r.alphaMode || se.OPAQUE;
+    if (h === se.BLEND ? (l.transparent = !0, l.depthWrite = !1) : (l.transparent = !1, h === se.MASK && (l.alphaTest = r.alphaCutoff !== void 0 ? r.alphaCutoff : 0.5)), r.normalTexture !== void 0 && i !== G && (c.push(t.assignTexture(l, "normalMap", r.normalTexture)), l.normalScale = new je(1, 1), r.normalTexture.scale !== void 0)) {
+      const d = r.normalTexture.scale;
+      l.normalScale.set(d, d);
+    }
+    if (r.occlusionTexture !== void 0 && i !== G && (c.push(t.assignTexture(l, "aoMap", r.occlusionTexture)), r.occlusionTexture.strength !== void 0 && (l.aoMapIntensity = r.occlusionTexture.strength)), r.emissiveFactor !== void 0 && i !== G) {
+      const d = r.emissiveFactor;
+      l.emissive = new O().setRGB(d[0], d[1], d[2], R);
+    }
+    return r.emissiveTexture !== void 0 && i !== G && c.push(t.assignTexture(l, "emissiveMap", r.emissiveTexture, D)), Promise.all(c).then(function() {
+      const d = new i(l);
+      return r.name && (d.name = r.name), C(d, r), t.associations.set(d, { materials: e }), r.extensions && P(n, d, r), d;
+    });
+  }
+  /** When Object3D instances are targeted by animation, they need unique names. */
+  createUniqueName(e) {
+    const t = At.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, s = this.extensions, n = this.primitiveCache;
+    function r(l) {
+      return s[w.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(l, t).then(function(a) {
+        return Pe(a, l, t);
+      });
+    }
+    const i = [];
+    for (let l = 0, a = e.length; l < a; l++) {
+      const c = e[l], h = Dn(c), d = n[h];
+      if (d)
+        i.push(d.promise);
+      else {
+        let u;
+        c.extensions && c.extensions[w.KHR_DRACO_MESH_COMPRESSION] ? u = r(c) : u = Pe(new Be(), c, t), n[h] = { primitive: c, promise: u }, i.push(u);
+      }
+    }
+    return Promise.all(i);
+  }
+  /**
+   * 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, s = this.json, n = this.extensions, r = s.meshes[e], i = r.primitives, l = [];
+    for (let a = 0, c = i.length; a < c; a++) {
+      const h = i[a].material === void 0 ? Mn(this.cache) : this.getDependency("material", i[a].material);
+      l.push(h);
+    }
+    return l.push(t.loadGeometries(i)), Promise.all(l).then(function(a) {
+      const c = a.slice(0, a.length - 1), h = a[a.length - 1], d = [];
+      for (let p = 0, f = h.length; p < f; p++) {
+        const b = h[p], m = i[p];
+        let A;
+        const y = c[p];
+        if (m.mode === x.TRIANGLES || m.mode === x.TRIANGLE_STRIP || m.mode === x.TRIANGLE_FAN || m.mode === void 0)
+          A = r.isSkinnedMesh === !0 ? new bt(b, y) : new wt(b, y), A.isSkinnedMesh === !0 && A.normalizeSkinWeights(), m.mode === x.TRIANGLE_STRIP ? A.geometry = Ie(A.geometry, Ge) : m.mode === x.TRIANGLE_FAN && (A.geometry = Ie(A.geometry, le));
+        else if (m.mode === x.LINES)
+          A = new yt(b, y);
+        else if (m.mode === x.LINE_STRIP)
+          A = new _t(b, y);
+        else if (m.mode === x.LINE_LOOP)
+          A = new Tt(b, y);
+        else if (m.mode === x.POINTS)
+          A = new xt(b, y);
+        else
+          throw new Error("THREE.GLTFLoader: Primitive mode unsupported: " + m.mode);
+        Object.keys(A.geometry.morphAttributes).length > 0 && kn(A, r), A.name = t.createUniqueName(r.name || "mesh_" + e), C(A, r), m.extensions && P(n, A, m), t.assignFinalMaterial(A), d.push(A);
+      }
+      for (let p = 0, f = d.length; p < f; p++)
+        t.associations.set(d[p], {
+          meshes: e,
+          primitives: p
+        });
+      if (d.length === 1)
+        return r.extensions && P(n, d[0], r), d[0];
+      const u = new J();
+      r.extensions && P(n, u, r), t.associations.set(u, { meshes: e });
+      for (let p = 0, f = d.length; p < f; p++)
+        u.add(d[p]);
+      return u;
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
+   * @param {number} cameraIndex
+   * @return {Promise<THREE.Camera>}
+   */
+  loadCamera(e) {
+    let t;
+    const s = this.json.cameras[e], n = s[s.type];
+    if (!n) {
+      console.warn("THREE.GLTFLoader: Missing camera parameters.");
+      return;
+    }
+    return s.type === "perspective" ? t = new Et(vt.radToDeg(n.yfov), n.aspectRatio || 1, n.znear || 1, n.zfar || 2e6) : s.type === "orthographic" && (t = new Lt(-n.xmag, n.xmag, n.ymag, -n.ymag, n.znear, n.zfar)), s.name && (t.name = this.createUniqueName(s.name)), C(t, s), 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], s = [];
+    for (let n = 0, r = t.joints.length; n < r; n++)
+      s.push(this._loadNodeShallow(t.joints[n]));
+    return t.inverseBindMatrices !== void 0 ? s.push(this.getDependency("accessor", t.inverseBindMatrices)) : s.push(null), Promise.all(s).then(function(n) {
+      const r = n.pop(), i = n, l = [], a = [];
+      for (let c = 0, h = i.length; c < h; c++) {
+        const d = i[c];
+        if (d) {
+          l.push(d);
+          const u = new X();
+          r !== null && u.fromArray(r.array, c * 16), a.push(u);
+        } else
+          console.warn('THREE.GLTFLoader: Joint "%s" could not be found.', t.joints[c]);
+      }
+      return new Rt(l, a);
+    });
+  }
+  /**
+   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
+   * @param {number} animationIndex
+   * @return {Promise<AnimationClip>}
+   */
+  loadAnimation(e) {
+    const t = this.json, s = this, n = t.animations[e], r = n.name ? n.name : "animation_" + e, i = [], l = [], a = [], c = [], h = [];
+    for (let d = 0, u = n.channels.length; d < u; d++) {
+      const p = n.channels[d], f = n.samplers[p.sampler], b = p.target, m = b.node, A = n.parameters !== void 0 ? n.parameters[f.input] : f.input, y = n.parameters !== void 0 ? n.parameters[f.output] : f.output;
+      b.node !== void 0 && (i.push(this.getDependency("node", m)), l.push(this.getDependency("accessor", A)), a.push(this.getDependency("accessor", y)), c.push(f), h.push(b));
+    }
+    return Promise.all([
+      Promise.all(i),
+      Promise.all(l),
+      Promise.all(a),
+      Promise.all(c),
+      Promise.all(h)
+    ]).then(function(d) {
+      const u = d[0], p = d[1], f = d[2], b = d[3], m = d[4], A = [];
+      for (let y = 0, T = u.length; y < T; y++) {
+        const _ = u[y], v = p[y], M = f[y], E = b[y], H = m[y];
+        if (_ === void 0) continue;
+        _.updateMatrix && _.updateMatrix();
+        const I = s._createAnimationTracks(_, v, M, E, H);
+        if (I)
+          for (let Y = 0; Y < I.length; Y++)
+            A.push(I[Y]);
+      }
+      return new St(r, void 0, A);
+    });
+  }
+  createNodeMesh(e) {
+    const t = this.json, s = this, n = t.nodes[e];
+    return n.mesh === void 0 ? null : s.getDependency("mesh", n.mesh).then(function(r) {
+      const i = s._getNodeRef(s.meshCache, n.mesh, r);
+      return n.weights !== void 0 && i.traverse(function(l) {
+        if (l.isMesh)
+          for (let a = 0, c = n.weights.length; a < c; a++)
+            l.morphTargetInfluences[a] = n.weights[a];
+      }), i;
+    });
+  }
+  /**
+   * 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, s = this, n = t.nodes[e], r = s._loadNodeShallow(e), i = [], l = n.children || [];
+    for (let c = 0, h = l.length; c < h; c++)
+      i.push(s.getDependency("node", l[c]));
+    const a = n.skin === void 0 ? Promise.resolve(null) : s.getDependency("skin", n.skin);
+    return Promise.all([
+      r,
+      Promise.all(i),
+      a
+    ]).then(function(c) {
+      const h = c[0], d = c[1], u = c[2];
+      u !== null && h.traverse(function(p) {
+        p.isSkinnedMesh && p.bind(u, Pn);
+      });
+      for (let p = 0, f = d.length; p < f; p++)
+        h.add(d[p]);
+      return h;
+    });
+  }
+  // ._loadNodeShallow() parses a single node.
+  // skin and child nodes are created and added in .loadNode() (no '_' prefix).
+  _loadNodeShallow(e) {
+    const t = this.json, s = this.extensions, n = this;
+    if (this.nodeCache[e] !== void 0)
+      return this.nodeCache[e];
+    const r = t.nodes[e], i = r.name ? n.createUniqueName(r.name) : "", l = [], a = n._invokeOne(function(c) {
+      return c.createNodeMesh && c.createNodeMesh(e);
+    });
+    return a && l.push(a), r.camera !== void 0 && l.push(n.getDependency("camera", r.camera).then(function(c) {
+      return n._getNodeRef(n.cameraCache, r.camera, c);
+    })), n._invokeAll(function(c) {
+      return c.createNodeAttachment && c.createNodeAttachment(e);
+    }).forEach(function(c) {
+      l.push(c);
+    }), this.nodeCache[e] = Promise.all(l).then(function(c) {
+      let h;
+      if (r.isBone === !0 ? h = new Ct() : c.length > 1 ? h = new J() : c.length === 1 ? h = c[0] : h = new Ve(), h !== c[0])
+        for (let d = 0, u = c.length; d < u; d++)
+          h.add(c[d]);
+      if (r.name && (h.userData.name = r.name, h.name = i), C(h, r), r.extensions && P(s, h, r), r.matrix !== void 0) {
+        const d = new X();
+        d.fromArray(r.matrix), h.applyMatrix4(d);
+      } else
+        r.translation !== void 0 && h.position.fromArray(r.translation), r.rotation !== void 0 && h.quaternion.fromArray(r.rotation), r.scale !== void 0 && h.scale.fromArray(r.scale);
+      return n.associations.has(h) || n.associations.set(h, {}), n.associations.get(h).nodes = e, h;
+    }), 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, s = this.json.scenes[e], n = this, r = new J();
+    s.name && (r.name = n.createUniqueName(s.name)), C(r, s), s.extensions && P(t, r, s);
+    const i = s.nodes || [], l = [];
+    for (let a = 0, c = i.length; a < c; a++)
+      l.push(n.getDependency("node", i[a]));
+    return Promise.all(l).then(function(a) {
+      for (let h = 0, d = a.length; h < d; h++)
+        r.add(a[h]);
+      const c = (h) => {
+        const d = /* @__PURE__ */ new Map();
+        for (const [u, p] of n.associations)
+          (u instanceof q || u instanceof Le) && d.set(u, p);
+        return h.traverse((u) => {
+          const p = n.associations.get(u);
+          p != null && d.set(u, p);
+        }), d;
+      };
+      return n.associations = c(r), r;
+    });
+  }
+  _createAnimationTracks(e, t, s, n, r) {
+    const i = [], l = e.name ? e.name : e.uuid, a = [];
+    k[r.path] === k.weights ? e.traverse(function(u) {
+      u.morphTargetInfluences && a.push(u.name ? u.name : u.uuid);
+    }) : a.push(l);
+    let c;
+    switch (k[r.path]) {
+      case k.weights:
+        c = Se;
+        break;
+      case k.rotation:
+        c = Ce;
+        break;
+      case k.position:
+      case k.scale:
+        c = Re;
+        break;
+      default:
+        switch (s.itemSize) {
+          case 1:
+            c = Se;
+            break;
+          case 2:
+          case 3:
+          default:
+            c = Re;
+            break;
+        }
+        break;
+    }
+    const h = n.interpolation !== void 0 ? Cn[n.interpolation] : Ye, d = this._getArrayFromAccessor(s);
+    for (let u = 0, p = a.length; u < p; u++) {
+      const f = new c(
+        a[u] + "." + k[r.path],
+        t.array,
+        d,
+        h
+      );
+      n.interpolation === "CUBICSPLINE" && this._createCubicSplineTrackInterpolant(f), i.push(f);
+    }
+    return i;
+  }
+  _getArrayFromAccessor(e) {
+    let t = e.array;
+    if (e.normalized) {
+      const s = pe(t.constructor), n = new Float32Array(t.length);
+      for (let r = 0, i = t.length; r < i; r++)
+        n[r] = t[r] * s;
+      t = n;
+    }
+    return t;
+  }
+  _createCubicSplineTrackInterpolant(e) {
+    e.createInterpolant = function(s) {
+      const n = this instanceof Ce ? Sn : Qe;
+      return new n(this.times, this.values, this.getValueSize() / 3, s);
+    }, e.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = !0;
+  }
+}
+function $n(o, e, t) {
+  const s = e.attributes, n = new Ft();
+  if (s.POSITION !== void 0) {
+    const l = t.json.accessors[s.POSITION], a = l.min, c = l.max;
+    if (a !== void 0 && c !== void 0) {
+      if (n.set(
+        new N(a[0], a[1], a[2]),
+        new N(c[0], c[1], c[2])
+      ), l.normalized) {
+        const h = pe(F[l.componentType]);
+        n.min.multiplyScalar(h), n.max.multiplyScalar(h);
+      }
+    } else {
+      console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      return;
+    }
+  } else
+    return;
+  const r = e.targets;
+  if (r !== void 0) {
+    const l = new N(), a = new N();
+    for (let c = 0, h = r.length; c < h; c++) {
+      const d = r[c];
+      if (d.POSITION !== void 0) {
+        const u = t.json.accessors[d.POSITION], p = u.min, f = u.max;
+        if (p !== void 0 && f !== void 0) {
+          if (a.setX(Math.max(Math.abs(p[0]), Math.abs(f[0]))), a.setY(Math.max(Math.abs(p[1]), Math.abs(f[1]))), a.setZ(Math.max(Math.abs(p[2]), Math.abs(f[2]))), u.normalized) {
+            const b = pe(F[u.componentType]);
+            a.multiplyScalar(b);
+          }
+          l.max(a);
+        } else
+          console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
+      }
+    }
+    n.expandByVector(l);
+  }
+  o.boundingBox = n;
+  const i = new Ht();
+  n.getCenter(i.center), i.radius = n.min.distanceTo(n.max) / 2, o.boundingSphere = i;
+}
+function Pe(o, e, t) {
+  const s = e.attributes, n = [];
+  function r(i, l) {
+    return t.getDependency("accessor", i).then(function(a) {
+      o.setAttribute(l, a);
+    });
+  }
+  for (const i in s) {
+    const l = ue[i] || i.toLowerCase();
+    l in o.attributes || n.push(r(s[i], l));
+  }
+  if (e.indices !== void 0 && !o.index) {
+    const i = t.getDependency("accessor", e.indices).then(function(l) {
+      o.setIndex(l);
+    });
+    n.push(i);
+  }
+  return ae.workingColorSpace !== R && "COLOR_0" in s && console.warn(`THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${ae.workingColorSpace}" not supported.`), C(o, e), $n(o, e, t), Promise.all(n).then(function() {
+    return e.targets !== void 0 ? In(o, e.targets, t) : o;
+  });
+}
+var Fn = Object.defineProperty, Hn = Object.getOwnPropertyDescriptor, Bn = (o, e, t, s) => {
+  for (var n = s > 1 ? void 0 : s ? Hn(e, t) : e, r = o.length - 1, i; r >= 0; r--)
+    (i = o[r]) && (n = (s ? i(e, t, n) : i(n)) || n);
+  return s && n && Fn(e, t, n), n;
+};
+let fe = class {
+  constructor() {
+    g(this, "loadingManager", new Gt());
+    g(this, "loaders", {});
+    g(this, "resources", []);
+    g(this, "items", {});
+    g(this, "toLoad", 0);
+    g(this, "loaded", 0);
+  }
+  get videoLoader() {
+    return {
+      load: (o, e) => {
+        let t = document.createElement("video");
+        t.muted = !0, t.loop = !0, t.controls = !1, t.playsInline = !0, t.src = o, t.autoplay = !0;
+        const s = () => {
+          if (!t) return;
+          t.play();
+          const n = new Vt(t), r = n.dispose.bind(n);
+          n.dispose = () => {
+            n.userData.element = void 0, t == null || t.remove(), t = void 0, r();
+          }, e(n), n.userData.element = t, t.removeEventListener("canplaythrough", s);
+        };
+        t.addEventListener("canplaythrough", s);
+      }
+    };
+  }
+  _setLoaders() {
+    this.loaders.gltfLoader = new nn(this.loadingManager), this.loaders.textureLoader = new Ke(this.loadingManager), this.loaders.cubeTextureLoader = new jt(this.loadingManager), this.loaders.audioLoader = new Ut(this.loadingManager), this.loaders.videoLoader = this.videoLoader;
+  }
+  setResources(o) {
+    this.resources = o, this.toLoad = this.resources.length, this.loaded = 0;
+  }
+  init(o = []) {
+    this.resources = o, this._setLoaders();
+  }
+};
+fe = Bn([
+  _e(we.ResolutionScoped)
+], fe);
+var Gn = Object.defineProperty, jn = Object.getOwnPropertyDescriptor, Un = (o, e, t, s) => {
+  for (var n = s > 1 ? void 0 : s ? jn(e, t) : e, r = o.length - 1, i; r >= 0; r--)
+    (i = o[r]) && (n = (s ? i(e, t, n) : i(n)) || n);
+  return s && n && Gn(e, t, n), n;
+}, Ne = (o, e) => (t, s) => e(t, s, o);
+let me = class {
+  constructor(o, e) {
+    this.controller = o, this.component = e, typeof self < "u" && (self.onmessage = (t) => {
+      var n;
+      const s = (n = t == null ? void 0 : t.data) == null ? void 0 : n.resources;
+      s && this.init(s);
+    });
+  }
+  _handleLoadedResource(o, e) {
+    this.component.items[o.name] = e, this.component.loaded++, this.controller.progress$$.next({
+      file: e,
+      resource: o,
+      loaded: this.component.loaded,
+      toLoad: this.component.toLoad
+    });
+  }
+  setDracoLoader(o, e = !0) {
+    this.component.loaders.dracoLoader = new Jt(
+      this.component.loadingManager
+    ), this.component.loaders.dracoLoader.setDecoderPath(o), e && this.component.loaders.gltfLoader && this.component.loaders.gltfLoader.setDRACOLoader(
+      this.component.loaders.dracoLoader
+    );
+  }
+  load() {
+    var e, t, s, n, r;
+    const o = this.component.resources[0];
+    if (o) {
+      this.controller.progress$$.next({
+        resource: o,
+        loaded: this.component.loaded,
+        toLoad: this.component.toLoad
+      });
+      for (const i of this.component.resources)
+        this.component.items[i.name] || (i.type === "gltfModel" && typeof i.path == "string" && ((e = this.component.loaders.gltfLoader) == null || e.load(
+          i.path,
+          (l) => this._handleLoadedResource(i, l)
+        )), i.type === "texture" && typeof i.path == "string" && ((t = this.component.loaders.textureLoader) == null || t.load(i.path, (l) => {
+          this._handleLoadedResource(i, new Kt(l));
+        })), i.type === "cubeTexture" && typeof i.path == "object" && ((s = this.component.loaders.cubeTextureLoader) == null || s.load(
+          i.path,
+          (l) => this._handleLoadedResource(i, l)
+        )), i.type === "video" && typeof i.path == "string" && ((n = this.component.loaders.videoLoader) == null || n.load(
+          i.path,
+          (l) => this._handleLoadedResource(i, l)
+        )), i.type === "audio" && typeof i.path == "string" && ((r = this.component.loaders.audioLoader) == null || r.load(
+          i.path,
+          (l) => {
+            this._handleLoadedResource(i, l);
+          }
+        )));
+    }
+  }
+  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(o = []) {
+    this.component.init(o);
+  }
+  dispose() {
+    this.controller.lifecycle$$.complete(), this.controller.progress$$.complete();
+  }
+  lifecycle$() {
+    return this.controller.lifecycle$;
+  }
+  progress$() {
+    return this.controller.progress$;
+  }
+  progressCompleted$() {
+    return this.controller.progressCompleted$;
+  }
+};
+me = Un([
+  _e(we.ResolutionScoped),
+  Ne(0, $(de)),
+  Ne(1, $(fe))
+], me);
+const gs = K.resolve(me);
+/**
+ * lil-gui
+ * https://lil-gui.georgealways.com
+ * @version 0.17.0
+ * @author George Michael Brower
+ * @license MIT
+ */
+class L {
+  constructor(e, t, s, n, r = "div") {
+    this.parent = e, this.object = t, this.property = s, this._disabled = !1, this._hidden = !1, this.initialValue = this.getValue(), this.domElement = document.createElement("div"), this.domElement.classList.add("controller"), this.domElement.classList.add(n), this.$name = document.createElement("div"), this.$name.classList.add("name"), L.nextNameID = L.nextNameID || 0, this.$name.id = "lil-gui-name-" + ++L.nextNameID, this.$widget = document.createElement(r), this.$widget.classList.add("widget"), this.$disable = this.$widget, this.domElement.appendChild(this.$name), this.domElement.appendChild(this.$widget), this.parent.children.push(this), this.parent.controllers.push(this), this.parent.$children.appendChild(this.domElement), this._listenCallback = this._listenCallback.bind(this), this.name(s);
+  }
+  name(e) {
+    return this._name = e, this.$name.innerHTML = e, this;
+  }
+  onChange(e) {
+    return this._onChange = e, this;
+  }
+  _callOnChange() {
+    this.parent._callOnChange(this), this._onChange !== void 0 && this._onChange.call(this, this.getValue()), this._changed = !0;
+  }
+  onFinishChange(e) {
+    return this._onFinishChange = e, this;
+  }
+  _callOnFinishChange() {
+    this._changed && (this.parent._callOnFinishChange(this), this._onFinishChange !== void 0 && this._onFinishChange.call(this, this.getValue())), this._changed = !1;
+  }
+  reset() {
+    return this.setValue(this.initialValue), this._callOnFinishChange(), this;
+  }
+  enable(e = !0) {
+    return this.disable(!e);
+  }
+  disable(e = !0) {
+    return e === this._disabled || (this._disabled = e, this.domElement.classList.toggle("disabled", e), this.$disable.toggleAttribute("disabled", e)), this;
+  }
+  show(e = !0) {
+    return this._hidden = !e, this.domElement.style.display = this._hidden ? "none" : "", this;
+  }
+  hide() {
+    return this.show(!1);
+  }
+  options(e) {
+    const t = this.parent.add(this.object, this.property, e);
+    return t.name(this._name), this.destroy(), t;
+  }
+  min(e) {
+    return this;
+  }
+  max(e) {
+    return this;
+  }
+  step(e) {
+    return this;
+  }
+  decimals(e) {
+    return this;
+  }
+  listen(e = !0) {
+    return this._listening = e, this._listenCallbackID !== void 0 && (cancelAnimationFrame(this._listenCallbackID), this._listenCallbackID = void 0), this._listening && this._listenCallback(), this;
+  }
+  _listenCallback() {
+    this._listenCallbackID = requestAnimationFrame(this._listenCallback);
+    const e = this.save();
+    e !== this._listenPrevValue && this.updateDisplay(), this._listenPrevValue = e;
+  }
+  getValue() {
+    return this.object[this.property];
+  }
+  setValue(e) {
+    return this.object[this.property] = e, this._callOnChange(), this.updateDisplay(), this;
+  }
+  updateDisplay() {
+    return this;
+  }
+  load(e) {
+    return this.setValue(e), this._callOnFinishChange(), this;
+  }
+  save() {
+    return this.getValue();
+  }
+  destroy() {
+    this.listen(!1), this.parent.children.splice(this.parent.children.indexOf(this), 1), this.parent.controllers.splice(this.parent.controllers.indexOf(this), 1), this.parent.$children.removeChild(this.domElement);
+  }
+}
+class Vn extends L {
+  constructor(e, t, s) {
+    super(e, t, s, "boolean", "label"), this.$input = document.createElement("input"), this.$input.setAttribute("type", "checkbox"), this.$input.setAttribute("aria-labelledby", this.$name.id), this.$widget.appendChild(this.$input), this.$input.addEventListener("change", () => {
+      this.setValue(this.$input.checked), this._callOnFinishChange();
+    }), this.$disable = this.$input, this.updateDisplay();
+  }
+  updateDisplay() {
+    return this.$input.checked = this.getValue(), this;
+  }
+}
+function ge(o) {
+  let e, t;
+  return (e = o.match(/(#|0x)?([a-f0-9]{6})/i)) ? t = e[2] : (e = o.match(/rgb\(\s*(\d*)\s*,\s*(\d*)\s*,\s*(\d*)\s*\)/)) ? t = parseInt(e[1]).toString(16).padStart(2, 0) + parseInt(e[2]).toString(16).padStart(2, 0) + parseInt(e[3]).toString(16).padStart(2, 0) : (e = o.match(/^#?([a-f0-9])([a-f0-9])([a-f0-9])$/i)) && (t = e[1] + e[1] + e[2] + e[2] + e[3] + e[3]), !!t && "#" + t;
+}
+const Kn = { isPrimitive: !0, match: (o) => typeof o == "string", fromHexString: ge, toHexString: ge }, V = { isPrimitive: !0, match: (o) => typeof o == "number", fromHexString: (o) => parseInt(o.substring(1), 16), toHexString: (o) => "#" + o.toString(16).padStart(6, 0) }, zn = { isPrimitive: !1, match: Array.isArray, fromHexString(o, e, t = 1) {
+  const s = V.fromHexString(o);
+  e[0] = (s >> 16 & 255) / 255 * t, e[1] = (s >> 8 & 255) / 255 * t, e[2] = (255 & s) / 255 * t;
+}, toHexString: ([o, e, t], s = 1) => V.toHexString(o * (s = 255 / s) << 16 ^ e * s << 8 ^ t * s << 0) }, Xn = { isPrimitive: !1, match: (o) => Object(o) === o, fromHexString(o, e, t = 1) {
+  const s = V.fromHexString(o);
+  e.r = (s >> 16 & 255) / 255 * t, e.g = (s >> 8 & 255) / 255 * t, e.b = (255 & s) / 255 * t;
+}, toHexString: ({ r: o, g: e, b: t }, s = 1) => V.toHexString(o * (s = 255 / s) << 16 ^ e * s << 8 ^ t * s << 0) }, Wn = [Kn, V, zn, Xn];
+class Yn extends L {
+  constructor(e, t, s, n) {
+    var r;
+    super(e, t, s, "color"), this.$input = document.createElement("input"), this.$input.setAttribute("type", "color"), this.$input.setAttribute("tabindex", -1), this.$input.setAttribute("aria-labelledby", this.$name.id), this.$text = document.createElement("input"), this.$text.setAttribute("type", "text"), this.$text.setAttribute("spellcheck", "false"), this.$text.setAttribute("aria-labelledby", this.$name.id), this.$display = document.createElement("div"), this.$display.classList.add("display"), this.$display.appendChild(this.$input), this.$widget.appendChild(this.$display), this.$widget.appendChild(this.$text), this._format = (r = this.initialValue, Wn.find((i) => i.match(r))), this._rgbScale = n, this._initialValueHexString = this.save(), this._textFocused = !1, this.$input.addEventListener("input", () => {
+      this._setValueFromHexString(this.$input.value);
+    }), this.$input.addEventListener("blur", () => {
+      this._callOnFinishChange();
+    }), this.$text.addEventListener("input", () => {
+      const i = ge(this.$text.value);
+      i && this._setValueFromHexString(i);
+    }), this.$text.addEventListener("focus", () => {
+      this._textFocused = !0, this.$text.select();
+    }), this.$text.addEventListener("blur", () => {
+      this._textFocused = !1, this.updateDisplay(), this._callOnFinishChange();
+    }), this.$disable = this.$text, this.updateDisplay();
+  }
+  reset() {
+    return this._setValueFromHexString(this._initialValueHexString), this;
+  }
+  _setValueFromHexString(e) {
+    if (this._format.isPrimitive) {
+      const t = this._format.fromHexString(e);
+      this.setValue(t);
+    } else this._format.fromHexString(e, this.getValue(), this._rgbScale), this._callOnChange(), this.updateDisplay();
+  }
+  save() {
+    return this._format.toHexString(this.getValue(), this._rgbScale);
+  }
+  load(e) {
+    return this._setValueFromHexString(e), this._callOnFinishChange(), this;
+  }
+  updateDisplay() {
+    return this.$input.value = this._format.toHexString(this.getValue(), this._rgbScale), this._textFocused || (this.$text.value = this.$input.value.substring(1)), this.$display.style.backgroundColor = this.$input.value, this;
+  }
+}
+class re extends L {
+  constructor(e, t, s) {
+    super(e, t, s, "function"), this.$button = document.createElement("button"), this.$button.appendChild(this.$name), this.$widget.appendChild(this.$button), this.$button.addEventListener("click", (n) => {
+      n.preventDefault(), this.getValue().call(this.object);
+    }), this.$button.addEventListener("touchstart", () => {
+    }, { passive: !0 }), this.$disable = this.$button;
+  }
+}
+class qn extends L {
+  constructor(e, t, s, n, r, i) {
+    super(e, t, s, "number"), this._initInput(), this.min(n), this.max(r);
+    const l = i !== void 0;
+    this.step(l ? i : this._getImplicitStep(), l), this.updateDisplay();
+  }
+  decimals(e) {
+    return this._decimals = e, this.updateDisplay(), this;
+  }
+  min(e) {
+    return this._min = e, this._onUpdateMinMax(), this;
+  }
+  max(e) {
+    return this._max = e, this._onUpdateMinMax(), this;
+  }
+  step(e, t = !0) {
+    return this._step = e, this._stepExplicit = t, this;
+  }
+  updateDisplay() {
+    const e = this.getValue();
+    if (this._hasSlider) {
+      let t = (e - this._min) / (this._max - this._min);
+      t = Math.max(0, Math.min(t, 1)), this.$fill.style.width = 100 * t + "%";
+    }
+    return this._inputFocused || (this.$input.value = this._decimals === void 0 ? e : e.toFixed(this._decimals)), this;
+  }
+  _initInput() {
+    this.$input = document.createElement("input"), this.$input.setAttribute("type", "number"), this.$input.setAttribute("step", "any"), this.$input.setAttribute("aria-labelledby", this.$name.id), this.$widget.appendChild(this.$input), this.$disable = this.$input;
+    const e = (h) => {
+      const d = parseFloat(this.$input.value);
+      isNaN(d) || (this._snapClampSetValue(d + h), this.$input.value = this.getValue());
+    };
+    let t, s, n, r, i, l = !1;
+    const a = (h) => {
+      if (l) {
+        const d = h.clientX - t, u = h.clientY - s;
+        Math.abs(u) > 5 ? (h.preventDefault(), this.$input.blur(), l = !1, this._setDraggingStyle(!0, "vertical")) : Math.abs(d) > 5 && c();
+      }
+      if (!l) {
+        const d = h.clientY - n;
+        i -= d * this._step * this._arrowKeyMultiplier(h), r + i > this._max ? i = this._max - r : r + i < this._min && (i = this._min - r), this._snapClampSetValue(r + i);
+      }
+      n = h.clientY;
+    }, c = () => {
+      this._setDraggingStyle(!1, "vertical"), this._callOnFinishChange(), window.removeEventListener("mousemove", a), window.removeEventListener("mouseup", c);
+    };
+    this.$input.addEventListener("input", () => {
+      let h = parseFloat(this.$input.value);
+      isNaN(h) || (this._stepExplicit && (h = this._snap(h)), this.setValue(this._clamp(h)));
+    }), this.$input.addEventListener("keydown", (h) => {
+      h.code === "Enter" && this.$input.blur(), h.code === "ArrowUp" && (h.preventDefault(), e(this._step * this._arrowKeyMultiplier(h))), h.code === "ArrowDown" && (h.preventDefault(), e(this._step * this._arrowKeyMultiplier(h) * -1));
+    }), this.$input.addEventListener("wheel", (h) => {
+      this._inputFocused && (h.preventDefault(), e(this._step * this._normalizeMouseWheel(h)));
+    }, { passive: !1 }), this.$input.addEventListener("mousedown", (h) => {
+      t = h.clientX, s = n = h.clientY, l = !0, r = this.getValue(), i = 0, window.addEventListener("mousemove", a), window.addEventListener("mouseup", c);
+    }), this.$input.addEventListener("focus", () => {
+      this._inputFocused = !0;
+    }), this.$input.addEventListener("blur", () => {
+      this._inputFocused = !1, this.updateDisplay(), this._callOnFinishChange();
+    });
+  }
+  _initSlider() {
+    this._hasSlider = !0, this.$slider = document.createElement("div"), this.$slider.classList.add("slider"), this.$fill = document.createElement("div"), this.$fill.classList.add("fill"), this.$slider.appendChild(this.$fill), this.$widget.insertBefore(this.$slider, this.$input), this.domElement.classList.add("hasSlider");
+    const e = (u) => {
+      const p = this.$slider.getBoundingClientRect();
+      let f = (b = u, m = p.left, A = p.right, y = this._min, T = this._max, (b - m) / (A - m) * (T - y) + y);
+      var b, m, A, y, T;
+      this._snapClampSetValue(f);
+    }, t = (u) => {
+      e(u.clientX);
+    }, s = () => {
+      this._callOnFinishChange(), this._setDraggingStyle(!1), window.removeEventListener("mousemove", t), window.removeEventListener("mouseup", s);
+    };
+    let n, r, i = !1;
+    const l = (u) => {
+      u.preventDefault(), this._setDraggingStyle(!0), e(u.touches[0].clientX), i = !1;
+    }, a = (u) => {
+      if (i) {
+        const p = u.touches[0].clientX - n, f = u.touches[0].clientY - r;
+        Math.abs(p) > Math.abs(f) ? l(u) : (window.removeEventListener("touchmove", a), window.removeEventListener("touchend", c));
+      } else u.preventDefault(), e(u.touches[0].clientX);
+    }, c = () => {
+      this._callOnFinishChange(), this._setDraggingStyle(!1), window.removeEventListener("touchmove", a), window.removeEventListener("touchend", c);
+    }, h = this._callOnFinishChange.bind(this);
+    let d;
+    this.$slider.addEventListener("mousedown", (u) => {
+      this._setDraggingStyle(!0), e(u.clientX), window.addEventListener("mousemove", t), window.addEventListener("mouseup", s);
+    }), this.$slider.addEventListener("touchstart", (u) => {
+      u.touches.length > 1 || (this._hasScrollBar ? (n = u.touches[0].clientX, r = u.touches[0].clientY, i = !0) : l(u), window.addEventListener("touchmove", a, { passive: !1 }), window.addEventListener("touchend", c));
+    }, { passive: !1 }), this.$slider.addEventListener("wheel", (u) => {
+      if (Math.abs(u.deltaX) < Math.abs(u.deltaY) && this._hasScrollBar) return;
+      u.preventDefault();
+      const p = this._normalizeMouseWheel(u) * this._step;
+      this._snapClampSetValue(this.getValue() + p), this.$input.value = this.getValue(), clearTimeout(d), d = setTimeout(h, 400);
+    }, { passive: !1 });
+  }
+  _setDraggingStyle(e, t = "horizontal") {
+    this.$slider && this.$slider.classList.toggle("active", e), document.body.classList.toggle("lil-gui-dragging", e), document.body.classList.toggle("lil-gui-" + t, e);
+  }
+  _getImplicitStep() {
+    return this._hasMin && this._hasMax ? (this._max - this._min) / 1e3 : 0.1;
+  }
+  _onUpdateMinMax() {
+    !this._hasSlider && this._hasMin && this._hasMax && (this._stepExplicit || this.step(this._getImplicitStep(), !1), this._initSlider(), this.updateDisplay());
+  }
+  _normalizeMouseWheel(e) {
+    let { deltaX: t, deltaY: s } = e;
+    return Math.floor(e.deltaY) !== e.deltaY && e.wheelDelta && (t = 0, s = -e.wheelDelta / 120, s *= this._stepExplicit ? 1 : 10), t + -s;
+  }
+  _arrowKeyMultiplier(e) {
+    let t = this._stepExplicit ? 1 : 10;
+    return e.shiftKey ? t *= 10 : e.altKey && (t /= 10), t;
+  }
+  _snap(e) {
+    const t = Math.round(e / this._step) * this._step;
+    return parseFloat(t.toPrecision(15));
+  }
+  _clamp(e) {
+    return e < this._min && (e = this._min), e > this._max && (e = this._max), e;
+  }
+  _snapClampSetValue(e) {
+    this.setValue(this._clamp(this._snap(e)));
+  }
+  get _hasScrollBar() {
+    const e = this.parent.root.$children;
+    return e.scrollHeight > e.clientHeight;
+  }
+  get _hasMin() {
+    return this._min !== void 0;
+  }
+  get _hasMax() {
+    return this._max !== void 0;
+  }
+}
+class Jn extends L {
+  constructor(e, t, s, n) {
+    super(e, t, s, "option"), this.$select = document.createElement("select"), this.$select.setAttribute("aria-labelledby", this.$name.id), this.$display = document.createElement("div"), this.$display.classList.add("display"), this._values = Array.isArray(n) ? n : Object.values(n), this._names = Array.isArray(n) ? n : Object.keys(n), this._names.forEach((r) => {
+      const i = document.createElement("option");
+      i.innerHTML = r, this.$select.appendChild(i);
+    }), this.$select.addEventListener("change", () => {
+      this.setValue(this._values[this.$select.selectedIndex]), this._callOnFinishChange();
+    }), this.$select.addEventListener("focus", () => {
+      this.$display.classList.add("focus");
+    }), this.$select.addEventListener("blur", () => {
+      this.$display.classList.remove("focus");
+    }), this.$widget.appendChild(this.$select), this.$widget.appendChild(this.$display), this.$disable = this.$select, this.updateDisplay();
+  }
+  updateDisplay() {
+    const e = this.getValue(), t = this._values.indexOf(e);
+    return this.$select.selectedIndex = t, this.$display.innerHTML = t === -1 ? e : this._names[t], this;
+  }
+}
+class Qn extends L {
+  constructor(e, t, s) {
+    super(e, t, s, "string"), this.$input = document.createElement("input"), this.$input.setAttribute("type", "text"), this.$input.setAttribute("aria-labelledby", this.$name.id), this.$input.addEventListener("input", () => {
+      this.setValue(this.$input.value);
+    }), this.$input.addEventListener("keydown", (n) => {
+      n.code === "Enter" && this.$input.blur();
+    }), this.$input.addEventListener("blur", () => {
+      this._callOnFinishChange();
+    }), this.$widget.appendChild(this.$input), this.$disable = this.$input, this.updateDisplay();
+  }
+  updateDisplay() {
+    return this.$input.value = this.getValue(), this;
+  }
+}
+let $e = !1;
+class Te {
+  constructor({ parent: e, autoPlace: t = e === void 0, container: s, width: n, title: r = "Controls", injectStyles: i = !0, touchStyles: l = !0 } = {}) {
+    if (this.parent = e, this.root = e ? e.root : this, this.children = [], this.controllers = [], this.folders = [], this._closed = !1, this._hidden = !1, this.domElement = document.createElement("div"), this.domElement.classList.add("lil-gui"), this.$title = document.createElement("div"), this.$title.classList.add("title"), this.$title.setAttribute("role", "button"), this.$title.setAttribute("aria-expanded", !0), this.$title.setAttribute("tabindex", 0), this.$title.addEventListener("click", () => this.openAnimated(this._closed)), this.$title.addEventListener("keydown", (a) => {
+      a.code !== "Enter" && a.code !== "Space" || (a.preventDefault(), this.$title.click());
+    }), this.$title.addEventListener("touchstart", () => {
+    }, { passive: !0 }), this.$children = document.createElement("div"), this.$children.classList.add("children"), this.domElement.appendChild(this.$title), this.domElement.appendChild(this.$children), this.title(r), l && this.domElement.classList.add("allow-touch-styles"), this.parent) return this.parent.children.push(this), this.parent.folders.push(this), void this.parent.$children.appendChild(this.domElement);
+    this.domElement.classList.add("root"), !$e && i && (function(a) {
+      const c = document.createElement("style");
+      c.innerHTML = a;
+      const h = document.querySelector("head link[rel=stylesheet], head style");
+      h ? document.head.insertBefore(c, h) : document.head.appendChild(c);
+    }('.lil-gui{--background-color:#1f1f1f;--text-color:#ebebeb;--title-background-color:#111;--title-text-color:#ebebeb;--widget-color:#424242;--hover-color:#4f4f4f;--focus-color:#595959;--number-color:#2cc9ff;--string-color:#a2db3c;--font-size:11px;--input-font-size:11px;--font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Arial,sans-serif;--font-family-mono:Menlo,Monaco,Consolas,"Droid Sans Mono",monospace;--padding:4px;--spacing:4px;--widget-height:20px;--name-width:45%;--slider-knob-width:2px;--slider-input-width:27%;--color-input-width:27%;--slider-input-min-width:45px;--color-input-min-width:45px;--folder-indent:7px;--widget-padding:0 0 0 3px;--widget-border-radius:2px;--checkbox-size:calc(var(--widget-height)*0.75);--scrollbar-width:5px;background-color:var(--background-color);color:var(--text-color);font-family:var(--font-family);font-size:var(--font-size);font-style:normal;font-weight:400;line-height:1;text-align:left;touch-action:manipulation;user-select:none;-webkit-user-select:none}.lil-gui,.lil-gui *{box-sizing:border-box;margin:0;padding:0}.lil-gui.root{display:flex;flex-direction:column;width:var(--width,245px)}.lil-gui.root>.title{background:var(--title-background-color);color:var(--title-text-color)}.lil-gui.root>.children{overflow-x:hidden;overflow-y:auto}.lil-gui.root>.children::-webkit-scrollbar{background:var(--background-color);height:var(--scrollbar-width);width:var(--scrollbar-width)}.lil-gui.root>.children::-webkit-scrollbar-thumb{background:var(--focus-color);border-radius:var(--scrollbar-width)}.lil-gui.force-touch-styles{--widget-height:28px;--padding:6px;--spacing:6px;--font-size:13px;--input-font-size:16px;--folder-indent:10px;--scrollbar-width:7px;--slider-input-min-width:50px;--color-input-min-width:65px}.lil-gui.autoPlace{max-height:100%;position:fixed;right:15px;top:0;z-index:1001}.lil-gui .controller{align-items:center;display:flex;margin:var(--spacing) 0;padding:0 var(--padding)}.lil-gui .controller.disabled{opacity:.5}.lil-gui .controller.disabled,.lil-gui .controller.disabled *{pointer-events:none!important}.lil-gui .controller>.name{flex-shrink:0;line-height:var(--widget-height);min-width:var(--name-width);padding-right:var(--spacing);white-space:pre}.lil-gui .controller .widget{align-items:center;display:flex;min-height:var(--widget-height);position:relative;width:100%}.lil-gui .controller.string input{color:var(--string-color)}.lil-gui .controller.boolean .widget{cursor:pointer}.lil-gui .controller.color .display{border-radius:var(--widget-border-radius);height:var(--widget-height);position:relative;width:100%}.lil-gui .controller.color input[type=color]{cursor:pointer;height:100%;opacity:0;width:100%}.lil-gui .controller.color input[type=text]{flex-shrink:0;font-family:var(--font-family-mono);margin-left:var(--spacing);min-width:var(--color-input-min-width);width:var(--color-input-width)}.lil-gui .controller.option select{max-width:100%;opacity:0;position:absolute;width:100%}.lil-gui .controller.option .display{background:var(--widget-color);border-radius:var(--widget-border-radius);height:var(--widget-height);line-height:var(--widget-height);max-width:100%;overflow:hidden;padding-left:.55em;padding-right:1.75em;pointer-events:none;position:relative;word-break:break-all}.lil-gui .controller.option .display.active{background:var(--focus-color)}.lil-gui .controller.option .display:after{bottom:0;content:"↕";font-family:lil-gui;padding-right:.375em;position:absolute;right:0;top:0}.lil-gui .controller.option .widget,.lil-gui .controller.option select{cursor:pointer}.lil-gui .controller.number input{color:var(--number-color)}.lil-gui .controller.number.hasSlider input{flex-shrink:0;margin-left:var(--spacing);min-width:var(--slider-input-min-width);width:var(--slider-input-width)}.lil-gui .controller.number .slider{background-color:var(--widget-color);border-radius:var(--widget-border-radius);cursor:ew-resize;height:var(--widget-height);overflow:hidden;padding-right:var(--slider-knob-width);touch-action:pan-y;width:100%}.lil-gui .controller.number .slider.active{background-color:var(--focus-color)}.lil-gui .controller.number .slider.active .fill{opacity:.95}.lil-gui .controller.number .fill{border-right:var(--slider-knob-width) solid var(--number-color);box-sizing:content-box;height:100%}.lil-gui-dragging .lil-gui{--hover-color:var(--widget-color)}.lil-gui-dragging *{cursor:ew-resize!important}.lil-gui-dragging.lil-gui-vertical *{cursor:ns-resize!important}.lil-gui .title{--title-height:calc(var(--widget-height) + var(--spacing)*1.25);-webkit-tap-highlight-color:transparent;text-decoration-skip:objects;cursor:pointer;font-weight:600;height:var(--title-height);line-height:calc(var(--title-height) - 4px);outline:none;padding:0 var(--padding)}.lil-gui .title:before{content:"▾";display:inline-block;font-family:lil-gui;padding-right:2px}.lil-gui .title:active{background:var(--title-background-color);opacity:.75}.lil-gui.root>.title:focus{text-decoration:none!important}.lil-gui.closed>.title:before{content:"▸"}.lil-gui.closed>.children{opacity:0;transform:translateY(-7px)}.lil-gui.closed:not(.transition)>.children{display:none}.lil-gui.transition>.children{overflow:hidden;pointer-events:none;transition-duration:.3s;transition-property:height,opacity,transform;transition-timing-function:cubic-bezier(.2,.6,.35,1)}.lil-gui .children:empty:before{content:"Empty";display:block;font-style:italic;height:var(--widget-height);line-height:var(--widget-height);margin:var(--spacing) 0;opacity:.5;padding:0 var(--padding)}.lil-gui.root>.children>.lil-gui>.title{border-width:0;border-bottom:1px solid var(--widget-color);border-left:0 solid var(--widget-color);border-right:0 solid var(--widget-color);border-top:1px solid var(--widget-color);transition:border-color .3s}.lil-gui.root>.children>.lil-gui.closed>.title{border-bottom-color:transparent}.lil-gui+.controller{border-top:1px solid var(--widget-color);margin-top:0;padding-top:var(--spacing)}.lil-gui .lil-gui .lil-gui>.title{border:none}.lil-gui .lil-gui .lil-gui>.children{border:none;border-left:2px solid var(--widget-color);margin-left:var(--folder-indent)}.lil-gui .lil-gui .controller{border:none}.lil-gui input{-webkit-tap-highlight-color:transparent;background:var(--widget-color);border:0;border-radius:var(--widget-border-radius);color:var(--text-color);font-family:var(--font-family);font-size:var(--input-font-size);height:var(--widget-height);outline:none;width:100%}.lil-gui input:disabled{opacity:1}.lil-gui input[type=number],.lil-gui input[type=text]{padding:var(--widget-padding)}.lil-gui input[type=number]:focus,.lil-gui input[type=text]:focus{background:var(--focus-color)}.lil-gui input::-webkit-inner-spin-button,.lil-gui input::-webkit-outer-spin-button{-webkit-appearance:none;margin:0}.lil-gui input[type=number]{-moz-appearance:textfield}.lil-gui input[type=checkbox]{appearance:none;-webkit-appearance:none;border-radius:var(--widget-border-radius);cursor:pointer;height:var(--checkbox-size);text-align:center;width:var(--checkbox-size)}.lil-gui input[type=checkbox]:checked:before{content:"✓";font-family:lil-gui;font-size:var(--checkbox-size);line-height:var(--checkbox-size)}.lil-gui button{-webkit-tap-highlight-color:transparent;background:var(--widget-color);border:1px solid var(--widget-color);border-radius:var(--widget-border-radius);color:var(--text-color);cursor:pointer;font-family:var(--font-family);font-size:var(--font-size);height:var(--widget-height);line-height:calc(var(--widget-height) - 4px);outline:none;text-align:center;text-transform:none;width:100%}.lil-gui button:active{background:var(--focus-color)}@font-face{font-family:lil-gui;src:url("data:application/font-woff;charset=utf-8;base64,d09GRgABAAAAAAUsAAsAAAAACJwAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAABHU1VCAAABCAAAAH4AAADAImwmYE9TLzIAAAGIAAAAPwAAAGBKqH5SY21hcAAAAcgAAAD0AAACrukyyJBnbHlmAAACvAAAAF8AAACEIZpWH2hlYWQAAAMcAAAAJwAAADZfcj2zaGhlYQAAA0QAAAAYAAAAJAC5AHhobXR4AAADXAAAABAAAABMAZAAAGxvY2EAAANsAAAAFAAAACgCEgIybWF4cAAAA4AAAAAeAAAAIAEfABJuYW1lAAADoAAAASIAAAIK9SUU/XBvc3QAAATEAAAAZgAAAJCTcMc2eJxVjbEOgjAURU+hFRBK1dGRL+ALnAiToyMLEzFpnPz/eAshwSa97517c/MwwJmeB9kwPl+0cf5+uGPZXsqPu4nvZabcSZldZ6kfyWnomFY/eScKqZNWupKJO6kXN3K9uCVoL7iInPr1X5baXs3tjuMqCtzEuagm/AAlzQgPAAB4nGNgYRBlnMDAysDAYM/gBiT5oLQBAwuDJAMDEwMrMwNWEJDmmsJwgCFeXZghBcjlZMgFCzOiKOIFAB71Bb8AeJy1kjFuwkAQRZ+DwRAwBtNQRUGKQ8OdKCAWUhAgKLhIuAsVSpWz5Bbkj3dEgYiUIszqWdpZe+Z7/wB1oCYmIoboiwiLT2WjKl/jscrHfGg/pKdMkyklC5Zs2LEfHYpjcRoPzme9MWWmk3dWbK9ObkWkikOetJ554fWyoEsmdSlt+uR0pCJR34b6t/TVg1SY3sYvdf8vuiKrpyaDXDISiegp17p7579Gp3p++y7HPAiY9pmTibljrr85qSidtlg4+l25GLCaS8e6rRxNBmsnERunKbaOObRz7N72ju5vdAjYpBXHgJylOAVsMseDAPEP8LYoUHicY2BiAAEfhiAGJgZWBgZ7RnFRdnVJELCQlBSRlATJMoLV2DK4glSYs6ubq5vbKrJLSbGrgEmovDuDJVhe3VzcXFwNLCOILB/C4IuQ1xTn5FPilBTj5FPmBAB4WwoqAHicY2BkYGAA4sk1sR/j+W2+MnAzpDBgAyEMQUCSg4EJxAEAwUgFHgB4nGNgZGBgSGFggJMhDIwMqEAYAByHATJ4nGNgAIIUNEwmAABl3AGReJxjYAACIQYlBiMGJ3wQAEcQBEV4nGNgZGBgEGZgY2BiAAEQyQWEDAz/wXwGAAsPATIAAHicXdBNSsNAHAXwl35iA0UQXYnMShfS9GPZA7T7LgIu03SSpkwzYTIt1BN4Ak/gKTyAeCxfw39jZkjymzcvAwmAW/wgwHUEGDb36+jQQ3GXGot79L24jxCP4gHzF/EIr4jEIe7wxhOC3g2TMYy4Q7+Lu/SHuEd/ivt4wJd4wPxbPEKMX3GI5+DJFGaSn4qNzk8mcbKSR6xdXdhSzaOZJGtdapd4vVPbi6rP+cL7TGXOHtXKll4bY1Xl7EGnPtp7Xy2n00zyKLVHfkHBa4IcJ2oD3cgggWvt/V/FbDrUlEUJhTn/0azVWbNTNr0Ens8de1tceK9xZmfB1CPjOmPH4kitmvOubcNpmVTN3oFJyjzCvnmrwhJTzqzVj9jiSX911FjeAAB4nG3HMRKCMBBA0f0giiKi4DU8k0V2GWbIZDOh4PoWWvq6J5V8If9NVNQcaDhyouXMhY4rPTcG7jwYmXhKq8Wz+p762aNaeYXom2n3m2dLTVgsrCgFJ7OTmIkYbwIbC6vIB7WmFfAAAA==") format("woff")}@media (pointer:coarse){.lil-gui.allow-touch-styles{--widget-height:28px;--padding:6px;--spacing:6px;--font-size:13px;--input-font-size:16px;--folder-indent:10px;--scrollbar-width:7px;--slider-input-min-width:50px;--color-input-min-width:65px}}@media (hover:hover){.lil-gui .controller.color .display:hover:before{border:1px solid #fff9;border-radius:var(--widget-border-radius);bottom:0;content:" ";display:block;left:0;position:absolute;right:0;top:0}.lil-gui .controller.option .display.focus{background:var(--focus-color)}.lil-gui .controller.option .widget:hover .display{background:var(--hover-color)}.lil-gui .controller.number .slider:hover{background-color:var(--hover-color)}body:not(.lil-gui-dragging) .lil-gui .title:hover{background:var(--title-background-color);opacity:.85}.lil-gui .title:focus{text-decoration:underline var(--focus-color)}.lil-gui input:hover{background:var(--hover-color)}.lil-gui input:active{background:var(--focus-color)}.lil-gui input[type=checkbox]:focus{box-shadow:inset 0 0 0 1px var(--focus-color)}.lil-gui button:hover{background:var(--hover-color);border-color:var(--hover-color)}.lil-gui button:focus{border-color:var(--focus-color)}}'), $e = !0), s ? s.appendChild(this.domElement) : t && (this.domElement.classList.add("autoPlace"), document.body.appendChild(this.domElement)), n && this.domElement.style.setProperty("--width", n + "px"), this.domElement.addEventListener("keydown", (a) => a.stopPropagation()), this.domElement.addEventListener("keyup", (a) => a.stopPropagation());
+  }
+  add(e, t, s, n, r) {
+    if (Object(s) === s) return new Jn(this, e, t, s);
+    const i = e[t];
+    switch (typeof i) {
+      case "number":
+        return new qn(this, e, t, s, n, r);
+      case "boolean":
+        return new Vn(this, e, t);
+      case "string":
+        return new Qn(this, e, t);
+      case "function":
+        return new re(this, e, t);
+    }
+    console.error(`gui.add failed
+	property:`, t, `
+	object:`, e, `
+	value:`, i);
+  }
+  addColor(e, t, s = 1) {
+    return new Yn(this, e, t, s);
+  }
+  addFolder(e) {
+    return new Te({ parent: this, title: e });
+  }
+  load(e, t = !0) {
+    return e.controllers && this.controllers.forEach((s) => {
+      s instanceof re || s._name in e.controllers && s.load(e.controllers[s._name]);
+    }), t && e.folders && this.folders.forEach((s) => {
+      s._title in e.folders && s.load(e.folders[s._title]);
+    }), this;
+  }
+  save(e = !0) {
+    const t = { controllers: {}, folders: {} };
+    return this.controllers.forEach((s) => {
+      if (!(s instanceof re)) {
+        if (s._name in t.controllers) throw new Error(`Cannot save GUI with duplicate property "${s._name}"`);
+        t.controllers[s._name] = s.save();
+      }
+    }), e && this.folders.forEach((s) => {
+      if (s._title in t.folders) throw new Error(`Cannot save GUI with duplicate folder "${s._title}"`);
+      t.folders[s._title] = s.save();
+    }), t;
+  }
+  open(e = !0) {
+    return this._closed = !e, this.$title.setAttribute("aria-expanded", !this._closed), this.domElement.classList.toggle("closed", this._closed), this;
+  }
+  close() {
+    return this.open(!1);
+  }
+  show(e = !0) {
+    return this._hidden = !e, this.domElement.style.display = this._hidden ? "none" : "", this;
+  }
+  hide() {
+    return this.show(!1);
+  }
+  openAnimated(e = !0) {
+    return this._closed = !e, this.$title.setAttribute("aria-expanded", !this._closed), requestAnimationFrame(() => {
+      const t = this.$children.clientHeight;
+      this.$children.style.height = t + "px", this.domElement.classList.add("transition");
+      const s = (r) => {
+        r.target === this.$children && (this.$children.style.height = "", this.domElement.classList.remove("transition"), this.$children.removeEventListener("transitionend", s));
+      };
+      this.$children.addEventListener("transitionend", s);
+      const n = e ? this.$children.scrollHeight : 0;
+      this.domElement.classList.toggle("closed", !e), requestAnimationFrame(() => {
+        this.$children.style.height = n + "px";
+      });
+    }), this;
+  }
+  title(e) {
+    return this._title = e, this.$title.innerHTML = e, this;
+  }
+  reset(e = !0) {
+    return (e ? this.controllersRecursive() : this.controllers).forEach((t) => t.reset()), this;
+  }
+  onChange(e) {
+    return this._onChange = e, this;
+  }
+  _callOnChange(e) {
+    this.parent && this.parent._callOnChange(e), this._onChange !== void 0 && this._onChange.call(this, { object: e.object, property: e.property, value: e.getValue(), controller: e });
+  }
+  onFinishChange(e) {
+    return this._onFinishChange = e, this;
+  }
+  _callOnFinishChange(e) {
+    this.parent && this.parent._callOnFinishChange(e), this._onFinishChange !== void 0 && this._onFinishChange.call(this, { object: e.object, property: e.property, value: e.getValue(), controller: e });
+  }
+  destroy() {
+    this.parent && (this.parent.children.splice(this.parent.children.indexOf(this), 1), this.parent.folders.splice(this.parent.folders.indexOf(this), 1)), this.domElement.parentElement && this.domElement.parentElement.removeChild(this.domElement), Array.from(this.children).forEach((e) => e.destroy());
+  }
+  controllersRecursive() {
+    let e = Array.from(this.controllers);
+    return this.folders.forEach((t) => {
+      e = e.concat(t.controllersRecursive());
+    }), e;
+  }
+  foldersRecursive() {
+    let e = Array.from(this.folders);
+    return this.folders.forEach((t) => {
+      e = e.concat(t.foldersRecursive());
+    }), e;
+  }
+}
+var Zn = Object.defineProperty, es = Object.getOwnPropertyDescriptor, ts = (o, e, t, s) => {
+  for (var n = s > 1 ? void 0 : s ? es(e, t) : e, r = o.length - 1, i; r >= 0; r--)
+    (i = o[r]) && (n = (s ? i(e, t, n) : i(n)) || n);
+  return s && n && Zn(e, t, n), n;
+};
+let W = class {
+  constructor() {
+    g(this, "workerPool", Wt());
+    g(this, "canvas");
+    g(this, "worker");
+    g(this, "thread");
+    g(this, "gui");
+    g(this, "stats");
+  }
+  init(o) {
+    this.worker = o.worker, this.thread = o.thread, this.gui = new Te(), this.stats = Me && new Me(), this.stats.showPanel(0), window && (window.document.body.appendChild(this.stats.dom), window.innerWidth <= 450 && this.gui.close());
+  }
+};
+W = ts([
+  ye()
+], W);
+var ns = Object.defineProperty, ss = Object.getOwnPropertyDescriptor, is = (o, e, t, s) => {
+  for (var n = s > 1 ? void 0 : s ? ss(e, t) : e, r = o.length - 1, i; r >= 0; r--)
+    (i = o[r]) && (n = (s ? i(e, t, n) : i(n)) || n);
+  return s && n && ns(e, t, n), n;
+}, rs = (o, e) => (t, s) => e(t, s, o);
+let Ae = class extends st {
+  constructor(e) {
+    super();
+    g(this, "canvas");
+    g(this, "lifecycle$$", new he());
+    g(this, "lifecycle$", this.lifecycle$$.pipe());
+    this.component = e;
+  }
+  init(e) {
+    this.canvas = e;
+    for (const t of Fe) {
+      const s = 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}$`] = zt(
+        t === "resize" ? window : e,
+        t
+      ).pipe(
+        // @ts-ignore
+        Xt(s.bind(this)),
+        qe((n) => !(t === "keydown" && !n))
+      ), this[`${t}$`].subscribe((n) => {
+        var r, i;
+        (i = (r = this.component.thread) == null ? void 0 : r[t]) == null || i.call(r, 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(),
+      ...Q(e, [
+        "ctrlKey",
+        "metaKey",
+        "shiftKey",
+        "button",
+        "pointerType",
+        "clientX",
+        "clientY",
+        "pageX",
+        "pageY"
+      ])
+    };
+  }
+  touchEventHandler(e) {
+    const t = [], s = { type: e.type, touches: t };
+    for (let n = 0; n < e.touches.length; ++n) {
+      const r = e.touches[n];
+      t.push({
+        pageX: (r == null ? void 0 : r.pageX) ?? 0,
+        pageY: (r == null ? void 0 : r.pageY) ?? 0
+      });
+    }
+    return { ...this.getScreenSizes(), ...s };
+  }
+  wheelEventHandler(e) {
+    return e.preventDefault(), {
+      ...this.getScreenSizes(),
+      ...Q(e, ["deltaX", "deltaY"])
+    };
+  }
+  keyEventHandler(e) {
+    if (it.includes(e.code))
+      return e.preventDefault(), {
+        ...this.getScreenSizes(),
+        ...Q(e, ["ctrlKey", "metaKey", "shiftKey", "keyCode"])
+      };
+  }
+};
+Ae = is([
+  ye(),
+  rs(0, $(W))
+], Ae);
+class Ze {
+  constructor() {
+    /**
+     * @description The app worker logic location.
+     *
+     * @required
+     */
+    g(this, "location");
+    /**
+     * @description App `canvas` element reference.
+     *
+     * @default undefined
+     */
+    g(this, "canvas");
+    /**
+     * @description Set the `canvas` view in fullscreen and auto-resize it.
+     *
+     * @default true
+     */
+    g(this, "fullScreen");
+    /**
+     * Default used camera.
+     *
+     * @see {@link DefaultCameraType}
+     *
+     * @default DefaultCameraType.PERSPECTIVE
+     */
+    g(this, "defaultCamera");
+    /**
+     * @description Start timer update on launch.
+     *
+     * @default true
+     */
+    g(this, "startTimer");
+    /**
+     * Enable the debug mode
+     *
+     * @default undefined
+     */
+    g(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
+     */
+    g(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
+     */
+    g(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
+     */
+    g(this, "withMiniCamera");
+    /**
+     * @description Handler called when the app is ready.
+     *
+     * @default undefined
+     */
+    g(this, "onReady");
+  }
+}
+class os {
+  constructor() {
+    g(this, "contextmenu$");
+    g(this, "resize$");
+    g(this, "mousedown$");
+    g(this, "mousemove$");
+    g(this, "mouseup$");
+    g(this, "pointerdown$");
+    g(this, "pointermove$");
+    g(this, "pointercancel$");
+    g(this, "pointerup$");
+    g(this, "touchstart$");
+    g(this, "touchmove$");
+    g(this, "touchend$");
+    g(this, "wheel$");
+    g(this, "keydown$");
+  }
+}
+var as = Object.defineProperty, ls = Object.getOwnPropertyDescriptor, cs = (o, e, t, s) => {
+  for (var n = s > 1 ? void 0 : s ? ls(e, t) : e, r = o.length - 1, i; r >= 0; r--)
+    (i = o[r]) && (n = (s ? i(e, t, n) : i(n)) || n);
+  return s && n && as(e, t, n), n;
+}, oe = (o, e) => (t, s) => e(t, s, o);
+let be = class extends os {
+  constructor(o, e, t) {
+    super(), this.component = o, this.controller = e, this.registerProps = t, this.init();
+  }
+  async _initCanvas() {
+    try {
+      if (this.component.canvas = document.createElement("canvas"), this.registerProps.canvas instanceof HTMLCanvasElement && (this.component.canvas = this.registerProps.canvas), typeof this.registerProps.canvas == "string") {
+        const o = document.querySelector(
+          this.registerProps.canvas
+        );
+        o instanceof HTMLCanvasElement && (this.component.canvas = o);
+      }
+      this.component.canvas.parentElement || document.body.appendChild(this.component.canvas);
+    } catch (o) {
+      console.error(
+        `🛑 Unable to initialize the canvas:
+${(o == null ? void 0 : o.message) ?? "Something went wrong"}`
+      );
+    }
+  }
+  async _initComponent() {
+    this.component.init({
+      worker: this.component.worker,
+      thread: this.component.thread
+    });
+  }
+  async _initController() {
+    var o, e, t;
+    this.controller.init(this.component.canvas), !(!this.component.thread || !this.component.worker) && ((e = (o = this.component.thread) == null ? void 0 : o.resize) == null || e.call(o, {
+      ...this.controller.uiEventHandler({ type: "resize" })
+    }), (t = this.component.thread) == null || t.lifecycle$().subscribe((s) => {
+      var n, r;
+      s === xe.STEP_STARTED && ((n = this.component.stats) == null || n.begin()), s === xe.STEP_ENDED && ((r = this.component.stats) == null || r.end());
+    }));
+  }
+  async _initWorkerThread() {
+    const o = this.component.canvas.transferControlToOffscreen();
+    o.width = this.component.canvas.clientWidth, o.height = this.component.canvas.clientHeight;
+    const e = await this.component.workerPool.run({
+      payload: {
+        path: this.registerProps.location,
+        subject: {
+          ...Yt(this.registerProps, [
+            "canvas",
+            "location",
+            "onReady"
+          ]),
+          canvas: o
+        },
+        transferSubject: [o]
+      }
+    });
+    if (!e.thread || !e.worker)
+      throw new Error("Unable to retrieve app worker info.");
+    this.component.worker = e.worker, this.component.thread = e.thread;
+  }
+  async _initProxyEvents() {
+    Fe.forEach(
+      (o) => this[`${o}$`] = () => {
+        var e;
+        return (e = this.controller) == null ? void 0 : e[`${o}$`];
+      }
+    );
+  }
+  async init() {
+    var o, e;
+    await this._initCanvas(), await this._initWorkerThread(), await this._initComponent(), await this._initController(), await this._initProxyEvents(), this.controller.lifecycle$$.next(Ee.INITIALIZED), (e = (o = this.registerProps).onReady) == null || e.call(o, this);
+  }
+  async loadResources(o) {
+    var t, s, n, r, i, l, a, c, h;
+    const e = await this.component.workerPool.run({
+      payload: {
+        path: "../loader/loader.module-worker.ts",
+        subject: {
+          resources: o.resources
+        }
+      }
+    });
+    return (t = e.thread) == null || t.progress$().subscribe((d) => {
+      var u;
+      (u = o.onProgress) == null || u.call(o, d);
+    }), (s = e.thread) == null || s.progressCompleted$().subscribe((d) => {
+      var u, p;
+      (u = o.onProgressComplete) == null || u.call(o, d), (o.disposeOnComplete || o.disposeOnComplete === void 0) && ((p = e.thread) == null || p.dispose());
+    }), (o.immediateLoad || o.immediateLoad === void 0) && await ((n = e.thread) == null ? void 0 : n.load()), {
+      ...e,
+      load: await ((r = e.thread) == null ? void 0 : r.load),
+      items: await ((i = e.thread) == null ? void 0 : i.items()),
+      loaders: await ((l = e.thread) == null ? void 0 : l.items()),
+      toLoad: await ((a = e.thread) == null ? void 0 : a.toLoad()),
+      loaded: await ((c = e.thread) == null ? void 0 : c.loaded()),
+      resources: await ((h = e.thread) == null ? void 0 : h.resources())
+    };
+  }
+  workerPool() {
+    return this.component.workerPool;
+  }
+  canvas() {
+    return this.component.canvas;
+  }
+  worker() {
+    return this.component.worker;
+  }
+  thread() {
+    return this.component.thread;
+  }
+  gui() {
+    return this.component.gui;
+  }
+  dispose() {
+    this.component.workerPool.terminateAll(), this.controller.lifecycle$$.next(Ee.DISPOSED);
+  }
+  lifecycle$() {
+    return this.controller.lifecycle$;
+  }
+};
+be = cs([
+  ye(),
+  oe(0, $(W)),
+  oe(1, $(Ae)),
+  oe(2, $(Ze))
+], be);
+const As = (o) => {
+  if (typeof (o == null ? void 0 : o.location) != "string" && !((o == null ? void 0 : o.location) instanceof URL))
+    throw new Error(
+      "Invalid register props detected. location path is required"
+    );
+  return o.defaultCamera = o != null && o.defaultCamera && o.defaultCamera in ve ? o.defaultCamera : ve.PERSPECTIVE, o.withMiniCamera = Z(o.withMiniCamera) || !ee(o.withMiniCamera) ? !1 : o.withMiniCamera, o.startTimer = Z(o.startTimer) || !ee(o.startTimer) ? !0 : o.startTimer, o.fullScreen = Z(o.fullScreen) || !ee(o.fullScreen) ? !0 : o.fullScreen, o.onReady = qt(o.onReady) ? o.onReady : void 0, K.register(Ze, { useValue: o }), K.resolve(be);
+};
+class bs {
+  constructor() {
+    /**
+     * @description Handler triggered when the app is ready.
+     */
+    g(this, "onReady");
+  }
+}
+export {
+  xe as AppLifecycleState,
+  _s as AppModule,
+  Ts as AppProxyEventHandlersModel,
+  ve as DefaultCameraType,
+  it as KEYBOARD_EVENT_CODES,
+  bs as LaunchAppProps,
+  me as LoaderModule,
+  Fe as PROXY_EVENT_LISTENERS,
+  st as ProxyEventHandlersModel,
+  xs as ProxyEventObservablesModel,
+  Es as ProxyEventSubjectsModel,
+  Ee as RegisterLifecycleState,
+  be as RegisterModule,
+  Ze as RegisterPropsModel,
+  os as RegisterProxyEventHandlersModel,
+  vs as appModule,
+  gs as loaderModule,
+  As as register
+};