shaders 2.2.23 → 2.2.25

package/dist/core/CRTScreen-C_U9g_IR.js

@@ -1,91 +0,0 @@
-import { O as E } from "./three.tsl-Btj1hLsf.js";
-const N = {
-  name: "CRTScreen",
-  category: "Stylize",
-  description: "Retro CRT monitor simulation with scanlines",
-  requiresRTT: !0,
-  requiresChild: !0,
-  props: {
-    pixelSize: {
-      default: 128,
-      description: "Size of individual TV pixels (lower = more pixels)",
-      ui: {
-        type: "range",
-        min: 8,
-        max: 128,
-        step: 1,
-        label: "Pixel Size"
-      }
-    },
-    colorShift: {
-      default: 1,
-      description: "Chromatic aberration amount",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 10,
-        step: 0.1,
-        label: "Color Shift"
-      }
-    },
-    scanlineIntensity: {
-      default: 0.3,
-      description: "Strength of horizontal scanlines",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Scanline Intensity"
-      }
-    },
-    scanlineFrequency: {
-      default: 200,
-      description: "Number of scanlines across screen",
-      ui: {
-        type: "range",
-        min: 100,
-        max: 800,
-        step: 10,
-        label: "Scanline Frequency"
-      }
-    },
-    brightness: {
-      default: 1.1,
-      description: "Screen brightness boost",
-      ui: {
-        type: "range",
-        min: 0.5,
-        max: 2,
-        step: 0.01,
-        label: "Brightness"
-      }
-    },
-    contrast: {
-      default: 1.2,
-      description: "Screen contrast enhancement",
-      ui: {
-        type: "range",
-        min: 0.5,
-        max: 2,
-        step: 0.01,
-        label: "Contrast"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: n, childNode: a, onCleanup: d }) => {
-    const { vec2: i, vec3: c, vec4: u, float: e, screenUV: t, sin: o, fract: p, smoothstep: f, length: g, convertToTexture: h } = E;
-    if (!a) return u(0, 0, 0, 0);
-    const s = h(a);
-    d(() => {
-      s?.renderTarget?.dispose && s.renderTarget.dispose();
-    });
-    const b = n.pixelSize.uniform, S = n.colorShift.uniform, x = n.scanlineIntensity.uniform, y = n.scanlineFrequency.uniform, C = n.brightness.uniform, T = n.contrast.uniform, m = S.mul(e(2e-3)), v = t.add(i(m, e(0))), z = t, q = t.sub(i(m, e(0))), R = s.sample(v).r, V = s.sample(z).g, F = s.sample(q).b, I = c(R, V, F).sub(e(0.5)).mul(T).add(e(0.5)).mul(C), U = o(t.y.mul(y).mul(e(3.14159 * 2))), k = e(1).sub(x.mul(U.mul(e(0.5)).add(e(0.5)))), r = I.mul(k), M = b.mul(e(0.5)), l = p(t.mul(M)), _ = o(l.x.mul(e(6.28318))).mul(e(0.1)).add(e(0.95)), w = o(l.x.mul(e(6.28318)).add(e(2.09))).mul(e(0.1)).add(e(0.95)), D = o(l.x.mul(e(6.28318)).add(e(4.18))).mul(e(0.1)).add(e(0.95)), P = c(r.r.mul(_), r.g.mul(w), r.b.mul(D)), j = g(t.sub(i(0.5, 0.5))), B = f(e(0.8), e(0.3), j);
-    return u(P.mul(B), e(1));
-  }
-};
-var W = N;
-export {
-  N as n,
-  W as t
-};

package/dist/core/ChannelBlur-5pzcB6Zv.js

