hys-ui 0.3.0 → 0.5.0

package/dist/components/HysAnimatedNumber/animation/physics.js

@@ -0,0 +1,66 @@
+import { glyph as y, smooth as g, wave as r } from "./paint.js";
+function b(a) {
+  return a < 1 / 2.75 ? 7.5625 * a ** 2 : a < 2 / 2.75 ? 7.5625 * (a - 1.5 / 2.75) ** 2 + 0.75 : a < 2.5 / 2.75 ? 7.5625 * (a - 2.25 / 2.75) ** 2 + 0.9375 : 7.5625 * (a - 2.625 / 2.75) ** 2 + 0.984375;
+}
+function p(a, e) {
+  const { p: t, strength: n, from: l, to: M, index: i } = a, h = 1 - t, s = Math.sin(2 * Math.PI * (a.plan.cycles ?? 3) * t) * h * n, o = r(t) * n, x = (Math.exp(-(((t - 0.3) * 12) ** 2)) + 0.55 * Math.exp(-(((t - 0.47) * 15) ** 2))) * n, c = [
+    { y: -(1 - t ** 2) * 0.82 * n },
+    { y: -(1 - t ** 3) * 0.98 * n, angle: -0.2 * h * n },
+    {
+      y: -(1 - b(t)) * 0.86 * n,
+      sx: 1 + 0.15 * s,
+      sy: 1 - 0.16 * s
+    },
+    { sy: 1 + s * 0.66, sx: 1 - s * 0.23 },
+    { sx: 1 + s * 0.48, sy: 1 - s * 0.48 },
+    {
+      x: s * 0.14,
+      sx: 1 + s * 0.28,
+      sy: 1 - s * 0.25,
+      angle: 0.12 * s
+    },
+    { sx: 1 + 0.35 * o, sy: 1 - 0.34 * o, y: 0.15 * o },
+    {
+      x: 0.24 * s,
+      y: 0.13 * Math.abs(s),
+      angle: 0.9 * s
+    },
+    { x: 0.28 * s, angle: 0.3 * s },
+    { x: -(h ** 3) * 0.95 * n, blur: 0.05 * h },
+    {
+      x: h ** 2 * 0.55 * n - s * 0.2,
+      sx: 1 + Math.abs(s) * 0.16
+    },
+    { y: Math.sin(t * Math.PI * 4 - i * 0.72) * 0.36 * o },
+    {
+      sx: 1 + 0.24 * Math.abs(s),
+      sy: 1 + 0.24 * Math.abs(s)
+    },
+    { sx: 1 + 0.25 * o, sy: 1 + 0.25 * o, alpha: 0.7 + 0.3 * t },
+    { sx: 1 + 0.25 * x, sy: 1 + 0.25 * x, glow: 0.16 * x },
+    {
+      x: 0.11 * Math.sin(18 * Math.PI * t) * o,
+      y: 0.08 * Math.cos(24 * Math.PI * t) * o
+    },
+    {
+      x: 0.12 * s,
+      sy: 1 - 0.34 * Math.abs(s),
+      glow: 0.22 * h * n
+    },
+    {
+      y: -Math.sin(Math.PI * g(t)) * 0.76 * n + h * 0.14,
+      x: -0.42 * h,
+      angle: -0.46 * h
+    },
+    {
+      angle: h * Math.PI * 2,
+      sx: 0.25 + 0.75 * t + 0.23 * o,
+      sy: 0.25 + 0.75 * t + 0.23 * o
+    },
+    { y: s * 0.38, x: h * 0.65 * n, angle: s * 0.42 }
+  ];
+  y(a, l, { alpha: h ** 3 }), y(a, M, { alpha: Math.min(1, t * 4 + 0.2), ...c[e] });
+}
+export {
+  p as paintPhysics
+};

package/dist/components/HysAnimatedNumber/animation/render.js

