bt-core-app 2.2.10 → 2.2.12

package/dist/bt-core/core/node_modules/vuetify/lib/components/VPagination/VPagination.mjs

@@ -0,0 +1,315 @@
+import { shallowRef as W, computed as g, toRef as c, createVNode as m, normalizeClass as S, normalizeStyle as q, createElementVNode as b, mergeProps as P, nextTick as A } from "vue";
+import "../../../../../../../_virtual/VPagination.sass.mjs";
+import { makeBorderProps as G } from "../../composables/border.mjs";
+import { makeComponentProps as O } from "../../composables/component.mjs";
+import { provideDefaults as R } from "../../composables/defaults.mjs";
+import { makeDensityProps as X } from "../../composables/density.mjs";
+import { makeElevationProps as j } from "../../composables/elevation.mjs";
+import { IconValue as x } from "../../composables/icons.mjs";
+import { useLocale as H, useRtl as J } from "../../composables/locale.mjs";
+import { useProxiedModel as Q } from "../../composables/proxiedModel.mjs";
+import { useRefs as U } from "../../composables/refs.mjs";
+import { useResizeObserver as Y } from "../../composables/resizeObserver.mjs";
+import { makeRoundedProps as Z } from "../../composables/rounded.mjs";
+import { makeSizeProps as ee } from "../../composables/size.mjs";
+import { makeTagProps as ae } from "../../composables/tag.mjs";
+import { makeThemeProps as te, provideTheme as ie } from "../../composables/theme.mjs";
+import { makeVariantProps as le } from "../../composables/variant.mjs";
+import { useDisplay as ne } from "../../composables/display.mjs";
+import { VBtn as h } from "../VBtn/VBtn.mjs";
+import { propsFactory as re } from "../../util/propsFactory.mjs";
+import { genericComponent as oe } from "../../util/defineComponent.mjs";
+import { createRange as k, keyValues as N } from "../../util/helpers.mjs";
+import { useRender as se } from "../../util/useRender.mjs";
+const ue = re({
+  activeColor: String,
+  start: {
+    type: [Number, String],
+    default: 1
+  },
+  modelValue: {
+    type: Number,
+    default: (e) => e.start
+  },
+  disabled: Boolean,
+  length: {
+    type: [Number, String],
+    default: 1,
+    validator: (e) => e % 1 === 0
+  },
+  totalVisible: [Number, String],
+  firstIcon: {
+    type: x,
+    default: "$first"
+  },
+  prevIcon: {
+    type: x,
+    default: "$prev"
+  },
+  nextIcon: {
+    type: x,
+    default: "$next"
+  },
+  lastIcon: {
+    type: x,
+    default: "$last"
+  },
+  ariaLabel: {
+    type: String,
+    default: "$vuetify.pagination.ariaLabel.root"
+  },
+  pageAriaLabel: {
+    type: String,
+    default: "$vuetify.pagination.ariaLabel.page"
+  },
+  currentPageAriaLabel: {
+    type: String,
+    default: "$vuetify.pagination.ariaLabel.currentPage"
+  },
+  firstAriaLabel: {
+    type: String,
+    default: "$vuetify.pagination.ariaLabel.first"
+  },
+  previousAriaLabel: {
+    type: String,
+    default: "$vuetify.pagination.ariaLabel.previous"
+  },
+  nextAriaLabel: {
+    type: String,
+    default: "$vuetify.pagination.ariaLabel.next"
+  },
+  lastAriaLabel: {
+    type: String,
+    default: "$vuetify.pagination.ariaLabel.last"
+  },
+  ellipsis: {
+    type: String,
+    default: "..."
+  },
+  showFirstLastPage: Boolean,
+  ...G(),
+  ...O(),
+  ...X(),
+  ...j(),
+  ...Z(),
+  ...ee(),
+  ...ae({
+    tag: "nav"
+  }),
+  ...te(),
+  ...le({
+    variant: "text"
+  })
+}, "VPagination"), Ce = oe()({
+  name: "VPagination",
+  props: ue(),
+  emits: {
+    "update:modelValue": (e) => !0,
+    first: (e) => !0,
+    prev: (e) => !0,
+    next: (e) => !0,
+    last: (e) => !0
+  },
+  setup(e, $) {
+    let {
+      slots: s,
+      emit: B
+    } = $;
+    const l = Q(e, "modelValue"), {
+      t: d,
+      n: C
+    } = H(), {
+      isRtl: L
+    } = J(), {
+      themeClasses: w
+    } = ie(e), {
+      width: F
+    } = ne(), V = W(-1);
+    R(void 0, {
+      scoped: !0
+    });
+    const {
+      resizeRef: M
+    } = Y((a) => {
+      if (!a.length)
+        return;
+      const {
+        target: t,
+        contentRect: i
+      } = a[0], o = t.querySelector(".v-pagination__list > *");
+      if (!o)
+        return;
+      const u = i.width, p = o.offsetWidth + parseFloat(getComputedStyle(o).marginRight) * 2;
+      V.value = _(u, p);
+    }), n = g(() => parseInt(e.length, 10)), r = g(() => parseInt(e.start, 10)), v = g(() => e.totalVisible != null ? parseInt(e.totalVisible, 10) : V.value >= 0 ? V.value : _(F.value, 58));
+    function _(a, t) {
+      const i = e.showFirstLastPage ? 5 : 3;
+      return Math.max(0, Math.floor(
+        // Round to two decimal places to avoid floating point errors
+        Number(((a - t * i) / t).toFixed(2))
+      ));
+    }
+    const z = g(() => {
+      if (n.value <= 0 || isNaN(n.value) || n.value > Number.MAX_SAFE_INTEGER)
+        return [];
+      if (v.value <= 0)
+        return [];
+      if (v.value === 1)
+        return [l.value];
+      if (n.value <= v.value)
+        return k(n.value, r.value);
+      const a = v.value % 2 === 0, t = a ? v.value / 2 : Math.floor(v.value / 2), i = a ? t : t + 1, o = n.value - t;
+      if (i - l.value >= 0)
+        return [...k(Math.max(1, v.value - 1), r.value), e.ellipsis, n.value];
+      if (l.value - o >= (a ? 1 : 0)) {
+        const u = v.value - 1, p = n.value - u + r.value;
+        return [r.value, e.ellipsis, ...k(u, p)];
+      } else {
+        const u = Math.max(1, v.value - 2), p = u === 1 ? l.value : l.value - Math.ceil(u / 2) + r.value;
+        return [r.value, e.ellipsis, ...k(u, p), e.ellipsis, n.value];
+      }
+    });
+    function y(a, t, i) {
+      a.preventDefault(), l.value = t, i && B(i, t);
+    }
+    const {
+      refs: D,
+      updateRef: E
+    } = U();
+    R({
+      VPaginationBtn: {
+        color: c(() => e.color),
+        border: c(() => e.border),
+        density: c(() => e.density),
+        size: c(() => e.size),
+        variant: c(() => e.variant),
+        rounded: c(() => e.rounded),
+        elevation: c(() => e.elevation)
+      }
+    });
+    const T = g(() => z.value.map((a, t) => {
+      const i = (o) => E(o, t);
+      if (typeof a == "string")
+        return {
+          isActive: !1,
+          key: `ellipsis-${t}`,
+          page: a,
+          props: {
+            ref: i,
+            ellipsis: !0,
+            icon: !0,
+            disabled: !0
+          }
+        };
+      {
+        const o = a === l.value;
+        return {
+          isActive: o,
+          key: a,
+          page: C(a),
+          props: {
+            ref: i,
+            ellipsis: !1,
+            icon: !0,
+            disabled: !!e.disabled || Number(e.length) < 2,
+            color: o ? e.activeColor : e.color,
+            "aria-current": o,
+            "aria-label": d(o ? e.currentPageAriaLabel : e.pageAriaLabel, a),
+            onClick: (u) => y(u, a)
+          }
+        };
+      }
+    })), f = g(() => {
+      const a = !!e.disabled || l.value <= r.value, t = !!e.disabled || l.value >= r.value + n.value - 1;
+      return {
+        first: e.showFirstLastPage ? {
+          icon: L.value ? e.lastIcon : e.firstIcon,
+          onClick: (i) => y(i, r.value, "first"),
+          disabled: a,
+          "aria-label": d(e.firstAriaLabel),
+          "aria-disabled": a
+        } : void 0,
+        prev: {
+          icon: L.value ? e.nextIcon : e.prevIcon,
+          onClick: (i) => y(i, l.value - 1, "prev"),
+          disabled: a,
+          "aria-label": d(e.previousAriaLabel),
+          "aria-disabled": a
+        },
+        next: {
+          icon: L.value ? e.prevIcon : e.nextIcon,
+          onClick: (i) => y(i, l.value + 1, "next"),
+          disabled: t,
+          "aria-label": d(e.nextAriaLabel),
+          "aria-disabled": t
+        },
+        last: e.showFirstLastPage ? {
+          icon: L.value ? e.firstIcon : e.lastIcon,
+          onClick: (i) => y(i, r.value + n.value - 1, "last"),
+          disabled: t,
+          "aria-label": d(e.lastAriaLabel),
+          "aria-disabled": t
+        } : void 0
+      };
+    });
+    function I() {
+      var t;
+      const a = l.value - r.value;
+      (t = D.value[a]) == null || t.$el.focus();
+    }
+    function K(a) {
+      a.key === N.left && !e.disabled && l.value > Number(e.start) ? (l.value = l.value - 1, A(I)) : a.key === N.right && !e.disabled && l.value < r.value + n.value - 1 && (l.value = l.value + 1, A(I));
+    }
+    return se(() => m(e.tag, {
+      ref: M,
+      class: S(["v-pagination", w.value, e.class]),
+      style: q(e.style),
+      role: "navigation",
+      "aria-label": d(e.ariaLabel),
+      onKeydown: K,
+      "data-test": "v-pagination-root"
+    }, {
+      default: () => [b("ul", {
+        class: "v-pagination__list"
+      }, [e.showFirstLastPage && b("li", {
+        key: "first",
+        class: "v-pagination__first",
+        "data-test": "v-pagination-first"
+      }, [s.first ? s.first(f.value.first) : m(h, P({
+        _as: "VPaginationBtn"
+      }, f.value.first), null)]), b("li", {
+        key: "prev",
+        class: "v-pagination__prev",
+        "data-test": "v-pagination-prev"
+      }, [s.prev ? s.prev(f.value.prev) : m(h, P({
+        _as: "VPaginationBtn"
+      }, f.value.prev), null)]), T.value.map((a, t) => b("li", {
+        key: a.key,
+        class: S(["v-pagination__item", {
+          "v-pagination__item--is-active": a.isActive
+        }]),
+        "data-test": "v-pagination-item"
+      }, [s.item ? s.item(a) : m(h, P({
+        _as: "VPaginationBtn"
+      }, a.props), {
+        default: () => [a.page]
+      })])), b("li", {
+        key: "next",
+        class: "v-pagination__next",
+        "data-test": "v-pagination-next"
+      }, [s.next ? s.next(f.value.next) : m(h, P({
+        _as: "VPaginationBtn"
+      }, f.value.next), null)]), e.showFirstLastPage && b("li", {
+        key: "last",
+        class: "v-pagination__last",
+        "data-test": "v-pagination-last"
+      }, [s.last ? s.last(f.value.last) : m(h, P({
+        _as: "VPaginationBtn"
+      }, f.value.last), null)])])]
+    })), {};
+  }
+});
+export {
+  Ce as VPagination,
+  ue as makeVPaginationProps
+};

