@la-batcave/ui 3.1.2

package/dist/backgrounds/Aurora.d.ts

@@ -0,0 +1,7 @@
+export interface AuroraProps {
+    colorStops?: string[];
+    amplitude?: number;
+    blend?: number;
+    speed?: number;
+}
+export default function Aurora({ colorStops, amplitude, blend, speed, }: AuroraProps): import("react/jsx-runtime").JSX.Element;

package/dist/backgrounds/Aurora.js

@@ -0,0 +1,126 @@
+"use client";
+import { jsx as A } from "react/jsx-runtime";
+import { useRef as C, useEffect as R } from "react";
+import { Renderer as S, Triangle as B, Color as h, Program as z, Mesh as E } from "ogl";
+const _ = `#version 300 es
+in vec2 position;
+void main() {
+  gl_Position = vec4(position, 0.0, 1.0);
+}
+`, b = `#version 300 es
+precision highp float;
+uniform float uTime;
+uniform float uAmplitude;
+uniform vec3 uColorStops[3];
+uniform vec2 uResolution;
+uniform float uBlend;
+out vec4 fragColor;
+vec3 permute(vec3 x) { return mod(((x * 34.0) + 1.0) * x, 289.0); }
+float snoise(vec2 v){
+  const vec4 C = vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439);
+  vec2 i = floor(v + dot(v, C.yy));
+  vec2 x0 = v - i + dot(i, C.xx);
+  vec2 i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+  vec4 x12 = x0.xyxy + C.xxzz;
+  x12.xy -= i1;
+  i = mod(i, 289.0);
+  vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0)) + i.x + vec3(0.0, i1.x, 1.0));
+  vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
+  m = m * m; m = m * m;
+  vec3 x = 2.0 * fract(p * C.www) - 1.0;
+  vec3 h = abs(x) - 0.5;
+  vec3 ox = floor(x + 0.5);
+  vec3 a0 = x - ox;
+  m *= 1.79284291400159 - 0.85373472095314 * (a0*a0 + h*h);
+  vec3 g;
+  g.x = a0.x * x0.x + h.x * x0.y;
+  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+  return 130.0 * dot(m, g);
+}
+struct ColorStop { vec3 color; float position; };
+#define COLOR_RAMP(colors, factor, finalColor) { \\
+  int index = 0; \\
+  for (int i = 0; i < 2; i++) { \\
+    ColorStop currentColor = colors[i]; \\
+    bool isInBetween = currentColor.position <= factor; \\
+    index = int(mix(float(index), float(i), float(isInBetween))); \\
+  } \\
+  ColorStop currentColor = colors[index]; \\
+  ColorStop nextColor = colors[index + 1]; \\
+  float range = nextColor.position - currentColor.position; \\
+  float lerpFactor = (factor - currentColor.position) / range; \\
+  finalColor = mix(currentColor.color, nextColor.color, lerpFactor); \\
+}
+void main() {
+  vec2 uv = gl_FragCoord.xy / uResolution;
+  ColorStop colors[3];
+  colors[0] = ColorStop(uColorStops[0], 0.0);
+  colors[1] = ColorStop(uColorStops[1], 0.5);
+  colors[2] = ColorStop(uColorStops[2], 1.0);
+  vec3 rampColor;
+  COLOR_RAMP(colors, uv.x, rampColor);
+  float height = snoise(vec2(uv.x * 2.0 + uTime * 0.1, uTime * 0.25)) * 0.5 * uAmplitude;
+  height = exp(height);
+  height = (uv.y * 2.0 - height + 0.2);
+  float intensity = 0.6 * height;
+  float midPoint = 0.20;
+  float auroraAlpha = smoothstep(midPoint - uBlend * 0.5, midPoint + uBlend * 0.5, intensity);
+  vec3 auroraColor = intensity * rampColor;
+  fragColor = vec4(auroraColor * auroraAlpha, auroraAlpha);
+}
+`;
+function T({
+  colorStops: i = ["#E7BB1D", "#B8941A", "#E7BB1D"],
+  amplitude: l = 1,
+  blend: u = 0.5,
+  speed: f = 1
+}) {
+  const x = C(null), p = C({ colorStops: i, amplitude: l, blend: u, speed: f });
+  return p.current = { colorStops: i, amplitude: l, blend: u, speed: f }, R(() => {
+    const r = x.current;
+    if (!r) return;
+    const a = new S({ alpha: !0, premultipliedAlpha: !0, antialias: !0 }), o = a.gl;
+    o.clearColor(0, 0, 0, 0), o.enable(o.BLEND), o.blendFunc(o.ONE, o.ONE_MINUS_SRC_ALPHA), o.canvas.style.backgroundColor = "transparent";
+    let t;
+    function s() {
+      if (!r) return;
+      const n = r.offsetWidth, e = r.offsetHeight;
+      a.setSize(n, e), t && (t.uniforms.uResolution.value = [n, e]);
+    }
+    window.addEventListener("resize", s);
+    const c = new B(o);
+    c.attributes.uv && delete c.attributes.uv;
+    const g = i.map((n) => {
+      const e = new h(n);
+      return [e.r, e.g, e.b];
+    });
+    t = new z(o, {
+      vertex: _,
+      fragment: b,
+      uniforms: {
+        uTime: { value: 0 },
+        uAmplitude: { value: l },
+        uColorStops: { value: g },
+        uResolution: { value: [r.offsetWidth, r.offsetHeight] },
+        uBlend: { value: u }
+      }
+    });
+    const y = new E(o, { geometry: c, program: t });
+    r.appendChild(o.canvas);
+    let m = 0;
+    const d = (n) => {
+      m = requestAnimationFrame(d);
+      const e = p.current;
+      t.uniforms.uTime.value = n * 0.01 * (e.speed ?? 1) * 0.1, t.uniforms.uAmplitude.value = e.amplitude ?? 1, t.uniforms.uBlend.value = e.blend ?? 0.5, t.uniforms.uColorStops.value = (e.colorStops ?? i).map((w) => {
+        const v = new h(w);
+        return [v.r, v.g, v.b];
+      }), a.render({ scene: y });
+    };
+    return m = requestAnimationFrame(d), s(), () => {
+      cancelAnimationFrame(m), window.removeEventListener("resize", s), r && o.canvas.parentNode === r && r.removeChild(o.canvas), o.getExtension("WEBGL_lose_context")?.loseContext();
+    };
+  }, [l]), /* @__PURE__ */ A("div", { ref: x, style: { width: "100%", height: "100%" } });
+}
+export {
+  T as default
+};