@@ -0,0 +1,89 @@
+import { glyph as e, wave as p } from "./paint.js";
+import { paintRoll as i } from "./rolling.js";
+import { paintSpatial as o } from "./spatial.js";
+import { paintMorph as d } from "./morph.js";
+import { paintReveal as c } from "./reveal.js";
+import { paintPhysics as s } from "./physics.js";
+import { paintParticles as y } from "./particles.js";
+import { paintDigital as l } from "./digital.js";
+import { paintSpecial as b, paintSequence as w, paintData as v } from "./scenarios.js";
+const S = {
+  rolling: i,
+  spatial: o,
+  morph: d,
+  reveal: c,
+  physics: s,
+  particles: y,
+  digital: l,
+  data: v,
+  sequence: w,
+  special: b
+};
+function j(t) {
+  const { plan: a, digit: n, from: u, to: h, p: r, strength: g } = t;
+  if (a.entry) {
+    S[a.entry.category](t, a.entry.variant);
+    return;
+  }
+  switch (a.effect) {
+    case "odometer":
+      i(t, 19);
+      return;
+    case "wheel":
+      i(t, 6);
+      return;
+    case "slot":
+      i(t, 10);
+      return;
+    case "random":
+      l(t, 9);
+      return;
+    case "scramble":
+      l(t, 6);
+      return;
+    case "flip":
+      o(t, 14);
+      return;
+    case "appear":
+      c(t, 0);
+      return;
+    case "disappear":
+      e(t, u, { alpha: 1 - r, y: -0.3 * r }), e(t, h, { alpha: r });
+      return;
+    case "fade":
+      e(t, u, { alpha: 1 - r }), e(t, h, { alpha: r });
+      return;
+    case "scale":
+      o(t, 10);
+      return;
+    case "bounce":
+      s(t, 2);
+      return;
+    case "spring":
+      s(t, 3);
+      return;
+    case "slide":
+      c(t, 7);
+      return;
+    case "blur":
+      e(t, n, { blur: (1 - r) * 0.16 * g });
+      return;
+    case "flash":
+      e(t, n, { alpha: 1 - 0.3 * p(r) });
+      return;
+    case "highlight":
+      e(t, n, { glow: 0.22 * p(r), color: t.accent });
+      return;
+    case "gradient":
+      e(t, n, {
+        color: r < 0.5 ? t.accent : t.color,
+        glow: 0.1 * p(r)
+      });
+      return;
+    default:
+      e(t, n);
+  }
+}
+export {
+  j as paintNumberAnimation
+};

package/dist/components/HysAnimatedNumber/animation/reveal.js

