hys-ui 0.3.0 → 0.5.0

package/dist/components/HysAnimatedNumber/HysAnimatedNumber2.vue.js

@@ -1,4 +1,469 @@
-import f from "./HysAnimatedNumber.vue.js";
+import { defineComponent as Ke, useSlots as Ue, useTemplateRef as Ge, ref as j, computed as i, watch as M, onMounted as Ze, onActivated as Je, onDeactivated as Qe, onBeforeUnmount as Xe, openBlock as s, createElementBlock as r, mergeProps as Ye, unref as m, renderSlot as k, createTextVNode as W, toDisplayString as b, createCommentVNode as B, createElementVNode as z, normalizeStyle as ee, normalizeProps as O, guardReactiveProps as S, Fragment as $, createBlock as te, normalizeClass as be, createSlots as _e, withCtx as et, renderList as tt } from "vue";
+import { useHysRootAttrs as at } from "../../config.js";
+import { decimal as nt } from "../../composables/numberInput.js";
+import { numberValue as xe, createNumberPresentation as it, numberTrend as ae, bounded as ke } from "../../composables/animatedNumberFormat.js";
+import { useHysAnimatedNumber as lt } from "../../composables/useHysAnimatedNumber.js";
+import { resolveNumberAnimation as ne } from "../../composables/numberAnimation.js";
+import { useNumberCountdown as ot } from "./useNumberCountdown.js";
+import { useNumberVisuals as ut } from "./useNumberVisuals.js";
+import st from "./NumberDigits/NumberDigits.vue.js";
+import rt from "./NumberAnimationCanvas/NumberAnimationCanvas.vue.js";
+const dt = ["data-tone", "data-direction", "data-status", "data-appearance", "role", "tabindex"], ct = {
+  key: 0,
+  class: "hys-ui-motion-number-title"
+}, vt = ["role", "aria-label"], ft = {
+  key: 0,
+  class: "hys-ui-motion-number-affix hys-ui-motion-number-prefix"
+}, mt = {
+  class: "hys-number-measure",
+  "aria-hidden": "true"
+}, pt = {
+  class: "hys-number-measure",
+  "aria-hidden": "true"
+}, yt = {
+  key: 3,
+  class: "hys-ui-motion-number-unit"
+}, gt = {
+  key: 5,
+  class: "hys-ui-motion-number-affix hys-ui-motion-number-suffix"
+}, ht = {
+  key: 2,
+  class: "hys-number-live",
+  role: "status",
+  "aria-live": "polite",
+  "aria-atomic": "true"
+}, Nt = /* @__PURE__ */ Ke({
+  __name: "HysAnimatedNumber",
+  props: {
+    modelValue: {},
+    trigger: {},
+    canPlay: { type: [Boolean, Function], default: !0 },
+    visibleOnce: { type: Boolean, default: !0 },
+    pauseOutside: { type: Boolean },
+    visibilityThreshold: {},
+    effect: {},
+    animation: {},
+    animationPresets: {},
+    fallbackAnimation: {},
+    digitAnimations: {},
+    motionIntensity: {},
+    animationMotion: {},
+    thresholdEffect: {},
+    axis: {},
+    stagger: {},
+    digitDuration: {},
+    digitOrder: {},
+    animationStyle: {},
+    stableWidth: { type: Boolean },
+    appearance: { default: "plain" },
+    colorBySign: { type: Boolean },
+    colorByDirection: { type: Boolean },
+    changeThreshold: {},
+    title: {},
+    prefix: {},
+    suffix: {},
+    valueStyle: { type: [Boolean, null, String, Object, Array] },
+    formatter: {},
+    announce: { type: Boolean },
+    deadline: {},
+    format: { default: "HH:mm:ss" },
+    value: {},
+    from: {},
+    duration: { default: 650 },
+    delay: {},
+    speed: {},
+    easing: {},
+    interpolate: {},
+    loop: { type: [Boolean, Number] },
+    alternate: { type: Boolean },
+    interrupt: {},
+    queueLimit: {},
+    updateInterval: {},
+    fps: {},
+    disabled: { type: Boolean },
+    pauseWhenHidden: { type: Boolean, default: !0 },
+    decimals: {},
+    precision: {},
+    trimZeros: { type: Boolean },
+    minimumIntegerDigits: {},
+    rounding: {},
+    groupSeparator: {},
+    decimalSeparator: {},
+    grouping: { type: Boolean, default: void 0 },
+    locale: {},
+    numberFormat: {},
+    percentInput: {},
+    currency: {},
+    currencySymbol: {},
+    currencyDisplay: {},
+    compact: {},
+    unit: {},
+    signDisplay: {},
+    positiveSign: {},
+    negativeSign: {}
+  },
+  emits: ["update:modelValue", "value-change", "threshold", "change", "finish", "start", "update", "progress", "pause", "resume", "end", "cancel", "loop"],
+  setup(l, { expose: Be, emit: Oe }) {
+    const e = l, T = Oe, u = Ue(), ie = at(), w = Ge("root"), le = j(0), p = i(
+      () => xe(e.modelValue ?? e.value ?? le.value)
+    ), o = i(() => e.deadline !== void 0), P = i(() => it(e)), R = j(""), y = lt(
+      () => ({
+        from: e.from,
+        value: p.value,
+        duration: e.duration,
+        delay: e.delay,
+        speed: e.speed,
+        easing: e.easing,
+        interpolate: e.interpolate,
+        loop: e.loop,
+        alternate: e.alternate,
+        interrupt: e.interrupt,
+        queueLimit: e.queueLimit,
+        updateInterval: e.updateInterval,
+        fps: e.fps,
+        disabled: e.disabled || e.animationMotion === "off",
+        pauseWhenHidden: e.pauseWhenHidden,
+        autoPlay: !1,
+        autoUpdate: !1
+      }),
+      (t, a) => {
+        T(t, a), t === "end" && e.announce && (R.value = _(
+          P.value.format(a.value).text
+        ));
+      }
+    ), {
+      frame: g,
+      motionEnabled: F,
+      play: Se,
+      pause: Te,
+      resume: Pe,
+      stop: oe,
+      reset: Ve,
+      restart: L,
+      reverse: Ae,
+      seek: Ne,
+      finishAnimation: Ce
+    } = y, d = j(
+      ae(e.from ?? p.value, p.value, e.changeThreshold)
+    ), {
+      remaining: q,
+      parts: ue,
+      milliseconds: De
+    } = ot(
+      () => e.deadline,
+      () => e.format,
+      () => e.pauseWhenHidden,
+      (t) => T("change", t),
+      () => {
+        T("finish"), e.announce && (R.value = _(f.value.text));
+      }
+    ), K = i(
+      () => e.trigger === void 0 ? ["mount", "update"] : typeof e.trigger == "string" ? [e.trigger] : e.trigger
+    ), c = (t) => K.value.includes(t) && !K.value.includes("manual"), E = (t) => {
+      if (!c(t) || o.value) return !1;
+      try {
+        return typeof e.canPlay == "function" ? e.canPlay(t, p.value) : e.canPlay !== !1;
+      } catch {
+        return !1;
+      }
+    };
+    let v, V = !1, N = !1, C = !1, I = !1;
+    const D = j(!1);
+    function A(t) {
+      return E(t) ? (t === "activate" || t === "visible" || g.value.to === p.value ? L() : y.updateTarget(p.value), I = !1, !0) : !1;
+    }
+    function se() {
+      const t = !N || !e.visibleOnce, a = ["delayed", "paused", "playing"].includes(g.value.status);
+      I && E("update") ? (y.updateTarget(p.value), I = !1, c("visible") && (N = !0)) : t && !(e.pauseOutside && a) && A("visible") && (N = !0);
+    }
+    function re() {
+      if (v == null || v.disconnect(), v = void 0, !V || o.value || !c("visible") && !e.pauseOutside) {
+        D.value = !1, y.hold(!1);
+        return;
+      }
+      if (typeof IntersectionObserver > "u" || !w.value) {
+        D.value = !1, C = !0, y.hold(!1), se();
+        return;
+      }
+      C = !1, D.value = !0, y.hold(!!e.pauseOutside || c("visible"));
+      const t = ke(e.visibilityThreshold, 0.2, 0, 1);
+      v = new IntersectionObserver(
+        ([a]) => {
+          if (!V || !a) return;
+          const n = a.isIntersecting && a.intersectionRatio >= t, x = n && !C;
+          C = n, x && se(), y.hold(
+            !n && (!!e.pauseOutside || c("visible") && !N)
+          );
+        },
+        { threshold: t }
+      ), v.observe(w.value);
+    }
+    M(p, (t, a) => {
+      d.value = ae(a, t, e.changeThreshold), T("value-change", d.value), d.value.significant && T("threshold", d.value), E("update") && (c("visible") && D.value && !C && (!N || e.pauseOutside) ? I = !0 : y.updateTarget(t));
+    }), M(
+      () => e.changeThreshold,
+      (t) => {
+        d.value = ae(d.value.previous, p.value, t);
+      }
+    ), M(o, (t) => {
+      t ? oe() : y.sync();
+    }), M(
+      [
+        K,
+        () => e.pauseOutside,
+        () => e.visibilityThreshold,
+        o
+      ],
+      re,
+      { flush: "post" }
+    );
+    function de() {
+      V || (V = !0, re());
+    }
+    function ce() {
+      V = !1, v == null || v.disconnect(), v = void 0, D.value = !1;
+    }
+    Ze(() => {
+      de(), e.from !== void 0 && E("mount") && !c("visible") && L();
+    }), Je(() => {
+      V || (de(), A("activate"));
+    }), Qe(ce), Xe(ce);
+    const f = i((t) => {
+      const a = o.value ? {
+        text: ue.value.map(({ text: n }) => n).join(""),
+        unit: "",
+        parts: ue.value.map(({ text: n, numeric: x }) => ({
+          type: x ? "integer" : "literal",
+          value: n
+        }))
+      } : P.value.format(g.value.value);
+      return (t == null ? void 0 : t.text) === a.text && t.unit === a.unit && t.parts.length === a.parts.length && t.parts.every(
+        (n, x) => n.type === a.parts[x].type && n.value === a.parts[x].value
+      ) ? t : a;
+    }), U = i(() => f.value.text), h = i(() => ({
+      ...g.value,
+      value: o.value ? q.value : g.value.value,
+      displayValue: U.value,
+      unit: f.value.unit,
+      remaining: o.value ? q.value : void 0,
+      trend: d.value
+    })), G = i(() => {
+      const t = ne(e.animation, e.animationPresets);
+      return t.length ? t : ne(e.fallbackAnimation, e.animationPresets);
+    }), ve = i(
+      () => Object.fromEntries(
+        Object.entries(e.digitAnimations ?? {}).flatMap(([t, a]) => {
+          const n = ne(a, e.animationPresets);
+          return n.length ? [[t, n]] : [];
+        })
+      )
+    ), fe = i(() => ke(e.motionIntensity, 1, 0, 2)), Z = i(
+      () => e.animationMotion !== "simplified" && e.animationMotion !== "off" && fe.value > 0
+    ), me = i(
+      () => !o.value && Z.value && !u.digit && (G.value.some(({ entry: t }) => t) || Object.keys(ve.value).length > 0)
+    ), $e = i(() => {
+      if (!Z.value) return [];
+      if (me.value) return [];
+      const t = G.value.flatMap(
+        ({ effect: a, entry: n }) => a ? [a] : o.value && (n == null ? void 0 : n.name) === "flip-clock" ? ["flip"] : []
+      );
+      return t.length ? t : typeof e.effect == "string" ? [e.effect] : e.effect ?? [];
+    }), {
+      from: we,
+      to: Ee,
+      status: Ie,
+      running: He,
+      digitEffect: J,
+      visualStyle: je,
+      outgoingStyle: pe,
+      sliding: Me
+    } = ut(
+      e,
+      g,
+      h,
+      F,
+      o,
+      $e,
+      Z
+    ), H = i(
+      () => o.value ? f.value : P.value.format(we.value)
+    ), Q = i(
+      () => o.value ? f.value : P.value.format(Ee.value)
+    ), X = i(
+      () => He.value || d.value.direction === "none" ? g.value.direction : d.value.direction
+    ), We = i(() => {
+      var t;
+      if (!o.value) {
+        if (e.colorByDirection && X.value !== "none")
+          return X.value;
+        if (e.colorBySign) {
+          const a = ((t = nt(g.value.value)) == null ? void 0 : t.units) ?? 0n;
+          return a > 0n ? "up" : a < 0n ? "down" : void 0;
+        }
+      }
+    }), ye = i(
+      () => !!J.value && F.value && !De.value
+    ), Y = i(() => {
+      if (!(!e.formatter || u.formatter || u.default))
+        try {
+          return { value: e.formatter(h.value) };
+        } catch {
+          return;
+        }
+    }), ge = i(
+      () => !!(u.formatter || u.default || Y.value || u.digit)
+    ), ze = i(
+      () => ye.value && !ge.value && !o.value
+    ), he = i(
+      () => !o.value && (c("click") || c("hover"))
+    );
+    function _(t) {
+      return [
+        e.title,
+        [e.prefix, t, e.suffix].filter(Boolean).join(" ")
+      ].filter(Boolean).join(" ");
+    }
+    function Re(t) {
+      t.target !== w.value || t.repeat || !c("click") || !["Enter", " "].includes(t.key) || (t.preventDefault(), A("click"));
+    }
+    function Fe(t) {
+      const a = xe(t);
+      e.modelValue === void 0 && e.value === void 0 && (le.value = a), T("update:modelValue", a);
+    }
+    const Le = ({ value: t }) => t;
+    return Be({
+      displayValue: U,
+      remaining: q,
+      frame: g,
+      trend: d,
+      setValue: Fe,
+      play: Se,
+      pause: Te,
+      resume: Pe,
+      stop: oe,
+      restart: L,
+      reset: Ve,
+      reverse: Ae,
+      seek: Ne,
+      finishAnimation: Ce
+    }), (t, a) => (s(), r("span", Ye({
+      ref_key: "root",
+      ref: w
+    }, m(ie), {
+      class: "hys-ui-motion-number",
+      "data-tone": We.value,
+      "data-direction": X.value,
+      "data-status": o.value ? void 0 : m(Ie),
+      "data-appearance": l.appearance,
+      role: he.value && c("click") ? "button" : void 0,
+      tabindex: he.value ? 0 : void 0,
+      onClick: a[0] || (a[0] = (n) => A("click")),
+      onPointerenter: a[1] || (a[1] = (n) => A("hover")),
+      onFocus: a[2] || (a[2] = (n) => A("hover")),
+      onKeydown: Re
+    }), [
+      l.title || u.title ? (s(), r("span", ct, [
+        k(t.$slots, "title", {}, () => [
+          W(b(l.title), 1)
+        ], !0)
+      ])) : B("", !0),
+      z("span", {
+        class: "hys-ui-motion-number-value",
+        style: ee(l.valueStyle),
+        role: o.value ? "timer" : void 0,
+        "aria-label": o.value && !ge.value ? _(U.value) : void 0
+      }, [
+        l.prefix || u.prefix ? (s(), r("span", ft, [
+          u.prefix ? k(t.$slots, "prefix", O(S(h.value)), void 0, !0, 0) : (s(), r($, { key: 1 }, [
+            W(b(l.prefix), 1)
+          ], 64))
+        ])) : B("", !0),
+        u.formatter ? k(t.$slots, "formatter", O(S(h.value)), void 0, !0, 1) : u.default ? k(t.$slots, "default", O(S(h.value)), void 0, !0, 2) : Y.value ? (s(), te(Le, {
+          key: 3,
+          value: Y.value.value
+        }, null, 8, ["value"])) : (s(), r("span", {
+          key: 4,
+          class: be(["hys-ui-motion-number-layout", {
+            "hys-number-stable": l.stableWidth,
+            "hys-number-sliding": m(Me)
+          }])
+        }, [
+          l.stableWidth && !o.value ? (s(), r($, { key: 0 }, [
+            z("span", mt, b(H.value.text), 1),
+            z("span", pt, b(Q.value.text), 1)
+          ], 64)) : B("", !0),
+          m(pe) ? (s(), r("span", {
+            key: 1,
+            class: "hys-ui-motion-number-outgoing",
+            "aria-hidden": "true",
+            style: ee(m(pe))
+          }, b(H.value.text), 5)) : B("", !0),
+          z("span", {
+            class: "hys-ui-motion-number-content",
+            style: ee(m(je))
+          }, [
+            me.value ? (s(), te(rt, {
+              key: 0,
+              current: f.value,
+              start: H.value,
+              end: Q.value,
+              glyphs: P.value.localized,
+              context: h.value,
+              plans: G.value,
+              "digit-plans": ve.value,
+              intensity: fe.value,
+              motion: m(F),
+              axis: l.axis,
+              theme: m(ie)["data-hys-theme"]
+            }, null, 8, ["current", "start", "end", "glyphs", "context", "plans", "digit-plans", "intensity", "motion", "axis", "theme"])) : m(J) || u.digit || l.appearance !== "plain" ? (s(), te(st, {
+              key: 1,
+              current: f.value,
+              start: H.value,
+              end: Q.value,
+              glyphs: P.value.localized,
+              context: h.value,
+              effect: m(J),
+              axis: l.axis,
+              order: l.digitOrder,
+              stagger: l.stagger,
+              duration: l.duration,
+              "digit-duration": l.digitDuration,
+              motion: ye.value,
+              timer: o.value,
+              accessible: ze.value,
+              split: l.appearance !== "plain"
+            }, _e({ _: 2 }, [
+              u.digit ? {
+                name: "digit",
+                fn: et((n) => [
+                  k(t.$slots, "digit", O(S(n)), void 0, !0)
+                ]),
+                key: "0"
+              } : void 0
+            ]), 1032, ["current", "start", "end", "glyphs", "context", "effect", "axis", "order", "stagger", "duration", "digit-duration", "motion", "timer", "accessible", "split"])) : (s(!0), r($, { key: 2 }, tt(f.value.parts, ({ type: n, value: x }, qe) => (s(), r("span", {
+              key: qe,
+              class: be({
+                "hys-ui-motion-number-separator": n === "group" || n === "decimal"
+              })
+            }, b(x), 3))), 128)),
+            f.value.unit || u.unit ? (s(), r("span", yt, [
+              u.unit ? k(t.$slots, "unit", O(S(h.value)), void 0, !0, 0) : (s(), r($, { key: 1 }, [
+                W(b(f.value.unit), 1)
+              ], 64))
+            ])) : B("", !0)
+          ], 4)
+        ], 2)),
+        l.suffix || u.suffix ? (s(), r("span", gt, [
+          u.suffix ? k(t.$slots, "suffix", O(S(h.value)), void 0, !0, 0) : (s(), r($, { key: 1 }, [
+            W(b(l.suffix), 1)
+          ], 64))
+        ])) : B("", !0)
+      ], 12, vt),
+      u.trend ? k(t.$slots, "trend", O(S(d.value)), void 0, !0, 1) : B("", !0),
+      l.announce ? (s(), r("span", ht, b(R.value), 1)) : B("", !0)
+    ], 16, dt));
+  }
+});
 export {
-  f as default
+  Nt as default
 };