package/dist/backgrounds/Iridescence.d.ts

@@ -0,0 +1,7 @@
+export interface IridescenceProps {
+    color?: [number, number, number];
+    speed?: number;
+    amplitude?: number;
+    mouseReact?: boolean;
+}
+export default function Iridescence({ color, speed, amplitude, mouseReact }: IridescenceProps): import("react/jsx-runtime").JSX.Element;

package/dist/backgrounds/Iridescence.js

@@ -0,0 +1,77 @@
+"use client";
+import { jsx as C } from "react/jsx-runtime";
+import { useRef as g, useEffect as R } from "react";
+import { Renderer as A, Triangle as E, Program as M, Color as v, Mesh as S } from "ogl";
+const T = `
+attribute vec2 uv;
+attribute vec2 position;
+varying vec2 vUv;
+void main() { vUv = uv; gl_Position = vec4(position, 0, 1); }
+`, F = `
+precision highp float;
+uniform float uTime;
+uniform vec3 uColor;
+uniform vec3 uResolution;
+uniform vec2 uMouse;
+uniform float uAmplitude;
+uniform float uSpeed;
+varying vec2 vUv;
+void main() {
+  float mr = min(uResolution.x, uResolution.y);
+  vec2 uv = (vUv.xy * 2.0 - 1.0) * uResolution.xy / mr;
+  uv += (uMouse - vec2(0.5)) * uAmplitude;
+  float d = -uTime * 0.5 * uSpeed;
+  float a = 0.0;
+  for (float i = 0.0; i < 8.0; ++i) {
+    a += cos(i - d - a * uv.x);
+    d += sin(uv.y * i + a);
+  }
+  d += uTime * 0.5 * uSpeed;
+  vec3 col = vec3(cos(uv * vec2(d, a)) * 0.6 + 0.4, cos(a + d) * 0.5 + 0.5);
+  col = cos(col * cos(vec3(d, a, 2.5)) * 0.5 + 0.5) * uColor;
+  gl_FragColor = vec4(col, 1.0);
+}
+`;
+function _({ color: c = [0.91, 0.73, 0.11], speed: l = 1, amplitude: m = 0.1, mouseReact: u = !0 }) {
+  const f = g(null);
+  return g({ x: 0.5, y: 0.5 }), R(() => {
+    const o = f.current;
+    if (!o) return;
+    const r = new A(), e = r.gl;
+    e.clearColor(0.11, 0.09, 0.09, 1);
+    let n;
+    function a() {
+      r.setSize(o.offsetWidth, o.offsetHeight), n && (n.uniforms.uResolution.value = new v(e.canvas.width, e.canvas.height, e.canvas.width / e.canvas.height));
+    }
+    window.addEventListener("resize", a), a();
+    const p = new E(e);
+    n = new M(e, {
+      vertex: T,
+      fragment: F,
+      uniforms: {
+        uTime: { value: 0 },
+        uColor: { value: new v(...c) },
+        uResolution: { value: new v(e.canvas.width, e.canvas.height, e.canvas.width / e.canvas.height) },
+        uMouse: { value: new Float32Array([0.5, 0.5]) },
+        uAmplitude: { value: m },
+        uSpeed: { value: l }
+      }
+    });
+    const w = new S(e, { geometry: p, program: n });
+    let s = 0;
+    const d = (t) => {
+      s = requestAnimationFrame(d), n.uniforms.uTime.value = t * 1e-3, r.render({ scene: w });
+    };
+    s = requestAnimationFrame(d), o.appendChild(e.canvas);
+    const h = (t) => {
+      const i = o.getBoundingClientRect(), x = (t.clientX - i.left) / i.width, y = 1 - (t.clientY - i.top) / i.height;
+      n.uniforms.uMouse.value[0] = x, n.uniforms.uMouse.value[1] = y;
+    };
+    return u && o.addEventListener("mousemove", h), () => {
+      cancelAnimationFrame(s), window.removeEventListener("resize", a), u && o.removeEventListener("mousemove", h), o.contains(e.canvas) && o.removeChild(e.canvas), e.getExtension("WEBGL_lose_context")?.loseContext();
+    };
+  }, [c, l, m, u]), /* @__PURE__ */ C("div", { ref: f, style: { width: "100%", height: "100%" } });
+}
+export {
+  _ as default
+};