@@ -0,0 +1,125 @@
+import { glyph as r, noise as T, clamp as g, rectangle as b, smooth as R, localProgress as k } from "./paint.js";
+import { tracePath as v, digitPath as z } from "./paths.js";
+function j(c, h) {
+  const { p: u, from: d, to: i, index: P, count: w, size: n, width: x, strength: p, ctx: s } = c, t = x / n * 0.54;
+  let e = R(u);
+  [0, 10, 18, 19].includes(h) && (e = k(e, P, w, h === 10 ? 0.8 : 0.58)), r(c, d, { alpha: (1 - u) ** 2 * 0.55 });
+  const o = (l, a, y, M, I = () => r(c, i)) => b(c, l, a, y, M, I);
+  switch (h) {
+    case 0:
+      r(c, i, { alpha: e, y: (1 - e) * 0.18 });
+      return;
+    case 1: {
+      s.save(), s.beginPath(), s.ellipse(0, 0, t * e * 1.5 * n, 0.85 * e * n, 0, 0, 2 * Math.PI), s.clip(), r(c, i), s.restore();
+      return;
+    }
+    case 2:
+      o(-t, -0.6, t * 2 * e, 1.2);
+      return;
+    case 3:
+      o(-t, -0.6, t * 2, 1.2 * e), o(
+        -t,
+        -0.6 + e * 1.2,
+        t * 2,
+        0.05,
+        () => r(c, i, { color: c.accent, glow: 0.11 })
+      );
+      return;
+    case 4: {
+      s.save(), s.beginPath(), s.moveTo(-t * n, -0.62 * n), s.lineTo((-t + t * 4 * e) * n, -0.62 * n), s.lineTo((-t + t * 4 * e - t * 0.8) * n, 0.62 * n), s.lineTo(-t * n, 0.62 * n), s.clip(), r(c, i), s.restore();
+      return;
+    }
+    case 5:
+      o(-t * e, -0.6, 2 * t * e, 1.2);
+      return;
+    case 6:
+      o(-t, -0.6, t * e, 1.2), o(t * (1 - e), -0.6, t * e, 1.2);
+      return;
+    case 7:
+      o(
+        -t,
+        -0.6,
+        t * 2,
+        1.2,
+        () => r(c, i, { y: (1 - e) * p })
+      );
+      return;
+    case 8:
+      o(
+        -t,
+        -0.6,
+        t * 2,
+        1.2,
+        () => r(c, i, { y: (e - 1) * p })
+      );
+      return;
+    case 9:
+      for (let l = 0; l < 5; l++) o(-t, -0.6 + l * 0.24, t * 2, 0.24 * e);
+      return;
+    case 10:
+      e > 0.25 && r(c, i);
+      return;
+    case 11:
+    case 12:
+      v(c, z(c.toIndex), e, {
+        smooth: h === 11,
+        width: h === 11 ? 0.085 : 0.065,
+        color: c.accent
+      }), r(c, i, { alpha: g((e - 0.78) / 0.22) });
+      return;
+    case 13:
+      r(c, i, { stroke: 0.02 }), o(-t, 0.6 - e * 1.2, t * 2, e * 1.2);
+      return;
+    case 14:
+      o(-t, 0.6 - e * 1.2, t * 2, e * 1.2);
+      return;
+    case 15:
+      for (let l = 0; l < 12; l++) {
+        const a = g(
+          e + 0.13 * Math.sin(l / 2 + u * 10) * Math.sin(u * Math.PI)
+        );
+        o(-t + l * t / 6, 0.6 - a * 1.2, t / 6 + 5e-3, a * 1.2);
+      }
+      return;
+    case 16:
+      r(c, i, { alpha: 0.55 + e * 0.45 }), o(
+        -t + 2 * t * e,
+        -0.6,
+        0.09,
+        1.2,
+        () => r(c, i, { color: c.accent, glow: 0.2 })
+      );
+      return;
+    case 17:
+      o(-t, -0.6, e * t * 2, 1.2), s.save(), s.globalAlpha *= Math.sin(Math.PI * u) * 0.52, s.fillStyle = c.accent, s.fillRect(
+        (-t + t * 2 * e) * n,
+        -0.6 * n,
+        0.022 * n,
+        1.2 * n
+      ), s.restore();
+      return;
+    case 18:
+      for (let l = 0; l < 6; l++) {
+        const a = (T(c.seed, l) - 0.5) * (1 - e) * p;
+        o(
+          -t,
+          -0.6 + l * 0.2,
+          t * 2,
+          0.2,
+          () => r(c, i, { x: a, alpha: e })
+        );
+      }
+      return;
+    default:
+      o(
+        -t,
+        -0.6,
+        t * 2 * e,
+        1.2,
+        () => r(c, i, { y: 0.4 * (1 - e), alpha: e })
+      );
+  }
+}
+export {
+  j as paintReveal
+};

package/dist/components/HysAnimatedNumber/animation/rolling.js