@@ -1,89 +0,0 @@
-import { O as C } from "./three.tsl-Btj1hLsf.js";
-const A = {
-  name: "ChannelBlur",
-  category: "Blurs",
-  description: "Independent blur for red, green, and blue channels",
-  requiresRTT: !0,
-  requiresChild: !0,
-  props: {
-    redIntensity: {
-      default: 0,
-      description: "Blur intensity for red channel",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 100,
-        step: 1,
-        label: "Red Intensity"
-      }
-    },
-    greenIntensity: {
-      default: 20,
-      description: "Blur intensity for green channel",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 100,
-        step: 1,
-        label: "Green Intensity"
-      }
-    },
-    blueIntensity: {
-      default: 40,
-      description: "Blur intensity for blue channel",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 100,
-        step: 1,
-        label: "Blue Intensity"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: m, childNode: x, onCleanup: I }) => {
-    const { vec2: t, vec4: p, float: e, screenUV: S, convertToTexture: v, viewportSize: O, Fn: B } = C;
-    if (!x) return p(0, 0, 0, 0);
-    const i = v(x);
-    I(() => {
-      i?.renderTarget?.dispose && i.renderTarget.dispose();
-    });
-    const V = [
-      0.056,
-      0.135,
-      0.278,
-      0.487,
-      0.726,
-      0.923,
-      1,
-      0.923,
-      0.726,
-      0.487,
-      0.278,
-      0.135,
-      0.056
-    ], w = 6.214, R = m.redIntensity.uniform.mul(0.1), z = m.greenIntensity.uniform.mul(0.1), _ = m.blueIntensity.uniform.mul(0.1), u = v(B(() => {
-      const n = S, f = t(1).div(O), r = e(0).toVar(), a = e(0).toVar(), l = e(0).toVar();
-      for (let d = -6; d <= 6; d++) {
-        const s = e(V[d + 6] / w), o = e(d).mul(f.x), c = t(o.mul(R), e(0)), g = t(o.mul(z), e(0)), y = t(o.mul(_), e(0)), b = i.sample(n.add(c)).r.mul(s), T = i.sample(n.add(g)).g.mul(s), h = i.sample(n.add(y)).b.mul(s);
-        r.assign(r.add(b)), a.assign(a.add(T)), l.assign(l.add(h));
-      }
-      return p(r, a, l, e(1));
-    })());
-    return I(() => {
-      u?.renderTarget?.dispose && u.renderTarget.dispose();
-    }), B(() => {
-      const n = S, f = t(1).div(O), r = e(0).toVar(), a = e(0).toVar(), l = e(0).toVar();
-      for (let s = -6; s <= 6; s++) {
-        const o = e(V[s + 6] / w), c = e(s).mul(f.y), g = t(e(0), c.mul(R)), y = t(e(0), c.mul(z)), b = t(e(0), c.mul(_)), T = u.sample(n.add(g)).r.mul(o), h = u.sample(n.add(y)).g.mul(o), q = u.sample(n.add(b)).b.mul(o);
-        r.assign(r.add(T)), a.assign(a.add(h)), l.assign(l.add(q));
-      }
-      const d = i.sample(n).a;
-      return p(r, a, l, d);
-    })();
-  }
-};
-var F = A;
-export {
-  A as n,
-  F as t
-};

package/dist/core/Checkerboard-CrQkqXhD.js

