@tresjs/post-processing 2.0.0 → 2.1.0

package/dist/tres-post-processing.js

@@ -1,46 +1,46 @@
 /**
  * name: @tresjs/post-processing
- * version: v2.0.0
+ * version: v2.1.0
  * (c) 2025
  * description: Post-processing library for TresJS
  * author: Alvaro Saburido <hola@alvarosaburido.dev> (https://github.com/alvarosabu/)
  */
-import { watch as D, defineComponent as p, shallowRef as N, provide as de, computed as O, onUnmounted as j, renderSlot as ue, inject as ce, watchEffect as m, nextTick as fe } from "vue";
-import { EffectComposer as K, RenderPass as Te, NormalPass as we, DepthDownsamplingPass as Me, EffectPass as ye, BloomEffect as Z, DepthOfFieldEffect as J, GlitchEffect as V, GlitchMode as Ce, BlendFunction as he, NoiseEffect as _, OutlineEffect as $, PixelationEffect as ee, VignetteTechnique as Ee, VignetteEffect as te } from "postprocessing";
-import { useTresContext as S, useLoop as z, normalizeColor as Y } from "@tresjs/core";
-import { HalfFloatType as b, OrthographicCamera as De, BufferGeometry as Le, Float32BufferAttribute as se, Mesh as Pe, ShaderMaterial as x, UniformsUtils as w, Vector2 as h, WebGLRenderTarget as M, NoBlending as Be, Clock as Re, Color as X, MathUtils as v, DataTexture as Ne, RedFormat as Oe, FloatType as ze, MeshNormalMaterial as Fe, NearestFilter as E, DepthTexture as We, Vector4 as Ue, RawShaderMaterial as He, ColorManagement as Ge, SRGBTransfer as Xe, LinearToneMapping as je, ReinhardToneMapping as Ie, CineonToneMapping as Ve, ACESFilmicToneMapping as Ye, AgXToneMapping as Qe, NeutralToneMapping as qe, Texture as ae, LinearFilter as ke, Vector3 as R, AdditiveBlending as Ke, MeshBasicMaterial as Ze } from "three";
-import { useDevicePixelRatio as me } from "@vueuse/core";
-const pe = /([^[.\]])+/g, Je = (i, e) => {
+import { watch as C, defineComponent as c, shallowRef as z, provide as Ce, computed as F, onUnmounted as V, renderSlot as Ee, inject as De, watchEffect as v, nextTick as Pe } from "vue";
+import { EffectComposer as oe, RenderPass as We, NormalPass as Ue, DepthDownsamplingPass as He, EffectPass as Ge, BloomEffect as ae, DepthOfFieldEffect as se, GlitchEffect as Y, GlitchMode as Xe, NoiseEffect as re, OutlineEffect as ie, PixelationEffect as ne, VignetteEffect as le, Effect as Z, BlendFunction as _, ToneMappingEffect as ue, ChromaticAberrationEffect as q, HueSaturationEffect as ce, ScanlineEffect as k, ColorAverageEffect as Q, LensDistortionEffect as de, ShockWaveEffect as fe, TiltShiftEffect as he, DotScreenEffect as pe, SepiaEffect as me } from "postprocessing";
+import { useTresContext as A, useLoop as W, normalizeColor as K } from "@tresjs/core";
+import { HalfFloatType as w, Uniform as E, Vector2 as d, Vector3 as P, OrthographicCamera as Ie, BufferGeometry as je, Float32BufferAttribute as ge, Mesh as Ve, ShaderMaterial as S, UniformsUtils as M, WebGLRenderTarget as D, NoBlending as Ye, Clock as qe, Color as j, MathUtils as b, DataTexture as ke, RedFormat as Qe, FloatType as Ke, MeshNormalMaterial as Je, NearestFilter as O, DepthTexture as Ze, Vector4 as _e, RawShaderMaterial as $e, ColorManagement as et, SRGBTransfer as tt, LinearToneMapping as ot, ReinhardToneMapping as at, CineonToneMapping as st, ACESFilmicToneMapping as rt, AgXToneMapping as it, NeutralToneMapping as nt, Texture as ve, LinearFilter as lt, AdditiveBlending as ut, MeshBasicMaterial as ct } from "three";
+import { useDevicePixelRatio as Le } from "@vueuse/core";
+const Oe = /([^[.\]])+/g, dt = (r, e) => {
   if (!e)
     return;
-  const t = Array.isArray(e) ? e : e.match(pe);
-  return t == null ? void 0 : t.reduce((s, a) => s && s[a], i);
-}, re = (i, e, t) => {
-  const s = Array.isArray(e) ? e : e.match(pe);
-  s && s.reduce((a, r, o) => (a[r] === void 0 && (a[r] = {}), o === s.length - 1 && (a[r] = t), a[r]), i);
-}, q = (i, e) => {
-  const t = { ...i };
-  return e.forEach((s) => delete t[s]), t;
-}, ge = (i, e, t, s, a = {}) => D(i, (r) => {
-  var o;
+  const t = Array.isArray(e) ? e : e.match(Oe);
+  return t == null ? void 0 : t.reduce((o, a) => o && o[a], r);
+}, xe = (r, e, t) => {
+  const o = Array.isArray(e) ? e : e.match(Oe);
+  o && o.reduce((a, s, i) => (a[s] === void 0 && (a[s] = {}), i === o.length - 1 && (a[s] = t), a[s]), r);
+}, $ = (r, e) => {
+  const t = { ...r };
+  return e.forEach((o) => delete t[o]), t;
+}, ee = (r, e, t, o, a = {}) => C(r, (s) => {
+  var i;
   if (e.value)
-    if (r === void 0) {
-      const n = s();
-      re(e.value, t, Je(n, t)), (o = n.dispose) == null || o.call(n);
+    if (s === void 0) {
+      const n = o();
+      xe(e.value, t, dt(n, t)), (i = n.dispose) == null || i.call(n);
     } else
-      re(e.value, t, i());
-}, a), F = (i, e, t) => i.map(([s, a]) => ge(
-  s,
+      xe(e.value, t, r());
+}, a), g = (r, e, t) => r.map(([o, a]) => ee(
+  o,
   e,
   a,
   t
-)), I = (i, e, t) => Object.keys(i).map((s) => ge(
-  () => i[s],
+)), U = (r, e, t) => Object.keys(r).map((o) => ee(
+  () => r[o],
   e,
-  s,
+  o,
   t
 ));
-class oe {
+class be {
   static isWebGL2Available() {
     try {
       const e = document.createElement("canvas");
@@ -51,8 +51,8 @@ class oe {
   }
   static isColorSpaceAvailable(e) {
     try {
-      const t = document.createElement("canvas"), s = window.WebGL2RenderingContext && t.getContext("webgl2");
-      return s.drawingBufferColorSpace = e, s.drawingBufferColorSpace === e;
+      const t = document.createElement("canvas"), o = window.WebGL2RenderingContext && t.getContext("webgl2");
+      return o.drawingBufferColorSpace = e, o.drawingBufferColorSpace === e;
     } catch {
       return !1;
     }
@@ -64,13 +64,13 @@ class oe {
     const t = {
       1: "WebGL",
       2: "WebGL 2"
-    }, s = {
+    }, o = {
       1: window.WebGLRenderingContext,
       2: window.WebGL2RenderingContext
     };
     let a = 'Your $0 does not seem to support <a href="http://khronos.org/webgl/wiki/Getting_a_WebGL_Implementation" style="color:#000">$1</a>';
-    const r = document.createElement("div");
-    return r.id = "webglmessage", r.style.fontFamily = "monospace", r.style.fontSize = "13px", r.style.fontWeight = "normal", r.style.textAlign = "center", r.style.background = "#fff", r.style.color = "#000", r.style.padding = "1.5em", r.style.width = "400px", r.style.margin = "5em auto 0", s[e] ? a = a.replace("$0", "graphics card") : a = a.replace("$0", "browser"), a = a.replace("$1", t[e]), r.innerHTML = a, r;
+    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", o[e] ? a = a.replace("$0", "graphics card") : a = a.replace("$0", "browser"), a = a.replace("$1", t[e]), s.innerHTML = a, s;
   }
   // @deprecated, r168
   static isWebGLAvailable() {
@@ -86,7 +86,7 @@ class oe {
     return console.warn("getWebGLErrorMessage() has been deprecated and will be removed in r178. Use getWebGL2ErrorMessage() instead."), this.getErrorMessage(1);
   }
 }
-const ve = Symbol("effectComposerPmndrs"), pt = /* @__PURE__ */ p({
+const Re = Symbol("effectComposerPmndrs"), Lt = /* @__PURE__ */ c({
   __name: "EffectComposerPmndrs",
   props: {
     enabled: { type: Boolean, default: !0 },
@@ -96,65 +96,65 @@ const ve = Symbol("effectComposerPmndrs"), pt = /* @__PURE__ */ p({
     resolutionScale: {},
     autoClear: { type: Boolean, default: !0 },
     multisampling: { default: 0 },
-    frameBufferType: { default: b }
+    frameBufferType: { default: w }
   },
   emits: ["render"],
-  setup(i, { expose: e, emit: t }) {
-    const s = i, a = t, { scene: r, camera: o, renderer: n, sizes: l, render: g } = S(), d = N(null);
-    let c = null, u = null;
-    de(ve, d), e({ composer: d });
-    const T = () => {
-      d.value && (u = new we(r.value, o.value), u.enabled = !1, d.value.addPass(u), s.resolutionScale !== void 0 && oe.isWebGL2Available() && (c = new Me({
-        normalBuffer: u.texture,
-        resolutionScale: s.resolutionScale
-      }), c.enabled = !1, d.value.addPass(c)));
-    }, W = O(() => {
-      const f = new K(), B = {
-        depthBuffer: s.depthBuffer !== void 0 ? s.depthBuffer : f.inputBuffer.depthBuffer,
-        stencilBuffer: s.stencilBuffer !== void 0 ? s.stencilBuffer : f.inputBuffer.stencilBuffer,
-        multisampling: oe.isWebGL2Available() ? s.multisampling !== void 0 ? s.multisampling : f.multisampling : 0,
-        frameBufferType: s.frameBufferType !== void 0 ? s.frameBufferType : b
+  setup(r, { expose: e, emit: t }) {
+    const o = r, a = t, { scene: s, camera: i, renderer: n, sizes: l, render: x } = A(), u = z(null);
+    let p = null, f = null;
+    Ce(Re, u), e({ composer: u });
+    const y = () => {
+      u.value && (f = new Ue(s.value, i.value), f.enabled = !1, u.value.addPass(f), o.resolutionScale !== void 0 && be.isWebGL2Available() && (p = new He({
+        normalBuffer: f.texture,
+        resolutionScale: o.resolutionScale
+      }), p.enabled = !1, u.value.addPass(p)));
+    }, H = F(() => {
+      const m = new oe(), N = {
+        depthBuffer: o.depthBuffer !== void 0 ? o.depthBuffer : m.inputBuffer.depthBuffer,
+        stencilBuffer: o.stencilBuffer !== void 0 ? o.stencilBuffer : m.inputBuffer.stencilBuffer,
+        multisampling: be.isWebGL2Available() ? o.multisampling !== void 0 ? o.multisampling : m.multisampling : 0,
+        frameBufferType: o.frameBufferType !== void 0 ? o.frameBufferType : w
       };
-      return f.dispose(), B;
-    }), k = () => {
-      var f;
-      !n.value && !r.value && !o.value || ((f = d.value) == null || f.dispose(), d.value = new K(n.value, W.value), d.value.addPass(new Te(r.value, o.value)), s.disableNormalPass || T());
+      return m.dispose(), N;
+    }), te = () => {
+      var m;
+      !n.value && !s.value && !i.value || ((m = u.value) == null || m.dispose(), u.value = new oe(n.value, H.value), u.value.addPass(new We(s.value, i.value)), o.disableNormalPass || y());
     };
-    D([n, r, o, () => s.disableNormalPass], () => {
-      !l.width.value || !l.height.value || k();
-    }), D(() => [l.width.value, l.height.value], ([f, B]) => {
-      !f && !B || (d.value ? d.value.setSize(f, B) : k());
+    C([n, s, i, () => o.disableNormalPass], () => {
+      !l.width.value || !l.height.value || te();
+    }), C(() => [l.width.value, l.height.value], ([m, N]) => {
+      !m && !N || (u.value ? u.value.setSize(m, N) : te());
     }, {
       immediate: !0
     });
-    const { render: Ae } = z();
-    return Ae(() => {
-      if (s.enabled && n.value && d.value && l.width.value && l.height.value && g.frames.value > 0) {
-        const f = n.value.autoClear;
-        n.value.autoClear = s.autoClear, s.stencilBuffer && !s.autoClear && n.value.clearStencil(), d.value.render(), a("render", d.value), n.value.autoClear = f;
+    const { render: Fe } = W();
+    return Fe(() => {
+      if (o.enabled && n.value && u.value && l.width.value && l.height.value && x.frames.value > 0) {
+        const m = n.value.autoClear;
+        n.value.autoClear = o.autoClear, o.stencilBuffer && !o.autoClear && n.value.clearStencil(), u.value.render(), a("render", u.value), n.value.autoClear = m;
       }
-      g.frames.value = g.mode.value === "always" ? 1 : Math.max(0, g.frames.value - 1);
-    }), j(() => {
-      var f;
-      (f = d.value) == null || f.dispose();
-    }), (f, B) => ue(f.$slots, "default");
-  }
-}), y = (i, e) => {
-  const t = ce(ve), s = N(null), a = N(null), { scene: r, camera: o, invalidate: n } = S();
-  e && D(e, () => n()), m(() => {
-    !o.value || !(a != null && a.value) || (a.value.mainCamera = o.value);
+      x.frames.value = x.mode.value === "always" ? 1 : Math.max(0, x.frames.value - 1);
+    }), V(() => {
+      var m;
+      (m = u.value) == null || m.dispose();
+    }), (m, N) => Ee(m.$slots, "default");
+  }
+}), h = (r, e) => {
+  const t = De(Re), o = z(null), a = z(null), { scene: s, camera: i, invalidate: n } = A();
+  e && C(e, () => n()), v(() => {
+    !i.value || !(a != null && a.value) || (a.value.mainCamera = i.value);
   });
-  const l = m(() => {
-    !o.value || !(t != null && t.value) || !r.value || (fe(() => l()), !a.value && (a.value = i(), s.value = new ye(o.value, a.value), t.value.addPass(s.value)));
+  const l = v(() => {
+    !i.value || !(t != null && t.value) || !s.value || (Pe(() => l()), !a.value && (a.value = r(), o.value = new Ge(i.value, a.value), t.value.addPass(o.value)));
   });
-  return j(() => {
-    var g, d, c;
-    s.value && ((g = t == null ? void 0 : t.value) == null || g.removePass(s.value)), (d = a.value) == null || d.dispose(), (c = s.value) == null || c.dispose();
+  return V(() => {
+    var x, u, p;
+    o.value && ((x = t == null ? void 0 : t.value) == null || x.removePass(o.value)), (u = a.value) == null || u.dispose(), (p = o.value) == null || p.dispose();
   }), {
-    pass: s,
+    pass: o,
     effect: a
   };
-}, gt = /* @__PURE__ */ p({
+}, Ot = /* @__PURE__ */ c({
   __name: "BloomPmndrs",
   props: {
     blendFunction: {},
@@ -164,9 +164,9 @@ const ve = Symbol("effectComposerPmndrs"), pt = /* @__PURE__ */ p({
     luminanceSmoothing: {},
     mipmapBlur: { type: Boolean, default: void 0 }
   },
-  setup(i, { expose: e }) {
-    const t = i, { pass: s, effect: a } = y(() => new Z(t), t);
-    return e({ pass: s, effect: a }), F(
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new ae(t), t);
+    return e({ pass: o, effect: a }), g(
       [
         // blendFunction is not updated, because it has no setter in BloomEffect
         [() => t.intensity, "intensity"],
@@ -175,11 +175,11 @@ const ve = Symbol("effectComposerPmndrs"), pt = /* @__PURE__ */ p({
         [() => t.luminanceThreshold, "luminanceMaterial.threshold"]
       ],
       a,
-      () => new Z()
+      () => new ae()
     ), () => {
     };
   }
-}), vt = /* @__PURE__ */ p({
+}), Rt = /* @__PURE__ */ c({
   __name: "DepthOfFieldPmndrs",
   props: {
     blendFunction: {},
@@ -192,9 +192,9 @@ const ve = Symbol("effectComposerPmndrs"), pt = /* @__PURE__ */ p({
     resolutionX: {},
     resolutionY: {}
   },
-  setup(i, { expose: e }) {
-    const t = i, { camera: s } = S(), { pass: a, effect: r } = y(() => new J(s.value, t), t);
-    return e({ pass: a, effect: r }), F(
+  setup(r, { expose: e }) {
+    const t = r, { camera: o } = A(), { pass: a, effect: s } = h(() => new se(o.value, t), t);
+    return e({ pass: a, effect: s }), g(
       [
         // blendFunction is not updated, because it has no setter in BloomEffect
         [() => t.worldFocusDistance, "circleOfConfusionMaterial.worldFocusDistance"],
@@ -206,12 +206,12 @@ const ve = Symbol("effectComposerPmndrs"), pt = /* @__PURE__ */ p({
         [() => t.resolutionX, "resolution.width"],
         [() => t.resolutionY, "resolution.height"]
       ],
-      r,
-      () => new J()
+      s,
+      () => new se()
     ), () => {
     };
   }
-}), xt = /* @__PURE__ */ p({
+}), Bt = /* @__PURE__ */ c({
   __name: "GlitchPmndrs",
   props: {
     blendFunction: {},
@@ -226,43 +226,43 @@ const ve = Symbol("effectComposerPmndrs"), pt = /* @__PURE__ */ p({
     perturbationMap: {},
     dtSize: {}
   },
-  setup(i, { expose: e }) {
-    const t = i, { pass: s, effect: a } = y(() => new V(t), t);
-    e({ pass: s, effect: a });
-    const { onBeforeRender: r } = z();
-    return r(({ invalidate: o }) => o()), m(() => {
-      const o = () => {
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new Y(t), t);
+    e({ pass: o, effect: a });
+    const { onBeforeRender: s } = W();
+    return s(({ invalidate: i }) => i()), v(() => {
+      const i = () => {
         if (t.mode !== void 0)
-          return t.active === !1 ? Ce.DISABLED : t.mode;
-        const n = new V(), l = n.mode;
+          return t.active === !1 ? Xe.DISABLED : t.mode;
+        const n = new Y(), l = n.mode;
         return n.dispose(), l;
       };
-      a.value && (a.value.mode = o());
-    }), I(
-      q(t, ["active", "mode", "blendFunction"]),
+      a.value && (a.value.mode = i());
+    }), U(
+      $(t, ["active", "mode", "blendFunction"]),
       a,
-      () => new V()
+      () => new Y()
     ), () => {
     };
   }
-}), bt = /* @__PURE__ */ p({
+}), Nt = /* @__PURE__ */ c({
   __name: "NoisePmndrs",
   props: {
-    premultiply: { type: Boolean, default: !1 },
-    blendFunction: { default: he.SCREEN }
+    premultiply: { type: Boolean, default: void 0 },
+    blendFunction: {}
   },
-  setup(i, { expose: e }) {
-    const t = i, { pass: s, effect: a } = y(() => new _(t), t);
-    e({ pass: s, effect: a });
-    const { onBeforeRender: r } = z();
-    return r(({ invalidate: o }) => o()), I(
-      q(t, ["blendFunction"]),
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new re(t), t);
+    e({ pass: o, effect: a });
+    const { onBeforeRender: s } = W();
+    return s(({ invalidate: i }) => i()), U(
+      $(t, ["blendFunction"]),
       a,
-      () => new _()
+      () => new re()
     ), () => {
     };
   }
-}), St = /* @__PURE__ */ p({
+}), zt = /* @__PURE__ */ c({
   __name: "OutlinePmndrs",
   props: {
     outlinedObjects: {},
@@ -281,8 +281,8 @@ const ve = Symbol("effectComposerPmndrs"), pt = /* @__PURE__ */ p({
     hiddenEdgeColor: {},
     visibleEdgeColor: {}
   },
-  setup(i, { expose: e }) {
-    const t = i, s = (d) => d !== void 0 ? Y(d).getHex() : void 0, { camera: a, scene: r } = S(), o = {
+  setup(r, { expose: e }) {
+    const t = r, o = (u) => u !== void 0 ? K(u).getHex() : void 0, { camera: a, scene: s } = A(), i = {
       blur: t.blur,
       xRay: t.xRay,
       kernelSize: t.kernelSize,
@@ -295,25 +295,25 @@ const ve = Symbol("effectComposerPmndrs"), pt = /* @__PURE__ */ p({
       multisampling: t.multisampling,
       patternTexture: t.patternTexture,
       resolutionScale: t.resolutionScale,
-      hiddenEdgeColor: s(t.hiddenEdgeColor),
-      visibleEdgeColor: s(t.visibleEdgeColor)
-    }, { pass: n, effect: l } = y(() => new $(r.value, a.value, o), t);
-    e({ pass: n, effect: l }), D(
+      hiddenEdgeColor: o(t.hiddenEdgeColor),
+      visibleEdgeColor: o(t.visibleEdgeColor)
+    }, { pass: n, effect: l } = h(() => new ie(s.value, a.value, i), t);
+    e({ pass: n, effect: l }), C(
       [() => t.outlinedObjects, l],
       // watchEffect is intentionally not used here as it would result in an endless loop
       () => {
-        var d;
-        (d = l.value) == null || d.selection.set(t.outlinedObjects || []);
+        var u;
+        (u = l.value) == null || u.selection.set(t.outlinedObjects || []);
       },
       {
         immediate: !0
       }
     );
-    const g = O(() => ({
-      hiddenEdgeColor: t.hiddenEdgeColor ? Y(t.hiddenEdgeColor) : void 0,
-      visibleEdgeColor: t.visibleEdgeColor ? Y(t.visibleEdgeColor) : void 0
+    const x = F(() => ({
+      hiddenEdgeColor: t.hiddenEdgeColor ? K(t.hiddenEdgeColor) : void 0,
+      visibleEdgeColor: t.visibleEdgeColor ? K(t.visibleEdgeColor) : void 0
     }));
-    return F(
+    return g(
       [
         /* some properties are not updated because of different reasons:
             resolutionX - has no setter in OutlineEffect
@@ -329,46 +329,732 @@ const ve = Symbol("effectComposerPmndrs"), pt = /* @__PURE__ */ p({
         [() => t.edgeStrength, "edgeStrength"],
         [() => t.patternScale, "patternScale"],
         [() => t.multisampling, "multisampling"],
-        [() => g.value.hiddenEdgeColor, "hiddenEdgeColor"],
-        [() => g.value.visibleEdgeColor, "visibleEdgeColor"]
+        [() => x.value.hiddenEdgeColor, "hiddenEdgeColor"],
+        [() => x.value.visibleEdgeColor, "visibleEdgeColor"]
       ],
       l,
-      () => new $()
+      () => new ie()
     ), () => {
     };
   }
-}), At = /* @__PURE__ */ p({
+}), Ft = /* @__PURE__ */ c({
   __name: "PixelationPmndrs",
   props: {
     granularity: {}
   },
-  setup(i, { expose: e }) {
-    const t = i, { pass: s, effect: a } = y(() => new ee(t.granularity), t);
-    return e({ pass: s, effect: a }), I(
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new ne(t.granularity), t);
+    return e({ pass: o, effect: a }), U(
       t,
       a,
-      () => new ee()
+      () => new ne()
     ), () => {
     };
   }
-}), Tt = /* @__PURE__ */ p({
+}), Wt = /* @__PURE__ */ c({
   __name: "VignettePmndrs",
   props: {
-    technique: { default: Ee.DEFAULT },
-    blendFunction: { default: he.NORMAL },
-    offset: { default: 0.5 },
-    darkness: { default: 0.5 }
+    technique: {},
+    blendFunction: {},
+    offset: {},
+    darkness: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new le(t), t);
+    return e({ pass: o, effect: a }), U(
+      $(t, ["blendFunction"]),
+      a,
+      () => new le()
+    ), () => {
+    };
+  }
+});
+class Se extends Z {
+  /**
+   * Creates a new BarrelBlurEffect instance.
+   *
+   * @param {object} [options] - Configuration options for the effect.
+   * @param {BlendFunction} [options.blendFunction] - Blend mode.
+   * @param {number} [options.amount] - Intensity of the barrel distortion (0 to 1).
+   * @param {Vector2} [options.offset] - Offset of the barrel distortion center (0 to 1 for both x and y). This allows you to change the position of the distortion effect.
+   *
+   */
+  constructor({ blendFunction: e = _.NORMAL, amount: t = 0.15, offset: o = new d(0.5, 0.5) } = {}) {
+    super("BarrelBlurEffect", `
+    uniform float amount;
+    uniform vec2 offset;
+
+    #define NUM_ITER 16
+    #define RECIP_NUM_ITER 0.0625
+    #define GAMMA 1.0
+
+    vec3 spectrum_offset(float t) {
+        float lo = step(t, 0.5);
+        float hi = 1.0 - lo;
+        float w = 1.0 - abs(2.0 * t - 1.0);
+        return pow(vec3(lo, 1.0, hi) * vec3(1.0 - w, w, 1.0 - w), vec3(1.0 / GAMMA));
+    }
+
+    vec2 barrelDistortion(vec2 p, float amt) {
+        p = p - offset;
+        float theta = atan(p.y, p.x);
+        float radius = pow(length(p), 1.0 + 3.0 * amt);
+        return vec2(cos(theta), sin(theta)) * radius + offset;
+    }
+
+    void mainUv(inout vec2 uv) {
+        uv = barrelDistortion(uv, amount * 0.5);
+    }
+
+    void mainImage(const in vec4 inputColor, const in vec2 uv, out vec4 outputColor) {
+        vec3 sumcol = vec3(0.0);
+        vec3 sumw = vec3(0.0);
+
+        for (int i = 0; i < NUM_ITER; ++i) {
+            float t = float(i) * RECIP_NUM_ITER;
+            vec3 w = spectrum_offset(t);
+            vec2 distortedUV = barrelDistortion(uv, amount * t);
+            sumcol += w * texture(inputBuffer, distortedUV).rgb;
+            sumw += w;
+        }
+
+        vec3 outcol = pow(sumcol / sumw, vec3(1.0 / GAMMA));
+
+        outcol = clamp(outcol, 0.0, 1.0); // Ensures normalized color values
+
+        outputColor = vec4(outcol, inputColor.a); // Preserves original alpha
+    }
+      `, {
+      blendFunction: e,
+      uniforms: /* @__PURE__ */ new Map([
+        ["amount", new E(t)],
+        // Uniform controlling the intensity of distortion
+        ["offset", new E(o)]
+        // Uniform controlling the offset of distortion
+      ])
+    });
+  }
+  /**
+   * The amount.
+   *
+   * @type {number}
+   */
+  get amount() {
+    var e;
+    return (e = this.uniforms.get("amount")) == null ? void 0 : e.value;
+  }
+  set amount(e) {
+    this.uniforms.get("amount").value = e;
+  }
+  /**
+   * The offset.
+   *
+   * @type {Vector2}
+   */
+  get offset() {
+    var e;
+    return (e = this.uniforms.get("offset")) == null ? void 0 : e.value;
+  }
+  set offset(e) {
+    this.uniforms.get("offset").value = e;
+  }
+}
+const Ut = /* @__PURE__ */ c({
+  __name: "BarrelBlurPmndrs",
+  props: {
+    blendFunction: {},
+    amount: {},
+    offset: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(
+      () => new Se({
+        ...t,
+        offset: Array.isArray(t.offset) ? new d(...t.offset) : t.offset
+      }),
+      t
+    );
+    return e({ pass: o, effect: a }), g(
+      [
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.amount, "amount"],
+        [() => t.offset, "offset"]
+      ],
+      a,
+      () => new Se()
+    ), () => {
+    };
+  }
+}), Ht = /* @__PURE__ */ c({
+  __name: "ToneMappingPmndrs",
+  props: {
+    mode: {},
+    blendFunction: {},
+    resolution: {},
+    averageLuminance: {},
+    middleGrey: {},
+    minLuminance: {},
+    whitePoint: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new ue(t), t);
+    return e({ pass: o, effect: a }), g(
+      [
+        [() => t.mode, "mode"],
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.resolution, "resolution"],
+        [() => t.averageLuminance, "averageLuminance"],
+        [() => t.middleGrey, "middleGrey"],
+        [() => t.minLuminance, "adaptiveLuminanceMaterial.minLuminance"],
+        [() => t.whitePoint, "whitePoint"]
+      ],
+      a,
+      () => new ue()
+    ), () => {
+    };
+  }
+}), Gt = /* @__PURE__ */ c({
+  __name: "ChromaticAberrationPmndrs",
+  props: {
+    blendFunction: {},
+    offset: {},
+    radialModulation: { type: Boolean, default: void 0 },
+    modulationOffset: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, o = new q(), { pass: a, effect: s } = h(() => new q({
+      ...t,
+      // Unfortunately, these defaults must be set this way as the type in postprocessing is not correct.
+      // The arguments are optional in the actual constructor, but not in the type.
+      radialModulation: t.radialModulation ?? o.radialModulation,
+      modulationOffset: t.modulationOffset ?? o.modulationOffset
+    }), t);
+    return o.dispose(), e({ pass: a, effect: s }), g(
+      [
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.offset, "offset"],
+        [() => t.radialModulation, "radialModulation"],
+        [() => t.modulationOffset, "modulationOffset"]
+      ],
+      s,
+      () => new q()
+    ), () => {
+    };
+  }
+}), Xt = /* @__PURE__ */ c({
+  __name: "HueSaturationPmndrs",
+  props: {
+    saturation: {},
+    hue: {},
+    blendFunction: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new ce(t), t);
+    return e({ pass: o, effect: a }), g(
+      [
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.hue, "hue"],
+        [() => t.saturation, "saturation"]
+      ],
+      a,
+      () => new ce()
+    ), () => {
+    };
+  }
+}), It = /* @__PURE__ */ c({
+  __name: "ScanlinePmndrs",
+  props: {
+    blendFunction: {},
+    density: {},
+    scrollSpeed: {},
+    opacity: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new k(t), t);
+    return e({ pass: o, effect: a }), g(
+      [
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.density, "density"],
+        [() => t.scrollSpeed, "scrollSpeed"]
+      ],
+      a,
+      () => new k()
+    ), C(
+      [() => t.opacity],
+      () => {
+        var s, i;
+        if (t.opacity !== void 0)
+          (s = a.value) == null || s.blendMode.setOpacity(t.opacity);
+        else {
+          const n = new k();
+          (i = a.value) == null || i.blendMode.setOpacity(n.blendMode.getOpacity()), n.dispose();
+        }
+      },
+      {
+        immediate: !0
+      }
+    ), () => {
+    };
+  }
+}), ft = `
+uniform float radius;
+uniform int sectorCount;
+
+const int MAX_SECTOR_COUNT = 8;
+
+float polynomialWeight(float x, float y, float eta, float lambda) {
+    float polyValue = (x + eta) - lambda * (y * y);
+    return max(0.0, polyValue * polyValue);
+}
+
+void getSectorVarianceAndAverageColor(mat2 anisotropyMat, float angle, float radius, out vec3 avgColor, out float variance) {
+    vec3 weightedColorSum = vec3(0.0);
+    vec3 weightedSquaredColorSum = vec3(0.0);
+    float totalWeight = 0.0;
+
+    float eta = 0.1;
+    float lambda = 0.5;
+    float angleStep = 0.196349; // Precompute angle step
+    float halfAngleRange = 0.392699; // Precompute half angle range
+
+    float cosAngle = cos(angle);
+    float sinAngle = sin(angle);
+
+    for (float r = 1.0; r <= radius; r += 1.0) {
+        float rCosAngle = r * cosAngle;
+        float rSinAngle = r * sinAngle;
+        for (float a = -halfAngleRange; a <= halfAngleRange; a += angleStep) {
+            float cosA = cos(a);
+            float sinA = sin(a);
+            vec2 sampleOffset = vec2(rCosAngle * cosA - rSinAngle * sinA, rCosAngle * sinA + rSinAngle * cosA) / resolution;
+            sampleOffset *= anisotropyMat;
+
+            vec3 color = texture2D(inputBuffer, vUv + sampleOffset).rgb;
+            float weight = polynomialWeight(sampleOffset.x, sampleOffset.y, eta, lambda);
+            
+            weightedColorSum += color * weight;
+            weightedSquaredColorSum += color * color * weight;
+            totalWeight += weight;
+        }
+    }
+
+    // Calculate average color and variance
+    avgColor = weightedColorSum / totalWeight;
+    vec3 varianceRes = (weightedSquaredColorSum / totalWeight) - (avgColor * avgColor);
+    variance = dot(varianceRes, vec3(0.299, 0.587, 0.114)); // Convert to luminance
+}
+
+vec4 getDominantOrientation(vec4 structureTensor) {
+    float Jxx = structureTensor.r; 
+    float Jyy = structureTensor.g; 
+    float Jxy = structureTensor.b; 
+
+    float trace = Jxx + Jyy;
+    float det = Jxx * Jyy - Jxy * Jxy;
+    float lambda1 = 0.5 * (trace + sqrt(trace * trace - 4.0 * det));
+    float lambda2 = 0.5 * (trace - sqrt(trace * trace - 4.0 * det));
+
+    float dominantOrientation = atan(2.0 * Jxy, Jxx - Jyy) / 2.0;
+    return vec4(dominantOrientation, lambda1, lambda2, 0.0);
+}
+
+void mainImage(const in vec4 inputColor, const in vec2 uv, out vec4 outputColor) {
+    vec4 structureTensor = texture2D(inputBuffer, uv);
+
+    vec3 sectorAvgColors[MAX_SECTOR_COUNT];
+    float sectorVariances[MAX_SECTOR_COUNT];
+
+    vec4 orientationAndAnisotropy = getDominantOrientation(structureTensor);
+    vec2 orientation = orientationAndAnisotropy.xy;
+
+    float anisotropy = (orientationAndAnisotropy.z - orientationAndAnisotropy.w) / (orientationAndAnisotropy.z + orientationAndAnisotropy.w + 1e-7);
+
+    float alpha = 25.0;
+    float scaleX = alpha / (anisotropy + alpha);
+    float scaleY = (anisotropy + alpha) / alpha;
+
+    mat2 anisotropyMat = mat2(orientation.x, -orientation.y, orientation.y, orientation.x) * mat2(scaleX, 0.0, 0.0, scaleY);
+
+    for (int i = 0; i < sectorCount; i++) {
+      float angle = float(i) * 6.28318 / float(sectorCount); // 2π / sectorCount
+      getSectorVarianceAndAverageColor(anisotropyMat, angle, float(radius), sectorAvgColors[i], sectorVariances[i]);
+    }
+
+    float minVariance = sectorVariances[0];
+    vec3 finalColor = sectorAvgColors[0];
+
+    for (int i = 1; i < sectorCount; i++) {
+        if (sectorVariances[i] < minVariance) {
+            minVariance = sectorVariances[i];
+            finalColor = sectorAvgColors[i];
+        }
+    }
+
+    outputColor = vec4(finalColor, inputColor.a);
+}
+`;
+class Ae extends Z {
+  /**
+   * Creates a new KuwaharaEffect instance.
+   *
+   * @param {object} [options] - Configuration options for the effect.
+   * @param {BlendFunction} [options.blendFunction] - Blend mode.
+   * @param {number} [options.radius] - Intensity of the effect.
+   * @param {number} [options.sectorCount] - Number of sectors.
+   *
+   */
+  constructor({ blendFunction: e = _.NORMAL, radius: t = 1, sectorCount: o = 4 } = {}) {
+    super("KuwaharaEffect", ft, {
+      blendFunction: e,
+      uniforms: /* @__PURE__ */ new Map([
+        ["radius", new E(t)],
+        ["sectorCount", new E(o)]
+      ])
+    });
+  }
+  /**
+   * The radius.
+   *
+   * @type {number}
+   */
+  get radius() {
+    var e;
+    return (e = this.uniforms.get("radius")) == null ? void 0 : e.value;
+  }
+  set radius(e) {
+    this.uniforms.get("radius").value = e;
+  }
+  /**
+   * The sector count.
+   *
+   * @type {number}
+   */
+  get sectorCount() {
+    var e;
+    return (e = this.uniforms.get("sectorCount")) == null ? void 0 : e.value;
+  }
+  set sectorCount(e) {
+    this.uniforms.get("sectorCount").value = e;
+  }
+}
+const jt = /* @__PURE__ */ c({
+  __name: "KuwaharaPmndrs",
+  props: {
+    blendFunction: {},
+    radius: {},
+    sectorCount: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(
+      () => new Ae(t),
+      t
+    );
+    return e({ pass: o, effect: a }), g(
+      [
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.radius, "radius"],
+        [() => t.sectorCount, "sectorCount"]
+      ],
+      a,
+      () => new Ae()
+    ), () => {
+    };
+  }
+}), Vt = /* @__PURE__ */ c({
+  __name: "ColorAveragePmndrs",
+  props: {
+    blendFunction: {},
+    opacity: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new Q(t.blendFunction), t);
+    return e({ pass: o, effect: a }), ee(
+      () => t.blendFunction,
+      a,
+      "blendMode.blendFunction",
+      () => new Q()
+    ), C(
+      [a, () => t.opacity],
+      () => {
+        var s, i;
+        if (a.value)
+          if (t.opacity !== void 0)
+            (s = a.value) == null || s.blendMode.setOpacity(t.opacity);
+          else {
+            const n = new Q();
+            (i = a.value) == null || i.blendMode.setOpacity(n.blendMode.getOpacity()), n.dispose();
+          }
+      }
+    ), () => {
+    };
+  }
+}), Yt = /* @__PURE__ */ c({
+  __name: "LensDistortionPmndrs",
+  props: {
+    distortion: {},
+    principalPoint: {},
+    focalLength: {},
+    skew: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(
+      () => new de({
+        ...t,
+        distortion: t.distortion ? Array.isArray(t.distortion) ? new d(...t.distortion) : t.distortion : new d(),
+        principalPoint: t.principalPoint ? Array.isArray(t.principalPoint) ? new d(...t.principalPoint) : t.principalPoint : new d(),
+        focalLength: t.focalLength ? Array.isArray(t.focalLength) ? new d(...t.focalLength) : t.focalLength : new d()
+      }),
+      t
+    );
+    return e({ pass: o, effect: a }), U(
+      t,
+      a,
+      () => new de()
+    ), () => {
+    };
+  }
+}), qt = /* @__PURE__ */ c({
+  __name: "ShockWavePmndrs",
+  props: {
+    position: {},
+    amplitude: {},
+    speed: {},
+    maxRadius: {},
+    waveSize: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { camera: o } = A(), { pass: a, effect: s } = h(
+      () => new fe(o.value, Array.isArray(t.position) ? new P(...t.position) : t.position, t),
+      t
+    );
+    return e({ pass: a, effect: s }), C(
+      () => t.position,
+      (i) => {
+        s.value && (Array.isArray(i) ? s.value.position.set(...i) : i instanceof P && s.value.position.copy(i));
+      },
+      { immediate: !0 }
+    ), g(
+      [
+        [() => t.amplitude, "amplitude"],
+        [() => t.waveSize, "waveSize"],
+        [() => t.maxRadius, "maxRadius"],
+        [() => t.speed, "speed"]
+      ],
+      s,
+      () => new fe()
+    ), () => {
+    };
+  }
+}), kt = /* @__PURE__ */ c({
+  __name: "TiltShiftPmndrs",
+  props: {
+    blendFunction: {},
+    offset: {},
+    rotation: {},
+    focusArea: {},
+    feather: {},
+    kernelSize: {},
+    resolutionScale: {},
+    resolutionX: {},
+    resolutionY: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new he(t), t);
+    return e({ pass: o, effect: a }), g(
+      [
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.offset, "offset"],
+        [() => t.rotation, "rotation"],
+        [() => t.focusArea, "focusArea"],
+        [() => t.feather, "feather"],
+        [() => t.kernelSize, "kernelSize"],
+        [() => t.resolutionScale, "resolution.scale"],
+        [() => t.resolutionX, "resolution.width"],
+        [() => t.resolutionY, "resolution.height"]
+      ],
+      a,
+      () => new he()
+    ), () => {
+    };
+  }
+}), Qt = /* @__PURE__ */ c({
+  __name: "DotScreenPmndrs",
+  props: {
+    angle: {},
+    scale: {},
+    blendFunction: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new pe(t), t);
+    return e({ pass: o, effect: a }), g(
+      [
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.angle, "angle"],
+        [() => t.scale, "scale"]
+      ],
+      a,
+      () => new pe()
+    ), () => {
+    };
+  }
+}), Kt = /* @__PURE__ */ c({
+  __name: "SepiaPmndrs",
+  props: {
+    blendFunction: {},
+    intensity: {}
+  },
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(() => new me(t), t);
+    return e({ pass: o, effect: a }), g(
+      [
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.intensity, "intensity"]
+      ],
+      a,
+      () => new me()
+    ), () => {
+    };
+  }
+});
+class we extends Z {
+  /**
+   * Creates a new LinocutEffect instance.
+   *
+   * @param {LinocutPmndrsProps} [options] - Configuration options for the effect.
+   *
+   */
+  constructor({ blendFunction: e = _.NORMAL, scale: t = 0.85, noiseScale: o = 0, center: a = [0.5, 0.5], rotation: s = 0 } = {}) {
+    const i = Array.isArray(a) ? new d().fromArray(a) : a;
+    super("LinocutEffect", `
+    uniform float scale;
+    uniform float noiseScale;
+    uniform vec2 center;
+    uniform float rotation;
+
+    float luma(vec3 color) {
+      return dot(color, vec3(0.299, 0.587, 0.114));
+    }
+
+    float luma(vec4 color) {
+      return dot(color.rgb, vec3(0.299, 0.587, 0.114));
+    }
+
+    // Simple pseudo-random noise function
+    float noise(vec2 p) {
+      return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453123);
+    }
+
+    void mainImage(const in vec4 inputColor, const in vec2 uv, out vec4 outputColor) {
+      // Calculate the center based on center
+      vec2 fragCoord = uv * resolution.xy;
+
+      // Apply rotation to the coordinates
+      vec2 d = fragCoord - center * resolution.xy;
+      mat2 rotMat = mat2(cos(rotation), -sin(rotation), sin(rotation), cos(rotation));
+      vec2 rotatedD = d * rotMat;
+
+      // Calculate radial distance and angle
+      float r = length(rotatedD) / (1000.0 / max(scale, 0.01)); // Normalization to avoid artifacts
+      float a = atan(rotatedD.y, rotatedD.x) + scale * (0.5 - r) / 0.5;
+
+      // Calculate transformed coordinates
+      vec2 uvt = center * resolution.xy + r * vec2(cos(a), sin(a));
+
+      // Normalize UV coordinates
+      vec2 uv2 = fragCoord / resolution.xy;
+
+      // Generate sinusoidal line patterns
+      float c = (0.75 + 0.25 * sin(uvt.x * 1000.0 * max(scale, 0.01))); // Prevent excessive distortions
+
+      // Load the texture and convert to grayscale
+      vec4 color = texture(inputBuffer, uv2);
+      color.rgb = color.rgb * color.rgb; // Convert from sRGB to linear
+      float l = luma(color);
+
+      // Add noise based on noiseScale
+      float n = noise(uv2 * 10.0); // Generate noise
+      l += noiseScale * (n - 0.5); // Apply noise as a perturbation
+
+      // Apply smoothing to achieve the linocut effect
+      float f = smoothstep(0.5 * c, c, l);
+      f = smoothstep(0.0, 0.5, f);
+
+      // Convert the final value back to sRGB
+      f = sqrt(f);
+
+      // Output the final color in black and white
+      outputColor = vec4(vec3(f), 1.0);
+    }
+    `, {
+      blendFunction: e,
+      uniforms: /* @__PURE__ */ new Map([
+        ["scale", new E(t)],
+        ["noiseScale", new E(o)],
+        ["center", new E(i)],
+        ["rotation", new E(s)]
+      ])
+    });
+  }
+  get scale() {
+    var e;
+    return (e = this.uniforms.get("scale")) == null ? void 0 : e.value;
+  }
+  set scale(e) {
+    this.uniforms.get("scale").value = e;
+  }
+  get noiseScale() {
+    var e;
+    return (e = this.uniforms.get("noiseScale")) == null ? void 0 : e.value;
+  }
+  set noiseScale(e) {
+    this.uniforms.get("noiseScale").value = e;
+  }
+  get center() {
+    var e;
+    return (e = this.uniforms.get("center")) == null ? void 0 : e.value;
+  }
+  set center(e) {
+    this.uniforms.get("center").value = Array.isArray(e) ? new d().fromArray(e) : e;
+  }
+  get rotation() {
+    var e;
+    return (e = this.uniforms.get("rotation")) == null ? void 0 : e.value;
+  }
+  set rotation(e) {
+    this.uniforms.get("rotation").value = e;
+  }
+}
+const Jt = /* @__PURE__ */ c({
+  __name: "LinocutPmndrs",
+  props: {
+    blendFunction: {},
+    scale: {},
+    noiseScale: {},
+    center: {},
+    rotation: {}
   },
-  setup(i, { expose: e }) {
-    const t = i, { pass: s, effect: a } = y(() => new te(t), t);
-    return e({ pass: s, effect: a }), I(
-      q(t, ["blendFunction"]),
+  setup(r, { expose: e }) {
+    const t = r, { pass: o, effect: a } = h(
+      () => new we({
+        ...t,
+        center: t.center instanceof d ? [t.center.x, t.center.y] : t.center
+      }),
+      t
+    );
+    return e({ pass: o, effect: a }), g(
+      [
+        [() => t.blendFunction, "blendMode.blendFunction"],
+        [() => t.scale, "scale"],
+        [() => t.noiseScale, "noiseScale"],
+        [() => t.center, "center"],
+        [() => t.rotation, "rotation"]
+      ],
       a,
-      () => new te()
+      () => new we()
     ), () => {
     };
   }
-}), xe = {
+}), Be = {
   name: "CopyShader",
   uniforms: {
     tDiffuse: { value: null },
@@ -406,7 +1092,7 @@ const ve = Symbol("effectComposerPmndrs"), pt = /* @__PURE__ */ p({
 		}`
   )
 };
-class A {
+class T {
   constructor() {
     this.isPass = !0, this.enabled = !0, this.needsSwap = !0, this.clear = !1, this.renderToScreen = !1;
   }
@@ -418,22 +1104,22 @@ class A {
   dispose() {
   }
 }
-const _e = new De(-1, 1, 1, -1, 0, 1);
-class $e extends Le {
+const ht = new Ie(-1, 1, 1, -1, 0, 1);
+class pt extends je {
   constructor() {
-    super(), this.setAttribute("position", new se([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3)), this.setAttribute("uv", new se([0, 2, 0, 0, 2, 0], 2));
+    super(), this.setAttribute("position", new ge([-1, 3, 0, -1, -1, 0, 3, -1, 0], 3)), this.setAttribute("uv", new ge([0, 2, 0, 0, 2, 0], 2));
   }
 }
-const et = new $e();
-class C {
+const mt = new pt();
+class L {
   constructor(e) {
-    this._mesh = new Pe(et, e);
+    this._mesh = new Ve(mt, e);
   }
   dispose() {
     this._mesh.geometry.dispose();
   }
   render(e) {
-    e.render(this._mesh, _e);
+    e.render(this._mesh, ht);
   }
   get material() {
     return this._mesh.material;
@@ -442,35 +1128,35 @@ class C {
     this._mesh.material = e;
   }
 }
-class tt extends A {
+class gt extends T {
   constructor(e, t) {
-    super(), this.textureID = t !== void 0 ? t : "tDiffuse", e instanceof x ? (this.uniforms = e.uniforms, this.material = e) : e && (this.uniforms = w.clone(e.uniforms), this.material = new x({
+    super(), this.textureID = t !== void 0 ? t : "tDiffuse", e instanceof S ? (this.uniforms = e.uniforms, this.material = e) : e && (this.uniforms = M.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 C(this.material);
+    })), this.fsQuad = new L(this.material);
   }
-  render(e, t, s) {
-    this.uniforms[this.textureID] && (this.uniforms[this.textureID].value = s.texture), this.fsQuad.material = this.material, this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(e.autoClearColor, e.autoClearDepth, e.autoClearStencil), this.fsQuad.render(e));
+  render(e, t, o) {
+    this.uniforms[this.textureID] && (this.uniforms[this.textureID].value = o.texture), this.fsQuad.material = this.material, this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(e.autoClearColor, e.autoClearDepth, e.autoClearStencil), this.fsQuad.render(e));
   }
   dispose() {
     this.material.dispose(), this.fsQuad.dispose();
   }
 }
-class ie extends A {
+class Te extends T {
   constructor(e, t) {
     super(), this.scene = e, this.camera = t, this.clear = !0, this.needsSwap = !1, this.inverse = !1;
   }
-  render(e, t, s) {
-    const a = e.getContext(), r = e.state;
-    r.buffers.color.setMask(!1), r.buffers.depth.setMask(!1), r.buffers.color.setLocked(!0), r.buffers.depth.setLocked(!0);
-    let o, n;
-    this.inverse ? (o = 0, n = 1) : (o = 1, n = 0), r.buffers.stencil.setTest(!0), r.buffers.stencil.setOp(a.REPLACE, a.REPLACE, a.REPLACE), r.buffers.stencil.setFunc(a.ALWAYS, o, 4294967295), r.buffers.stencil.setClear(n), r.buffers.stencil.setLocked(!0), e.setRenderTarget(s), this.clear && e.clear(), e.render(this.scene, this.camera), e.setRenderTarget(t), this.clear && e.clear(), e.render(this.scene, this.camera), r.buffers.color.setLocked(!1), r.buffers.depth.setLocked(!1), r.buffers.color.setMask(!0), r.buffers.depth.setMask(!0), r.buffers.stencil.setLocked(!1), r.buffers.stencil.setFunc(a.EQUAL, 1, 4294967295), r.buffers.stencil.setOp(a.KEEP, a.KEEP, a.KEEP), r.buffers.stencil.setLocked(!0);
+  render(e, t, o) {
+    const a = 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 i, n;
+    this.inverse ? (i = 0, n = 1) : (i = 1, n = 0), s.buffers.stencil.setTest(!0), s.buffers.stencil.setOp(a.REPLACE, a.REPLACE, a.REPLACE), s.buffers.stencil.setFunc(a.ALWAYS, i, 4294967295), s.buffers.stencil.setClear(n), s.buffers.stencil.setLocked(!0), e.setRenderTarget(o), this.clear && e.clear(), e.render(this.scene, this.camera), e.setRenderTarget(t), 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(a.EQUAL, 1, 4294967295), s.buffers.stencil.setOp(a.KEEP, a.KEEP, a.KEEP), s.buffers.stencil.setLocked(!0);
   }
 }
-class st extends A {
+class vt extends T {
   constructor() {
     super(), this.needsSwap = !1;
   }
@@ -478,14 +1164,14 @@ class st extends A {
     e.state.buffers.stencil.setLocked(!1), e.state.buffers.stencil.setTest(!1);
   }
 }
-class at {
+class xt {
   constructor(e, t) {
     if (this.renderer = e, this._pixelRatio = e.getPixelRatio(), t === void 0) {
-      const s = e.getSize(new h());
-      this._width = s.width, this._height = s.height, t = new M(this._width * this._pixelRatio, this._height * this._pixelRatio, { type: b }), t.texture.name = "EffectComposer.rt1";
+      const o = e.getSize(new d());
+      this._width = o.width, this._height = o.height, t = new D(this._width * this._pixelRatio, this._height * this._pixelRatio, { type: w }), t.texture.name = "EffectComposer.rt1";
     } else
       this._width = t.width, this._height = t.height;
-    this.renderTarget1 = t, this.renderTarget2 = t.clone(), this.renderTarget2.texture.name = "EffectComposer.rt2", this.writeBuffer = this.renderTarget1, this.readBuffer = this.renderTarget2, this.renderToScreen = !0, this.passes = [], this.copyPass = new tt(xe), this.copyPass.material.blending = Be, this.clock = new Re();
+    this.renderTarget1 = t, this.renderTarget2 = t.clone(), this.renderTarget2.texture.name = "EffectComposer.rt2", this.writeBuffer = this.renderTarget1, this.readBuffer = this.renderTarget2, this.renderToScreen = !0, this.passes = [], this.copyPass = new gt(Be), this.copyPass.material.blending = Ye, this.clock = new qe();
   }
   swapBuffers() {
     const e = this.readBuffer;
@@ -510,35 +1196,35 @@ class at {
   render(e) {
     e === void 0 && (e = this.clock.getDelta());
     const t = this.renderer.getRenderTarget();
-    let s = !1;
-    for (let a = 0, r = this.passes.length; a < r; a++) {
-      const o = this.passes[a];
-      if (o.enabled !== !1) {
-        if (o.renderToScreen = this.renderToScreen && this.isLastEnabledPass(a), o.render(this.renderer, this.writeBuffer, this.readBuffer, e, s), o.needsSwap) {
-          if (s) {
+    let o = !1;
+    for (let a = 0, s = this.passes.length; a < s; a++) {
+      const i = this.passes[a];
+      if (i.enabled !== !1) {
+        if (i.renderToScreen = this.renderToScreen && this.isLastEnabledPass(a), i.render(this.renderer, this.writeBuffer, this.readBuffer, e, o), i.needsSwap) {
+          if (o) {
             const n = this.renderer.getContext(), l = this.renderer.state.buffers.stencil;
             l.setFunc(n.NOTEQUAL, 1, 4294967295), this.copyPass.render(this.renderer, this.writeBuffer, this.readBuffer, e), l.setFunc(n.EQUAL, 1, 4294967295);
           }
           this.swapBuffers();
         }
-        ie !== void 0 && (o instanceof ie ? s = !0 : o instanceof st && (s = !1));
+        Te !== void 0 && (i instanceof Te ? o = !0 : i instanceof vt && (o = !1));
       }
     }
     this.renderer.setRenderTarget(t);
   }
   reset(e) {
     if (e === void 0) {
-      const t = this.renderer.getSize(new h());
+      const t = this.renderer.getSize(new d());
       this._pixelRatio = this.renderer.getPixelRatio(), this._width = t.width, this._height = t.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, t) {
     this._width = e, this._height = t;
-    const s = this._width * this._pixelRatio, a = this._height * this._pixelRatio;
-    this.renderTarget1.setSize(s, a), this.renderTarget2.setSize(s, a);
-    for (let r = 0; r < this.passes.length; r++)
-      this.passes[r].setSize(s, a);
+    const o = this._width * this._pixelRatio, a = this._height * this._pixelRatio;
+    this.renderTarget1.setSize(o, a), this.renderTarget2.setSize(o, a);
+    for (let s = 0; s < this.passes.length; s++)
+      this.passes[s].setSize(o, a);
   }
   setPixelRatio(e) {
     this._pixelRatio = e, this.setSize(this._width, this._height);
@@ -547,61 +1233,61 @@ class at {
     this.renderTarget1.dispose(), this.renderTarget2.dispose(), this.copyPass.dispose();
   }
 }
-class rt extends A {
-  constructor(e, t, s = null, a = null, r = null) {
-    super(), this.scene = e, this.camera = t, this.overrideMaterial = s, this.clearColor = a, this.clearAlpha = r, this.clear = !0, this.clearDepth = !1, this.needsSwap = !1, this._oldClearColor = new X();
+class bt extends T {
+  constructor(e, t, o = null, a = null, s = null) {
+    super(), this.scene = e, this.camera = t, this.overrideMaterial = o, this.clearColor = a, this.clearAlpha = s, this.clear = !0, this.clearDepth = !1, this.needsSwap = !1, this._oldClearColor = new j();
   }
-  render(e, t, s) {
+  render(e, t, o) {
     const a = e.autoClear;
     e.autoClear = !1;
-    let r, o;
-    this.overrideMaterial !== null && (o = this.scene.overrideMaterial, this.scene.overrideMaterial = this.overrideMaterial), this.clearColor !== null && (e.getClearColor(this._oldClearColor), e.setClearColor(this.clearColor, e.getClearAlpha())), this.clearAlpha !== null && (r = e.getClearAlpha(), e.setClearAlpha(this.clearAlpha)), this.clearDepth == !0 && e.clearDepth(), e.setRenderTarget(this.renderToScreen ? null : s), this.clear === !0 && e.clear(e.autoClearColor, e.autoClearDepth, e.autoClearStencil), e.render(this.scene, this.camera), this.clearColor !== null && e.setClearColor(this._oldClearColor), this.clearAlpha !== null && e.setClearAlpha(r), this.overrideMaterial !== null && (this.scene.overrideMaterial = o), e.autoClear = a;
+    let s, i;
+    this.overrideMaterial !== null && (i = this.scene.overrideMaterial, this.scene.overrideMaterial = this.overrideMaterial), this.clearColor !== null && (e.getClearColor(this._oldClearColor), e.setClearColor(this.clearColor, e.getClearAlpha())), this.clearAlpha !== null && (s = e.getClearAlpha(), e.setClearAlpha(this.clearAlpha)), this.clearDepth == !0 && e.clearDepth(), e.setRenderTarget(this.renderToScreen ? null : o), this.clear === !0 && e.clear(e.autoClearColor, e.autoClearDepth, e.autoClearStencil), e.render(this.scene, this.camera), this.clearColor !== null && e.setClearColor(this._oldClearColor), this.clearAlpha !== null && e.setClearAlpha(s), this.overrideMaterial !== null && (this.scene.overrideMaterial = i), e.autoClear = a;
   }
 }
-const be = Symbol("effectComposerThree"), wt = /* @__PURE__ */ p({
+const Ne = Symbol("effectComposerThree"), Zt = /* @__PURE__ */ c({
   __name: "EffectComposer",
   props: {
     enabled: { type: Boolean, default: !0 },
     withoutRenderPass: { type: Boolean }
   },
-  setup(i, { expose: e }) {
-    const t = i, s = N(null);
-    de(be, s), e({ composer: s });
-    const { renderer: a, sizes: r, scene: o, camera: n, render: l } = S();
-    m(() => {
-      var u;
-      (u = s.value) == null || u.dispose(), s.value = new at(a.value);
-    }), m(() => {
-      var W;
-      const { width: u, height: T } = r;
-      T.value && u.value && ((W = s.value) == null || W.setSize(u.value, T.value));
+  setup(r, { expose: e }) {
+    const t = r, o = z(null);
+    Ce(Ne, o), e({ composer: o });
+    const { renderer: a, sizes: s, scene: i, camera: n, render: l } = A();
+    v(() => {
+      var f;
+      (f = o.value) == null || f.dispose(), o.value = new xt(a.value);
+    }), v(() => {
+      var H;
+      const { width: f, height: y } = s;
+      y.value && f.value && ((H = o.value) == null || H.setSize(f.value, y.value));
     });
-    const { pixelRatio: d } = me();
-    m(() => {
-      var u;
-      (u = s.value) == null || u.setPixelRatio(d.value);
-    }), t.withoutRenderPass || m(() => {
-      n.value && o.value && s.value && s.value.addPass(new rt(o.value, n.value));
+    const { pixelRatio: u } = Le();
+    v(() => {
+      var f;
+      (f = o.value) == null || f.setPixelRatio(u.value);
+    }), t.withoutRenderPass || v(() => {
+      n.value && i.value && o.value && o.value.addPass(new bt(i.value, n.value));
     });
-    const { render: c } = z();
-    return c(() => {
-      l.frames.value > 0 && s.value && t.enabled && s.value.render(), l.frames.value = l.mode.value === "always" ? 1 : Math.max(0, l.frames.value - 1);
-    }), j(() => {
-      var u;
-      (u = s.value) == null || u.dispose();
-    }), (u, T) => ue(u.$slots, "default");
-  }
-}), P = (i, e) => {
-  const t = ce(be), s = N(i()), { sizes: a, invalidate: r } = S();
-  e && D(e, () => r());
-  const o = m(() => {
-    !(t != null && t.value) || !a.height.value || !a.width.value || (t.value.addPass(s.value), fe(() => o()));
+    const { render: p } = W();
+    return p(() => {
+      l.frames.value > 0 && o.value && t.enabled && o.value.render(), l.frames.value = l.mode.value === "always" ? 1 : Math.max(0, l.frames.value - 1);
+    }), V(() => {
+      var f;
+      (f = o.value) == null || f.dispose();
+    }), (f, y) => Ee(f.$slots, "default");
+  }
+}), B = (r, e) => {
+  const t = De(Ne), o = z(r()), { sizes: a, invalidate: s } = A();
+  e && C(e, () => s());
+  const i = v(() => {
+    !(t != null && t.value) || !a.height.value || !a.width.value || (t.value.addPass(o.value), Pe(() => i()));
   });
-  return j(() => {
+  return V(() => {
     var n;
-    (n = t == null ? void 0 : t.value) == null || n.removePass(s.value), s.value.dispose();
-  }), { pass: s };
-}, ot = {
+    (n = t == null ? void 0 : t.value) == null || n.removePass(o.value), o.value.dispose();
+  }), { pass: o };
+}, St = {
   uniforms: {
     tDiffuse: { value: null },
     //diffuse texture
@@ -696,53 +1382,53 @@ const be = Symbol("effectComposerThree"), wt = /* @__PURE__ */ p({
 		}`
   )
 };
-class ne extends A {
+class ye extends T {
   constructor(e = 64) {
     super();
-    const t = ot;
-    this.uniforms = w.clone(t.uniforms), this.heightMap = this.generateHeightmap(e), this.uniforms.tDisp.value = this.heightMap, this.material = new x({
+    const t = St;
+    this.uniforms = M.clone(t.uniforms), this.heightMap = this.generateHeightmap(e), this.uniforms.tDisp.value = this.heightMap, this.material = new S({
       uniforms: this.uniforms,
       vertexShader: t.vertexShader,
       fragmentShader: t.fragmentShader
-    }), this.fsQuad = new C(this.material), this.goWild = !1, this.curF = 0, this.generateTrigger();
+    }), this.fsQuad = new L(this.material), this.goWild = !1, this.curF = 0, this.generateTrigger();
   }
-  render(e, t, s) {
-    this.uniforms.tDiffuse.value = s.texture, this.uniforms.seed.value = Math.random(), this.uniforms.byp.value = 0, this.curF % this.randX == 0 || this.goWild == !0 ? (this.uniforms.amount.value = Math.random() / 30, this.uniforms.angle.value = v.randFloat(-Math.PI, Math.PI), this.uniforms.seed_x.value = v.randFloat(-1, 1), this.uniforms.seed_y.value = v.randFloat(-1, 1), this.uniforms.distortion_x.value = v.randFloat(0, 1), this.uniforms.distortion_y.value = v.randFloat(0, 1), this.curF = 0, this.generateTrigger()) : this.curF % this.randX < this.randX / 5 ? (this.uniforms.amount.value = Math.random() / 90, this.uniforms.angle.value = v.randFloat(-Math.PI, Math.PI), this.uniforms.distortion_x.value = v.randFloat(0, 1), this.uniforms.distortion_y.value = v.randFloat(0, 1), this.uniforms.seed_x.value = v.randFloat(-0.3, 0.3), this.uniforms.seed_y.value = v.randFloat(-0.3, 0.3)) : this.goWild == !1 && (this.uniforms.byp.value = 1), this.curF++, this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(), this.fsQuad.render(e));
+  render(e, t, o) {
+    this.uniforms.tDiffuse.value = o.texture, this.uniforms.seed.value = Math.random(), this.uniforms.byp.value = 0, this.curF % this.randX == 0 || this.goWild == !0 ? (this.uniforms.amount.value = Math.random() / 30, this.uniforms.angle.value = b.randFloat(-Math.PI, Math.PI), this.uniforms.seed_x.value = b.randFloat(-1, 1), this.uniforms.seed_y.value = b.randFloat(-1, 1), this.uniforms.distortion_x.value = b.randFloat(0, 1), this.uniforms.distortion_y.value = b.randFloat(0, 1), this.curF = 0, this.generateTrigger()) : this.curF % this.randX < this.randX / 5 ? (this.uniforms.amount.value = Math.random() / 90, this.uniforms.angle.value = b.randFloat(-Math.PI, Math.PI), this.uniforms.distortion_x.value = b.randFloat(0, 1), this.uniforms.distortion_y.value = b.randFloat(0, 1), this.uniforms.seed_x.value = b.randFloat(-0.3, 0.3), this.uniforms.seed_y.value = b.randFloat(-0.3, 0.3)) : this.goWild == !1 && (this.uniforms.byp.value = 1), this.curF++, this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(), this.fsQuad.render(e));
   }
   generateTrigger() {
-    this.randX = v.randInt(120, 240);
+    this.randX = b.randInt(120, 240);
   }
   generateHeightmap(e) {
-    const t = new Float32Array(e * e), s = e * e;
-    for (let r = 0; r < s; r++) {
-      const o = v.randFloat(0, 1);
-      t[r] = o;
+    const t = new Float32Array(e * e), o = e * e;
+    for (let s = 0; s < o; s++) {
+      const i = b.randFloat(0, 1);
+      t[s] = i;
     }
-    const a = new Ne(t, e, e, Oe, ze);
+    const a = new ke(t, e, e, Qe, Ke);
     return a.needsUpdate = !0, a;
   }
   dispose() {
     this.material.dispose(), this.heightMap.dispose(), this.fsQuad.dispose();
   }
 }
-const Mt = /* @__PURE__ */ p({
+const _t = /* @__PURE__ */ c({
   __name: "Glitch",
   props: {
     dtSize: {},
     goWild: { type: Boolean }
   },
-  setup(i, { expose: e }) {
-    const t = i, { pass: s } = P(() => new ne(t.dtSize), t);
-    e({ pass: s });
-    const { onBeforeRender: a } = z();
-    return a(({ invalidate: r }) => r()), F(
+  setup(r, { expose: e }) {
+    const t = r, { pass: o } = B(() => new ye(t.dtSize), t);
+    e({ pass: o });
+    const { onBeforeRender: a } = W();
+    return a(({ invalidate: s }) => s()), g(
       [[() => t.goWild, "goWild"]],
-      s,
-      () => new ne()
+      o,
+      () => new ye()
     ), () => {
     };
   }
-}), G = {
+}), I = {
   name: "HalftoneShader",
   uniforms: {
     tDiffuse: { value: null },
@@ -1046,19 +1732,19 @@ const Mt = /* @__PURE__ */ p({
 		}`
   )
 };
-class it extends A {
-  constructor(e, t, s) {
-    super(), this.uniforms = w.clone(G.uniforms), this.material = new x({
+class At extends T {
+  constructor(e, t, o) {
+    super(), this.uniforms = M.clone(I.uniforms), this.material = new S({
       uniforms: this.uniforms,
-      fragmentShader: G.fragmentShader,
-      vertexShader: G.vertexShader
+      fragmentShader: I.fragmentShader,
+      vertexShader: I.vertexShader
     }), this.uniforms.width.value = e, this.uniforms.height.value = t;
-    for (const a in s)
-      s.hasOwnProperty(a) && this.uniforms.hasOwnProperty(a) && (this.uniforms[a].value = s[a]);
-    this.fsQuad = new C(this.material);
+    for (const a in o)
+      o.hasOwnProperty(a) && this.uniforms.hasOwnProperty(a) && (this.uniforms[a].value = o[a]);
+    this.fsQuad = new L(this.material);
   }
-  render(e, t, s) {
-    this.material.uniforms.tDiffuse.value = s.texture, this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(), this.fsQuad.render(e));
+  render(e, t, o) {
+    this.material.uniforms.tDiffuse.value = o.texture, this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(), this.fsQuad.render(e));
   }
   setSize(e, t) {
     this.uniforms.width.value = e, this.uniforms.height.value = t;
@@ -1067,7 +1753,7 @@ class it extends A {
     this.material.dispose(), this.fsQuad.dispose();
   }
 }
-const yt = /* @__PURE__ */ p({
+const $t = /* @__PURE__ */ c({
   __name: "Halftone",
   props: {
     shape: {},
@@ -1080,55 +1766,55 @@ const yt = /* @__PURE__ */ p({
     greyscale: { type: Boolean },
     blendingMode: {}
   },
-  setup(i, { expose: e }) {
-    const t = i, { sizes: s } = S(), a = O(
+  setup(r, { expose: e }) {
+    const t = r, { sizes: o } = A(), a = F(
       () => Object.fromEntries(
-        Object.entries(t).filter(([o, n]) => n !== void 0)
+        Object.entries(t).filter(([i, n]) => n !== void 0)
       )
-    ), { pass: r } = P(() => new it(
-      s.width.value,
-      s.height.value,
+    ), { pass: s } = B(() => new At(
+      o.width.value,
+      o.height.value,
       a.value
     ), t);
-    return e({ pass: r }), m(() => {
-      r.value.setSize(s.width.value, s.height.value);
-    }), m(() => {
-      Object.entries(t).forEach(([o, n]) => {
-        o in r.value.uniforms && (r.value.uniforms[o].value = n ?? G.uniforms[o].value);
+    return e({ pass: s }), v(() => {
+      s.value.setSize(o.width.value, o.height.value);
+    }), v(() => {
+      Object.entries(t).forEach(([i, n]) => {
+        i in s.value.uniforms && (s.value.uniforms[i].value = n ?? I.uniforms[i].value);
       });
     }), () => {
     };
   }
 });
-class le extends A {
-  constructor(e, t, s, a = {}) {
-    super(), this.pixelSize = e, this.resolution = new h(), this.renderResolution = new h(), this.pixelatedMaterial = this.createPixelatedMaterial(), this.normalMaterial = new Fe(), this.fsQuad = new C(this.pixelatedMaterial), this.scene = t, this.camera = s, this.normalEdgeStrength = a.normalEdgeStrength || 0.3, this.depthEdgeStrength = a.depthEdgeStrength || 0.4, this.beautyRenderTarget = new M(), this.beautyRenderTarget.texture.minFilter = E, this.beautyRenderTarget.texture.magFilter = E, this.beautyRenderTarget.texture.type = b, this.beautyRenderTarget.depthTexture = new We(), this.normalRenderTarget = new M(), this.normalRenderTarget.texture.minFilter = E, this.normalRenderTarget.texture.magFilter = E, this.normalRenderTarget.texture.type = b;
+class Me extends T {
+  constructor(e, t, o, a = {}) {
+    super(), this.pixelSize = e, this.resolution = new d(), this.renderResolution = new d(), this.pixelatedMaterial = this.createPixelatedMaterial(), this.normalMaterial = new Je(), this.fsQuad = new L(this.pixelatedMaterial), this.scene = t, this.camera = o, this.normalEdgeStrength = a.normalEdgeStrength || 0.3, this.depthEdgeStrength = a.depthEdgeStrength || 0.4, this.beautyRenderTarget = new D(), this.beautyRenderTarget.texture.minFilter = O, this.beautyRenderTarget.texture.magFilter = O, this.beautyRenderTarget.texture.type = w, this.beautyRenderTarget.depthTexture = new Ze(), this.normalRenderTarget = new D(), this.normalRenderTarget.texture.minFilter = O, this.normalRenderTarget.texture.magFilter = O, this.normalRenderTarget.texture.type = w;
   }
   dispose() {
     this.beautyRenderTarget.dispose(), this.normalRenderTarget.dispose(), this.pixelatedMaterial.dispose(), this.normalMaterial.dispose(), this.fsQuad.dispose();
   }
   setSize(e, t) {
     this.resolution.set(e, t), this.renderResolution.set(e / this.pixelSize | 0, t / this.pixelSize | 0);
-    const { x: s, y: a } = this.renderResolution;
-    this.beautyRenderTarget.setSize(s, a), this.normalRenderTarget.setSize(s, a), this.fsQuad.material.uniforms.resolution.value.set(s, a, 1 / s, 1 / a);
+    const { x: o, y: a } = this.renderResolution;
+    this.beautyRenderTarget.setSize(o, a), this.normalRenderTarget.setSize(o, a), this.fsQuad.material.uniforms.resolution.value.set(o, a, 1 / o, 1 / a);
   }
   setPixelSize(e) {
     this.pixelSize = e, this.setSize(this.resolution.x, this.resolution.y);
   }
   render(e, t) {
-    const s = this.fsQuad.material.uniforms;
-    s.normalEdgeStrength.value = this.normalEdgeStrength, s.depthEdgeStrength.value = this.depthEdgeStrength, e.setRenderTarget(this.beautyRenderTarget), e.render(this.scene, this.camera);
+    const o = this.fsQuad.material.uniforms;
+    o.normalEdgeStrength.value = this.normalEdgeStrength, o.depthEdgeStrength.value = this.depthEdgeStrength, e.setRenderTarget(this.beautyRenderTarget), e.render(this.scene, this.camera);
     const a = this.scene.overrideMaterial;
-    e.setRenderTarget(this.normalRenderTarget), this.scene.overrideMaterial = this.normalMaterial, e.render(this.scene, this.camera), this.scene.overrideMaterial = a, s.tDiffuse.value = this.beautyRenderTarget.texture, s.tDepth.value = this.beautyRenderTarget.depthTexture, s.tNormal.value = this.normalRenderTarget.texture, this.renderToScreen ? e.setRenderTarget(null) : (e.setRenderTarget(t), this.clear && e.clear()), this.fsQuad.render(e);
+    e.setRenderTarget(this.normalRenderTarget), this.scene.overrideMaterial = this.normalMaterial, e.render(this.scene, this.camera), this.scene.overrideMaterial = a, o.tDiffuse.value = this.beautyRenderTarget.texture, o.tDepth.value = this.beautyRenderTarget.depthTexture, o.tNormal.value = this.normalRenderTarget.texture, this.renderToScreen ? e.setRenderTarget(null) : (e.setRenderTarget(t), this.clear && e.clear()), this.fsQuad.render(e);
   }
   createPixelatedMaterial() {
-    return new x({
+    return new S({
       uniforms: {
         tDiffuse: { value: null },
         tDepth: { value: null },
         tNormal: { value: null },
         resolution: {
-          value: new Ue(
+          value: new _e(
             this.renderResolution.x,
             this.renderResolution.y,
             1 / this.renderResolution.x,
@@ -1247,28 +1933,28 @@ class le extends A {
     });
   }
 }
-const Ct = /* @__PURE__ */ p({
+const eo = /* @__PURE__ */ c({
   __name: "Pixelation",
   props: {
     pixelSize: {},
     depthEdgeStrength: {},
     normalEdgeStrength: {}
   },
-  setup(i, { expose: e }) {
-    const t = i, { scene: s, camera: a } = S(), { pass: r } = P(() => new le(t.pixelSize, s.value, a.value), t);
-    return e({ pass: r }), m(() => {
-      r.value.setPixelSize(t.pixelSize);
-    }), F(
+  setup(r, { expose: e }) {
+    const t = r, { scene: o, camera: a } = A(), { pass: s } = B(() => new Me(t.pixelSize, o.value, a.value), t);
+    return e({ pass: s }), v(() => {
+      s.value.setPixelSize(t.pixelSize);
+    }), g(
       [
         [() => t.depthEdgeStrength, "depthEdgeStrength"],
         [() => t.normalEdgeStrength, "normalEdgeStrength"]
       ],
-      r,
-      () => new le(1, s.value, a.value)
+      s,
+      () => new Me(1, o.value, a.value)
     ), () => {
     };
   }
-}), nt = {
+}), wt = {
   name: "OutputShader",
   uniforms: {
     tDiffuse: { value: null },
@@ -1350,39 +2036,39 @@ const Ct = /* @__PURE__ */ p({
 		}`
   )
 };
-class lt extends A {
+class Tt extends T {
   constructor() {
     super();
-    const e = nt;
-    this.uniforms = w.clone(e.uniforms), this.material = new He({
+    const e = wt;
+    this.uniforms = M.clone(e.uniforms), this.material = new $e({
       name: e.name,
       uniforms: this.uniforms,
       vertexShader: e.vertexShader,
       fragmentShader: e.fragmentShader
-    }), this.fsQuad = new C(this.material), this._outputColorSpace = null, this._toneMapping = null;
+    }), this.fsQuad = new L(this.material), this._outputColorSpace = null, this._toneMapping = null;
   }
-  render(e, t, s) {
-    this.uniforms.tDiffuse.value = s.texture, this.uniforms.toneMappingExposure.value = e.toneMappingExposure, (this._outputColorSpace !== e.outputColorSpace || this._toneMapping !== e.toneMapping) && (this._outputColorSpace = e.outputColorSpace, this._toneMapping = e.toneMapping, this.material.defines = {}, Ge.getTransfer(this._outputColorSpace) === Xe && (this.material.defines.SRGB_TRANSFER = ""), this._toneMapping === je ? this.material.defines.LINEAR_TONE_MAPPING = "" : this._toneMapping === Ie ? this.material.defines.REINHARD_TONE_MAPPING = "" : this._toneMapping === Ve ? this.material.defines.CINEON_TONE_MAPPING = "" : this._toneMapping === Ye ? this.material.defines.ACES_FILMIC_TONE_MAPPING = "" : this._toneMapping === Qe ? this.material.defines.AGX_TONE_MAPPING = "" : this._toneMapping === qe && (this.material.defines.NEUTRAL_TONE_MAPPING = ""), this.material.needsUpdate = !0), this.renderToScreen === !0 ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(e.autoClearColor, e.autoClearDepth, e.autoClearStencil), this.fsQuad.render(e));
+  render(e, t, o) {
+    this.uniforms.tDiffuse.value = o.texture, this.uniforms.toneMappingExposure.value = e.toneMappingExposure, (this._outputColorSpace !== e.outputColorSpace || this._toneMapping !== e.toneMapping) && (this._outputColorSpace = e.outputColorSpace, this._toneMapping = e.toneMapping, this.material.defines = {}, et.getTransfer(this._outputColorSpace) === tt && (this.material.defines.SRGB_TRANSFER = ""), this._toneMapping === ot ? this.material.defines.LINEAR_TONE_MAPPING = "" : this._toneMapping === at ? this.material.defines.REINHARD_TONE_MAPPING = "" : this._toneMapping === st ? this.material.defines.CINEON_TONE_MAPPING = "" : this._toneMapping === rt ? this.material.defines.ACES_FILMIC_TONE_MAPPING = "" : this._toneMapping === it ? this.material.defines.AGX_TONE_MAPPING = "" : this._toneMapping === nt && (this.material.defines.NEUTRAL_TONE_MAPPING = ""), this.material.needsUpdate = !0), this.renderToScreen === !0 ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(e.autoClearColor, e.autoClearDepth, e.autoClearStencil), this.fsQuad.render(e));
   }
   dispose() {
     this.material.dispose(), this.fsQuad.dispose();
   }
 }
-const Et = /* @__PURE__ */ p({
+const to = /* @__PURE__ */ c({
   __name: "Output",
-  setup(i, { expose: e }) {
-    const { pass: t } = P(() => new lt());
+  setup(r, { expose: e }) {
+    const { pass: t } = B(() => new Tt());
     return e({ pass: t }), () => {
     };
   }
-}), U = {
+}), G = {
   name: "SMAAEdgesShader",
   defines: {
     SMAA_THRESHOLD: "0.1"
   },
   uniforms: {
     tDiffuse: { value: null },
-    resolution: { value: new h(1 / 1024, 1 / 512) }
+    resolution: { value: new d(1 / 1024, 1 / 512) }
   },
   vertexShader: (
     /* glsl */
@@ -1476,7 +2162,7 @@ const Et = /* @__PURE__ */ p({
 
 		}`
   )
-}, H = {
+}, X = {
   name: "SMAAWeightsShader",
   defines: {
     SMAA_MAX_SEARCH_STEPS: "8",
@@ -1488,7 +2174,7 @@ const Et = /* @__PURE__ */ p({
     tDiffuse: { value: null },
     tArea: { value: null },
     tSearch: { value: null },
-    resolution: { value: new h(1 / 1024, 1 / 512) }
+    resolution: { value: new d(1 / 1024, 1 / 512) }
   },
   vertexShader: (
     /* glsl */
@@ -1726,12 +2412,12 @@ const Et = /* @__PURE__ */ p({
 
 		}`
   )
-}, Q = {
+}, J = {
   name: "SMAABlendShader",
   uniforms: {
     tDiffuse: { value: null },
     tColor: { value: null },
-    resolution: { value: new h(1 / 1024, 1 / 512) }
+    resolution: { value: new d(1 / 1024, 1 / 512) }
   },
   vertexShader: (
     /* glsl */
@@ -1816,40 +2502,40 @@ const Et = /* @__PURE__ */ p({
 		}`
   )
 };
-class dt extends A {
+class yt extends T {
   constructor(e, t) {
-    super(), this.edgesRT = new M(e, t, {
+    super(), this.edgesRT = new D(e, t, {
       depthBuffer: !1,
-      type: b
-    }), this.edgesRT.texture.name = "SMAAPass.edges", this.weightsRT = new M(e, t, {
+      type: w
+    }), this.edgesRT.texture.name = "SMAAPass.edges", this.weightsRT = new D(e, t, {
       depthBuffer: !1,
-      type: b
+      type: w
     }), this.weightsRT.texture.name = "SMAAPass.weights";
-    const s = this, a = new Image();
+    const o = this, a = new Image();
     a.src = this.getAreaTexture(), a.onload = function() {
-      s.areaTexture.needsUpdate = !0;
-    }, this.areaTexture = new ae(), this.areaTexture.name = "SMAAPass.area", this.areaTexture.image = a, this.areaTexture.minFilter = ke, this.areaTexture.generateMipmaps = !1, this.areaTexture.flipY = !1;
-    const r = new Image();
-    r.src = this.getSearchTexture(), r.onload = function() {
-      s.searchTexture.needsUpdate = !0;
-    }, this.searchTexture = new ae(), this.searchTexture.name = "SMAAPass.search", this.searchTexture.image = r, this.searchTexture.magFilter = E, this.searchTexture.minFilter = E, this.searchTexture.generateMipmaps = !1, this.searchTexture.flipY = !1, this.uniformsEdges = w.clone(U.uniforms), this.uniformsEdges.resolution.value.set(1 / e, 1 / t), this.materialEdges = new x({
-      defines: Object.assign({}, U.defines),
+      o.areaTexture.needsUpdate = !0;
+    }, this.areaTexture = new ve(), this.areaTexture.name = "SMAAPass.area", this.areaTexture.image = a, this.areaTexture.minFilter = lt, this.areaTexture.generateMipmaps = !1, this.areaTexture.flipY = !1;
+    const s = new Image();
+    s.src = this.getSearchTexture(), s.onload = function() {
+      o.searchTexture.needsUpdate = !0;
+    }, this.searchTexture = new ve(), this.searchTexture.name = "SMAAPass.search", this.searchTexture.image = s, this.searchTexture.magFilter = O, this.searchTexture.minFilter = O, this.searchTexture.generateMipmaps = !1, this.searchTexture.flipY = !1, this.uniformsEdges = M.clone(G.uniforms), this.uniformsEdges.resolution.value.set(1 / e, 1 / t), this.materialEdges = new S({
+      defines: Object.assign({}, G.defines),
       uniforms: this.uniformsEdges,
-      vertexShader: U.vertexShader,
-      fragmentShader: U.fragmentShader
-    }), this.uniformsWeights = w.clone(H.uniforms), this.uniformsWeights.resolution.value.set(1 / e, 1 / t), this.uniformsWeights.tDiffuse.value = this.edgesRT.texture, this.uniformsWeights.tArea.value = this.areaTexture, this.uniformsWeights.tSearch.value = this.searchTexture, this.materialWeights = new x({
-      defines: Object.assign({}, H.defines),
+      vertexShader: G.vertexShader,
+      fragmentShader: G.fragmentShader
+    }), this.uniformsWeights = M.clone(X.uniforms), this.uniformsWeights.resolution.value.set(1 / e, 1 / t), this.uniformsWeights.tDiffuse.value = this.edgesRT.texture, this.uniformsWeights.tArea.value = this.areaTexture, this.uniformsWeights.tSearch.value = this.searchTexture, this.materialWeights = new S({
+      defines: Object.assign({}, X.defines),
       uniforms: this.uniformsWeights,
-      vertexShader: H.vertexShader,
-      fragmentShader: H.fragmentShader
-    }), this.uniformsBlend = w.clone(Q.uniforms), this.uniformsBlend.resolution.value.set(1 / e, 1 / t), this.uniformsBlend.tDiffuse.value = this.weightsRT.texture, this.materialBlend = new x({
+      vertexShader: X.vertexShader,
+      fragmentShader: X.fragmentShader
+    }), this.uniformsBlend = M.clone(J.uniforms), this.uniformsBlend.resolution.value.set(1 / e, 1 / t), this.uniformsBlend.tDiffuse.value = this.weightsRT.texture, this.materialBlend = new S({
       uniforms: this.uniformsBlend,
-      vertexShader: Q.vertexShader,
-      fragmentShader: Q.fragmentShader
-    }), this.fsQuad = new C(null);
+      vertexShader: J.vertexShader,
+      fragmentShader: J.fragmentShader
+    }), this.fsQuad = new L(null);
   }
-  render(e, t, s) {
-    this.uniformsEdges.tDiffuse.value = s.texture, this.fsQuad.material = this.materialEdges, e.setRenderTarget(this.edgesRT), this.clear && e.clear(), this.fsQuad.render(e), this.fsQuad.material = this.materialWeights, e.setRenderTarget(this.weightsRT), this.clear && e.clear(), this.fsQuad.render(e), this.uniformsBlend.tColor.value = s.texture, this.fsQuad.material = this.materialBlend, this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(), this.fsQuad.render(e));
+  render(e, t, o) {
+    this.uniformsEdges.tDiffuse.value = o.texture, this.fsQuad.material = this.materialEdges, e.setRenderTarget(this.edgesRT), this.clear && e.clear(), this.fsQuad.render(e), this.fsQuad.material = this.materialWeights, e.setRenderTarget(this.weightsRT), this.clear && e.clear(), this.fsQuad.render(e), this.uniformsBlend.tColor.value = o.texture, this.fsQuad.material = this.materialBlend, this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(t), this.clear && e.clear(), this.fsQuad.render(e));
   }
   setSize(e, t) {
     this.edgesRT.setSize(e, t), this.weightsRT.setSize(e, t), this.materialEdges.uniforms.resolution.value.set(1 / e, 1 / t), this.materialWeights.uniforms.resolution.value.set(1 / e, 1 / t), this.materialBlend.uniforms.resolution.value.set(1 / e, 1 / t);
@@ -1864,27 +2550,27 @@ class dt extends A {
     this.edgesRT.dispose(), this.weightsRT.dispose(), this.areaTexture.dispose(), this.searchTexture.dispose(), this.materialEdges.dispose(), this.materialWeights.dispose(), this.materialBlend.dispose(), this.fsQuad.dispose();
   }
 }
-const Dt = /* @__PURE__ */ p({
+const oo = /* @__PURE__ */ c({
   __name: "SMAA",
   props: {
     width: {},
     height: {}
   },
-  setup(i, { expose: e }) {
-    const t = i, { sizes: s } = S(), { pixelRatio: a } = me(), r = O(() => t.width ?? s.width.value * a.value), o = O(() => t.height ?? s.height.value * a.value), { pass: n } = P(() => new dt(r.value, o.value), t);
-    return e({ pass: n }), m(() => {
-      n.value.setSize(r.value, o.value);
+  setup(r, { expose: e }) {
+    const t = r, { sizes: o } = A(), { pixelRatio: a } = Le(), s = F(() => t.width ?? o.width.value * a.value), i = F(() => t.height ?? o.height.value * a.value), { pass: n } = B(() => new yt(s.value, i.value), t);
+    return e({ pass: n }), v(() => {
+      n.value.setSize(s.value, i.value);
     }), () => {
     };
   }
-}), Se = {
+}), ze = {
   name: "LuminosityHighPassShader",
   shaderID: "luminosityHighPass",
   uniforms: {
     tDiffuse: { value: null },
     luminosityThreshold: { value: 1 },
     smoothWidth: { value: 1 },
-    defaultColor: { value: new X(0) },
+    defaultColor: { value: new j(0) },
     defaultOpacity: { value: 0 }
   },
   vertexShader: (
@@ -1928,40 +2614,40 @@ const Dt = /* @__PURE__ */ p({
 		}`
   )
 };
-class L extends A {
-  constructor(e, t, s, a) {
-    super(), this.strength = t !== void 0 ? t : 1, this.radius = s, this.threshold = a, this.resolution = e !== void 0 ? new h(e.x, e.y) : new h(256, 256), this.clearColor = new X(0, 0, 0), this.renderTargetsHorizontal = [], this.renderTargetsVertical = [], this.nMips = 5;
-    let r = Math.round(this.resolution.x / 2), o = Math.round(this.resolution.y / 2);
-    this.renderTargetBright = new M(r, o, { type: b }), this.renderTargetBright.texture.name = "UnrealBloomPass.bright", this.renderTargetBright.texture.generateMipmaps = !1;
-    for (let c = 0; c < this.nMips; c++) {
-      const u = new M(r, o, { type: b });
-      u.texture.name = "UnrealBloomPass.h" + c, u.texture.generateMipmaps = !1, this.renderTargetsHorizontal.push(u);
-      const T = new M(r, o, { type: b });
-      T.texture.name = "UnrealBloomPass.v" + c, T.texture.generateMipmaps = !1, this.renderTargetsVertical.push(T), r = Math.round(r / 2), o = Math.round(o / 2);
+class R extends T {
+  constructor(e, t, o, a) {
+    super(), this.strength = t !== void 0 ? t : 1, this.radius = o, this.threshold = a, this.resolution = e !== void 0 ? new d(e.x, e.y) : new d(256, 256), this.clearColor = new j(0, 0, 0), this.renderTargetsHorizontal = [], this.renderTargetsVertical = [], this.nMips = 5;
+    let s = Math.round(this.resolution.x / 2), i = Math.round(this.resolution.y / 2);
+    this.renderTargetBright = new D(s, i, { type: w }), this.renderTargetBright.texture.name = "UnrealBloomPass.bright", this.renderTargetBright.texture.generateMipmaps = !1;
+    for (let p = 0; p < this.nMips; p++) {
+      const f = new D(s, i, { type: w });
+      f.texture.name = "UnrealBloomPass.h" + p, f.texture.generateMipmaps = !1, this.renderTargetsHorizontal.push(f);
+      const y = new D(s, i, { type: w });
+      y.texture.name = "UnrealBloomPass.v" + p, y.texture.generateMipmaps = !1, this.renderTargetsVertical.push(y), s = Math.round(s / 2), i = Math.round(i / 2);
     }
-    const n = Se;
-    this.highPassUniforms = w.clone(n.uniforms), this.highPassUniforms.luminosityThreshold.value = a, this.highPassUniforms.smoothWidth.value = 0.01, this.materialHighPassFilter = new x({
+    const n = ze;
+    this.highPassUniforms = M.clone(n.uniforms), this.highPassUniforms.luminosityThreshold.value = a, this.highPassUniforms.smoothWidth.value = 0.01, this.materialHighPassFilter = new S({
       uniforms: this.highPassUniforms,
       vertexShader: n.vertexShader,
       fragmentShader: n.fragmentShader
     }), this.separableBlurMaterials = [];
     const l = [3, 5, 7, 9, 11];
-    r = Math.round(this.resolution.x / 2), o = Math.round(this.resolution.y / 2);
-    for (let c = 0; c < this.nMips; c++)
-      this.separableBlurMaterials.push(this.getSeparableBlurMaterial(l[c])), this.separableBlurMaterials[c].uniforms.invSize.value = new h(1 / r, 1 / o), r = Math.round(r / 2), o = Math.round(o / 2);
+    s = Math.round(this.resolution.x / 2), i = Math.round(this.resolution.y / 2);
+    for (let p = 0; p < this.nMips; p++)
+      this.separableBlurMaterials.push(this.getSeparableBlurMaterial(l[p])), this.separableBlurMaterials[p].uniforms.invSize.value = new d(1 / s, 1 / i), s = Math.round(s / 2), i = Math.round(i / 2);
     this.compositeMaterial = this.getCompositeMaterial(this.nMips), this.compositeMaterial.uniforms.blurTexture1.value = this.renderTargetsVertical[0].texture, this.compositeMaterial.uniforms.blurTexture2.value = this.renderTargetsVertical[1].texture, this.compositeMaterial.uniforms.blurTexture3.value = this.renderTargetsVertical[2].texture, this.compositeMaterial.uniforms.blurTexture4.value = this.renderTargetsVertical[3].texture, this.compositeMaterial.uniforms.blurTexture5.value = this.renderTargetsVertical[4].texture, this.compositeMaterial.uniforms.bloomStrength.value = t, this.compositeMaterial.uniforms.bloomRadius.value = 0.1;
-    const g = [1, 0.8, 0.6, 0.4, 0.2];
-    this.compositeMaterial.uniforms.bloomFactors.value = g, this.bloomTintColors = [new R(1, 1, 1), new R(1, 1, 1), new R(1, 1, 1), new R(1, 1, 1), new R(1, 1, 1)], this.compositeMaterial.uniforms.bloomTintColors.value = this.bloomTintColors;
-    const d = xe;
-    this.copyUniforms = w.clone(d.uniforms), this.blendMaterial = new x({
+    const x = [1, 0.8, 0.6, 0.4, 0.2];
+    this.compositeMaterial.uniforms.bloomFactors.value = x, this.bloomTintColors = [new P(1, 1, 1), new P(1, 1, 1), new P(1, 1, 1), new P(1, 1, 1), new P(1, 1, 1)], this.compositeMaterial.uniforms.bloomTintColors.value = this.bloomTintColors;
+    const u = Be;
+    this.copyUniforms = M.clone(u.uniforms), this.blendMaterial = new S({
       uniforms: this.copyUniforms,
-      vertexShader: d.vertexShader,
-      fragmentShader: d.fragmentShader,
-      blending: Ke,
+      vertexShader: u.vertexShader,
+      fragmentShader: u.fragmentShader,
+      blending: ut,
       depthTest: !1,
       depthWrite: !1,
       transparent: !0
-    }), this.enabled = !0, this.needsSwap = !1, this._oldClearColor = new X(), this.oldClearAlpha = 1, this.basic = new Ze(), this.fsQuad = new C(null);
+    }), this.enabled = !0, this.needsSwap = !1, this._oldClearColor = new j(), this.oldClearAlpha = 1, this.basic = new ct(), this.fsQuad = new L(null);
   }
   dispose() {
     for (let e = 0; e < this.renderTargetsHorizontal.length; e++)
@@ -1974,33 +2660,33 @@ class L extends A {
     this.compositeMaterial.dispose(), this.blendMaterial.dispose(), this.basic.dispose(), this.fsQuad.dispose();
   }
   setSize(e, t) {
-    let s = Math.round(e / 2), a = Math.round(t / 2);
-    this.renderTargetBright.setSize(s, a);
-    for (let r = 0; r < this.nMips; r++)
-      this.renderTargetsHorizontal[r].setSize(s, a), this.renderTargetsVertical[r].setSize(s, a), this.separableBlurMaterials[r].uniforms.invSize.value = new h(1 / s, 1 / a), s = Math.round(s / 2), a = Math.round(a / 2);
+    let o = Math.round(e / 2), a = Math.round(t / 2);
+    this.renderTargetBright.setSize(o, a);
+    for (let s = 0; s < this.nMips; s++)
+      this.renderTargetsHorizontal[s].setSize(o, a), this.renderTargetsVertical[s].setSize(o, a), this.separableBlurMaterials[s].uniforms.invSize.value = new d(1 / o, 1 / a), o = Math.round(o / 2), a = Math.round(a / 2);
   }
-  render(e, t, s, a, r) {
+  render(e, t, o, a, s) {
     e.getClearColor(this._oldClearColor), this.oldClearAlpha = e.getClearAlpha();
-    const o = e.autoClear;
-    e.autoClear = !1, e.setClearColor(this.clearColor, 0), r && e.state.buffers.stencil.setTest(!1), this.renderToScreen && (this.fsQuad.material = this.basic, this.basic.map = s.texture, e.setRenderTarget(null), e.clear(), this.fsQuad.render(e)), this.highPassUniforms.tDiffuse.value = s.texture, this.highPassUniforms.luminosityThreshold.value = this.threshold, this.fsQuad.material = this.materialHighPassFilter, e.setRenderTarget(this.renderTargetBright), e.clear(), this.fsQuad.render(e);
+    const i = e.autoClear;
+    e.autoClear = !1, e.setClearColor(this.clearColor, 0), s && e.state.buffers.stencil.setTest(!1), this.renderToScreen && (this.fsQuad.material = this.basic, this.basic.map = o.texture, e.setRenderTarget(null), e.clear(), this.fsQuad.render(e)), this.highPassUniforms.tDiffuse.value = o.texture, this.highPassUniforms.luminosityThreshold.value = this.threshold, this.fsQuad.material = this.materialHighPassFilter, e.setRenderTarget(this.renderTargetBright), e.clear(), this.fsQuad.render(e);
     let n = this.renderTargetBright;
     for (let l = 0; l < this.nMips; l++)
-      this.fsQuad.material = this.separableBlurMaterials[l], this.separableBlurMaterials[l].uniforms.colorTexture.value = n.texture, this.separableBlurMaterials[l].uniforms.direction.value = L.BlurDirectionX, e.setRenderTarget(this.renderTargetsHorizontal[l]), e.clear(), this.fsQuad.render(e), this.separableBlurMaterials[l].uniforms.colorTexture.value = this.renderTargetsHorizontal[l].texture, this.separableBlurMaterials[l].uniforms.direction.value = L.BlurDirectionY, e.setRenderTarget(this.renderTargetsVertical[l]), e.clear(), this.fsQuad.render(e), n = this.renderTargetsVertical[l];
-    this.fsQuad.material = this.compositeMaterial, this.compositeMaterial.uniforms.bloomStrength.value = this.strength, this.compositeMaterial.uniforms.bloomRadius.value = this.radius, this.compositeMaterial.uniforms.bloomTintColors.value = this.bloomTintColors, e.setRenderTarget(this.renderTargetsHorizontal[0]), e.clear(), this.fsQuad.render(e), this.fsQuad.material = this.blendMaterial, this.copyUniforms.tDiffuse.value = this.renderTargetsHorizontal[0].texture, r && e.state.buffers.stencil.setTest(!0), this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(s), this.fsQuad.render(e)), e.setClearColor(this._oldClearColor, this.oldClearAlpha), e.autoClear = o;
+      this.fsQuad.material = this.separableBlurMaterials[l], this.separableBlurMaterials[l].uniforms.colorTexture.value = n.texture, this.separableBlurMaterials[l].uniforms.direction.value = R.BlurDirectionX, e.setRenderTarget(this.renderTargetsHorizontal[l]), e.clear(), this.fsQuad.render(e), this.separableBlurMaterials[l].uniforms.colorTexture.value = this.renderTargetsHorizontal[l].texture, this.separableBlurMaterials[l].uniforms.direction.value = R.BlurDirectionY, e.setRenderTarget(this.renderTargetsVertical[l]), e.clear(), this.fsQuad.render(e), n = this.renderTargetsVertical[l];
+    this.fsQuad.material = this.compositeMaterial, this.compositeMaterial.uniforms.bloomStrength.value = this.strength, this.compositeMaterial.uniforms.bloomRadius.value = this.radius, this.compositeMaterial.uniforms.bloomTintColors.value = this.bloomTintColors, e.setRenderTarget(this.renderTargetsHorizontal[0]), e.clear(), this.fsQuad.render(e), this.fsQuad.material = this.blendMaterial, this.copyUniforms.tDiffuse.value = this.renderTargetsHorizontal[0].texture, s && e.state.buffers.stencil.setTest(!0), this.renderToScreen ? (e.setRenderTarget(null), this.fsQuad.render(e)) : (e.setRenderTarget(o), this.fsQuad.render(e)), e.setClearColor(this._oldClearColor, this.oldClearAlpha), e.autoClear = i;
   }
   getSeparableBlurMaterial(e) {
     const t = [];
-    for (let s = 0; s < e; s++)
-      t.push(0.39894 * Math.exp(-0.5 * s * s / (e * e)) / e);
-    return new x({
+    for (let o = 0; o < e; o++)
+      t.push(0.39894 * Math.exp(-0.5 * o * o / (e * e)) / e);
+    return new S({
       defines: {
         KERNEL_RADIUS: e
       },
       uniforms: {
         colorTexture: { value: null },
-        invSize: { value: new h(0.5, 0.5) },
+        invSize: { value: new d(0.5, 0.5) },
         // inverse texture size
-        direction: { value: new h(0.5, 0.5) },
+        direction: { value: new d(0.5, 0.5) },
         gaussianCoefficients: { value: t }
         // precomputed Gaussian coefficients
       },
@@ -2033,7 +2719,7 @@ class L extends A {
     });
   }
   getCompositeMaterial(e) {
-    return new x({
+    return new S({
       defines: {
         NUM_MIPS: e
       },
@@ -2079,51 +2765,64 @@ class L extends A {
     });
   }
 }
-L.BlurDirectionX = new h(1, 0);
-L.BlurDirectionY = new h(0, 1);
-const Lt = /* @__PURE__ */ p({
+R.BlurDirectionX = new d(1, 0);
+R.BlurDirectionY = new d(0, 1);
+const ao = /* @__PURE__ */ c({
   __name: "UnrealBloom",
   props: {
     radius: { default: 0 },
     strength: { default: 1 },
     threshold: { default: 0 }
   },
-  setup(i, { expose: e }) {
-    const t = i, { sizes: s } = S(), { pass: a } = P(() => new L(
-      new h(s.width.value, s.height.value),
+  setup(r, { expose: e }) {
+    const t = r, { sizes: o } = A(), { pass: a } = B(() => new R(
+      new d(o.width.value, o.height.value),
       t.radius,
       t.strength,
       t.threshold
     ), t);
-    return e({ pass: a }), m(() => {
-      var r;
-      a.value.radius = t.radius ?? ((r = a.value.getCompositeMaterial().uniforms.bloomRadius) == null ? void 0 : r.value) ?? 0.1;
-    }), m(() => {
-      var r;
-      a.value.strength = t.strength ?? ((r = a.value.getCompositeMaterial().uniforms.bloomStrength) == null ? void 0 : r.value) ?? 1;
-    }), m(() => {
-      var r;
-      a.value.threshold = t.threshold ?? ((r = Se.uniforms.luminosityThreshold) == null ? void 0 : r.value) ?? 1;
+    return e({ pass: a }), v(() => {
+      var s;
+      a.value.radius = t.radius ?? ((s = a.value.getCompositeMaterial().uniforms.bloomRadius) == null ? void 0 : s.value) ?? 0.1;
+    }), v(() => {
+      var s;
+      a.value.strength = t.strength ?? ((s = a.value.getCompositeMaterial().uniforms.bloomStrength) == null ? void 0 : s.value) ?? 1;
+    }), v(() => {
+      var s;
+      a.value.threshold = t.threshold ?? ((s = ze.uniforms.luminosityThreshold) == null ? void 0 : s.value) ?? 1;
     }), () => {
     };
   }
 });
 export {
-  gt as BloomPmndrs,
-  vt as DepthOfFieldPmndrs,
-  wt as EffectComposer,
-  pt as EffectComposerPmndrs,
-  Mt as Glitch,
-  xt as GlitchPmndrs,
-  yt as Halftone,
-  bt as NoisePmndrs,
-  St as OutlinePmndrs,
-  Et as Output,
-  Ct as Pixelation,
-  At as PixelationPmndrs,
-  Dt as SMAA,
-  Lt as UnrealBloom,
-  Tt as VignettePmndrs,
-  P as useEffect,
-  y as useEffectPmndrs
+  Ut as BarrelBlurPmndrs,
+  Ot as BloomPmndrs,
+  Gt as ChromaticAberrationPmndrs,
+  Vt as ColorAveragePmndrs,
+  Rt as DepthOfFieldPmndrs,
+  Qt as DotScreenPmndrs,
+  Zt as EffectComposer,
+  Lt as EffectComposerPmndrs,
+  _t as Glitch,
+  Bt as GlitchPmndrs,
+  $t as Halftone,
+  Xt as HueSaturationPmndrs,
+  jt as KuwaharaPmndrs,
+  Yt as LensDistortionPmndrs,
+  Jt as LinocutPmndrs,
+  Nt as NoisePmndrs,
+  zt as OutlinePmndrs,
+  to as Output,
+  eo as Pixelation,
+  Ft as PixelationPmndrs,
+  oo as SMAA,
+  It as ScanlinePmndrs,
+  Kt as SepiaPmndrs,
+  qt as ShockWavePmndrs,
+  kt as TiltShiftPmndrs,
+  Ht as ToneMappingPmndrs,
+  ao as UnrealBloom,
+  Wt as VignettePmndrs,
+  B as useEffect,
+  h as useEffectPmndrs
 };