@@ -0,0 +1,66 @@
+import { rectangle as W, glyph as z, noise as j, rollingGlyph as k, smooth as h, localProgress as P, clamp as q, wave as B } from "./paint.js";
+function F(c, t) {
+  const { p: o, index: n, count: a, fromIndex: p, toIndex: I, ctx: s, size: M, width: r, strength: A } = c, f = I < p ? -1 : 1, G = ((I - p) * f + 10) % 10, R = [
+    h(o),
+    o,
+    h(o),
+    P(o, n, a, 0.34),
+    o,
+    1 - (1 - o) ** 4,
+    o ** 3,
+    1 - (1 - o) ** 3,
+    1 - (1 - o) ** 2 * Math.cos(o * Math.PI * 1.8),
+    1 - Math.exp(-5 * o) * Math.cos(o * Math.PI * 5) * (1 - o),
+    o,
+    (Math.floor(o * 3) + h(o * 3 % 1)) / 3,
+    Math.floor(o * 8) / 8,
+    Math.floor(o * 5) / 5,
+    o ** (0.65 + n / Math.max(1, a - 1) * 1.45),
+    h(o),
+    P(o, n % 2, 2, 0.36),
+    P(o, n, a, 0.42),
+    h(o),
+    o
+  ][t] ?? o;
+  let x = (Math.round(
+    c.plan.cycles ?? (t === 10 ? 4 : [12, 13, 19].includes(t) ? 0 : 1)
+  ) * 10 + G) * f * R;
+  t === 13 && (x = Math.trunc(x / 2) * 2);
+  const y = Math.floor(x), w = x - y, g = t === 18 ? h(q((w - 0.65) / 0.35)) : w, d = c.axis === "horizontal" || t === 2, S = d ? r / M : 0.88, T = (l) => (l - g) * S, b = (l) => {
+    const e = T(l), i = t === 0 || t === 1, u = i ? Math.max(0.18, Math.cos((l - g) * 1.22)) : 1;
+    z(c, k(c, p + y + l), {
+      x: d ? e : t === 4 ? Math.sin(e * 4 + o * 10) * 0.22 * B(o) * A : 0,
+      y: d ? 0 : e,
+      sx: d ? u : 1,
+      sy: d ? 1 : u,
+      angle: t === 1 ? e * 0.45 : t === 4 ? e * 0.55 : 0,
+      alpha: i ? 0.45 + 0.55 * u : 1,
+      blur: t === 5 ? 0.045 * (1 - o) : 0
+    });
+  };
+  if (t === 1) {
+    s.save(), s.rotate(o * Math.PI * 2), s.strokeStyle = c.accent, s.globalAlpha *= 0.38, s.lineWidth = 0.035 * M, s.beginPath();
+    for (let l = 0; l <= 32; l++) {
+      const e = l / 32 * 2 * Math.PI, i = M * (l % 4 < 2 ? 0.56 : 0.47);
+      s.lineTo(Math.cos(e) * i, Math.sin(e) * i);
+    }
+    s.closePath(), s.stroke(), s.restore();
+  }
+  W(
+    c,
+    -r / M * 0.52,
+    -0.55,
+    r / M * 1.04,
+    1.1,
+    () => {
+      b(0), [12, 13].includes(t) || b(1);
+    }
+  ), (t === 19 || t === 18 || t === 11) && z(c, k(c, p + y), {
+    color: c.accent,
+    alpha: 0.7 * (t === 19 ? (1 - g) ** 8 : g ** 6),
+    glow: 0.07 + 0.02 * j(c.seed, n)
+  });
+}
+export {
+  F as paintRoll
+};

package/dist/components/HysAnimatedNumber/animation/scenarios.js