package/dist/bt-core/core/node_modules/vuetify/lib/components/VProgressCircular/VProgressCircular.mjs

@@ -0,0 +1,129 @@
+import { ref as I, toRef as r, computed as M, watchEffect as O, createVNode as A, normalizeClass as C, normalizeStyle as h, createElementVNode as n } from "vue";
+import "../../../../../../../_virtual/VProgressCircular.sass.mjs";
+import { useTextColor as y } from "../../composables/color.mjs";
+import { makeComponentProps as D } from "../../composables/component.mjs";
+import { useIntersectionObserver as F } from "../../composables/intersectionObserver.mjs";
+import { useResizeObserver as U } from "../../composables/resizeObserver.mjs";
+import { makeRevealProps as $, useReveal as B } from "../../composables/reveal.mjs";
+import { makeSizeProps as G, useSize as L } from "../../composables/size.mjs";
+import { makeTagProps as W } from "../../composables/tag.mjs";
+import { makeThemeProps as j, provideTheme as q } from "../../composables/theme.mjs";
+import { propsFactory as H } from "../../util/propsFactory.mjs";
+import { genericComponent as J } from "../../util/defineComponent.mjs";
+import { clamp as K, convertToUnit as k } from "../../util/helpers.mjs";
+import { useRender as Q } from "../../util/useRender.mjs";
+import { PREFERS_REDUCED_MOTION as X } from "../../util/globals.mjs";
+const Y = H({
+  bgColor: String,
+  color: String,
+  indeterminate: [Boolean, String],
+  rounded: Boolean,
+  modelValue: {
+    type: [Number, String],
+    default: 0
+  },
+  rotate: {
+    type: [Number, String],
+    default: 0
+  },
+  width: {
+    type: [Number, String],
+    default: 4
+  },
+  ...D(),
+  ...$(),
+  ...G(),
+  ...W({
+    tag: "div"
+  }),
+  ...j()
+}, "VProgressCircular"), fe = J()({
+  name: "VProgressCircular",
+  props: Y(),
+  setup(e, S) {
+    let {
+      slots: m
+    } = S;
+    const o = 20, t = 2 * Math.PI * o, i = I(), {
+      themeClasses: b
+    } = q(e), {
+      sizeClasses: p,
+      sizeStyles: v
+    } = L(e), {
+      textColorClasses: R,
+      textColorStyles: w
+    } = y(() => e.color), {
+      textColorClasses: x,
+      textColorStyles: N
+    } = y(() => e.bgColor), {
+      intersectionRef: P,
+      isIntersecting: z
+    } = F(), {
+      resizeRef: _,
+      contentRect: d
+    } = U(), {
+      state: f,
+      duration: E
+    } = B(e), a = r(() => f.value === "initial" ? 0 : K(parseFloat(e.modelValue), 0, 100)), u = r(() => Number(e.width)), g = r(() => v.value ? Number(e.size) : d.value ? d.value.width : Math.max(u.value, 32)), c = r(() => o / (1 - u.value / g.value) * 2), s = r(() => u.value / g.value * c.value), V = r(() => {
+      const l = (100 - a.value) / 100 * t;
+      return e.rounded && a.value > 0 && a.value < 100 ? k(Math.min(t - 0.01, l + s.value)) : k(l);
+    }), T = M(() => {
+      const l = Number(e.rotate);
+      return e.rounded ? l + s.value / 2 / t * 360 : l;
+    });
+    return O(() => {
+      P.value = i.value, _.value = i.value;
+    }), Q(() => A(e.tag, {
+      ref: i,
+      class: C(["v-progress-circular", {
+        "v-progress-circular--indeterminate": !!e.indeterminate,
+        "v-progress-circular--visible": z.value,
+        "v-progress-circular--disable-shrink": e.indeterminate && (e.indeterminate === "disable-shrink" || X()),
+        "v-progress-circular--revealing": ["initial", "pending"].includes(f.value)
+      }, b.value, p.value, R.value, e.class]),
+      style: h([v.value, w.value, {
+        "--progress-reveal-duration": `${E.value}ms`
+      }, e.style]),
+      role: "progressbar",
+      "aria-valuemin": "0",
+      "aria-valuemax": "100",
+      "aria-valuenow": e.indeterminate ? void 0 : a.value
+    }, {
+      default: () => [n("svg", {
+        style: {
+          transform: `rotate(calc(-90deg + ${T.value}deg))`
+        },
+        xmlns: "http://www.w3.org/2000/svg",
+        viewBox: `0 0 ${c.value} ${c.value}`
+      }, [n("circle", {
+        class: C(["v-progress-circular__underlay", x.value]),
+        style: h(N.value),
+        fill: "transparent",
+        cx: "50%",
+        cy: "50%",
+        r: o,
+        "stroke-width": s.value,
+        "stroke-dasharray": t,
+        "stroke-dashoffset": 0
+      }, null), n("circle", {
+        class: "v-progress-circular__overlay",
+        fill: "transparent",
+        cx: "50%",
+        cy: "50%",
+        r: o,
+        "stroke-width": s.value,
+        "stroke-dasharray": t,
+        "stroke-dashoffset": V.value,
+        "stroke-linecap": e.rounded ? "round" : void 0
+      }, null)]), m.default && n("div", {
+        class: "v-progress-circular__content"
+      }, [m.default({
+        value: a.value
+      })])]
+    })), {};
+  }
+});
+export {
+  fe as VProgressCircular,
+  Y as makeVProgressCircularProps
+};