package/dist/backgrounds/Lightning.d.ts

@@ -0,0 +1,8 @@
+export interface LightningProps {
+    hue?: number;
+    xOffset?: number;
+    speed?: number;
+    intensity?: number;
+    size?: number;
+}
+export default function Lightning({ hue, xOffset, speed, intensity, size }: LightningProps): import("react/jsx-runtime").JSX.Element;

package/dist/backgrounds/Lightning.js

@@ -0,0 +1,75 @@
+"use client";
+import { jsx as U } from "react/jsx-runtime";
+import { useRef as _, useEffect as z } from "react";
+function H({ hue: a = 45, xOffset: c = 0, speed: f = 1, intensity: s = 1, size: u = 1 }) {
+  const m = _(null);
+  return z(() => {
+    const o = m.current;
+    if (!o) return;
+    const i = () => {
+      o.width = o.clientWidth, o.height = o.clientHeight;
+    };
+    i(), window.addEventListener("resize", i);
+    const t = o.getContext("webgl");
+    if (!t) return;
+    const h = "attribute vec2 aPosition; void main() { gl_Position = vec4(aPosition, 0.0, 1.0); }", d = `
+      precision mediump float;
+      uniform vec2 iResolution;
+      uniform float iTime;
+      uniform float uHue;
+      uniform float uXOffset;
+      uniform float uSpeed;
+      uniform float uIntensity;
+      uniform float uSize;
+      #define OCTAVE_COUNT 10
+      vec3 hsv2rgb(vec3 c) {
+        vec3 rgb = clamp(abs(mod(c.x*6.0+vec3(0.0,4.0,2.0),6.0)-3.0)-1.0,0.0,1.0);
+        return c.z*mix(vec3(1.0),rgb,c.y);
+      }
+      float hash11(float p) { p=fract(p*.1031); p*=p+33.33; p*=p+p; return fract(p); }
+      float hash12(vec2 p) { vec3 p3=fract(vec3(p.xyx)*.1031); p3+=dot(p3,p3.yzx+33.33); return fract((p3.x+p3.y)*p3.z); }
+      mat2 rotate2d(float t) { float c=cos(t),s=sin(t); return mat2(c,-s,s,c); }
+      float noise(vec2 p) {
+        vec2 ip=floor(p),fp=fract(p);
+        float a=hash12(ip),b=hash12(ip+vec2(1,0)),c=hash12(ip+vec2(0,1)),d=hash12(ip+vec2(1,1));
+        vec2 t=smoothstep(0.0,1.0,fp);
+        return mix(mix(a,b,t.x),mix(c,d,t.x),t.y);
+      }
+      float fbm(vec2 p) {
+        float v=0.0,a=0.5;
+        for(int i=0;i<OCTAVE_COUNT;++i){v+=a*noise(p);p*=rotate2d(0.45);p*=2.0;a*=0.5;}
+        return v;
+      }
+      void main() {
+        vec2 uv=gl_FragCoord.xy/iResolution.xy;
+        uv=2.0*uv-1.0;
+        uv.x*=iResolution.x/iResolution.y;
+        uv.x+=uXOffset;
+        uv+=2.0*fbm(uv*uSize+0.8*iTime*uSpeed)-1.0;
+        float dist=abs(uv.x);
+        vec3 baseColor=hsv2rgb(vec3(uHue/360.0,0.7,0.8));
+        vec3 col=baseColor*pow(mix(0.0,0.07,hash11(iTime*uSpeed))/dist,1.0)*uIntensity;
+        gl_FragColor=vec4(col,1.0);
+      }
+    `, l = (F, C) => {
+      const n = t.createShader(C);
+      return t.shaderSource(n, F), t.compileShader(n), n;
+    }, g = l(h, t.VERTEX_SHADER), b = l(d, t.FRAGMENT_SHADER), e = t.createProgram();
+    t.attachShader(e, g), t.attachShader(e, b), t.linkProgram(e), t.useProgram(e);
+    const x = t.createBuffer();
+    t.bindBuffer(t.ARRAY_BUFFER, x), t.bufferData(t.ARRAY_BUFFER, new Float32Array([-1, -1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1]), t.STATIC_DRAW);
+    const p = t.getAttribLocation(e, "aPosition");
+    t.enableVertexAttribArray(p), t.vertexAttribPointer(p, 2, t.FLOAT, !1, 0, 0);
+    const A = t.getUniformLocation(e, "iResolution"), R = t.getUniformLocation(e, "iTime"), S = t.getUniformLocation(e, "uHue"), w = t.getUniformLocation(e, "uXOffset"), y = t.getUniformLocation(e, "uSpeed"), T = t.getUniformLocation(e, "uIntensity"), E = t.getUniformLocation(e, "uSize"), L = performance.now();
+    let r = 0;
+    const v = () => {
+      r = requestAnimationFrame(v), i(), t.viewport(0, 0, o.width, o.height), t.uniform2f(A, o.width, o.height), t.uniform1f(R, (performance.now() - L) / 1e3), t.uniform1f(S, a), t.uniform1f(w, c), t.uniform1f(y, f), t.uniform1f(T, s), t.uniform1f(E, u), t.drawArrays(t.TRIANGLES, 0, 6);
+    };
+    return r = requestAnimationFrame(v), () => {
+      cancelAnimationFrame(r), window.removeEventListener("resize", i);
+    };
+  }, [a, c, f, s, u]), /* @__PURE__ */ U("canvas", { ref: m, style: { width: "100%", height: "100%", display: "block" } });
+}
+export {
+  H as default
+};