@@ -1,75 +0,0 @@
-import { O as B } from "./three.tsl-Btj1hLsf.js";
-import { i as U, r as f, t as w } from "./transformations-CsrIJXh-.js";
-import { t as A } from "./colorMixing--dhzx0ch.js";
-const _ = {
-  name: "Checkerboard",
-  category: "Base Layers",
-  description: "Classic checkerboard pattern with two alternating colors",
-  acceptsUVContext: !0,
-  props: {
-    colorA: {
-      default: "#cccccc",
-      transform: f,
-      description: "First color of the checkerboard pattern",
-      ui: {
-        type: "color",
-        label: "Color A"
-      }
-    },
-    colorB: {
-      default: "#999999",
-      transform: f,
-      description: "Second color of the checkerboard pattern",
-      ui: {
-        type: "color",
-        label: "Color B"
-      }
-    },
-    cells: {
-      default: 8,
-      description: "Number of cells along the shortest canvas edge (creates square cells)",
-      ui: {
-        type: "range",
-        min: 1,
-        max: 50,
-        step: 1,
-        label: "Cells"
-      }
-    },
-    softness: {
-      default: 0,
-      description: "Smoothness of the transition between colors (0 = hard edges, 1 = very soft)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Softness"
-      }
-    },
-    colorSpace: {
-      default: "linear",
-      transform: U,
-      description: "Color space for color interpolation",
-      ui: {
-        type: "select",
-        options: w,
-        label: "Color Space"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: o, uvContext: m }) => {
-    const { vec2: u, float: e, floor: b, mod: h, fract: g, smoothstep: y, min: r, screenUV: C, viewportSize: s } = B, c = m ?? C, x = s.x.div(s.y), S = u(c.x.mul(x), c.y.oneMinus()), v = o.cells.uniform, l = o.softness.uniform, a = S.mul(v), n = b(a), i = h(n.x.add(n.y), 2);
-    let d = i;
-    if (l) {
-      const t = g(a), k = r(r(t.x, e(1).sub(t.x)), r(t.y, e(1).sub(t.y))), V = l.mul(0.5), p = y(e(0), V, k);
-      d = i.mul(p).add(e(0.5).mul(e(1).sub(p)));
-    }
-    return A(o.colorA.uniform, o.colorB.uniform, d, o.colorSpace.uniform);
-  }
-};
-var q = _;
-export {
-  _ as n,
-  q as t
-};

package/dist/core/ChromaFlow-CNrQdL8f.js