@@ -0,0 +1,217 @@
+import { rectangle as D, wave as k, glyph as g, clamp as w, noise as S, smooth as T, localProgress as W } from "./paint.js";
+import { paintRoll as I } from "./rolling.js";
+import { paintSpatial as z } from "./spatial.js";
+import { paintPhysics as A } from "./physics.js";
+import { paintReveal as x } from "./reveal.js";
+import { paintParticles as C } from "./particles.js";
+import { paintDigital as q } from "./digital.js";
+function b(e, o, s) {
+  const { ctx: l, size: n, width: h, accent: t } = e;
+  l.save(), l.strokeStyle = l.fillStyle = t, l.lineWidth = 0.025 * n, l.lineCap = "round", l.globalAlpha *= 0.8;
+  const d = h / n * 0.48;
+  if (s === 17 || s === 18)
+    l.beginPath(), l.arc(0, 0, 0.53 * n, -Math.PI / 2, Math.PI * (2 * o - 0.5)), l.stroke(), s === 18 && (l.beginPath(), l.moveTo(0, 0.42 * n), l.lineTo(
+      Math.cos(Math.PI * (o - 1)) * 0.33 * n,
+      (0.42 + Math.sin(Math.PI * (o - 1)) * 0.33) * n
+    ), l.stroke());
+  else if (s === 19 || s === 20) {
+    l.beginPath(), l.moveTo(-d * n, 0.64 * n);
+    for (let M = 1; M <= 8; M++) {
+      const i = M / 8, f = s === 19 ? 0.62 - 0.17 * i - Math.sin(i * 11) * 0.08 : 0.64 - i * 0.21;
+      l.lineTo((-d + d * 2 * i * o) * n, f * n);
+    }
+    l.stroke();
+  } else l.fillRect(-d * n, 0.58 * n, d * 2 * o * n, 0.028 * n);
+  l.restore();
+}
+function K(e, o) {
+  const { p: s, from: l, to: n, digit: h, index: t, strength: d, accent: M, ctx: i, size: f } = e;
+  if (o === 2 && e.section === "integer") {
+    g(e, h);
+    return;
+  }
+  if (o < 3 || o === 28 || o === 29) {
+    I(e, [17, 7, 15][o] ?? (o === 28 ? 13 : 19));
+    return;
+  }
+  if (o === 3 || o === 4) {
+    z(e, o === 3 ? 6 : 14);
+    return;
+  }
+  if (o === 5) {
+    x(e, 19);
+    return;
+  }
+  if (o === 10 || o === 11) {
+    x(e, o === 10 ? 5 : 14);
+    return;
+  }
+  if (o >= 16 && o <= 20) {
+    g(e, h), b(e, s, o);
+    return;
+  }
+  if ([21, 22, 23, 24].includes(o)) {
+    A(
+      e,
+      o === 22 ? 19 : o === 23 ? 0 : o === 24 ? 12 : 11
+    );
+    return;
+  }
+  const c = k(s) * d, p = [6, 8, 12, 13, 14, 15, 26].includes(o), y = o === 25 || o === 27 ? "#df5268" : M, P = [6, 7, 12, 13, 14, 15, 25, 26, 27].includes(o);
+  if (g(e, l, { y: (p ? 0.28 : -0.28) * s, alpha: (1 - s) ** 2 }), g(e, n, {
+    y: (p ? -0.23 : 0.23) * (1 - s) * d,
+    sx: 1 + (P ? 0.18 * c : 0),
+    sy: 1 + (P ? 0.18 * c : 0),
+    alpha: Math.min(1, 0.35 + s),
+    color: P && s > 0.28 ? y : void 0,
+    glow: P ? c * 0.2 : 0
+  }), (o === 8 || o === 9) && t === e.count - 1 && g(e, o === 8 ? "↑" : "↓", {
+    x: 0.57,
+    y: (1 - s) * 0.17,
+    sx: 0.47,
+    sy: 0.47,
+    color: y,
+    alpha: c
+  }), [6, 12, 26].includes(o)) {
+    i.save(), i.fillStyle = y, i.globalAlpha *= c * 0.7;
+    const u = o === 6 ? e.width * 0.52 : e.width * 0.72 * s;
+    i.fillRect(
+      -u / 2,
+      f * (o === 26 ? -0.58 : 0.54),
+      u,
+      f * 0.022
+    ), i.restore();
+  }
+  if (o === 13 || o === 14 || o === 15 || o === 25) {
+    i.save(), i.strokeStyle = y, i.lineWidth = 0.022 * f, i.globalAlpha *= c * 0.7;
+    const u = (0.42 + c * 0.16) * f;
+    o === 13 ? (i.setLineDash([f * 0.045, f * 0.045]), i.strokeRect(-u / 2, -u, u, u * 2)) : o === 14 || o === 15 ? (i.beginPath(), i.ellipse(
+      0,
+      0,
+      u * 0.62,
+      u * 1.16,
+      0,
+      -Math.PI / 2,
+      (s * 2 - 0.5) * Math.PI
+    ), i.stroke(), o === 15 && b(e, s, 16)) : i.strokeRect(-u / 2, -u, u, u * 2), i.restore();
+  }
+}
+function B(e, o) {
+  const { p: s, from: l, to: n, size: h, ctx: t, seed: d, strength: M, accent: i } = e, f = [i, "#e9903d", "#d8649e", "#23aa85"];
+  g(e, l, { alpha: (1 - s) ** 3 }), g(e, n, { alpha: w(s * 1.7), glow: 0.17 * k(s) });
+  const c = w((s - 0.17) / 0.83);
+  if (c)
+    for (let p = 0; p < 18; p++) {
+      const y = p / 18 * Math.PI * 2 + S(d, p) * 0.19, P = (0.3 + S(d + 7, p) * 0.69) * T(c) * M, u = Math.cos(y) * P, R = Math.sin(y) * P + c ** 2 * (o ? 0.58 : 0.19);
+      t.save(), t.globalAlpha *= (1 - c) * 0.9, t.fillStyle = t.strokeStyle = f[p % f.length], o ? (t.translate(u * h, R * h), t.rotate(y + c * Math.PI * 3), t.fillRect(-0.023 * h, -0.046 * h, 0.047 * h, 0.095 * h)) : (t.shadowColor = t.strokeStyle, t.shadowBlur = h * 0.08, t.lineWidth = h * 0.021, t.beginPath(), t.moveTo(
+        (u - Math.cos(y) * 0.13 * (1 - c)) * h,
+        (R - Math.sin(y) * 0.13 * (1 - c)) * h
+      ), t.lineTo(u * h, R * h), t.stroke()), t.restore();
+    }
+}
+function N(e, o) {
+  const { p: s, index: l, count: n, seed: h } = e, t = Math.abs(l - (n - 1) / 2), d = Math.min(l, n - l - 1), M = [
+    l,
+    l,
+    Math.floor(l / 2),
+    t * 2,
+    d * 2,
+    S(h, l) * (n - 1),
+    0,
+    l,
+    l % 2,
+    l,
+    l,
+    l % 3,
+    l,
+    d * 2,
+    Math.floor(l / 3),
+    Math.floor(l / 3) + l % 3,
+    l,
+    S(h + 37, l) * (n - 1),
+    Math.floor(l / 3),
+    l % 3
+  ][o], f = W(s, M, n, o === 6 ? 0 : o === 9 ? 0.75 : o === 10 ? 0.62 : o === 12 ? 0.54 : 0.45), c = { ...e, p: f };
+  if (f === 0) {
+    g(e, e.from);
+    return;
+  }
+  if (f === 1) {
+    g(e, e.to);
+    return;
+  }
+  o === 1 || o === 13 ? A(c, o === 1 ? 11 : 8) : o === 8 || o === 9 || o === 6 || o === 7 ? I(
+    { ...c, axis: l % 2 === 0 ? e.axis : "horizontal" },
+    o === 7 ? 17 : 15
+  ) : o === 10 ? x(c, 16) : o === 12 ? x(c, 8) : x(c, [2, 15, 16, 18, 19].includes(o) ? 18 : 2);
+}
+function O(e, o) {
+  const { p: s, from: l, to: n, size: h, ctx: t, seed: d, accent: M, width: i, strength: f } = e;
+  if (o === 0) {
+    z(e, 8);
+    return;
+  }
+  if (o <= 4) {
+    I(e, [0, 5, 10, 17, 6][o]);
+    return;
+  }
+  if (o === 9) {
+    C(e, 19), b(e, s, 17);
+    return;
+  }
+  if (o === 10 || o === 11) {
+    B(e, o === 11);
+    return;
+  }
+  if (o >= 14) {
+    if (o === 17 || o === 19)
+      b(e, s, o === 17 ? 18 : 16);
+    else {
+      const c = T(s) * 0.94, p = i / h * 0.47;
+      D(
+        e,
+        -p,
+        0.49 - c,
+        p * 2,
+        c,
+        () => g(e, n, { color: M, glow: 0.1 })
+      ), t.save(), t.globalAlpha *= 0.38 * k(s), t.fillStyle = M, o === 15 && t.fillRect(
+        -i * 0.58,
+        (0.42 - c) * h,
+        0.04 * h,
+        c * h
+      ), o === 16 && t.fillRect(-i * 0.5, -0.54 * h, i * s, 0.055 * h), o === 18 && t.fillRect(-i * 0.5, (0.55 - c) * h, i, 0.038 * h), t.restore();
+    }
+    g(e, n, { alpha: 0.38 + 0.62 * s });
+    return;
+  }
+  if (o === 7 || o === 8) {
+    g(e, l, { alpha: (1 - s) ** 3 }), g(e, n, { alpha: w(s * 1.4) });
+    for (let c = 0; c < 6; c++) {
+      const p = w(s * 1.6 - c * 0.09);
+      !p || p === 1 && o === 7 || (t.save(), t.globalAlpha *= k(s), t.fillStyle = c % 2 ? "#f1a52f" : "#ffd67a", t.beginPath(), t.ellipse(
+        (S(d, c) - 0.5) * i * 1.3,
+        (o === 7 ? -1 + p ** 2 * 1.55 : 0.48 - c * 0.085 - (1 - p) * 0.72) * h,
+        0.11 * h,
+        (0.04 + Math.abs(Math.sin(p * 12)) * 0.035) * h,
+        0,
+        0,
+        Math.PI * 2
+      ), t.fill(), t.restore());
+    }
+    return;
+  }
+  if (o === 13) {
+    q(e, 27), b(e, s, 17);
+    return;
+  }
+  A(
+    { ...e, strength: f * 0.9 },
+    o === 12 ? 18 : o === 6 ? 14 : 2
+  ), b(e, s, 17);
+}
+export {
+  K as paintData,
+  N as paintSequence,
+  O as paintSpecial
+};

