nfx-ui 0.6.2 → 0.7.1

package/dist/chunk-animations-CEZ01ALd.mjs

@@ -0,0 +1,740 @@
+import { n as et } from "./chunk-useTheme-oHcq3d0o.mjs";
+import { memo as ct, useCallback as K, useEffect as tt, useMemo as Q, useRef as x } from "react";
+import { jsx as N, jsxs as lt } from "react/jsx-runtime";
+var ht = "style-module__waves___oR3u7", dt = "style-module__wavesCanvas___zkhTC", st = {
+  waves: ht,
+  wavesCanvas: dt
+}, P = class {
+  x;
+  y;
+  z;
+  constructor(r, e, s) {
+    this.x = r, this.y = e, this.z = s;
+  }
+  dot2(r, e) {
+    return this.x * r + this.y * e;
+  }
+}, ft = class {
+  grad3;
+  p;
+  perm;
+  gradP;
+  constructor(r = 0) {
+    this.grad3 = [
+      new P(1, 1, 0),
+      new P(-1, 1, 0),
+      new P(1, -1, 0),
+      new P(-1, -1, 0),
+      new P(1, 0, 1),
+      new P(-1, 0, 1),
+      new P(1, 0, -1),
+      new P(-1, 0, -1),
+      new P(0, 1, 1),
+      new P(0, -1, 1),
+      new P(0, 1, -1),
+      new P(0, -1, -1)
+    ], this.p = [
+      151,
+      160,
+      137,
+      91,
+      90,
+      15,
+      131,
+      13,
+      201,
+      95,
+      96,
+      53,
+      194,
+      233,
+      7,
+      225,
+      140,
+      36,
+      103,
+      30,
+      69,
+      142,
+      8,
+      99,
+      37,
+      240,
+      21,
+      10,
+      23,
+      190,
+      6,
+      148,
+      247,
+      120,
+      234,
+      75,
+      0,
+      26,
+      197,
+      62,
+      94,
+      252,
+      219,
+      203,
+      117,
+      35,
+      11,
+      32,
+      57,
+      177,
+      33,
+      88,
+      237,
+      149,
+      56,
+      87,
+      174,
+      20,
+      125,
+      136,
+      171,
+      168,
+      68,
+      175,
+      74,
+      165,
+      71,
+      134,
+      139,
+      48,
+      27,
+      166,
+      77,
+      146,
+      158,
+      231,
+      83,
+      111,
+      229,
+      122,
+      60,
+      211,
+      133,
+      230,
+      220,
+      105,
+      92,
+      41,
+      55,
+      46,
+      245,
+      40,
+      244,
+      102,
+      143,
+      54,
+      65,
+      25,
+      63,
+      161,
+      1,
+      216,
+      80,
+      73,
+      209,
+      76,
+      132,
+      187,
+      208,
+      89,
+      18,
+      169,
+      200,
+      196,
+      135,
+      130,
+      116,
+      188,
+      159,
+      86,
+      164,
+      100,
+      109,
+      198,
+      173,
+      186,
+      3,
+      64,
+      52,
+      217,
+      226,
+      250,
+      124,
+      123,
+      5,
+      202,
+      38,
+      147,
+      118,
+      126,
+      255,
+      82,
+      85,
+      212,
+      207,
+      206,
+      59,
+      227,
+      47,
+      16,
+      58,
+      17,
+      182,
+      189,
+      28,
+      42,
+      223,
+      183,
+      170,
+      213,
+      119,
+      248,
+      152,
+      2,
+      44,
+      154,
+      163,
+      70,
+      221,
+      153,
+      101,
+      155,
+      167,
+      43,
+      172,
+      9,
+      129,
+      22,
+      39,
+      253,
+      19,
+      98,
+      108,
+      110,
+      79,
+      113,
+      224,
+      232,
+      178,
+      185,
+      112,
+      104,
+      218,
+      246,
+      97,
+      228,
+      251,
+      34,
+      242,
+      193,
+      238,
+      210,
+      144,
+      12,
+      191,
+      179,
+      162,
+      241,
+      81,
+      51,
+      145,
+      235,
+      249,
+      14,
+      239,
+      107,
+      49,
+      192,
+      214,
+      31,
+      181,
+      199,
+      106,
+      157,
+      184,
+      84,
+      204,
+      176,
+      115,
+      121,
+      50,
+      45,
+      127,
+      4,
+      150,
+      254,
+      138,
+      236,
+      205,
+      93,
+      222,
+      114,
+      67,
+      29,
+      24,
+      72,
+      243,
+      141,
+      128,
+      195,
+      78,
+      66,
+      215,
+      61,
+      156,
+      180
+    ], this.perm = new Array(512), this.gradP = new Array(512), this.seed(r);
+  }
+  seed(r) {
+    r > 0 && r < 1 && (r *= 65536), r = Math.floor(r), r < 256 && (r |= r << 8);
+    for (let e = 0; e < 256; e++) {
+      let s = e & 1 ? this.p[e] ^ r & 255 : this.p[e] ^ r >> 8 & 255;
+      this.perm[e] = this.perm[e + 256] = s, this.gradP[e] = this.gradP[e + 256] = this.grad3[s % 12];
+    }
+  }
+  fade(r) {
+    return r * r * r * (r * (r * 6 - 15) + 10);
+  }
+  lerp(r, e, s) {
+    return (1 - s) * r + s * e;
+  }
+  perlin2(r, e) {
+    let s = Math.floor(r), t = Math.floor(e);
+    r -= s, e -= t, s &= 255, t &= 255;
+    const h = this.gradP[s + this.perm[t]].dot2(r, e), m = this.gradP[s + this.perm[t + 1]].dot2(r, e - 1), v = this.gradP[s + 1 + this.perm[t]].dot2(r - 1, e), b = this.gradP[s + 1 + this.perm[t + 1]].dot2(r - 1, e - 1), g = this.fade(r);
+    return this.lerp(this.lerp(h, v, g), this.lerp(m, b, g), this.fade(e));
+  }
+}, mt = ({ lineColor: r = "black", backgroundColor: e = "transparent", waveSpeedX: s = 0.0125, waveSpeedY: t = 5e-3, waveAmpX: h = 32, waveAmpY: m = 16, xGap: v = 10, yGap: b = 32, friction: g = 0.925, tension: $ = 5e-3, maxCursorMove: M = 100, style: d = {}, className: _ = "" }) => {
+  const u = x(null), R = x(null), T = x(null), W = x({
+    width: 0,
+    height: 0,
+    left: 0,
+    top: 0
+  }), H = x(new ft(Math.random())), X = x([]), F = x({
+    x: -10,
+    y: 0,
+    lx: 0,
+    ly: 0,
+    sx: 0,
+    sy: 0,
+    v: 0,
+    vs: 0,
+    a: 0,
+    set: !1
+  }), y = x({
+    lineColor: r,
+    waveSpeedX: s,
+    waveSpeedY: t,
+    waveAmpX: h,
+    waveAmpY: m,
+    friction: g,
+    tension: $,
+    maxCursorMove: M,
+    xGap: v,
+    yGap: b
+  }), I = x(null);
+  return tt(() => {
+    y.current = {
+      lineColor: r,
+      waveSpeedX: s,
+      waveSpeedY: t,
+      waveAmpX: h,
+      waveAmpY: m,
+      friction: g,
+      tension: $,
+      maxCursorMove: M,
+      xGap: v,
+      yGap: b
+    };
+  }, [
+    r,
+    s,
+    t,
+    h,
+    m,
+    g,
+    $,
+    M,
+    v,
+    b
+  ]), tt(() => {
+    const E = R.current, C = u.current;
+    if (!E || !C) return;
+    T.current = E.getContext("2d");
+    function A() {
+      if (!C || !E) return;
+      const i = C.getBoundingClientRect();
+      W.current = {
+        width: i.width,
+        height: i.height,
+        left: i.left,
+        top: i.top
+      }, E.width = i.width, E.height = i.height;
+    }
+    function V() {
+      const { width: i, height: o } = W.current;
+      X.current = [];
+      const a = i + 200, p = o + 30, { xGap: L, yGap: D } = y.current, J = Math.ceil(a / L), B = Math.ceil(p / D), O = (i - L * J) / 2, Z = (o - D * B) / 2;
+      for (let G = 0; G <= J; G++) {
+        const S = [];
+        for (let f = 0; f <= B; f++) S.push({
+          x: O + L * G,
+          y: Z + D * f,
+          wave: {
+            x: 0,
+            y: 0
+          },
+          cursor: {
+            x: 0,
+            y: 0,
+            vx: 0,
+            vy: 0
+          }
+        });
+        X.current.push(S);
+      }
+    }
+    function k(i) {
+      const o = X.current, a = F.current, p = H.current, { waveSpeedX: L, waveSpeedY: D, waveAmpX: J, waveAmpY: B, friction: O, tension: Z, maxCursorMove: G } = y.current;
+      o.forEach((S) => {
+        S.forEach((f) => {
+          const nt = p.perlin2((f.x + i * L) * 2e-3, (f.y + i * D) * 15e-4) * 12;
+          f.wave.x = Math.cos(nt) * J, f.wave.y = Math.sin(nt) * B;
+          const at = f.x - a.sx, it = f.y - a.sy, rt = Math.hypot(at, it), q = Math.max(175, a.vs);
+          if (rt < q) {
+            const ut = 1 - rt / q, ot = Math.cos(rt * 1e-3) * ut;
+            f.cursor.vx += Math.cos(a.a) * ot * q * a.vs * 65e-5, f.cursor.vy += Math.sin(a.a) * ot * q * a.vs * 65e-5;
+          }
+          f.cursor.vx += (0 - f.cursor.x) * Z, f.cursor.vy += (0 - f.cursor.y) * Z, f.cursor.vx *= O, f.cursor.vy *= O, f.cursor.x += f.cursor.vx * 2, f.cursor.y += f.cursor.vy * 2, f.cursor.x = Math.min(G, Math.max(-G, f.cursor.x)), f.cursor.y = Math.min(G, Math.max(-G, f.cursor.y));
+        });
+      });
+    }
+    function Y(i, o = !0) {
+      const a = i.x + i.wave.x + (o ? i.cursor.x : 0), p = i.y + i.wave.y + (o ? i.cursor.y : 0);
+      return {
+        x: Math.round(a * 10) / 10,
+        y: Math.round(p * 10) / 10
+      };
+    }
+    function U() {
+      const { width: i, height: o } = W.current, a = T.current;
+      a && (a.clearRect(0, 0, i, o), a.beginPath(), a.strokeStyle = y.current.lineColor, X.current.forEach((p) => {
+        let L = Y(p[0], !1);
+        a.moveTo(L.x, L.y), p.forEach((D, J) => {
+          const B = J === p.length - 1;
+          L = Y(D, !B);
+          const O = Y(p[J + 1] || p[p.length - 1], !B);
+          a.lineTo(L.x, L.y), B && a.moveTo(O.x, O.y);
+        });
+      }), a.stroke());
+    }
+    function j(i) {
+      if (!C) return;
+      const o = F.current;
+      o.sx += (o.x - o.sx) * 0.1, o.sy += (o.y - o.sy) * 0.1;
+      const a = o.x - o.lx, p = o.y - o.ly, L = Math.hypot(a, p);
+      o.v = L, o.vs += (L - o.vs) * 0.1, o.vs = Math.min(100, o.vs), o.lx = o.x, o.ly = o.y, o.a = Math.atan2(p, a), C.style.setProperty("--x", `${o.sx}px`), C.style.setProperty("--y", `${o.sy}px`), k(i), U(), I.current = requestAnimationFrame(j);
+    }
+    function n() {
+      A(), V();
+    }
+    function l(i) {
+      w(i.clientX, i.clientY);
+    }
+    function c(i) {
+      const o = i.touches[0];
+      w(o.clientX, o.clientY);
+    }
+    function w(i, o) {
+      const a = F.current, p = W.current;
+      a.x = i - p.left, a.y = o - p.top, a.set || (a.sx = a.x, a.sy = a.y, a.lx = a.x, a.ly = a.y, a.set = !0);
+    }
+    return A(), V(), I.current = requestAnimationFrame(j), window.addEventListener("resize", n), window.addEventListener("mousemove", l), window.addEventListener("touchmove", c, { passive: !1 }), () => {
+      window.removeEventListener("resize", n), window.removeEventListener("mousemove", l), window.removeEventListener("touchmove", c), I.current !== null && cancelAnimationFrame(I.current);
+    };
+  }, []), /* @__PURE__ */ N("div", {
+    ref: u,
+    className: `${st.waves} ${_}`,
+    style: {
+      position: "absolute",
+      top: 0,
+      left: 0,
+      margin: 0,
+      padding: 0,
+      width: "100%",
+      height: "100%",
+      overflow: "hidden",
+      backgroundColor: e,
+      ...d
+    },
+    children: /* @__PURE__ */ N("canvas", {
+      ref: R,
+      className: st.wavesCanvas
+    })
+  });
+}, It = (r) => {
+  const { currentTheme: e } = et();
+  return /* @__PURE__ */ N(mt, {
+    lineColor: Q(() => {
+      const s = e.colors.variables.primary || "rgb(59, 130, 246)", t = (v, b, g, $ = 0.4) => `rgb(${Math.round(v + (255 - v) * $)}, ${Math.round(b + (255 - b) * $)}, ${Math.round(g + (255 - g) * $)})`;
+      if (s.startsWith("#")) {
+        const v = s.slice(1);
+        return t(parseInt(v.slice(0, 2), 16), parseInt(v.slice(2, 4), 16), parseInt(v.slice(4, 6), 16));
+      }
+      const h = s.match(/rgb\((\d+),\s*(\d+),\s*(\d+)\)/);
+      if (h) return t(parseInt(h[1], 10), parseInt(h[2], 10), parseInt(h[3], 10));
+      const m = s.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+      return m ? t(parseInt(m[1], 10), parseInt(m[2], 10), parseInt(m[3], 10)) : s;
+    }, [e]),
+    backgroundColor: "transparent",
+    waveSpeedX: 0.05,
+    waveSpeedY: 0.01,
+    waveAmpX: 40,
+    waveAmpY: 20,
+    ...r
+  });
+}, vt = "style-module__squaresCanvas___22kMc", gt = { squaresCanvas: vt }, yt = ({ direction: r = "right", speed: e = 1, borderColor: s = "#999", squareSize: t = 40, hoverFillColor: h = "#222", className: m = "", style: v = {} }) => {
+  const b = x(null), g = x(null), $ = x(0), M = x(0), d = x({
+    x: 0,
+    y: 0
+  }), _ = x(null);
+  return tt(() => {
+    const u = b.current;
+    if (!u) return;
+    const R = u.getContext("2d"), T = () => {
+      u.width = u.offsetWidth, u.height = u.offsetHeight, $.current = Math.ceil(u.width / t) + 1, M.current = Math.ceil(u.height / t) + 1;
+    };
+    window.addEventListener("resize", T), T();
+    const W = () => {
+      if (!R) return;
+      R.clearRect(0, 0, u.width, u.height);
+      const y = Math.floor(d.current.x / t) * t, I = Math.floor(d.current.y / t) * t;
+      for (let C = y; C < u.width + t; C += t) for (let A = I; A < u.height + t; A += t) {
+        const V = C - d.current.x % t, k = A - d.current.y % t;
+        _.current && Math.floor((C - y) / t) === _.current.x && Math.floor((A - I) / t) === _.current.y && (R.fillStyle = h, R.fillRect(V, k, t, t)), R.strokeStyle = s, R.strokeRect(V, k, t, t);
+      }
+      const E = R.createRadialGradient(u.width / 2, u.height / 2, 0, u.width / 2, u.height / 2, Math.sqrt(u.width ** 2 + u.height ** 2) / 2);
+      E.addColorStop(0, "rgba(0, 0, 0, 0)"), E.addColorStop(1, "#060010"), R.fillStyle = E, R.fillRect(0, 0, u.width, u.height);
+    }, H = () => {
+      const y = Math.max(e, 0.1);
+      switch (r) {
+        case "right":
+          d.current.x = (d.current.x - y + t) % t;
+          break;
+        case "left":
+          d.current.x = (d.current.x + y + t) % t;
+          break;
+        case "up":
+          d.current.y = (d.current.y + y + t) % t;
+          break;
+        case "down":
+          d.current.y = (d.current.y - y + t) % t;
+          break;
+        case "diagonal":
+          d.current.x = (d.current.x - y + t) % t, d.current.y = (d.current.y - y + t) % t;
+          break;
+        default:
+          break;
+      }
+      W(), g.current = requestAnimationFrame(H);
+    }, X = (y) => {
+      const I = u.getBoundingClientRect(), E = y.clientX - I.left, C = y.clientY - I.top, A = Math.floor(d.current.x / t) * t, V = Math.floor(d.current.y / t) * t, k = Math.floor((E + d.current.x - A) / t), Y = Math.floor((C + d.current.y - V) / t);
+      (!_.current || _.current.x !== k || _.current.y !== Y) && (_.current = {
+        x: k,
+        y: Y
+      });
+    }, F = () => {
+      _.current = null;
+    };
+    return u.addEventListener("mousemove", X), u.addEventListener("mouseleave", F), g.current = requestAnimationFrame(H), () => {
+      window.removeEventListener("resize", T), g.current && cancelAnimationFrame(g.current), u.removeEventListener("mousemove", X), u.removeEventListener("mouseleave", F);
+    };
+  }, [
+    r,
+    e,
+    s,
+    h,
+    t
+  ]), /* @__PURE__ */ N("canvas", {
+    ref: b,
+    className: `${gt.squaresCanvas} ${m}`,
+    style: v
+  });
+}, Lt = (r) => {
+  const { currentTheme: e } = et();
+  return /* @__PURE__ */ N(yt, {
+    borderColor: Q(() => {
+      const s = e.colors.variables.border5 || e.colors.variables.fg || "#271E37";
+      if (s.startsWith("#")) return s;
+      const t = s.match(/rgb\((\d+),\s*(\d+),\s*(\d+)\)/);
+      return t ? `#${parseInt(t[1], 10).toString(16).padStart(2, "0")}${parseInt(t[2], 10).toString(16).padStart(2, "0")}${parseInt(t[3], 10).toString(16).padStart(2, "0")}` : s;
+    }, [e]),
+    hoverFillColor: Q(() => {
+      const s = e.colors.variables.bg3 || e.colors.variables.border3 || "#222222", t = (m, v, b, g = 0.3) => `rgb(${Math.round(m * (1 - g))}, ${Math.round(v * (1 - g))}, ${Math.round(b * (1 - g))})`;
+      if (s.startsWith("#")) {
+        const m = s.slice(1);
+        return t(parseInt(m.slice(0, 2), 16), parseInt(m.slice(2, 4), 16), parseInt(m.slice(4, 6), 16));
+      }
+      const h = s.match(/rgb\((\d+),\s*(\d+),\s*(\d+)\)/);
+      return h ? t(parseInt(h[1], 10), parseInt(h[2], 10), parseInt(h[3], 10)) : s;
+    }, [e]),
+    speed: 0.5,
+    squareSize: 40,
+    direction: "diagonal",
+    ...r
+  });
+}, wt = "style-module__container___HkxIe", xt = "style-module__canvas___MR9JX", Mt = "style-module__outerVignette___i75nw", pt = "style-module__centerVignette___n9uVG", z = {
+  container: wt,
+  canvas: xt,
+  outerVignette: Mt,
+  centerVignette: pt
+}, bt = ct(({ glitchColors: r = [
+  "#2b4539",
+  "#61dca3",
+  "#61b3dc"
+], glitchSpeed: e = 500, centerVignette: s = !1, outerVignette: t = !0, smooth: h = !0, characters: m = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!@#$&*()-_+=/[]{};:<>.,0123456789", className: v = "", style: b = {} }) => {
+  const g = x(null), $ = x(null), M = x([]), d = x({
+    columns: 0,
+    rows: 0
+  }), _ = x(null), u = x(Date.now()), R = Q(() => Array.from(m), [m]), T = x(/* @__PURE__ */ new Map()), W = 16, H = 10, X = 20, F = K(() => R[Math.floor(Math.random() * R.length)], [R]), y = K(() => r[Math.floor(Math.random() * r.length)], [r]), I = K((n) => {
+    if (T.current.has(n)) return T.current.get(n);
+    const l = n.replace(/^#?([a-f\d])([a-f\d])([a-f\d])$/i, (i, o, a, p) => o + o + a + a + p + p), c = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(l), w = c ? {
+      r: parseInt(c[1], 16),
+      g: parseInt(c[2], 16),
+      b: parseInt(c[3], 16)
+    } : null;
+    return T.current.set(n, w), w;
+  }, []), E = (n, l, c) => {
+    const w = {
+      r: Math.round(n.r + (l.r - n.r) * c),
+      g: Math.round(n.g + (l.g - n.g) * c),
+      b: Math.round(n.b + (l.b - n.b) * c)
+    };
+    return `rgb(${w.r}, ${w.g}, ${w.b})`;
+  }, C = (n, l) => ({
+    columns: Math.ceil(n / H),
+    rows: Math.ceil(l / X)
+  }), A = (n, l) => {
+    d.current = {
+      columns: n,
+      rows: l
+    };
+    const c = n * l;
+    M.current = Array.from({ length: c }, () => ({
+      char: F(),
+      color: y(),
+      targetColor: y(),
+      colorProgress: 1
+    }));
+  }, V = () => {
+    const n = g.current;
+    if (!n) return;
+    const l = n.parentElement;
+    if (!l) return;
+    const c = window.devicePixelRatio || 1, w = l.getBoundingClientRect();
+    n.width = w.width * c, n.height = w.height * c, n.style.width = `${w.width}px`, n.style.height = `${w.height}px`, _.current && _.current.setTransform(c, 0, 0, c, 0, 0);
+    const { columns: i, rows: o } = C(w.width, w.height);
+    A(i, o), k();
+  }, k = K(() => {
+    if (!_.current || M.current.length === 0) return;
+    const n = _.current, l = g.current;
+    l && (n.clearRect(0, 0, l.width, l.height), n.font = `${W}px monospace`, n.textBaseline = "top", n.textAlign = "left", M.current.forEach((c, w) => {
+      const i = w % d.current.columns * H, o = Math.floor(w / d.current.columns) * X;
+      n.fillStyle = c.color, n.fillText(c.char, i, o);
+    }));
+  }, []), Y = K(() => {
+    if (!M.current || M.current.length === 0) return;
+    const n = Math.max(1, Math.floor(M.current.length * 0.02));
+    for (let l = 0; l < n; l++) {
+      const c = Math.floor(Math.random() * M.current.length);
+      M.current[c] && (M.current[c].char = F(), M.current[c].targetColor = y(), h ? M.current[c].colorProgress = 0 : (M.current[c].color = M.current[c].targetColor, M.current[c].colorProgress = 1));
+    }
+  }, [
+    F,
+    y,
+    h
+  ]), U = K(() => {
+    let n = !1, l = 0;
+    M.current.forEach((c) => {
+      if (c.colorProgress < 1) {
+        l++, c.colorProgress += 0.03, c.colorProgress > 1 && (c.colorProgress = 1);
+        const w = I(c.color), i = I(c.targetColor);
+        w && i && (c.color = E(w, i, c.colorProgress), n = !0);
+      }
+    }), n && l > 0 && k();
+  }, [I, k]), j = K(() => {
+    const n = Date.now();
+    n - u.current >= e ? (Y(), k(), u.current = n) : h && U(), $.current = requestAnimationFrame(j);
+  }, [
+    e,
+    h,
+    Y,
+    U
+  ]);
+  return tt(() => {
+    const n = g.current;
+    if (!n) return;
+    _.current = n.getContext("2d"), V(), j();
+    let l;
+    const c = () => {
+      clearTimeout(l), l = setTimeout(() => {
+        $.current && cancelAnimationFrame($.current), V(), j();
+      }, 100);
+    };
+    return window.addEventListener("resize", c), () => {
+      $.current && cancelAnimationFrame($.current), window.removeEventListener("resize", c), clearTimeout(l), T.current.clear();
+    };
+  }, [
+    e,
+    h,
+    r,
+    j
+  ]), /* @__PURE__ */ lt("div", {
+    className: `${z.container} ${v}`,
+    style: b,
+    children: [
+      /* @__PURE__ */ N("canvas", {
+        ref: g,
+        className: z.canvas
+      }),
+      t && /* @__PURE__ */ N("div", { className: z.outerVignette }),
+      s && /* @__PURE__ */ N("div", { className: z.centerVignette })
+    ]
+  });
+}), _t = ct((r) => {
+  const { currentTheme: e } = et();
+  return /* @__PURE__ */ N(bt, {
+    glitchColors: Q(() => {
+      const s = e.colors.variables.primary || "#FA1E16", t = e.colors.variables.info || "#0095ff", h = e.colors.variables.success || "#00d68f", m = (v) => {
+        if (v.startsWith("#")) return v;
+        const b = v.match(/rgb\((\d+),\s*(\d+),\s*(\d+)\)/);
+        return b ? `#${parseInt(b[1], 10).toString(16).padStart(2, "0")}${parseInt(b[2], 10).toString(16).padStart(2, "0")}${parseInt(b[3], 10).toString(16).padStart(2, "0")}` : v;
+      };
+      return [
+        m(s),
+        m(t),
+        m(h)
+      ];
+    }, [e]),
+    glitchSpeed: 300,
+    centerVignette: !0,
+    outerVignette: !1,
+    smooth: !0,
+    ...r
+  });
+});
+_t.displayName = "LetterGlitchBackground";
+export {
+  Lt as n,
+  It as r,
+  _t as t
+};
+
+//# sourceMappingURL=chunk-animations-CEZ01ALd.mjs.map