@@ -1,134 +0,0 @@
-import { O as _t } from "./three.tsl-Btj1hLsf.js";
-import { r as X } from "./transformations-CsrIJXh-.js";
-import { DataTexture as at, FloatType as lt, LinearFilter as L, RGFormat as nt } from "three";
-const Wt = {
-  name: "ChromaFlow",
-  category: "Interactive",
-  description: "Interactive liquid flow effect that follows your cursor",
-  props: {
-    baseColor: {
-      default: "#0066ff",
-      transform: X,
-      description: "Base liquid color",
-      ui: {
-        type: "color",
-        label: "Base Color"
-      }
-    },
-    upColor: {
-      default: "#00ff00",
-      transform: X,
-      description: "Color for upward movement",
-      ui: {
-        type: "color",
-        label: "Up Color"
-      }
-    },
-    downColor: {
-      default: "#ff0000",
-      transform: X,
-      description: "Color for downward movement",
-      ui: {
-        type: "color",
-        label: "Down Color"
-      }
-    },
-    leftColor: {
-      default: "#0000ff",
-      transform: X,
-      description: "Color for leftward movement",
-      ui: {
-        type: "color",
-        label: "Left Color"
-      }
-    },
-    rightColor: {
-      default: "#ffff00",
-      transform: X,
-      description: "Color for rightward movement",
-      ui: {
-        type: "color",
-        label: "Right Color"
-      }
-    },
-    intensity: {
-      default: 1,
-      description: "Strength of the liquid effect",
-      ui: {
-        type: "range",
-        min: 0.5,
-        max: 1.5,
-        step: 0.1,
-        label: "Intensity"
-      }
-    },
-    radius: {
-      default: 2,
-      description: "Radius of the liquid effect",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 3,
-        step: 0.01,
-        label: "Radius"
-      }
-    },
-    momentum: {
-      default: 30,
-      description: "How much momentum colors retain in their flow direction",
-      ui: {
-        type: "range",
-        min: 10,
-        max: 60,
-        step: 1,
-        label: "Momentum"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: u, onBeforeRender: st, onCleanup: rt }) => {
-    const { vec2: l, vec4: it, float: t, uniform: Y, screenUV: n, texture: W, smoothstep: v, mix: dt } = _t, o = 128, f = new Float32Array(o * o * 2), r = new Float32Array(o * o * 2), w = new at(f, o, o, nt, lt);
-    w.magFilter = L, w.minFilter = L, w.needsUpdate = !0;
-    const C = new at(r, o, o, nt, lt);
-    C.magFilter = L, C.minFilter = L, C.needsUpdate = !0;
-    const F = W(w), b = W(C), ct = Y(0.5), mt = Y(0.5), q = Y(0), D = Y(0);
-    let j = 0.5, B = 0.5, G = Date.now();
-    st(({ pointer: p }) => {
-      const tt = Date.now(), s = Math.min((tt - G) / 1e3, 0.016);
-      G = tt;
-      const ot = s > 0 ? (p.x - j) / s : 0, et = s > 0 ? (p.y - B) / s : 0;
-      q.value = q.value * 0.85 + ot * 0.15, D.value = D.value * 0.85 + et * 0.15, ct.value = p.x, mt.value = p.y;
-      const _ = u.intensity.uniform.value, Yt = u.radius.uniform.value * 0.05, zt = u.momentum.uniform.value, x = new Float32Array(f), i = new Float32Array(r), It = 1 - s / Math.max(0.1, 1);
-      for (let a = 0; a < o * o * 2; a++) x[a] = f[a] * It;
-      for (let a = 0; a < o; a++) for (let d = 0; d < o; d++) {
-        const e = (a * o + d) * 2, S = 1 - s / Math.max(0.4, 1);
-        if (i[e] = r[e] * S, i[e + 1] = r[e + 1] * S, Math.abs(f[e]) > 1e-3 || Math.abs(f[e + 1]) > 1e-3) {
-          const T = zt * 50 * s, A = d - f[e] * T, R = a - f[e + 1] * T, c = Math.floor(A), m = Math.floor(R), h = c + 1, y = m + 1;
-          if (c >= 0 && m >= 0 && h < o && y < o) {
-            const M = A - c, U = R - m, Tt = (m * o + c) * 2, Ut = (m * o + h) * 2, Lt = (y * o + c) * 2, Vt = (y * o + h) * 2;
-            i[e] = (r[Tt] * (1 - M) * (1 - U) + r[Ut] * M * (1 - U) + r[Lt] * (1 - M) * U + r[Vt] * M * U) * S;
-          }
-        }
-      }
-      for (let a = 0; a < o; a++) for (let d = 0; d < o; d++) {
-        const e = (a * o + d) * 2, S = (d + 0.5) / o, T = (a + 0.5) / o, A = S - p.x, R = T - p.y, c = Math.sqrt(A * A + R * R), m = Math.sqrt(q.value * q.value + D.value * D.value), h = Yt * Math.min(m * m * 20, 1);
-        if (c < h * 2 && Math.abs(ot) + Math.abs(et) > 0.01) {
-          const y = Math.exp(-c * c / (h * h));
-          x[e] += q.value * y * (_ * 100) * s * 0.01, x[e + 1] += D.value * y * (_ * 100) * s * 0.01;
-          const M = Math.min(m * 10, 1);
-          i[e] += y * (_ * 100) * s * 0.01 * M, i[e + 1] = 0;
-        }
-        x[e] = Math.max(-1, Math.min(1, x[e])), x[e + 1] = Math.max(-1, Math.min(1, x[e + 1])), i[e] = Math.max(0, Math.min(1, i[e])), i[e + 1] = 0;
-      }
-      f.set(x), r.set(i), w.needsUpdate = !0, C.needsUpdate = !0, j = p.x, B = p.y;
-    }), rt(() => {
-      w.dispose(), C.dispose();
-    });
-    const ut = b.sample(n).x, z = l(t(1 / 128), t(1 / 128)), ft = b.sample(n.add(l(z.x, t(0)))).x, pt = b.sample(n.add(l(t(0), z.y))).x, xt = b.sample(n.add(l(z.x.negate(), t(0)))).x, ht = b.sample(n.add(l(t(0), z.y.negate()))).x, yt = ut.add(ft).add(pt).add(xt).add(ht).mul(t(0.2)), E = v(t(0), t(0.1), yt), I = l(t(1 / 128), t(1 / 128)), vt = F.sample(n).xy, wt = F.sample(n.add(l(I.x, t(0)))).xy, Ct = F.sample(n.add(l(t(0), I.y))).xy, gt = F.sample(n.add(l(I.x.negate(), t(0)))).xy, Mt = F.sample(n.add(l(t(0), I.y.negate()))).xy, g = vt.add(wt).add(Ct).add(gt).add(Mt).mul(t(0.2)), Ft = u.baseColor.uniform, bt = u.upColor.uniform, qt = u.downColor.uniform, Dt = u.leftColor.uniform, St = u.rightColor.uniform, V = g.x.mul(g.x).add(g.y.mul(g.y)).sqrt(), At = v(t(0.01), t(0.1), V), H = g.x.div(V.add(t(1e-3))), N = g.y.div(V.add(t(1e-3))), O = v(t(0), t(0.7), H.max(t(0))), P = v(t(0), t(0.7), H.negate().max(t(0))), Z = v(t(0), t(0.7), N.max(t(0))), k = v(t(0), t(0.7), N.negate().max(t(0))), Rt = Dt.mul(P).add(St.mul(O)), Xt = qt.mul(k).add(bt.mul(Z)), J = P.add(O), K = Z.add(k), Q = J.add(K).add(t(1e-3)), $ = dt(Ft, Rt.mul(J.div(Q)).add(Xt.mul(K.div(Q))), At);
-    return it($.rgb.mul(E), $.a.mul(E));
-  }
-};
-var Et = Wt;
-export {
-  Wt as n,
-  Et as t
-};