package/dist/backgrounds/LiquidChrome.d.ts

@@ -0,0 +1,9 @@
+export interface LiquidChromeProps {
+    baseColor?: [number, number, number];
+    speed?: number;
+    amplitude?: number;
+    frequencyX?: number;
+    frequencyY?: number;
+    interactive?: boolean;
+}
+export default function LiquidChrome({ baseColor, speed, amplitude, frequencyX, frequencyY, interactive }: LiquidChromeProps): import("react/jsx-runtime").JSX.Element;

package/dist/backgrounds/LiquidChrome.js

@@ -0,0 +1,89 @@
+"use client";
+import { jsx as F } from "react/jsx-runtime";
+import { useRef as R, useEffect as C } from "react";
+import { Renderer as A, Triangle as E, Program as M, Mesh as T } from "ogl";
+function B({ baseColor: n = [0.11, 0.09, 0.07], speed: v = 0.2, amplitude: c = 0.5, frequencyX: f = 3, frequencyY: m = 2, interactive: r = !0 }) {
+  const d = R(null);
+  return C(() => {
+    const t = d.current;
+    if (!t) return;
+    const a = new A({ antialias: !0 }), e = a.gl;
+    e.clearColor(n[0], n[1], n[2], 1);
+    const p = `
+      attribute vec2 position;
+      attribute vec2 uv;
+      varying vec2 vUv;
+      void main() { vUv = uv; gl_Position = vec4(position, 0.0, 1.0); }
+    `, y = `
+      precision highp float;
+      uniform float uTime;
+      uniform vec3 uResolution;
+      uniform vec3 uBaseColor;
+      uniform float uAmplitude;
+      uniform float uFrequencyX;
+      uniform float uFrequencyY;
+      uniform vec2 uMouse;
+      varying vec2 vUv;
+      vec4 renderImage(vec2 uvCoord) {
+        vec2 fragCoord = uvCoord * uResolution.xy;
+        vec2 uv = (2.0 * fragCoord - uResolution.xy) / min(uResolution.x, uResolution.y);
+        for (float i = 1.0; i < 10.0; i++) {
+          uv.x += uAmplitude / i * cos(i * uFrequencyX * uv.y + uTime + uMouse.x * 3.14159);
+          uv.y += uAmplitude / i * cos(i * uFrequencyY * uv.x + uTime + uMouse.y * 3.14159);
+        }
+        vec2 diff = (uvCoord - uMouse);
+        float dist = length(diff);
+        float falloff = exp(-dist * 20.0);
+        float ripple = sin(10.0 * dist - uTime * 2.0) * 0.03;
+        uv += (diff / (dist + 0.0001)) * ripple * falloff;
+        vec3 color = uBaseColor / abs(sin(uTime - uv.y - uv.x));
+        return vec4(color, 1.0);
+      }
+      void main() {
+        vec4 col = vec4(0.0);
+        int samples = 0;
+        for (int i = -1; i <= 1; i++) {
+          for (int j = -1; j <= 1; j++) {
+            vec2 offset = vec2(float(i), float(j)) * (1.0 / min(uResolution.x, uResolution.y));
+            col += renderImage(vUv + offset);
+            samples++;
+          }
+        }
+        gl_FragColor = col / float(samples);
+      }
+    `, w = new E(e), i = new M(e, {
+      vertex: p,
+      fragment: y,
+      uniforms: {
+        uTime: { value: 0 },
+        uResolution: { value: new Float32Array([e.canvas.width, e.canvas.height, e.canvas.width / e.canvas.height]) },
+        uBaseColor: { value: new Float32Array(n) },
+        uAmplitude: { value: c },
+        uFrequencyX: { value: f },
+        uFrequencyY: { value: m },
+        uMouse: { value: new Float32Array([0, 0]) }
+      }
+    }), x = new T(e, { geometry: w, program: i });
+    function s() {
+      a.setSize(t.offsetWidth, t.offsetHeight);
+      const o = i.uniforms.uResolution.value;
+      o[0] = e.canvas.width, o[1] = e.canvas.height, o[2] = e.canvas.width / e.canvas.height;
+    }
+    window.addEventListener("resize", s), s();
+    const h = (o) => {
+      const u = t.getBoundingClientRect();
+      i.uniforms.uMouse.value[0] = (o.clientX - u.left) / u.width, i.uniforms.uMouse.value[1] = 1 - (o.clientY - u.top) / u.height;
+    };
+    r && t.addEventListener("mousemove", h);
+    let l = 0;
+    const g = (o) => {
+      l = requestAnimationFrame(g), i.uniforms.uTime.value = o * 1e-3 * v, a.render({ scene: x });
+    };
+    return l = requestAnimationFrame(g), t.appendChild(e.canvas), () => {
+      cancelAnimationFrame(l), window.removeEventListener("resize", s), r && t.removeEventListener("mousemove", h), e.canvas.parentElement && e.canvas.parentElement.removeChild(e.canvas), e.getExtension("WEBGL_lose_context")?.loseContext();
+    };
+  }, [n, v, c, f, m, r]), /* @__PURE__ */ F("div", { ref: d, style: { width: "100%", height: "100%" } });
+}
+export {
+  B as default
+};