package/dist/components/HysAnimatedNumber/animation/spatial.js

@@ -0,0 +1,112 @@
+import { glyph as w, wave as h, rectangle as d, smooth as S, mix as R } from "./paint.js";
+function k(o, s, c, g = !1) {
+  const { p: t, from: M, to: l, ctx: y, size: p, strength: u } = o, x = [
+    { text: M, angle: t * 2 * Math.PI / s },
+    { text: l, angle: (t - 1) * 2 * Math.PI / s }
+  ];
+  s > 4 && (x.push({
+    text: o.glyphs[(o.fromIndex + 9) % 10],
+    angle: (t + 1) * 2 * Math.PI / s
+  }), x.push({
+    text: o.glyphs[(o.toIndex + 1) % 10],
+    angle: (t - 2) * 2 * Math.PI / s
+  }));
+  for (const q of x.sort(
+    (n, I) => Math.cos(n.angle) - Math.cos(I.angle)
+  )) {
+    const n = Math.cos(q.angle);
+    if (n <= 0) continue;
+    const I = (s > 4 ? 0.62 : 0.43) * (0.7 + u * 0.3), f = Math.sin(q.angle) * I, e = g ? Math.sqrt(n) : n;
+    y.save(), y.globalAlpha *= n * 0.28 * h(t), y.fillStyle = o.accent;
+    const A = (c ? f - 0.33 * e : -0.33) * p, b = (c ? -0.51 : f - 0.51 * e) * p;
+    y.fillRect(
+      A,
+      b,
+      0.66 * p * (c ? e : 1),
+      1.02 * p * (c ? 1 : e)
+    ), y.restore(), w(o, q.text, {
+      x: c ? f : 0,
+      y: c ? 0 : f,
+      sx: c ? e : g ? 0.88 + 0.12 * n : 1,
+      sy: c ? g ? 0.88 + 0.12 * n : 1 : e,
+      alpha: 0.38 + n * 0.62
+    });
+  }
+}
+function B(o, s) {
+  const { p: c, from: g, to: t, width: M, size: l, ctx: y } = o, p = s === 5 || s === 14 && o.axis === "horizontal", u = s === 9 ? 5 : s === 8 || s === 4 || s === 5 ? 2 : 1, x = M / l, q = Math.cos(c * Math.PI), n = c < 0.5, I = n ? g : t, f = s === 6 ? (n ? c : c - 1) * 0.36 : 0;
+  s === 8 && (d(
+    o,
+    -x / 2,
+    -0.57,
+    x,
+    0.57,
+    () => w(o, n ? t : I)
+  ), d(
+    o,
+    -x / 2,
+    0,
+    x,
+    0.57,
+    () => w(o, n ? I : g)
+  ));
+  for (let e = 0; e < u; e++) {
+    const A = p ? x / u * e - x / 2 : 1.12 / u * e - 0.56, b = p ? [A, -0.56, x / u, 1.12] : [-x / 2, A, x, 1.12 / u], P = s === 9 ? S(c * 1.25 - e * 0.055) : c, F = Math.abs(s === 9 ? Math.cos(P * Math.PI) : q), j = s === 7 ? -0.62 * h(P) : s === 8 ? 0.25 * h(P) * (n ? -1 : 1) : 0;
+    d(o, b[0], b[1], b[2], b[3], () => {
+      y.globalAlpha *= s === 8 ? 0.92 : 1, w(o, P < 0.5 ? g : t, {
+        x: p && s === 5 ? (e - 0.5) * 0.25 * h(P) : 0,
+        y: j + (s === 4 ? (e - 0.5) * 0.3 * h(P) : 0),
+        sx: p ? F : 1,
+        sy: p ? 1 : F,
+        angle: f
+      });
+    });
+  }
+}
+function D(o, s) {
+  const { from: c, to: g, p: t, strength: M } = o;
+  if (s < 4 || s === 15) {
+    k(
+      o,
+      [4, 8, 10, 6][s] ?? 3,
+      s === 0 || s === 2 || s === 15,
+      s === 2
+    );
+    return;
+  }
+  if (s <= 9 || s === 14) {
+    B(o, s);
+    return;
+  }
+  const l = (1 - t) * M, y = {
+    10: {
+      sx: 0.5 + S(t) * 0.5 + h(t) * 0.32,
+      sy: 0.5 + S(t) * 0.5 + h(t) * 0.32
+    },
+    11: { sx: 1 + l * 0.75, sy: 1 + l * 0.75, blur: 0.045 * l },
+    12: { sx: 0.25 + 0.75 * t, sy: 1 + 0.16 * l, angle: l * 0.5, x: -0.3 * l },
+    13: {
+      sx: R(0.25, 1, t),
+      sy: R(0.25, 1, t),
+      x: 0.6 * l,
+      y: -0.32 * l,
+      blur: 0.06 * l
+    },
+    16: {
+      y: -0.28 * h(t) * M,
+      sx: 1 + h(t) * 0.12,
+      sy: 1 + h(t) * 0.12,
+      glow: 0.2 * h(t)
+    },
+    17: { angle: -0.48 * l, sx: 1 - 0.28 * l, sy: 1 + 0.12 * l },
+    18: { sx: 1 + 0.4 * h(t) * M, sy: 1 - 0.42 * h(t) * M },
+    19: { sx: 0.14 + 0.86 * S(t), sy: 0.42 + 0.58 * t, angle: l * 0.28 }
+  };
+  w(o, c, { alpha: (1 - t) ** 2, sx: 1 + t * 0.3, sy: 1 + t * 0.3 }), w(o, g, {
+    ...y[s],
+    alpha: t ** 0.5
+  });
+}
+export {
+  D as paintSpatial
+};