package/dist/core/ChromaticAberration-D9H7O17Y.js

@@ -1,82 +0,0 @@
-import { O as T } from "./three.tsl-Btj1hLsf.js";
-import { n as C } from "./transformations-CsrIJXh-.js";
-const v = {
-  name: "ChromaticAberration",
-  category: "Stylize",
-  description: "Separate RGB channels for a prismatic distortion effect",
-  requiresRTT: !0,
-  requiresChild: !0,
-  props: {
-    strength: {
-      default: 0.2,
-      description: "Overall strength of the chromatic aberration effect",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Strength"
-      }
-    },
-    angle: {
-      default: 0,
-      transform: C,
-      description: "Direction of the chromatic aberration in degrees",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 360,
-        step: 1,
-        label: "Angle"
-      }
-    },
-    redOffset: {
-      default: -1,
-      description: "Red channel offset multiplier",
-      ui: {
-        type: "range",
-        min: -2,
-        max: 2,
-        step: 0.1,
-        label: "Red Offset"
-      }
-    },
-    greenOffset: {
-      default: 0,
-      description: "Green channel offset multiplier",
-      ui: {
-        type: "range",
-        min: -2,
-        max: 2,
-        step: 0.1,
-        label: "Green Offset"
-      }
-    },
-    blueOffset: {
-      default: 1,
-      description: "Blue channel offset multiplier",
-      ui: {
-        type: "range",
-        min: -2,
-        max: 2,
-        step: 0.1,
-        label: "Blue Offset"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: t, childNode: s, onCleanup: o }) => {
-    const { vec2: f, vec4: i, cos: c, sin: m, radians: u, screenUV: r, convertToTexture: d } = T;
-    if (!s) return i(0, 0, 0, 0);
-    const e = d(s);
-    o(() => {
-      e?.renderTarget?.dispose && e.renderTarget.dispose();
-    });
-    const l = u(t.angle.uniform), n = f(c(l), m(l)), a = t.strength.uniform.mul(0.1), p = r.add(n.mul(a).mul(t.redOffset.uniform)), g = r.add(n.mul(a).mul(t.greenOffset.uniform)), h = r.add(n.mul(a).mul(t.blueOffset.uniform)), b = e.sample(p).r, O = e.sample(g).g, x = e.sample(h).b, y = e.sample(r).a;
-    return i(b, O, x, y);
-  }
-};
-var S = v;
-export {
-  v as n,
-  S as t
-};

package/dist/core/Circle-DnLaDn8V.js