package/dist/components/HysAnimatedNumber/NumberAnimationCanvas/NumberAnimationCanvas.vue.js

@@ -0,0 +1,7 @@
+import a from "./NumberAnimationCanvas2.vue.js";
+/* empty css                           */
+import o from "../../../_virtual/_plugin-vue_export-helper.js";
+const f = /* @__PURE__ */ o(a, [["__scopeId", "data-v-fa57fa14"]]);
+export {
+  f as default
+};

package/dist/components/HysAnimatedNumber/NumberAnimationCanvas/NumberAnimationCanvas2.vue.js

@@ -0,0 +1,166 @@
+import { defineComponent as it, useTemplateRef as G, ref as ot, computed as z, watch as ct, onMounted as rt, onActivated as lt, onDeactivated as dt, onBeforeUnmount as pt, openBlock as ht, createElementBlock as ut, createElementVNode as J, toDisplayString as mt } from "vue";
+import { numberTokens as A, digitCount as ft } from "../../../composables/animatedNumberDigits.js";
+import { persistentDisplay as E } from "../animation/digital.js";
+import { glyph as O, clamp as gt, localProgress as xt } from "../animation/paint.js";
+import { paintNumberAnimation as vt } from "../animation/render.js";
+const yt = ["data-painted"], wt = { class: "hys-number-canvas-text" }, zt = /* @__PURE__ */ it({
+  __name: "NumberAnimationCanvas",
+  props: {
+    current: {},
+    start: {},
+    end: {},
+    glyphs: {},
+    context: {},
+    plans: {},
+    digitPlans: {},
+    intensity: {},
+    motion: { type: Boolean },
+    axis: {},
+    theme: {}
+  },
+  setup(K) {
+    const t = K, m = G("root"), R = G("canvas"), c = ot(!1), Q = z(
+      () => t.current.parts.map(({ value: a }) => a).join("")
+    ), X = z(
+      () => new Map(
+        A(t.start.parts, !0).map(({ key: a, text: i }) => [a, i])
+      )
+    ), Y = z(
+      () => new Map(
+        A(t.end.parts, !0).map(({ key: a, text: i }) => [a, i])
+      )
+    );
+    let r, f = !1;
+    function l() {
+      const a = R.value, i = m.value, d = ["playing", "paused"].includes(t.context.status) && t.context.progress < 1, g = ft(t.current.parts), Z = t.motion && t.intensity > 0 && g <= 48 && g > 0;
+      if (!f || !a || !i || !Z || typeof window.CanvasRenderingContext2D > "u") {
+        c.value = !1;
+        return;
+      }
+      const k = [
+        ...t.plans,
+        ...Object.values(t.digitPlans).flat()
+      ].some(
+        ({ entry: s }) => (s == null ? void 0 : s.category) === "digital" && E(s.variant)
+      );
+      if (!d && !k) {
+        c.value = !1;
+        return;
+      }
+      try {
+        const s = a.getContext("2d"), x = a.clientWidth, v = a.clientHeight;
+        if (!s || !x || !v) {
+          c.value = !1;
+          return;
+        }
+        const y = Math.min(3, window.devicePixelRatio || 1), N = Math.round(x * y), S = Math.round(v * y);
+        a.width !== N && (a.width = N), a.height !== S && (a.height = S), s.setTransform(y, 0, 0, y, 0, 0), s.clearRect(0, 0, x, v);
+        const o = getComputedStyle(i), D = Number.parseFloat(o.fontSize) || 16;
+        s.font = `${o.fontStyle} ${o.fontWeight} ${D}px ${o.fontFamily}`, s.textAlign = "center", s.textBaseline = "middle";
+        const I = o.color, tt = o.getPropertyValue("--hys-ui-theme-primary").trim() || I, et = Number.parseFloat(o.letterSpacing) || 0, F = A(t.current.parts, !0), st = Math.max(
+          ...t.glyphs.map((e) => s.measureText(e).width)
+        ), H = F.map(
+          ({ text: e, section: p }) => (p ? st : s.measureText(e).width) + et
+        ), M = H.reduce((e, p) => e + p, 0), w = M > i.clientWidth + 1 && i.clientWidth > 0 ? i.clientWidth / M : 1;
+        let j = (x - M * w) / 2, nt = 0;
+        F.forEach((e, p) => {
+          const _ = H[p], P = e.section ? nt++ : 0, L = ((e.section ? t.digitPlans[`${e.section}:${e.position}`] ?? t.digitPlans["*"] : void 0) ?? t.plans).filter(
+            ({ entry: n }) => e.section || (n == null ? void 0 : n.category) === "data" && [3, 4, 5].includes(n.variant)
+          ), W = X.value.get(e.key) ?? (e.section ? t.glyphs[0] : e.text), C = Y.value.get(e.key) ?? e.text, b = {
+            ctx: s,
+            from: W,
+            to: C,
+            digit: e.text,
+            section: e.section,
+            glyphs: t.glyphs,
+            fromIndex: Math.max(0, t.glyphs.indexOf(W)),
+            toIndex: Math.max(0, t.glyphs.indexOf(C)),
+            color: I,
+            accent: tt,
+            size: D,
+            width: _,
+            count: g,
+            index: P
+          };
+          s.save(), s.translate(j + _ * w / 2, v / 2), s.scale(w, 1);
+          const V = d ? L : L.filter(
+            ({ entry: n }) => (n == null ? void 0 : n.category) === "digital" && E(n.variant)
+          );
+          V.length || O(
+            {
+              ...b,
+              p: 1,
+              axis: t.axis ?? "vertical",
+              seed: 0,
+              strength: 1,
+              cycles: 1,
+              plan: {}
+            },
+            e.text
+          ), V.forEach((n, U) => {
+            var q;
+            const h = d ? gt(
+              n.stagger ? xt(
+                t.context.progress,
+                P,
+                g,
+                n.stagger
+              ) : t.context.easedProgress
+            ) : 1, u = Math.min(2, (n.strength ?? 1) * t.intensity), at = ((q = n.entry) == null ? void 0 : q.category) === "digital" && E(n.entry.variant), T = {
+              ...b,
+              p: h,
+              strength: u,
+              plan: n,
+              cycles: n.cycles ?? 1,
+              seed: (n.seed ?? 37) + P * 97,
+              axis: n.axis ?? t.axis ?? "vertical",
+              to: d ? b.to : e.text,
+              toIndex: d ? b.toIndex : Math.max(0, t.glyphs.indexOf(e.text))
+            };
+            s.save(), s.globalAlpha *= U === 0 ? 1 : 0.62, U === 0 && u < 1 && O(T, e.text, { alpha: 1 - u }), s.globalAlpha *= Math.min(1, u), u > 0 && (h > 0 && h < 1 || at) ? vt(T) : O(T, h === 0 ? W : h === 1 ? C : e.text), s.restore();
+          }), s.restore(), j += _ * w;
+        }), c.value = !0;
+      } catch {
+        c.value = !1;
+      }
+    }
+    function $() {
+      var a;
+      f || (f = !0, m.value && typeof ResizeObserver < "u" && (r = new ResizeObserver(l), r.observe(m.value)), window.addEventListener("resize", l), (a = document.fonts) == null || a.ready.then(l), l());
+    }
+    function B() {
+      f = !1, r == null || r.disconnect(), r = void 0, window.removeEventListener("resize", l);
+    }
+    return ct(
+      () => [
+        t.current,
+        t.start,
+        t.end,
+        t.context,
+        t.plans,
+        t.digitPlans,
+        t.motion,
+        t.intensity,
+        t.axis,
+        t.theme
+      ],
+      l,
+      { flush: "post" }
+    ), rt($), lt($), dt(B), pt(B), (a, i) => (ht(), ut("span", {
+      ref_key: "root",
+      ref: m,
+      class: "hys-number-canvas",
+      "data-painted": c.value ? "" : void 0
+    }, [
+      J("span", wt, mt(Q.value), 1),
+      J("canvas", {
+        ref_key: "canvas",
+        ref: R,
+        "aria-hidden": "true"
+      }, null, 512)
+    ], 8, yt));
+  }
+});
+export {
+  zt as default
+};

package/dist/components/HysAnimatedNumber/NumberDigits/NumberDigits.vue.js

@@ -0,0 +1,7 @@
+import o from "./NumberDigits2.vue.js";
+/* empty css                  */
+import t from "../../../_virtual/_plugin-vue_export-helper.js";
+const e = /* @__PURE__ */ t(o, [["__scopeId", "data-v-c4e6dfff"]]);
+export {
+  e as default
+};