@epigraph/epigraph-std-lib 3.3.1 → 4.0.0-alpha

package/dist/ThirdPartyLibs/threejs.js

@@ -0,0 +1,800 @@
+import { M as G, O as A, B as y, F as b, S, U as B, V as C, W as F, H as D, N as E, C as w } from "../chunks/VerticalBlurShader.B0rdEBFu.js";
+import { A as j, e as ee, f as ae, cc as se, g as te, h as re, i as ie, j as ne, k as oe, cd as le, ce, cf as fe, cg as ue, ch as de, ci as he, cj as pe, ck as me, cl as ge, l as Me, cm as be, cn as Se, co as Ce, cp as _e, cq as xe, cr as Te, cs as ve, ct as Le, m as Re, cu as Ge, cv as Ae, cw as ye, cx as Be, cy as Fe, cz as De, cA as Ee, cB as we, n as Pe, cC as Ie, o as Ue, cD as Ne, p as Oe, cE as ke, cF as We, cG as Ve, cH as He, cI as qe, cJ as ze, q as Ke, cK as Qe, r as $e, s as Xe, cL as Ze, t as Ye, cM as Je, cN as je, cO as ea, cP as aa, cQ as sa, u as ta, v as ra, cR as ia, cS as na, w as oa, x as la, y as ca, cT as fa, z as ua, cU as da, cV as ha, cW as pa, E as ma, I as ga, cX as Ma, J as ba, cY as Sa, cZ as Ca, K as _a, L as xa, c_ as Ta, c$ as va, D as La, P as Ra, Q as Ga, d0 as Aa, d1 as ya, d2 as Ba, d3 as Fa, d4 as Da, d5 as Ea, T as wa, X as Pa, Y as Ia, d6 as Ua, d7 as Na, d8 as Oa, d9 as ka, da as Wa, Z as Va, _ as Ha, $ as qa, db as za, dc as Ka, dd as Qa, de as $a, df as Xa, a0 as Za, a1 as Ya, dg as Ja, a2 as ja, a3 as es, a4 as as, a5 as ss, dh as ts, di as rs, dj as is, a6 as ns, dk as os, dl as ls, dm as cs, a7 as fs, a8 as us, dn as ds, dp as hs, a9 as ps, a as ms, G as gs, aa as Ms, ab as bs, ac as Ss, ad as Cs, dq as _s, dr as xs, ds as Ts, ae as vs, dt as Ls, du as Rs, c as Gs, dv as As, dw as ys, dx as Bs, dy as Fs, dz as Ds, dA as Es, dB as ws, dC as Ps, dD as Is, dE as Us, dF as Ns, dG as Os, dH as ks, af as Ws, dI as Vs, dJ as Hs, dK as qs, dL as zs, dM as Ks, dN as Qs, dO as $s, dP as Xs, dQ as Zs, dR as Ys, dS as Js, ag as js, ah as et, ai as at, aj as st, ak as tt, dT as rt, dU as it, dV as nt, dW as ot, dX as lt, dY as ct, dZ as ft, d_ as ut, d$ as dt, e0 as ht, e1 as pt, e2 as mt, al as gt, e3 as Mt, e4 as bt, e5 as St, am as Ct, an as _t, ao as xt, ap as Tt, aq as vt, e6 as Lt, e7 as Rt, e8 as Gt, e9 as At, ea as yt, eb as Bt, ar as Ft, as as Dt, ec as Et, ed as wt, ee as Pt, ef as It, eg as Ut, at as Nt, au as Ot, av as kt, aw as Wt, ax as Vt, ay as Ht, eh as qt, ei as zt, ej as Kt, ek as Qt, el as $t, em as Xt, en as Zt, az as Yt, aA as Jt, aB as jt, aC as er, aD as ar, aE as sr, eo as tr, ep as rr, aF as ir, aG as nr, aH as or, aI as lr, aJ as cr, eq as fr, aK as ur, aL as dr, er as hr, aM as pr, aN as mr, aO as gr, es as Mr, et as br, eu as Sr, ev as Cr, aP as _r, ew as xr, aQ as Tr, aR as vr, aS as Lr, aT as Rr, aU as Gr, aV as Ar, aW as yr, aX as Br, aY as Fr, aZ as Dr, ex as Er, a_ as wr, a$ as Pr, b0 as Ir, ey as Ur, ez as Nr, eA as Or, eB as kr, eC as Wr, eD as Vr, eE as Hr, eF as qr, eG as zr, eH as Kr, eI as Qr, eJ as $r, eK as Xr, eL as Zr, eM as Yr, b1 as Jr, b2 as jr, b3 as ei, b4 as ai, b5 as si, b6 as ti, b7 as ri, b8 as ii, b9 as ni, ba as oi, bb as li, bc as ci, bd as fi, be as ui, bf as di, bg as hi, bh as pi, bi as mi, bj as gi, bk as Mi, bl as bi, bm as Si, bn as Ci, bo as _i, bp as xi, bq as Ti, br as vi, eN as Li, R as Ri, bs as Gi, eO as Ai, bt as yi, bu as Bi, bv as Fi, bw as Di, bx as Ei, by as wi, bz as Pi, eP as Ii, bA as Ui, bB as Ni, eQ as Oi, eR as ki, eS as Wi, eT as Vi, bC as Hi, bD as qi, bE as zi, eU as Ki, eV as Qi, eW as $i, bF as Xi, eX as Zi, bG as Yi, eY as Ji, bH as ji, bI as en, bJ as an, bK as sn, eZ as tn, bL as rn, bM as nn, e_ as on, e$ as ln, f0 as cn, f1 as fn, f2 as un, bN as dn, f3 as hn, f4 as pn, f5 as mn, f6 as gn, f7 as Mn, f8 as bn, f9 as Sn, fa as Cn, fb as _n, fc as xn, fd as Tn, fe as vn, ff as Ln, bO as Rn, bP as Gn, bQ as An, fg as yn, fh as Bn, fi as Fn, fj as Dn, fk as En, fl as wn, fm as Pn, fn as In, bR as Un, bS as Nn, fo as On, bT as kn, fp as Wn, bU as Vn, fq as Hn, fr as qn, fs as zn, ft as Kn, fu as Qn, fv as $n, fw as Xn, fx as Zn, fy as Yn, b as Jn, fz as jn, bV as eo, bW as ao, fA as so, fB as to, fC as ro, fD as io, bX as no, bY as oo, bZ as lo, b_ as co, b$ as fo, c0 as uo, c1 as ho, c2 as po, c3 as mo, c4 as go, c5 as Mo, fE as bo, d as So, fF as Co, fG as _o, fH as xo, c6 as To, c7 as vo, c8 as Lo, c9 as Ro, fI as Go, fJ as Ao, fK as yo, fL as Bo, ca as Fo, fM as Do, fN as Eo, cb as wo } from "../chunks/VerticalBlurShader.B0rdEBFu.js";
+class Q {
+  static isWebGL2Available() {
+    try {
+      const e = document.createElement("canvas");
+      return !!(window.WebGL2RenderingContext && e.getContext("webgl2"));
+    } catch {
+      return !1;
+    }
+  }
+  static isColorSpaceAvailable(e) {
+    try {
+      const a = document.createElement("canvas"), t = window.WebGL2RenderingContext && a.getContext("webgl2");
+      return t.drawingBufferColorSpace = e, t.drawingBufferColorSpace === e;
+    } catch {
+      return !1;
+    }
+  }
+  static getWebGL2ErrorMessage() {
+    return this.getErrorMessage(2);
+  }
+  static getErrorMessage(e) {
+    const a = {
+      1: "WebGL",
+      2: "WebGL 2"
+    }, t = {
+      1: window.WebGLRenderingContext,
+      2: window.WebGL2RenderingContext
+    };
+    let i = 'Your $0 does not seem to support <a href="http://khronos.org/webgl/wiki/Getting_a_WebGL_Implementation" style="color:#000">$1</a>';
+    const s = document.createElement("div");
+    return s.id = "webglmessage", s.style.fontFamily = "monospace", s.style.fontSize = "13px", s.style.fontWeight = "normal", s.style.textAlign = "center", s.style.background = "#fff", s.style.color = "#000", s.style.padding = "1.5em", s.style.width = "400px", s.style.margin = "5em auto 0", t[e] ? i = i.replace("$0", "graphics card") : i = i.replace("$0", "browser"), i = i.replace("$1", a[e]), s.innerHTML = i, s;
+  }
+  // @deprecated, r168
+  static isWebGLAvailable() {
+    console.warn("isWebGLAvailable() has been deprecated and will be removed in r178. Use isWebGL2Available() instead.");
+    try {
+      const e = document.createElement("canvas");
+      return !!(window.WebGLRenderingContext && (e.getContext("webgl") || e.getContext("experimental-webgl")));
+    } catch {
+      return !1;
+    }
+  }
+  static getWebGLErrorMessage() {
+    return console.warn("getWebGLErrorMessage() has been deprecated and will be removed in r178. Use getWebGL2ErrorMessage() instead."), this.getErrorMessage(1);
+  }
+}
+class M {
+  constructor() {
+    this.isPass = !0, this.enabled = !0, this.needsSwap = !0, this.clear = !1, this.renderToScreen = !1;
+  }
+  setSize() {
+  }
+  render() {
+    console.error("THREE.Pass: .render() must be implemented in derived pass.");
+  }
+  dispose() {
+  }
+}
+const P = new A(-1, 1, 1, -1, 0, 1);
+class I extends y {
+  constructor() {
+    super(), this.setAttribute("position", new b([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3)), this.setAttribute("uv", new b([0, 2, 0, 0, 2, 0], 2));
+  }
+}
+const U = new I();
+class N {
+  constructor(e) {
+    this._mesh = new G(U, e);
+  }
+  dispose() {
+    this._mesh.geometry.dispose();
+  }
+  render(e) {
+    e.render(this._mesh, P);
+  }
+  get material() {
+    return this._mesh.material;
+  }
+  set material(e) {
+    this._mesh.material = e;
+  }
+}
+const O = {
+  name: "CopyShader",
+  uniforms: {
+    tDiffuse: { value: null },
+    opacity: { value: 1 }
+  },
+  vertexShader: (
+    /* glsl */
+    `
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`
+  ),
+  fragmentShader: (
+    /* glsl */
+    `
+
+		uniform float opacity;
+
+		uniform sampler2D tDiffuse;
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vec4 texel = texture2D( tDiffuse, vUv );
+			gl_FragColor = opacity * texel;
+
+
+		}`
+  )
+};
+class k extends M {
+  constructor(e, a) {
+    super(), this.textureID = a !== void 0 ? a : "tDiffuse", e instanceof S ? (this.uniforms = e.uniforms, this.material = e) : e && (this.uniforms = B.clone(e.uniforms), this.material = new S({
+      name: e.name !== void 0 ? e.name : "unspecified",
+      defines: Object.assign({}, e.defines),
+      uniforms: this.uniforms,
+      vertexShader: e.vertexShader,
+      fragmentShader: e.fragmentShader
+    })), this.fsQuad = new N(this.material);
+  }
+  render(e, a, t) {
+    this.uniforms[this.textureID] && (this.uniforms[this.textureID].value = t.texture), this.fsQuad.material = this.material, this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(a), this.clear && e.clear(e.autoClearColor, e.autoClearDepth, e.autoClearStencil), this.fsQuad.render(e));
+  }
+  dispose() {
+    this.material.dispose(), this.fsQuad.dispose();
+  }
+}
+class _ extends M {
+  constructor(e, a) {
+    super(), this.scene = e, this.camera = a, this.clear = !0, this.needsSwap = !1, this.inverse = !1;
+  }
+  render(e, a, t) {
+    const i = e.getContext(), s = e.state;
+    s.buffers.color.setMask(!1), s.buffers.depth.setMask(!1), s.buffers.color.setLocked(!0), s.buffers.depth.setLocked(!0);
+    let c, h;
+    this.inverse ? (c = 0, h = 1) : (c = 1, h = 0), s.buffers.stencil.setTest(!0), s.buffers.stencil.setOp(i.REPLACE, i.REPLACE, i.REPLACE), s.buffers.stencil.setFunc(i.ALWAYS, c, 4294967295), s.buffers.stencil.setClear(h), s.buffers.stencil.setLocked(!0), e.setRenderTarget(t), this.clear && e.clear(), e.render(this.scene, this.camera), e.setRenderTarget(a), this.clear && e.clear(), e.render(this.scene, this.camera), s.buffers.color.setLocked(!1), s.buffers.depth.setLocked(!1), s.buffers.color.setMask(!0), s.buffers.depth.setMask(!0), s.buffers.stencil.setLocked(!1), s.buffers.stencil.setFunc(i.EQUAL, 1, 4294967295), s.buffers.stencil.setOp(i.KEEP, i.KEEP, i.KEEP), s.buffers.stencil.setLocked(!0);
+  }
+}
+class W extends M {
+  constructor() {
+    super(), this.needsSwap = !1;
+  }
+  render(e) {
+    e.state.buffers.stencil.setLocked(!1), e.state.buffers.stencil.setTest(!1);
+  }
+}
+class $ {
+  constructor(e, a) {
+    if (this.renderer = e, this._pixelRatio = e.getPixelRatio(), a === void 0) {
+      const t = e.getSize(new C());
+      this._width = t.width, this._height = t.height, a = new F(this._width * this._pixelRatio, this._height * this._pixelRatio, { type: D }), a.texture.name = "EffectComposer.rt1";
+    } else
+      this._width = a.width, this._height = a.height;
+    this.renderTarget1 = a, this.renderTarget2 = a.clone(), this.renderTarget2.texture.name = "EffectComposer.rt2", this.writeBuffer = this.renderTarget1, this.readBuffer = this.renderTarget2, this.renderToScreen = !0, this.passes = [], this.copyPass = new k(O), this.copyPass.material.blending = E, this.clock = new w();
+  }
+  swapBuffers() {
+    const e = this.readBuffer;
+    this.readBuffer = this.writeBuffer, this.writeBuffer = e;
+  }
+  addPass(e) {
+    this.passes.push(e), e.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
+  }
+  insertPass(e, a) {
+    this.passes.splice(a, 0, e), e.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
+  }
+  removePass(e) {
+    const a = this.passes.indexOf(e);
+    a !== -1 && this.passes.splice(a, 1);
+  }
+  isLastEnabledPass(e) {
+    for (let a = e + 1; a < this.passes.length; a++)
+      if (this.passes[a].enabled)
+        return !1;
+    return !0;
+  }
+  render(e) {
+    e === void 0 && (e = this.clock.getDelta());
+    const a = this.renderer.getRenderTarget();
+    let t = !1;
+    for (let i = 0, s = this.passes.length; i < s; i++) {
+      const c = this.passes[i];
+      if (c.enabled !== !1) {
+        if (c.renderToScreen = this.renderToScreen && this.isLastEnabledPass(i), c.render(this.renderer, this.writeBuffer, this.readBuffer, e, t), c.needsSwap) {
+          if (t) {
+            const h = this.renderer.getContext(), f = this.renderer.state.buffers.stencil;
+            f.setFunc(h.NOTEQUAL, 1, 4294967295), this.copyPass.render(this.renderer, this.writeBuffer, this.readBuffer, e), f.setFunc(h.EQUAL, 1, 4294967295);
+          }
+          this.swapBuffers();
+        }
+        _ !== void 0 && (c instanceof _ ? t = !0 : c instanceof W && (t = !1));
+      }
+    }
+    this.renderer.setRenderTarget(a);
+  }
+  reset(e) {
+    if (e === void 0) {
+      const a = this.renderer.getSize(new C());
+      this._pixelRatio = this.renderer.getPixelRatio(), this._width = a.width, this._height = a.height, e = this.renderTarget1.clone(), e.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
+    }
+    this.renderTarget1.dispose(), this.renderTarget2.dispose(), this.renderTarget1 = e, this.renderTarget2 = e.clone(), this.writeBuffer = this.renderTarget1, this.readBuffer = this.renderTarget2;
+  }
+  setSize(e, a) {
+    this._width = e, this._height = a;
+    const t = this._width * this._pixelRatio, i = this._height * this._pixelRatio;
+    this.renderTarget1.setSize(t, i), this.renderTarget2.setSize(t, i);
+    for (let s = 0; s < this.passes.length; s++)
+      this.passes[s].setSize(t, i);
+  }
+  setPixelRatio(e) {
+    this._pixelRatio = e, this.setSize(this._width, this._height);
+  }
+  dispose() {
+    this.renderTarget1.dispose(), this.renderTarget2.dispose(), this.copyPass.dispose();
+  }
+}
+const V = (n) => {
+  const e = [], a = /* @__PURE__ */ new Set();
+  for (const t of n) {
+    let i = t, s = 0;
+    for (; a.has(i); )
+      i = t + "." + ++s;
+    a.add(i), e.push(i);
+  }
+  return e;
+}, H = (n, e) => {
+  const a = {};
+  for (const t of n.mappings)
+    for (const i of t.variants)
+      a[e[i]] = {
+        material: null,
+        gltfMaterialIndex: t.material
+      };
+  return a;
+}, m = (n) => n.material !== void 0 && // easier than (!object.isMesh && !object.isLine && !object.isPoints)
+n.userData && // just in case
+n.userData.variantMaterials, v = (n, e, a) => {
+  a(n, e);
+  for (let t = 0; t < n.children.length; t++)
+    v(n.children[t], e.children[t], a);
+}, x = (n, e) => {
+  e.userData.variantMaterials !== void 0 && (n.userData.variantMaterials = Object.assign({}, e.userData.variantMaterials)), e.userData.originalMaterial !== void 0 && (n.userData.originalMaterial = e.userData.originalMaterial);
+};
+class q {
+  constructor(e) {
+    this.parser = e, this.name = "KHR_materials_variants";
+  }
+  // Note that the following properties will be overridden even if they are pre-defined
+  // - gltf.userData.variants
+  // - mesh.userData.variantMaterials
+  afterRoot(e) {
+    const a = this.parser, t = a.json;
+    if (!t.extensions || !t.extensions[this.name])
+      return null;
+    const s = t.extensions[this.name].variants || [], c = V(s.map((r) => r.name));
+    for (const r of e.scenes)
+      r.traverse((l) => {
+        const o = a.associations.get(l);
+        if (!o || o.meshes === void 0 || o.primitives === void 0)
+          return;
+        const u = t.meshes[o.meshes].primitives[o.primitives].extensions;
+        !u || !u[this.name] || (l.userData.variantMaterials = H(u[this.name], c));
+      });
+    e.userData.variants = c, e.functions = e.functions || {};
+    const h = async (r, l, o) => {
+      r.userData.originalMaterial || (r.userData.originalMaterial = r.material);
+      const p = r.material;
+      let d = null;
+      if (l === null || !r.userData.variantMaterials[l])
+        r.material = r.userData.originalMaterial, a.associations.has(r.material) && (d = a.associations.get(r.material).index);
+      else {
+        const u = r.userData.variantMaterials[l];
+        u.material ? (r.material = u.material, u.gltfMaterialIndex !== void 0 && (d = u.gltfMaterialIndex)) : (d = u.gltfMaterialIndex, r.material = await a.getDependency("material", d), a.assignFinalMaterial(r), u.material = r.material);
+      }
+      o !== null && o(r, p, d);
+    }, f = (r) => {
+      const l = r.material, o = r.userData.variantMaterials, p = [];
+      for (const d in o) {
+        const u = o[d];
+        if (u.material)
+          continue;
+        const L = u.gltfMaterialIndex;
+        p.push(a.getDependency("material", L).then((R) => {
+          r.material = R, a.assignFinalMaterial(r), o[d].material = r.material;
+        }));
+      }
+      return Promise.all(p).then(() => {
+        r.material = l;
+      });
+    };
+    e.functions.selectVariant = (r, l, o = !0, p = null) => {
+      const d = [];
+      return o ? r.traverse((u) => m(u) && d.push(h(u, l, p))) : m(r) && d.push(h(r, l, p)), Promise.all(d);
+    }, e.functions.ensureLoadVariants = (r, l = !0) => {
+      const o = [];
+      return l ? r.traverse((p) => m(p) && o.push(f(p))) : m(r) && o.push(f(r)), Promise.all(o);
+    }, e.functions.copyVariantMaterials = (r, l, o = !0) => {
+      o ? v(r, l, (p, d) => x(p, d)) : x(r, l);
+    };
+  }
+}
+const X = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: q
+}, Symbol.toStringTag, { value: "Module" })), T = (n) => n.material !== void 0 && // easier than (!object.isMesh && !object.isLine && !object.isPoints)
+n.userData && // just in case
+n.userData.variantMaterials && // Is this line costly?
+!!Object.values(n.userData.variantMaterials).filter((e) => g(e.material)), g = (n) => n && n.isMaterial && !Array.isArray(n);
+class z {
+  constructor(e) {
+    this.writer = e, this.name = "KHR_materials_variants", this.variantNames = [];
+  }
+  beforeParse(e) {
+    const a = /* @__PURE__ */ new Set();
+    for (const t of e)
+      t.traverse((i) => {
+        if (!T(i))
+          return;
+        const s = i.userData.variantMaterials;
+        for (const c in s) {
+          const h = s[c];
+          g(h.material) && a.add(c);
+        }
+      });
+    a.forEach((t) => this.variantNames.push(t));
+  }
+  writeMesh(e, a) {
+    if (!T(e))
+      return;
+    const t = e.userData, i = t.variantMaterials, s = {};
+    for (const f in i) {
+      const r = i[f].material;
+      if (!g(r))
+        continue;
+      const l = this.variantNames.indexOf(f), o = this.writer.processMaterial(r);
+      s[o] || (s[o] = {
+        material: o,
+        variants: []
+      }), s[o].variants.push(l);
+    }
+    const c = Object.values(s).map((f) => f.variants.sort((r, l) => r - l) && f).sort((f, r) => f.material - r.material);
+    if (c.length === 0)
+      return;
+    const h = g(t.originalMaterial) ? this.writer.processMaterial(t.originalMaterial) : -1;
+    for (const f of a.primitives)
+      h >= 0 && (f.material = h), f.extensions = f.extensions || {}, f.extensions[this.name] = { mappings: c };
+  }
+  afterParse(e) {
+    if (this.variantNames.length === 0)
+      return;
+    const a = this.writer.json;
+    a.extensions = a.extensions || {};
+    const t = this.variantNames.map((i) => ({ name: i }));
+    a.extensions[this.name] = { variants: t }, this.writer.extensionsUsed[this.name] = !0;
+  }
+}
+const Z = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: z
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  j as ACESFilmicToneMapping,
+  ee as AddEquation,
+  ae as AddOperation,
+  se as AdditiveAnimationBlendMode,
+  te as AdditiveBlending,
+  re as AgXToneMapping,
+  ie as AlphaFormat,
+  ne as AlwaysCompare,
+  oe as AlwaysDepth,
+  le as AlwaysStencilFunc,
+  ce as AmbientLight,
+  fe as AnimationAction,
+  ue as AnimationClip,
+  de as AnimationLoader,
+  he as AnimationMixer,
+  pe as AnimationObjectGroup,
+  me as AnimationUtils,
+  ge as ArcCurve,
+  Me as ArrayCamera,
+  be as ArrowHelper,
+  Se as AttachedBindMode,
+  Ce as Audio,
+  _e as AudioAnalyser,
+  xe as AudioContext,
+  Te as AudioListener,
+  ve as AudioLoader,
+  Le as AxesHelper,
+  Re as BackSide,
+  Ge as BasicDepthPacking,
+  Ae as BasicShadowMap,
+  ye as BatchedMesh,
+  Be as Bone,
+  Fe as BooleanKeyframeTrack,
+  De as Box2,
+  Ee as Box3,
+  we as Box3Helper,
+  Pe as BoxGeometry,
+  Ie as BoxHelper,
+  Ue as BufferAttribute,
+  y as BufferGeometry,
+  Ne as BufferGeometryLoader,
+  Oe as ByteType,
+  ke as Cache,
+  We as Camera,
+  Ve as CameraHelper,
+  He as CanvasTexture,
+  qe as CapsuleGeometry,
+  ze as CatmullRomCurve3,
+  Ke as CineonToneMapping,
+  Qe as CircleGeometry,
+  $e as ClampToEdgeWrapping,
+  w as Clock,
+  Xe as Color,
+  Ze as ColorKeyframeTrack,
+  Ye as ColorManagement,
+  Je as CompressedArrayTexture,
+  je as CompressedCubeTexture,
+  ea as CompressedTexture,
+  aa as CompressedTextureLoader,
+  sa as ConeGeometry,
+  ta as ConstantAlphaFactor,
+  ra as ConstantColorFactor,
+  ia as Controls,
+  na as CubeCamera,
+  oa as CubeReflectionMapping,
+  la as CubeRefractionMapping,
+  ca as CubeTexture,
+  fa as CubeTextureLoader,
+  ua as CubeUVReflectionMapping,
+  da as CubicBezierCurve,
+  ha as CubicBezierCurve3,
+  pa as CubicInterpolant,
+  ma as CullFaceBack,
+  ga as CullFaceFront,
+  Ma as CullFaceFrontBack,
+  ba as CullFaceNone,
+  Sa as Curve,
+  Ca as CurvePath,
+  _a as CustomBlending,
+  xa as CustomToneMapping,
+  Ta as CylinderGeometry,
+  va as Cylindrical,
+  La as DRACOLoader,
+  Ra as Data3DTexture,
+  Ga as DataArrayTexture,
+  Aa as DataTexture,
+  ya as DataTextureLoader,
+  Ba as DataUtils,
+  Fa as DecrementStencilOp,
+  Da as DecrementWrapStencilOp,
+  Ea as DefaultLoadingManager,
+  wa as DepthFormat,
+  Pa as DepthStencilFormat,
+  Ia as DepthTexture,
+  Ua as DetachedBindMode,
+  Na as DirectionalLight,
+  Oa as DirectionalLightHelper,
+  ka as DiscreteInterpolant,
+  Wa as DodecahedronGeometry,
+  Va as DoubleSide,
+  Ha as DstAlphaFactor,
+  qa as DstColorFactor,
+  za as DynamicCopyUsage,
+  Ka as DynamicDrawUsage,
+  Qa as DynamicReadUsage,
+  $a as EdgesGeometry,
+  $ as EffectComposer,
+  Xa as EllipseCurve,
+  Za as EqualCompare,
+  Ya as EqualDepth,
+  Ja as EqualStencilFunc,
+  ja as EquirectangularReflectionMapping,
+  es as EquirectangularRefractionMapping,
+  as as Euler,
+  ss as EventDispatcher,
+  ts as ExtrudeGeometry,
+  rs as FileLoader,
+  is as Float16BufferAttribute,
+  b as Float32BufferAttribute,
+  ns as FloatType,
+  os as Fog,
+  ls as FogExp2,
+  cs as FramebufferTexture,
+  fs as FrontSide,
+  us as Frustum,
+  ds as GLBufferAttribute,
+  hs as GLSL1,
+  ps as GLSL3,
+  ms as GLTFExporter,
+  Z as GLTFExporterMaterialsVariantsExtension,
+  gs as GLTFLoader,
+  X as GLTFMaterialsVariantsExtension,
+  Ms as GreaterCompare,
+  bs as GreaterDepth,
+  Ss as GreaterEqualCompare,
+  Cs as GreaterEqualDepth,
+  _s as GreaterEqualStencilFunc,
+  xs as GreaterStencilFunc,
+  Ts as GridHelper,
+  vs as Group,
+  D as HalfFloatType,
+  Ls as HemisphereLight,
+  Rs as HemisphereLightHelper,
+  Gs as HorizontalBlurShader,
+  As as IcosahedronGeometry,
+  ys as ImageBitmapLoader,
+  Bs as ImageLoader,
+  Fs as ImageUtils,
+  Ds as IncrementStencilOp,
+  Es as IncrementWrapStencilOp,
+  ws as InstancedBufferAttribute,
+  Ps as InstancedBufferGeometry,
+  Is as InstancedInterleavedBuffer,
+  Us as InstancedMesh,
+  Ns as Int16BufferAttribute,
+  Os as Int32BufferAttribute,
+  ks as Int8BufferAttribute,
+  Ws as IntType,
+  Vs as InterleavedBuffer,
+  Hs as InterleavedBufferAttribute,
+  qs as Interpolant,
+  zs as InterpolateDiscrete,
+  Ks as InterpolateLinear,
+  Qs as InterpolateSmooth,
+  $s as InvertStencilOp,
+  Xs as KeepStencilOp,
+  Zs as KeyframeTrack,
+  Ys as LOD,
+  Js as LatheGeometry,
+  js as Layers,
+  et as LessCompare,
+  at as LessDepth,
+  st as LessEqualCompare,
+  tt as LessEqualDepth,
+  rt as LessEqualStencilFunc,
+  it as LessStencilFunc,
+  nt as Light,
+  ot as LightProbe,
+  lt as Line,
+  ct as Line3,
+  ft as LineBasicMaterial,
+  ut as LineCurve,
+  dt as LineCurve3,
+  ht as LineDashedMaterial,
+  pt as LineLoop,
+  mt as LineSegments,
+  gt as LinearFilter,
+  Mt as LinearInterpolant,
+  bt as LinearMipMapLinearFilter,
+  St as LinearMipMapNearestFilter,
+  Ct as LinearMipmapLinearFilter,
+  _t as LinearMipmapNearestFilter,
+  xt as LinearSRGBColorSpace,
+  Tt as LinearToneMapping,
+  vt as LinearTransfer,
+  Lt as Loader,
+  Rt as LoaderUtils,
+  Gt as LoadingManager,
+  At as LoopOnce,
+  yt as LoopPingPong,
+  Bt as LoopRepeat,
+  Ft as LuminanceAlphaFormat,
+  Dt as LuminanceFormat,
+  Et as MOUSE,
+  wt as Material,
+  Pt as MaterialLoader,
+  It as MathUtils,
+  Ut as Matrix2,
+  Nt as Matrix3,
+  Ot as Matrix4,
+  kt as MaxEquation,
+  G as Mesh,
+  Wt as MeshBasicMaterial,
+  Vt as MeshDepthMaterial,
+  Ht as MeshDistanceMaterial,
+  qt as MeshLambertMaterial,
+  zt as MeshMatcapMaterial,
+  Kt as MeshNormalMaterial,
+  Qt as MeshPhongMaterial,
+  $t as MeshPhysicalMaterial,
+  Xt as MeshStandardMaterial,
+  Zt as MeshToonMaterial,
+  Yt as MinEquation,
+  Jt as MirroredRepeatWrapping,
+  jt as MixOperation,
+  er as MultiplyBlending,
+  ar as MultiplyOperation,
+  sr as NearestFilter,
+  tr as NearestMipMapLinearFilter,
+  rr as NearestMipMapNearestFilter,
+  ir as NearestMipmapLinearFilter,
+  nr as NearestMipmapNearestFilter,
+  or as NeutralToneMapping,
+  lr as NeverCompare,
+  cr as NeverDepth,
+  fr as NeverStencilFunc,
+  E as NoBlending,
+  ur as NoColorSpace,
+  dr as NoToneMapping,
+  hr as NormalAnimationBlendMode,
+  pr as NormalBlending,
+  mr as NotEqualCompare,
+  gr as NotEqualDepth,
+  Mr as NotEqualStencilFunc,
+  br as NumberKeyframeTrack,
+  Sr as Object3D,
+  Cr as ObjectLoader,
+  _r as ObjectSpaceNormalMap,
+  xr as OctahedronGeometry,
+  Tr as OneFactor,
+  vr as OneMinusConstantAlphaFactor,
+  Lr as OneMinusConstantColorFactor,
+  Rr as OneMinusDstAlphaFactor,
+  Gr as OneMinusDstColorFactor,
+  Ar as OneMinusSrcAlphaFactor,
+  yr as OneMinusSrcColorFactor,
+  A as OrthographicCamera,
+  Br as PCFShadowMap,
+  Fr as PCFSoftShadowMap,
+  Dr as PMREMGenerator,
+  Er as Path,
+  wr as PerspectiveCamera,
+  Pr as Plane,
+  Ir as PlaneGeometry,
+  Ur as PlaneHelper,
+  Nr as PointLight,
+  Or as PointLightHelper,
+  kr as Points,
+  Wr as PointsMaterial,
+  Vr as PolarGridHelper,
+  Hr as PolyhedronGeometry,
+  qr as PositionalAudio,
+  zr as PropertyBinding,
+  Kr as PropertyMixer,
+  Qr as QuadraticBezierCurve,
+  $r as QuadraticBezierCurve3,
+  Xr as Quaternion,
+  Zr as QuaternionKeyframeTrack,
+  Yr as QuaternionLinearInterpolant,
+  Jr as RED_GREEN_RGTC2_Format,
+  jr as RED_RGTC1_Format,
+  ei as REVISION,
+  ai as RGBADepthPacking,
+  si as RGBAFormat,
+  ti as RGBAIntegerFormat,
+  ri as RGBA_ASTC_10x10_Format,
+  ii as RGBA_ASTC_10x5_Format,
+  ni as RGBA_ASTC_10x6_Format,
+  oi as RGBA_ASTC_10x8_Format,
+  li as RGBA_ASTC_12x10_Format,
+  ci as RGBA_ASTC_12x12_Format,
+  fi as RGBA_ASTC_4x4_Format,
+  ui as RGBA_ASTC_5x4_Format,
+  di as RGBA_ASTC_5x5_Format,
+  hi as RGBA_ASTC_6x5_Format,
+  pi as RGBA_ASTC_6x6_Format,
+  mi as RGBA_ASTC_8x5_Format,
+  gi as RGBA_ASTC_8x6_Format,
+  Mi as RGBA_ASTC_8x8_Format,
+  bi as RGBA_BPTC_Format,
+  Si as RGBA_ETC2_EAC_Format,
+  Ci as RGBA_PVRTC_2BPPV1_Format,
+  _i as RGBA_PVRTC_4BPPV1_Format,
+  xi as RGBA_S3TC_DXT1_Format,
+  Ti as RGBA_S3TC_DXT3_Format,
+  vi as RGBA_S3TC_DXT5_Format,
+  Li as RGBDepthPacking,
+  Ri as RGBELoader,
+  Gi as RGBFormat,
+  Ai as RGBIntegerFormat,
+  yi as RGB_BPTC_SIGNED_Format,
+  Bi as RGB_BPTC_UNSIGNED_Format,
+  Fi as RGB_ETC1_Format,
+  Di as RGB_ETC2_Format,
+  Ei as RGB_PVRTC_2BPPV1_Format,
+  wi as RGB_PVRTC_4BPPV1_Format,
+  Pi as RGB_S3TC_DXT1_Format,
+  Ii as RGDepthPacking,
+  Ui as RGFormat,
+  Ni as RGIntegerFormat,
+  Oi as RawShaderMaterial,
+  ki as Ray,
+  Wi as Raycaster,
+  Vi as RectAreaLight,
+  Hi as RedFormat,
+  qi as RedIntegerFormat,
+  zi as ReinhardToneMapping,
+  Ki as RenderTarget,
+  Qi as RenderTarget3D,
+  $i as RenderTargetArray,
+  Xi as RepeatWrapping,
+  Zi as ReplaceStencilOp,
+  Yi as ReverseSubtractEquation,
+  Ji as RingGeometry,
+  ji as SIGNED_RED_GREEN_RGTC2_Format,
+  en as SIGNED_RED_RGTC1_Format,
+  an as SRGBColorSpace,
+  sn as SRGBTransfer,
+  tn as Scene,
+  rn as ShaderChunk,
+  nn as ShaderLib,
+  S as ShaderMaterial,
+  on as ShadowMaterial,
+  ln as Shape,
+  cn as ShapeGeometry,
+  fn as ShapePath,
+  un as ShapeUtils,
+  dn as ShortType,
+  hn as Skeleton,
+  pn as SkeletonHelper,
+  mn as SkinnedMesh,
+  gn as Source,
+  Mn as Sphere,
+  bn as SphereGeometry,
+  Sn as Spherical,
+  Cn as SphericalHarmonics3,
+  _n as SplineCurve,
+  xn as SpotLight,
+  Tn as SpotLightHelper,
+  vn as Sprite,
+  Ln as SpriteMaterial,
+  Rn as SrcAlphaFactor,
+  Gn as SrcAlphaSaturateFactor,
+  An as SrcColorFactor,
+  yn as StaticCopyUsage,
+  Bn as StaticDrawUsage,
+  Fn as StaticReadUsage,
+  Dn as StereoCamera,
+  En as StreamCopyUsage,
+  wn as StreamDrawUsage,
+  Pn as StreamReadUsage,
+  In as StringKeyframeTrack,
+  Un as SubtractEquation,
+  Nn as SubtractiveBlending,
+  On as TOUCH,
+  kn as TangentSpaceNormalMap,
+  Wn as TetrahedronGeometry,
+  Vn as Texture,
+  Hn as TextureLoader,
+  qn as TextureUtils,
+  zn as TorusGeometry,
+  Kn as TorusKnotGeometry,
+  Qn as Triangle,
+  $n as TriangleFanDrawMode,
+  Xn as TriangleStripDrawMode,
+  Zn as TrianglesDrawMode,
+  Yn as TubeGeometry,
+  Jn as USDZExporter,
+  jn as UVMapping,
+  eo as Uint16BufferAttribute,
+  ao as Uint32BufferAttribute,
+  so as Uint8BufferAttribute,
+  to as Uint8ClampedBufferAttribute,
+  ro as Uniform,
+  io as UniformsGroup,
+  no as UniformsLib,
+  B as UniformsUtils,
+  oo as UnsignedByteType,
+  lo as UnsignedInt248Type,
+  co as UnsignedInt5999Type,
+  fo as UnsignedIntType,
+  uo as UnsignedShort4444Type,
+  ho as UnsignedShort5551Type,
+  po as UnsignedShortType,
+  mo as VSMShadowMap,
+  C as Vector2,
+  go as Vector3,
+  Mo as Vector4,
+  bo as VectorKeyframeTrack,
+  So as VerticalBlurShader,
+  Co as VideoTexture,
+  Q as WebGL,
+  _o as WebGL3DRenderTarget,
+  xo as WebGLArrayRenderTarget,
+  To as WebGLCoordinateSystem,
+  vo as WebGLCubeRenderTarget,
+  F as WebGLRenderTarget,
+  Lo as WebGLRenderer,
+  Ro as WebGLUtils,
+  Go as WebGPUCoordinateSystem,
+  Ao as WireframeGeometry,
+  yo as WrapAroundEnding,
+  Bo as ZeroCurvatureEnding,
+  Fo as ZeroFactor,
+  Do as ZeroSlopeEnding,
+  Eo as ZeroStencilOp,
+  wo as createCanvasElement
+};