package/dist/bt-core/core/node_modules/vuetify/lib/components/VProgressLinear/VProgressLinear.mjs

@@ -0,0 +1,195 @@
+import { ref as G, computed as t, shallowRef as H, watchEffect as V, createVNode as P, normalizeClass as n, normalizeStyle as s, createElementVNode as l, Transition as J } from "vue";
+import "../../../../../../../_virtual/VProgressLinear.sass.mjs";
+import { useTextColor as K, useBackgroundColor as h } from "../../composables/color.mjs";
+import { makeComponentProps as Q } from "../../composables/component.mjs";
+import { useIntersectionObserver as Y } from "../../composables/intersectionObserver.mjs";
+import { useRtl as Z } from "../../composables/locale.mjs";
+import { makeLocationProps as ee, useLocation as ae } from "../../composables/location.mjs";
+import { useProxiedModel as te } from "../../composables/proxiedModel.mjs";
+import { useResizeObserver as re } from "../../composables/resizeObserver.mjs";
+import { makeRoundedProps as le, useRounded as oe } from "../../composables/rounded.mjs";
+import { makeTagProps as ne } from "../../composables/tag.mjs";
+import { makeThemeProps as se, provideTheme as ie } from "../../composables/theme.mjs";
+import { useToggleScope as ue } from "../../composables/toggleScope.mjs";
+import { makeChunksProps as ce, useChunks as ve } from "./chunks.mjs";
+import { propsFactory as de } from "../../util/propsFactory.mjs";
+import { genericComponent as me } from "../../util/defineComponent.mjs";
+import { clamp as R, convertToUnit as a } from "../../util/helpers.mjs";
+import { useRender as fe } from "../../util/useRender.mjs";
+const ge = de({
+  absolute: Boolean,
+  active: {
+    type: Boolean,
+    default: !0
+  },
+  bgColor: String,
+  bgOpacity: [Number, String],
+  bufferValue: {
+    type: [Number, String],
+    default: 0
+  },
+  bufferColor: String,
+  bufferOpacity: [Number, String],
+  clickable: Boolean,
+  color: String,
+  height: {
+    type: [Number, String],
+    default: 4
+  },
+  indeterminate: Boolean,
+  max: {
+    type: [Number, String],
+    default: 100
+  },
+  modelValue: {
+    type: [Number, String],
+    default: 0
+  },
+  opacity: [Number, String],
+  reverse: Boolean,
+  stream: Boolean,
+  striped: Boolean,
+  roundedBar: Boolean,
+  ...ce(),
+  ...Q(),
+  ...ee({
+    location: "top"
+  }),
+  ...le(),
+  ...ne(),
+  ...se()
+}, "VProgressLinear"), ze = me()({
+  name: "VProgressLinear",
+  props: ge(),
+  emits: {
+    "update:modelValue": (e) => !0
+  },
+  setup(e, p) {
+    let {
+      slots: y
+    } = p;
+    const v = G(), d = te(e, "modelValue"), {
+      isRtl: x,
+      rtlClasses: w
+    } = Z(), {
+      themeClasses: F
+    } = ie(e), {
+      locationStyles: N
+    } = ae(e), {
+      textColorClasses: T,
+      textColorStyles: O
+    } = K(() => e.color), {
+      backgroundColorClasses: z,
+      backgroundColorStyles: L
+    } = h(() => e.bgColor || e.color), {
+      backgroundColorClasses: M,
+      backgroundColorStyles: W
+    } = h(() => e.bufferColor || e.bgColor || e.color), {
+      backgroundColorClasses: k,
+      backgroundColorStyles: S
+    } = h(() => e.color), {
+      roundedClasses: E
+    } = oe(e), {
+      intersectionRef: m,
+      isIntersecting: I
+    } = Y(), i = t(() => parseFloat(e.max)), o = t(() => parseFloat(e.height)), u = t(() => R(parseFloat(e.bufferValue) / i.value * 100, 0, 100)), f = t(() => R(parseFloat(d.value) / i.value * 100, 0, 100)), c = t(() => x.value !== e.reverse), X = t(() => e.indeterminate ? "fade-transition" : "slide-x-transition"), _ = H(0), {
+      hasChunks: g,
+      chunksMaskStyles: $,
+      snapValueToChunk: B
+    } = ve(e, _);
+    ue(g, () => {
+      const {
+        resizeRef: r
+      } = re((b) => _.value = b[0].contentRect.width);
+      V(() => r.value = v.value);
+    });
+    const U = t(() => g.value ? B(u.value) : u.value), j = t(() => g.value ? B(f.value) : f.value);
+    function q(r) {
+      if (!m.value)
+        return;
+      const {
+        left: b,
+        right: A,
+        width: C
+      } = m.value.getBoundingClientRect(), D = c.value ? C - r.clientX + (A - C) : r.clientX - b;
+      d.value = Math.round(D / C * i.value);
+    }
+    return V(() => {
+      m.value = v.value;
+    }), fe(() => P(e.tag, {
+      ref: v,
+      class: n(["v-progress-linear", {
+        "v-progress-linear--absolute": e.absolute,
+        "v-progress-linear--active": e.active && I.value,
+        "v-progress-linear--reverse": c.value,
+        "v-progress-linear--rounded": e.rounded,
+        "v-progress-linear--rounded-bar": e.roundedBar,
+        "v-progress-linear--striped": e.striped,
+        "v-progress-linear--clickable": e.clickable
+      }, E.value, F.value, w.value, e.class]),
+      style: s([{
+        bottom: e.location === "bottom" ? 0 : void 0,
+        top: e.location === "top" ? 0 : void 0,
+        height: e.active ? a(o.value) : 0,
+        "--v-progress-linear-height": a(o.value),
+        ...e.absolute ? N.value : {}
+      }, $.value, e.style]),
+      role: "progressbar",
+      "aria-hidden": e.active ? "false" : "true",
+      "aria-valuemin": "0",
+      "aria-valuemax": e.max,
+      "aria-valuenow": e.indeterminate ? void 0 : Math.min(parseFloat(d.value), i.value),
+      onClick: e.clickable && q
+    }, {
+      default: () => [e.stream && l("div", {
+        key: "stream",
+        class: n(["v-progress-linear__stream", T.value]),
+        style: {
+          ...O.value,
+          [c.value ? "left" : "right"]: a(-o.value),
+          borderTop: `${a(o.value / 2)} dotted`,
+          opacity: parseFloat(e.bufferOpacity),
+          top: `calc(50% - ${a(o.value / 4)})`,
+          width: a(100 - u.value, "%"),
+          "--v-progress-linear-stream-to": a(o.value * (c.value ? 1 : -1))
+        }
+      }, null), l("div", {
+        class: n(["v-progress-linear__background", z.value]),
+        style: s([L.value, {
+          opacity: parseFloat(e.bgOpacity),
+          width: e.stream ? 0 : void 0
+        }])
+      }, null), l("div", {
+        class: n(["v-progress-linear__buffer", M.value]),
+        style: s([W.value, {
+          opacity: parseFloat(e.bufferOpacity),
+          width: a(U.value, "%")
+        }])
+      }, null), P(J, {
+        name: X.value
+      }, {
+        default: () => [e.indeterminate ? l("div", {
+          class: "v-progress-linear__indeterminate"
+        }, [["long", "short"].map((r) => l("div", {
+          key: r,
+          class: n(["v-progress-linear__indeterminate", r, k.value]),
+          style: s(S.value)
+        }, null))]) : l("div", {
+          class: n(["v-progress-linear__determinate", k.value]),
+          style: s([S.value, {
+            width: a(j.value, "%")
+          }])
+        }, null)]
+      }), y.default && l("div", {
+        class: "v-progress-linear__content"
+      }, [y.default({
+        value: f.value,
+        buffer: u.value
+      })])]
+    })), {};
+  }
+});
+export {
+  ze as VProgressLinear,
+  ge as makeVProgressLinearProps
+};