package/dist/backgrounds/Particles.d.ts

@@ -0,0 +1,15 @@
+export interface ParticlesProps {
+    particleCount?: number;
+    particleSpread?: number;
+    speed?: number;
+    particleColors?: string[];
+    moveParticlesOnHover?: boolean;
+    particleHoverFactor?: number;
+    alphaParticles?: boolean;
+    particleBaseSize?: number;
+    sizeRandomness?: number;
+    cameraDistance?: number;
+    disableRotation?: boolean;
+    className?: string;
+}
+export default function Particles({ particleCount, particleSpread, speed, particleColors, moveParticlesOnHover, particleHoverFactor, alphaParticles, particleBaseSize, sizeRandomness, cameraDistance, disableRotation, className, }: ParticlesProps): import("react/jsx-runtime").JSX.Element;

package/dist/backgrounds/Particles.js

@@ -0,0 +1,137 @@
+"use client";
+import { jsx as G } from "react/jsx-runtime";
+import { useRef as L, useEffect as N } from "react";
+import { Renderer as W, Camera as X, Geometry as Y, Program as k, Mesh as J } from "ogl";
+const K = ["#ffffff", "#ffffff", "#ffffff"], Q = (e) => {
+  e = e.replace(/^#/, ""), e.length === 3 && (e = e.split("").map((r) => r + r).join(""));
+  const i = parseInt(e, 16);
+  return [(i >> 16 & 255) / 255, (i >> 8 & 255) / 255, (i & 255) / 255];
+}, U = (
+  /* glsl */
+  `
+  attribute vec3 position;
+  attribute vec4 random;
+  attribute vec3 color;
+  uniform mat4 modelMatrix;
+  uniform mat4 viewMatrix;
+  uniform mat4 projectionMatrix;
+  uniform float uTime;
+  uniform float uSpread;
+  uniform float uBaseSize;
+  uniform float uSizeRandomness;
+  varying vec4 vRandom;
+  varying vec3 vColor;
+  void main() {
+    vRandom = random;
+    vColor = color;
+    vec3 pos = position * uSpread;
+    pos.z *= 10.0;
+    vec4 mPos = modelMatrix * vec4(pos, 1.0);
+    float t = uTime;
+    mPos.x += sin(t * random.z + 6.28 * random.w) * mix(0.1, 1.5, random.x);
+    mPos.y += sin(t * random.y + 6.28 * random.x) * mix(0.1, 1.5, random.w);
+    mPos.z += sin(t * random.w + 6.28 * random.y) * mix(0.1, 1.5, random.z);
+    vec4 mvPos = viewMatrix * mPos;
+    if (uSizeRandomness == 0.0) {
+      gl_PointSize = uBaseSize;
+    } else {
+      gl_PointSize = (uBaseSize * (1.0 + uSizeRandomness * (random.x - 0.5))) / length(mvPos.xyz);
+    }
+    gl_Position = projectionMatrix * mvPos;
+  }
+`
+), V = (
+  /* glsl */
+  `
+  precision highp float;
+  uniform float uTime;
+  uniform float uAlphaParticles;
+  varying vec4 vRandom;
+  varying vec3 vColor;
+  void main() {
+    vec2 uv = gl_PointCoord.xy;
+    float d = length(uv - vec2(0.5));
+    if(uAlphaParticles < 0.5) {
+      if(d > 0.5) discard;
+      gl_FragColor = vec4(vColor + 0.2 * sin(uv.yxx + uTime + vRandom.y * 6.28), 1.0);
+    } else {
+      float circle = smoothstep(0.5, 0.4, d) * 0.8;
+      gl_FragColor = vec4(vColor + 0.2 * sin(uv.yxx + uTime + vRandom.y * 6.28), circle);
+    }
+  }
+`
+);
+function O({
+  particleCount: e = 200,
+  particleSpread: i = 10,
+  speed: r = 0.1,
+  particleColors: m,
+  moveParticlesOnHover: l = !1,
+  particleHoverFactor: u = 1,
+  alphaParticles: M = !1,
+  particleBaseSize: z = 100,
+  sizeRandomness: P = 1,
+  cameraDistance: R = 20,
+  disableRotation: S = !1,
+  className: I = ""
+}) {
+  const T = L(null), v = L({ x: 0, y: 0 });
+  return N(() => {
+    const a = T.current;
+    if (!a) return;
+    const h = new W({ dpr: Math.min(window.devicePixelRatio, 2), depth: !1, alpha: !0 }), o = h.gl;
+    a.appendChild(o.canvas), o.clearColor(0, 0, 0, 0);
+    const p = new X(o, { fov: 15 });
+    p.position.set(0, 0, R);
+    const g = () => {
+      h.setSize(a.clientWidth, a.clientHeight), p.perspective({ aspect: o.canvas.width / o.canvas.height });
+    };
+    window.addEventListener("resize", g, !1), g();
+    const A = (t) => {
+      const n = a.getBoundingClientRect();
+      v.current = {
+        x: (t.clientX - n.left) / n.width * 2 - 1,
+        y: -((t.clientY - n.top) / n.height * 2 - 1)
+      };
+    };
+    l && a.addEventListener("mousemove", A);
+    const C = new Float32Array(e * 3), F = new Float32Array(e * 4), _ = new Float32Array(e * 3), E = m && m.length > 0 ? m : K;
+    for (let t = 0; t < e; t++) {
+      let n, f, c, x;
+      do
+        n = Math.random() * 2 - 1, f = Math.random() * 2 - 1, c = Math.random() * 2 - 1, x = n * n + f * f + c * c;
+      while (x > 1 || x === 0);
+      const y = Math.cbrt(Math.random());
+      C.set([n * y, f * y, c * y], t * 3), F.set([Math.random(), Math.random(), Math.random(), Math.random()], t * 4), _.set(Q(E[Math.floor(Math.random() * E.length)]), t * 3);
+    }
+    const q = new Y(o, {
+      position: { size: 3, data: C },
+      random: { size: 4, data: F },
+      color: { size: 3, data: _ }
+    }), b = new k(o, {
+      vertex: U,
+      fragment: V,
+      uniforms: {
+        uTime: { value: 0 },
+        uSpread: { value: i },
+        uBaseSize: { value: z * Math.min(window.devicePixelRatio, 2) },
+        uSizeRandomness: { value: P },
+        uAlphaParticles: { value: M ? 1 : 0 }
+      },
+      transparent: !0,
+      depthTest: !1
+    }), s = new J(o, { mode: o.POINTS, geometry: q, program: b });
+    let w = 0, j = performance.now(), d = 0;
+    const B = (t) => {
+      w = requestAnimationFrame(B);
+      const n = t - j;
+      j = t, d += n * r, b.uniforms.uTime.value = d * 1e-3, l && (s.position.x = -v.current.x * u, s.position.y = -v.current.y * u), S || (s.rotation.x = Math.sin(d * 2e-4) * 0.1, s.rotation.y = Math.cos(d * 5e-4) * 0.15, s.rotation.z += 0.01 * r), h.render({ scene: s, camera: p });
+    };
+    return w = requestAnimationFrame(B), () => {
+      window.removeEventListener("resize", g), l && a.removeEventListener("mousemove", A), cancelAnimationFrame(w), a.contains(o.canvas) && a.removeChild(o.canvas);
+    };
+  }, [e, i, r, l, u, M, z, P, R, S, m]), /* @__PURE__ */ G("div", { ref: T, className: I, style: { position: "relative", width: "100%", height: "100%" } });
+}
+export {
+  O as default
+};

package/dist/backgrounds/PixelSnow.d.ts

@@ -0,0 +1,9 @@
+export interface PixelSnowProps {
+    snowColor?: string;
+    count?: number;
+    speed?: number;
+    pixelSize?: number;
+    wind?: number;
+    opacity?: number;
+}
+export default function PixelSnow({ snowColor, count, speed, pixelSize, wind, opacity, }: PixelSnowProps): import("react/jsx-runtime").JSX.Element;

package/dist/backgrounds/PixelSnow.js

@@ -0,0 +1,52 @@
+"use client";
+import { jsx as x } from "react/jsx-runtime";
+import { useRef as h, useEffect as y } from "react";
+function A({
+  snowColor: i = "#E7BB1D",
+  count: o = 180,
+  speed: d = 0.6,
+  pixelSize: r = 3,
+  wind: c = 0.3,
+  opacity: u = 0.7
+}) {
+  const l = h(null), n = h(null), m = h([]);
+  return y(() => {
+    const e = l.current;
+    if (!e) return;
+    const a = e.getContext("2d");
+    if (!a) return;
+    const s = () => {
+      e.width = e.offsetWidth, e.height = e.offsetHeight;
+    };
+    window.addEventListener("resize", s), s(), m.current = Array.from({ length: o }, () => ({
+      x: Math.random() * e.width,
+      y: Math.random() * e.height,
+      size: r * (0.5 + Math.random() * 1),
+      speed: d * (0.4 + Math.random() * 0.8),
+      drift: (Math.random() - 0.5) * c,
+      alpha: 0.3 + Math.random() * u * 0.7,
+      phase: Math.random() * Math.PI * 2,
+      phaseSpeed: 5e-3 + Math.random() * 0.01
+    }));
+    let M = 0;
+    const w = () => {
+      a.clearRect(0, 0, e.width, e.height), M++, m.current.forEach((t) => {
+        t.y += t.speed, t.x += t.drift + Math.sin(t.phase + M * t.phaseSpeed) * 0.3, t.y > e.height + t.size && (t.y = -t.size, t.x = Math.random() * e.width), t.x > e.width + t.size && (t.x = -t.size), t.x < -t.size && (t.x = e.width + t.size);
+        const g = Math.round(t.x / r) * r, p = Math.round(t.y / r) * r;
+        a.globalAlpha = t.alpha, a.fillStyle = i, a.fillRect(g, p, Math.round(t.size), Math.round(t.size));
+      }), a.globalAlpha = 1, n.current = requestAnimationFrame(w);
+    };
+    return n.current = requestAnimationFrame(w), () => {
+      window.removeEventListener("resize", s), n.current && cancelAnimationFrame(n.current);
+    };
+  }, [i, o, d, r, c, u]), /* @__PURE__ */ x(
+    "canvas",
+    {
+      ref: l,
+      style: { width: "100%", height: "100%", border: "none", display: "block" }
+    }
+  );
+}
+export {
+  A as default
+};

package/dist/backgrounds/Silk.d.ts

@@ -0,0 +1,8 @@
+export interface SilkProps {
+    speed?: number;
+    scale?: number;
+    color?: string;
+    noiseIntensity?: number;
+    rotation?: number;
+}
+export default function Silk({ speed, scale, color, noiseIntensity, rotation, }: SilkProps): import("react/jsx-runtime").JSX.Element;