@@ -1,62 +0,0 @@
-import { O as g } from "./three.tsl-Btj1hLsf.js";
-import { o as v, r as y } from "./transformations-CsrIJXh-.js";
-const x = {
-  name: "Circle",
-  category: "Base Layers",
-  description: "Generate a circle with adjustable size and softness",
-  acceptsUVContext: !0,
-  props: {
-    color: {
-      default: "#ffffff",
-      transform: y,
-      description: "The color of the circle",
-      ui: {
-        type: "color",
-        label: "Color"
-      }
-    },
-    radius: {
-      default: 1,
-      description: "The radius of the circle. A value of one (1) is sets the circle to fit the canvas.",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 2,
-        step: 0.01,
-        label: "Radius"
-      }
-    },
-    softness: {
-      default: 0,
-      description: "Edge softness. Lower values like zero (0) are sharp, higher values like one (1) are softer.",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Softness"
-      }
-    },
-    center: {
-      default: {
-        x: 0.5,
-        y: 0.5
-      },
-      transform: v,
-      description: "The center point of the circle",
-      ui: {
-        type: "position",
-        label: "Center Position"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: e, uvContext: i }) => {
-    const { vec2: t, vec4: c, length: a, smoothstep: l, screenUV: f, viewportSize: o } = g, r = i ?? f, s = o.x.div(o.y), u = t(r.x.mul(s), r.y), p = t(e.center.uniform.x.mul(s), e.center.uniform.y.oneMinus()), d = a(u.sub(p)), m = e.softness.uniform, n = e.radius.uniform.mul(0.5), h = l(n, n.sub(m), d);
-    return c(e.color.uniform.rgb, e.color.uniform.a.mul(h));
-  }
-};
-var k = x;
-export {
-  x as n,
-  k as t
-};

package/dist/core/ColorAdjustment-CKwpE_4M.js

@@ -1,14 +0,0 @@
-import { a as m, i as e, l as b, n as c, r as d, s as r, t as u, u as o } from "./TSLBase-BFMvTOak.js";
-const f = /* @__PURE__ */ e(([s]) => g(s.rgb)), v = /* @__PURE__ */ e(([s, a = m(1)]) => a.mix(g(s.rgb), s.rgb)), l = /* @__PURE__ */ e(([s, a = m(1)]) => {
-  const n = d(s.r, s.g, s.b).div(3), t = s.r.max(s.g.max(s.b)), i = t.sub(n).mul(a).mul(-3);
-  return c(s.rgb, t, i);
-}), p = /* @__PURE__ */ e(([s, a = m(1)]) => {
-  const n = r(0.57735, 0.57735, 0.57735), t = a.cos();
-  return r(s.rgb.mul(t).add(n.cross(s.rgb).mul(a.sin()).add(n.mul(u(n, s.rgb).mul(t.oneMinus())))));
-}), g = (s, a = r(o.getLuminanceCoefficients(new b()))) => u(s, a);
-export {
-  l as i,
-  p as n,
-  v as r,
-  f as t
-};

package/dist/core/CursorTrail-NY6n97VG.js