package/dist/bt-core/core/node_modules/vuetify/lib/components/VProgressLinear/chunks.mjs

@@ -0,0 +1,53 @@
+import { toRef as h, computed as k, toValue as l } from "vue";
+import { propsFactory as p } from "../../util/propsFactory.mjs";
+import { convertToUnit as s, clamp as v } from "../../util/helpers.mjs";
+const g = p({
+  chunkCount: {
+    type: [Number, String],
+    default: null
+  },
+  chunkWidth: {
+    type: [Number, String],
+    default: null
+  },
+  chunkGap: {
+    type: [Number, String],
+    default: 4
+  }
+}, "chunks");
+function N(t, c) {
+  const r = h(() => !!t.chunkCount || !!t.chunkWidth), o = k(() => {
+    const e = l(c);
+    if (!e)
+      return 0;
+    if (!t.chunkCount)
+      return Number(t.chunkWidth);
+    const n = Number(t.chunkCount);
+    return (e - Number(t.chunkGap) * (n - 1)) / n;
+  }), u = h(() => Number(t.chunkGap)), m = k(() => {
+    if (!r.value)
+      return {};
+    const e = s(u.value), n = s(o.value);
+    return {
+      maskRepeat: "repeat-x",
+      maskImage: `linear-gradient(90deg, #000, #000 ${n}, transparent ${n}, transparent)`,
+      maskSize: `calc(${n} + ${e}) 100%`
+    };
+  });
+  function f(e) {
+    const n = l(c);
+    if (!n)
+      return e;
+    const a = 100 * u.value / n, i = 100 * (o.value + u.value) / n, d = Math.floor((e + a) / i);
+    return v(0, d * i - a / 2, 100);
+  }
+  return {
+    hasChunks: r,
+    chunksMaskStyles: m,
+    snapValueToChunk: f
+  };
+}
+export {
+  g as makeChunksProps,
+  N as useChunks
+};