@@ -1,105 +0,0 @@
-import { A as p, O as at } from "./three.tsl-Btj1hLsf.js";
-import { i as et, r as B, t as ot } from "./transformations-CsrIJXh-.js";
-import { t as rt } from "./colorMixing--dhzx0ch.js";
-import { DataTexture as lt, FloatType as st, LinearFilter as _, RGBAFormat as nt } from "three";
-const ct = {
-  name: "CursorTrail",
-  category: "Interactive",
-  description: "Animated trail effect that tracks cursor movement",
-  props: {
-    colorA: {
-      default: "#00aaff",
-      transform: B,
-      description: "Color of fresh trails",
-      ui: {
-        type: "color",
-        label: "Start Color"
-      }
-    },
-    colorB: {
-      default: "#ff00aa",
-      transform: B,
-      description: "Color trails transition to as they fade",
-      ui: {
-        type: "color",
-        label: "End Color"
-      }
-    },
-    radius: {
-      default: 0.5,
-      description: "Base radius of trail circles",
-      ui: {
-        type: "range",
-        min: 0.5,
-        max: 2,
-        step: 0.01,
-        label: "Radius"
-      }
-    },
-    length: {
-      default: 0.5,
-      description: "How long trail circles persist (in seconds)",
-      ui: {
-        type: "range",
-        min: 0.1,
-        max: 2,
-        step: 0.1,
-        label: "Trail Length"
-      }
-    },
-    shrink: {
-      default: 1,
-      description: "How much circles shrink as they fade out (0 = no shrink, 1 = full shrink)",
-      ui: {
-        type: "range",
-        min: 0,
-        max: 1,
-        step: 0.01,
-        label: "Shrink Amount"
-      }
-    },
-    colorSpace: {
-      default: "linear",
-      transform: et,
-      description: "Color space for color interpolation",
-      ui: {
-        type: "select",
-        options: ot,
-        label: "Color Space"
-      }
-    }
-  },
-  fragmentNode: ({ uniforms: l, onBeforeRender: U, onCleanup: q }) => {
-    const { vec4: E, float: t, texture: G, step: H, screenUV: n } = at, a = 128, o = new Float32Array(a * a * 4), s = new lt(o, a, a, nt, st);
-    s.magFilter = _, s.minFilter = _, s.needsUpdate = !0;
-    const c = G(s);
-    let y = 0.5, M = 0.5, g = Date.now();
-    U(({ pointer: r }) => {
-      const T = Date.now(), f = Math.min((T - g) / 1e3, 0.016);
-      g = T;
-      const h = l.radius.uniform.value * 0.1, b = l.length.uniform.value, j = l.shrink.uniform.value, F = r.x - y, w = r.y - M, z = Math.sqrt(F * F + w * w), N = 1 - f / Math.max(0.1, b), V = f / Math.max(0.1, b);
-      for (let e = 0; e < a * a * 4; e += 4)
-        o[e] *= N, o[e + 1] = 1 - (1 - o[e]) * j, o[e + 2] = Math.min(1, o[e + 2] + V);
-      if (z > 1e-3) {
-        const e = h * 3, Z = Math.max(0, Math.floor((r.x - e) * a)), K = Math.min(a - 1, Math.ceil((r.x + e) * a)), P = Math.max(0, Math.floor((r.y - e) * a)), Q = Math.min(a - 1, Math.ceil((r.y + e) * a));
-        for (let m = P; m <= Q; m++) for (let d = Z; d <= K; d++) {
-          const u = (m * a + d) * 4, W = (d + 0.5) / a, $ = (m + 0.5) / a, I = W - r.x, R = $ - r.y, x = Math.sqrt(I * I + R * R);
-          if (x < e) {
-            const tt = Math.exp(-x * x / (h * h)) * z * 50 * f;
-            o[u] = Math.min(1, o[u] + tt), o[u + 1] = 1, o[u + 2] = 0;
-          }
-        }
-      }
-      s.needsUpdate = !0, y = r.x, M = r.y;
-    }), q(() => {
-      s.dispose();
-    });
-    const i = t(1 / a), C = c.sample(n), v = c.sample(n.add(p(i, t(0)))), A = c.sample(n.add(p(t(0), i))), S = c.sample(n.add(p(i.negate(), t(0)))), k = c.sample(n.add(p(t(0), i.negate()))), J = C.x.mul(t(0.5)).add(v.x.mul(t(0.125))).add(A.x.mul(t(0.125))).add(S.x.mul(t(0.125))).add(k.x.mul(t(0.125))), L = C.z.mul(t(0.5)).add(v.z.mul(t(0.125))).add(A.z.mul(t(0.125))).add(S.z.mul(t(0.125))).add(k.z.mul(t(0.125))), O = H(t(0.01), J), X = l.colorA.uniform, Y = l.colorB.uniform, D = rt(X, Y, L, l.colorSpace.uniform);
-    return E(D.rgb, D.a.mul(O));
-  }
-};
-var pt = ct;
-export {
-  ct as n,
-  pt as t
-};