bt-core-app 2.2.5 → 2.2.7

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

@@ -0,0 +1,183 @@
+import { useId as T, shallowRef as w, ref as U, toRef as R, createElementVNode as d, mergeProps as _, normalizeClass as B, normalizeStyle as j, withDirectives as E, Fragment as $, createVNode as N, inject as q, computed as v, nextTick as H } from "vue";
+import "../../../../../../../_virtual/VSelectionControl.sass.mjs";
+import { makeSelectionControlGroupProps as J, VSelectionControlGroupSymbol as K } from "../VSelectionControlGroup/VSelectionControlGroup.mjs";
+import { useTextColor as O, useBackgroundColor as Q } from "../../composables/color.mjs";
+import { makeComponentProps as W } from "../../composables/component.mjs";
+import { useDensity as X } from "../../composables/density.mjs";
+import { useProxiedModel as Y } from "../../composables/proxiedModel.mjs";
+import z from "../../directives/ripple/index.mjs";
+import { filterInputAttrs as Z, wrapInArray as g, matchesSelector as p } from "../../util/helpers.mjs";
+import { VIcon as ee } from "../VIcon/VIcon.mjs";
+import { VLabel as le } from "../VLabel/VLabel.mjs";
+import { propsFactory as te } from "../../util/propsFactory.mjs";
+import { genericComponent as oe } from "../../util/defineComponent.mjs";
+import { useRender as ae } from "../../util/useRender.mjs";
+const ne = te({
+  label: String,
+  baseColor: String,
+  trueValue: null,
+  falseValue: null,
+  value: null,
+  ...W(),
+  ...J()
+}, "VSelectionControl");
+function ue(e) {
+  const r = q(K, void 0), {
+    densityClasses: k
+  } = X(e), l = Y(e, "modelValue"), o = v(() => e.trueValue !== void 0 ? e.trueValue : e.value !== void 0 ? e.value : !0), f = v(() => e.falseValue !== void 0 ? e.falseValue : !1), s = v(() => !!e.multiple || e.multiple == null && Array.isArray(l.value)), t = v({
+    get() {
+      const i = r ? r.modelValue.value : l.value;
+      return s.value ? g(i).some((a) => e.valueComparator(a, o.value)) : e.valueComparator(i, o.value);
+    },
+    set(i) {
+      if (e.readonly)
+        return;
+      const a = i ? o.value : f.value;
+      let c = a;
+      s.value && (c = i ? [...g(l.value), a] : g(l.value).filter((n) => !e.valueComparator(n, o.value))), r ? r.modelValue.value = c : l.value = c;
+    }
+  }), {
+    textColorClasses: m,
+    textColorStyles: C
+  } = O(() => {
+    if (!(e.error || e.disabled))
+      return t.value ? e.color : e.baseColor;
+  }), {
+    backgroundColorClasses: b,
+    backgroundColorStyles: V
+  } = Q(() => t.value && !e.error && !e.disabled ? e.color : e.baseColor), S = v(() => t.value ? e.trueIcon : e.falseIcon);
+  return {
+    group: r,
+    densityClasses: k,
+    trueValue: o,
+    falseValue: f,
+    model: t,
+    textColorClasses: m,
+    textColorStyles: C,
+    backgroundColorClasses: b,
+    backgroundColorStyles: V,
+    icon: S
+  };
+}
+const ge = oe()({
+  name: "VSelectionControl",
+  directives: {
+    vRipple: z
+  },
+  inheritAttrs: !1,
+  props: ne(),
+  emits: {
+    "update:modelValue": (e) => !0
+  },
+  setup(e, r) {
+    let {
+      attrs: k,
+      slots: l
+    } = r;
+    const {
+      group: o,
+      densityClasses: f,
+      icon: s,
+      model: t,
+      textColorClasses: m,
+      textColorStyles: C,
+      backgroundColorClasses: b,
+      backgroundColorStyles: V,
+      trueValue: S
+    } = ue(e), i = T(), a = w(!1), c = w(!1), n = U(), y = R(() => e.id || `input-${i}`), h = R(() => !e.disabled && !e.readonly);
+    o == null || o.onForceUpdate(() => {
+      n.value && (n.value.checked = t.value);
+    });
+    function x(u) {
+      h.value && (a.value = !0, p(u.target, ":focus-visible") !== !1 && (c.value = !0));
+    }
+    function I() {
+      a.value = !1, c.value = !1;
+    }
+    function D(u) {
+      u.stopPropagation();
+    }
+    function G(u) {
+      if (!h.value) {
+        n.value && (n.value.checked = t.value);
+        return;
+      }
+      e.readonly && o && H(() => o.forceUpdate()), t.value = u.target.checked;
+    }
+    return ae(() => {
+      var F, P;
+      const u = l.label ? l.label({
+        label: e.label,
+        props: {
+          for: y.value
+        }
+      }) : e.label, [L, M] = Z(k), A = d("input", _({
+        ref: n,
+        checked: t.value,
+        disabled: !!e.disabled,
+        id: y.value,
+        onBlur: I,
+        onFocus: x,
+        onInput: G,
+        "aria-disabled": !!e.disabled,
+        "aria-label": e.label,
+        type: e.type,
+        value: S.value,
+        name: e.name,
+        "aria-checked": e.type === "checkbox" ? t.value : void 0
+      }, M), null);
+      return d("div", _({
+        class: ["v-selection-control", {
+          "v-selection-control--dirty": t.value,
+          "v-selection-control--disabled": e.disabled,
+          "v-selection-control--error": e.error,
+          "v-selection-control--focused": a.value,
+          "v-selection-control--focus-visible": c.value,
+          "v-selection-control--inline": e.inline
+        }, f.value, e.class]
+      }, L, {
+        style: e.style
+      }), [d("div", {
+        class: B(["v-selection-control__wrapper", m.value]),
+        style: j(C.value)
+      }, [(F = l.default) == null ? void 0 : F.call(l, {
+        backgroundColorClasses: b,
+        backgroundColorStyles: V
+      }), E(d("div", {
+        class: B(["v-selection-control__input"])
+      }, [((P = l.input) == null ? void 0 : P.call(l, {
+        model: t,
+        textColorClasses: m,
+        textColorStyles: C,
+        backgroundColorClasses: b,
+        backgroundColorStyles: V,
+        inputNode: A,
+        icon: s.value,
+        props: {
+          onFocus: x,
+          onBlur: I,
+          id: y.value
+        }
+      })) ?? d($, null, [s.value && N(ee, {
+        key: "icon",
+        icon: s.value
+      }, null), A])]), [[z, !e.disabled && !e.readonly && e.ripple, null, {
+        center: !0,
+        circle: !0
+      }]])]), u && N(le, {
+        for: y.value,
+        onClick: D
+      }, {
+        default: () => [u]
+      })]);
+    }), {
+      isFocused: a,
+      input: n
+    };
+  }
+});
+export {
+  ge as VSelectionControl,
+  ne as makeVSelectionControlProps,
+  ue as useSelectionControl
+};

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

@@ -0,0 +1,106 @@
+import { useId as f, toRef as o, provide as p, onScopeDispose as s, createElementVNode as y, normalizeClass as S, normalizeStyle as g } from "vue";
+import "../../../../../../../_virtual/VSelectionControlGroup.sass.mjs";
+import { makeComponentProps as v } from "../../composables/component.mjs";
+import { provideDefaults as C } from "../../composables/defaults.mjs";
+import { makeDensityProps as V } from "../../composables/density.mjs";
+import { IconValue as a } from "../../composables/icons.mjs";
+import { useProxiedModel as I } from "../../composables/proxiedModel.mjs";
+import { makeThemeProps as B } from "../../composables/theme.mjs";
+import { propsFactory as i } from "../../util/propsFactory.mjs";
+import { deepEqual as G } from "../../util/deepEqual.mjs";
+import { genericComponent as P } from "../../util/defineComponent.mjs";
+import { useRender as b } from "../../util/useRender.mjs";
+const k = Symbol.for("vuetify:selection-control-group"), T = i({
+  color: String,
+  disabled: {
+    type: Boolean,
+    default: null
+  },
+  defaultsTarget: String,
+  error: Boolean,
+  id: String,
+  inline: Boolean,
+  falseIcon: a,
+  trueIcon: a,
+  ripple: {
+    type: [Boolean, Object],
+    default: !0
+  },
+  multiple: {
+    type: Boolean,
+    default: null
+  },
+  name: String,
+  readonly: {
+    type: Boolean,
+    default: null
+  },
+  modelValue: null,
+  type: String,
+  valueComparator: {
+    type: Function,
+    default: G
+  },
+  ...v(),
+  ...V(),
+  ...B()
+}, "SelectionControlGroup"), D = i({
+  ...T({
+    defaultsTarget: "VSelectionControl"
+  })
+}, "VSelectionControlGroup");
+P()({
+  name: "VSelectionControlGroup",
+  props: D(),
+  emits: {
+    "update:modelValue": (e) => !0
+  },
+  setup(e, u) {
+    let {
+      slots: t
+    } = u;
+    const r = I(e, "modelValue"), m = f(), d = o(() => e.id || `v-selection-control-group-${m}`), c = o(() => e.name || d.value), n = /* @__PURE__ */ new Set();
+    return p(k, {
+      modelValue: r,
+      forceUpdate: () => {
+        n.forEach((l) => l());
+      },
+      onForceUpdate: (l) => {
+        n.add(l), s(() => {
+          n.delete(l);
+        });
+      }
+    }), C({
+      [e.defaultsTarget]: {
+        color: o(() => e.color),
+        disabled: o(() => e.disabled),
+        density: o(() => e.density),
+        error: o(() => e.error),
+        inline: o(() => e.inline),
+        modelValue: r,
+        multiple: o(() => !!e.multiple || e.multiple == null && Array.isArray(r.value)),
+        name: c,
+        falseIcon: o(() => e.falseIcon),
+        trueIcon: o(() => e.trueIcon),
+        readonly: o(() => e.readonly),
+        ripple: o(() => e.ripple),
+        type: o(() => e.type),
+        valueComparator: o(() => e.valueComparator)
+      }
+    }), b(() => {
+      var l;
+      return y("div", {
+        class: S(["v-selection-control-group", {
+          "v-selection-control-group--inline": e.inline
+        }, e.class]),
+        style: g(e.style),
+        role: e.type === "radio" ? "radiogroup" : void 0
+      }, [(l = t.default) == null ? void 0 : l.call(t)]);
+    }), {};
+  }
+});
+export {
+  k as VSelectionControlGroupSymbol,
+  T as makeSelectionControlGroupProps,
+  D as makeVSelectionControlGroupProps
+};

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

@@ -0,0 +1,61 @@
+import { createVNode as d, normalizeClass as p, normalizeStyle as f } from "vue";
+import "../../../../../../../_virtual/VSheet.sass.mjs";
+import { makeBorderProps as v, useBorder as k } from "../../composables/border.mjs";
+import { useBackgroundColor as C } from "../../composables/color.mjs";
+import { makeComponentProps as P } from "../../composables/component.mjs";
+import { makeDimensionProps as S, useDimension as h } from "../../composables/dimensions.mjs";
+import { makeElevationProps as g, useElevation as y } from "../../composables/elevation.mjs";
+import { makeLocationProps as V, useLocation as b } from "../../composables/location.mjs";
+import { makePositionProps as B, usePosition as R } from "../../composables/position.mjs";
+import { makeRoundedProps as T, useRounded as z } from "../../composables/rounded.mjs";
+import { makeTagProps as D } from "../../composables/tag.mjs";
+import { makeThemeProps as E, provideTheme as L } from "../../composables/theme.mjs";
+import { propsFactory as x } from "../../util/propsFactory.mjs";
+import { genericComponent as F } from "../../util/defineComponent.mjs";
+import { useRender as N } from "../../util/useRender.mjs";
+const j = x({
+  color: String,
+  ...v(),
+  ...P(),
+  ...S(),
+  ...g(),
+  ...V(),
+  ...B(),
+  ...T(),
+  ...D(),
+  ...E()
+}, "VSheet"), Z = F()({
+  name: "VSheet",
+  props: j(),
+  setup(o, e) {
+    let {
+      slots: s
+    } = e;
+    const {
+      themeClasses: r
+    } = L(o), {
+      backgroundColorClasses: t,
+      backgroundColorStyles: m
+    } = C(() => o.color), {
+      borderClasses: a
+    } = k(o), {
+      dimensionStyles: n
+    } = h(o), {
+      elevationClasses: i
+    } = y(o), {
+      locationStyles: l
+    } = b(o), {
+      positionClasses: u
+    } = R(o), {
+      roundedClasses: c
+    } = z(o);
+    return N(() => d(o.tag, {
+      class: p(["v-sheet", r.value, t.value, a.value, i.value, u.value, c.value, o.class]),
+      style: f([m.value, n.value, l.value, o.style])
+    }, s)), {};
+  }
+});
+export {
+  Z as VSheet,
+  j as makeVSheetProps
+};

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

@@ -0,0 +1,287 @@
+import { shallowRef as d, computed as c, watch as te, createVNode as m, normalizeClass as y, normalizeStyle as le, createElementVNode as x } from "vue";
+import "../../../../../../../_virtual/VSlideGroup.sass.mjs";
+import { VFadeTransition as D } from "../transitions/index.mjs";
+import { makeComponentProps as oe } from "../../composables/component.mjs";
+import { makeDisplayProps as ne, useDisplay as re } from "../../composables/display.mjs";
+import { useGoTo as ae } from "../../composables/goto.mjs";
+import { makeGroupProps as se, useGroup as ie } from "../../composables/group.mjs";
+import { IconValue as H } from "../../composables/icons.mjs";
+import { useRtl as ue } from "../../composables/locale.mjs";
+import { useResizeObserver as N } from "../../composables/resizeObserver.mjs";
+import { makeTagProps as ce } from "../../composables/tag.mjs";
+import { calculateCenteredTarget as fe, calculateUpdatedTarget as ve, getOffsetSize as de, getScrollPosition as me, getScrollSize as q, getClientSize as pe } from "./helpers.mjs";
+import { VIcon as K } from "../VIcon/VIcon.mjs";
+import { focusableChildren as ge } from "../../util/helpers.mjs";
+import { propsFactory as he } from "../../util/propsFactory.mjs";
+import { genericComponent as Se } from "../../util/defineComponent.mjs";
+import { IN_BROWSER as L } from "../../util/globals.mjs";
+import { useRender as ye } from "../../util/useRender.mjs";
+const xe = Symbol.for("vuetify:v-slide-group"), be = he({
+  centerActive: Boolean,
+  scrollToActive: {
+    type: Boolean,
+    default: !0
+  },
+  contentClass: null,
+  direction: {
+    type: String,
+    default: "horizontal"
+  },
+  symbol: {
+    type: null,
+    default: xe
+  },
+  nextIcon: {
+    type: H,
+    default: "$next"
+  },
+  prevIcon: {
+    type: H,
+    default: "$prev"
+  },
+  showArrows: {
+    type: [Boolean, String],
+    validator: (o) => typeof o == "boolean" || ["always", "desktop", "mobile", "never"].includes(o)
+  },
+  ...oe(),
+  ...ne({
+    mobile: null
+  }),
+  ...ce(),
+  ...se({
+    selectedClass: "v-slide-group-item--active"
+  })
+}, "VSlideGroup"), De = Se()({
+  name: "VSlideGroup",
+  props: be(),
+  emits: {
+    "update:modelValue": (o) => !0
+  },
+  setup(o, U) {
+    let {
+      slots: i
+    } = U;
+    const {
+      isRtl: u
+    } = ue(), {
+      displayClasses: $,
+      mobile: b
+    } = re(o), a = ie(o, o.symbol), p = d(!1), f = d(0), z = d(0), O = d(0), n = c(() => o.direction === "horizontal"), {
+      resizeRef: r,
+      contentRect: w
+    } = N(), {
+      resizeRef: s,
+      contentRect: k
+    } = N(), P = ae(), G = c(() => ({
+      container: r.el,
+      duration: 200,
+      easing: "easeOutQuart"
+    })), Q = c(() => a.selected.value.length ? a.items.value.findIndex((t) => t.id === a.selected.value[0]) : -1), j = c(() => a.selected.value.length ? a.items.value.findIndex((t) => t.id === a.selected.value[a.selected.value.length - 1]) : -1);
+    if (L) {
+      let t = -1;
+      te(() => [a.selected.value, w.value, k.value, n.value], () => {
+        cancelAnimationFrame(t), t = requestAnimationFrame(() => {
+          if (w.value && k.value) {
+            const e = n.value ? "width" : "height";
+            z.value = w.value[e], O.value = k.value[e], p.value = z.value + 1 < O.value;
+          }
+          if (o.scrollToActive && Q.value >= 0 && s.el) {
+            const e = s.el.children[j.value];
+            M(e, o.centerActive);
+          }
+        });
+      });
+    }
+    const g = d(!1);
+    function M(t, e) {
+      let l = 0;
+      e ? l = fe({
+        containerElement: r.el,
+        isHorizontal: n.value,
+        selectedElement: t
+      }) : l = ve({
+        containerElement: r.el,
+        isHorizontal: n.value,
+        isRtl: u.value,
+        selectedElement: t
+      }), W(l);
+    }
+    function W(t) {
+      if (!L || !r.el)
+        return;
+      const e = de(n.value, r.el), l = me(n.value, u.value, r.el);
+      if (!(q(n.value, r.el) <= e || // Prevent scrolling by only a couple of pixels, which doesn't look smooth
+      Math.abs(t - l) < 16)) {
+        if (n.value && u.value && r.el) {
+          const {
+            scrollWidth: _,
+            offsetWidth: V
+          } = r.el;
+          t = _ - V - t;
+        }
+        n.value ? P.horizontal(t, G.value) : P(t, G.value);
+      }
+    }
+    function J(t) {
+      const {
+        scrollTop: e,
+        scrollLeft: l
+      } = t.target;
+      f.value = n.value ? l : e;
+    }
+    function X(t) {
+      if (g.value = !0, !(!p.value || !s.el)) {
+        for (const e of t.composedPath())
+          for (const l of s.el.children)
+            if (l === e) {
+              M(l);
+              return;
+            }
+      }
+    }
+    function Y(t) {
+      g.value = !1;
+    }
+    let A = !1;
+    function Z(t) {
+      var e;
+      !A && !g.value && !(t.relatedTarget && ((e = s.el) != null && e.contains(t.relatedTarget))) && v(), A = !1;
+    }
+    function B() {
+      A = !0;
+    }
+    function ee(t) {
+      if (!s.el)
+        return;
+      function e(l) {
+        t.preventDefault(), v(l);
+      }
+      n.value ? t.key === "ArrowRight" ? e(u.value ? "prev" : "next") : t.key === "ArrowLeft" && e(u.value ? "next" : "prev") : t.key === "ArrowDown" ? e("next") : t.key === "ArrowUp" && e("prev"), t.key === "Home" ? e("first") : t.key === "End" && e("last");
+    }
+    function h(t, e) {
+      if (!t)
+        return;
+      let l = t;
+      do
+        l = l == null ? void 0 : l[e === "next" ? "nextElementSibling" : "previousElementSibling"];
+      while (l != null && l.hasAttribute("disabled"));
+      return l;
+    }
+    function v(t) {
+      if (!s.el)
+        return;
+      let e;
+      if (!t)
+        e = ge(s.el)[0];
+      else if (t === "next") {
+        if (e = h(s.el.querySelector(":focus"), t), !e)
+          return v("first");
+      } else if (t === "prev") {
+        if (e = h(s.el.querySelector(":focus"), t), !e)
+          return v("last");
+      } else
+        t === "first" ? (e = s.el.firstElementChild, e != null && e.hasAttribute("disabled") && (e = h(e, "next"))) : t === "last" && (e = s.el.lastElementChild, e != null && e.hasAttribute("disabled") && (e = h(e, "prev")));
+      e && e.focus({
+        preventScroll: !0
+      });
+    }
+    function R(t) {
+      const e = n.value && u.value ? -1 : 1, l = (t === "prev" ? -e : e) * z.value;
+      let I = f.value + l;
+      if (n.value && u.value && r.el) {
+        const {
+          scrollWidth: _,
+          offsetWidth: V
+        } = r.el;
+        I += _ - V;
+      }
+      W(I);
+    }
+    const C = c(() => ({
+      next: a.next,
+      prev: a.prev,
+      select: a.select,
+      isSelected: a.isSelected
+    })), S = c(() => p.value || Math.abs(f.value) > 0), T = c(() => {
+      switch (o.showArrows) {
+        case "never":
+          return !1;
+        case "always":
+          return !0;
+        case "desktop":
+          return !b.value;
+        case !0:
+          return S.value;
+        case "mobile":
+          return b.value || S.value;
+        default:
+          return !b.value && S.value;
+      }
+    }), E = c(() => Math.abs(f.value) > 1), F = c(() => {
+      if (!r.value || !S.value)
+        return !1;
+      const t = q(n.value, r.el), e = pe(n.value, r.el);
+      return t - e - Math.abs(f.value) > 1;
+    });
+    return ye(() => m(o.tag, {
+      class: y(["v-slide-group", {
+        "v-slide-group--vertical": !n.value,
+        "v-slide-group--has-affixes": T.value,
+        "v-slide-group--is-overflowing": p.value
+      }, $.value, o.class]),
+      style: le(o.style),
+      tabindex: g.value || a.selected.value.length ? -1 : 0,
+      onFocus: Z
+    }, {
+      default: () => {
+        var t, e, l;
+        return [T.value && x("div", {
+          key: "prev",
+          class: y(["v-slide-group__prev", {
+            "v-slide-group__prev--disabled": !E.value
+          }]),
+          onMousedown: B,
+          onClick: () => E.value && R("prev")
+        }, [((t = i.prev) == null ? void 0 : t.call(i, C.value)) ?? m(D, null, {
+          default: () => [m(K, {
+            icon: u.value ? o.nextIcon : o.prevIcon
+          }, null)]
+        })]), x("div", {
+          key: "container",
+          ref: r,
+          class: y(["v-slide-group__container", o.contentClass]),
+          onScroll: J
+        }, [x("div", {
+          ref: s,
+          class: "v-slide-group__content",
+          onFocusin: X,
+          onFocusout: Y,
+          onKeydown: ee
+        }, [(e = i.default) == null ? void 0 : e.call(i, C.value)])]), T.value && x("div", {
+          key: "next",
+          class: y(["v-slide-group__next", {
+            "v-slide-group__next--disabled": !F.value
+          }]),
+          onMousedown: B,
+          onClick: () => F.value && R("next")
+        }, [((l = i.next) == null ? void 0 : l.call(i, C.value)) ?? m(D, null, {
+          default: () => [m(K, {
+            icon: u.value ? o.prevIcon : o.nextIcon
+          }, null)]
+        })])];
+      }
+    })), {
+      selected: a.selected,
+      scrollTo: R,
+      scrollOffset: f,
+      focus: v,
+      hasPrev: E,
+      hasNext: F
+    };
+  }
+});
+export {
+  De as VSlideGroup,
+  xe as VSlideGroupSymbol,
+  be as makeVSlideGroupProps
+};

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

@@ -0,0 +1,54 @@
+function h(i) {
+  let {
+    selectedElement: t,
+    containerElement: o,
+    isRtl: n,
+    isHorizontal: r
+  } = i;
+  const c = e(r, o), s = d(r, n, o), l = e(r, t), f = a(r, t), u = l * 0.4;
+  return s > f ? f - u : s + c < f + l ? f - c + l + u : s;
+}
+function g(i) {
+  let {
+    selectedElement: t,
+    containerElement: o,
+    isHorizontal: n
+  } = i;
+  const r = e(n, o), c = a(n, t), s = e(n, t);
+  return c - r / 2 + s / 2;
+}
+function S(i, t) {
+  const o = i ? "scrollWidth" : "scrollHeight";
+  return (t == null ? void 0 : t[o]) || 0;
+}
+function z(i, t) {
+  const o = i ? "clientWidth" : "clientHeight";
+  return (t == null ? void 0 : t[o]) || 0;
+}
+function d(i, t, o) {
+  if (!o)
+    return 0;
+  const {
+    scrollLeft: n,
+    offsetWidth: r,
+    scrollWidth: c
+  } = o;
+  return i ? t ? c - r + n : n : o.scrollTop;
+}
+function e(i, t) {
+  const o = i ? "offsetWidth" : "offsetHeight";
+  return (t == null ? void 0 : t[o]) || 0;
+}
+function a(i, t) {
+  const o = i ? "offsetLeft" : "offsetTop";
+  return (t == null ? void 0 : t[o]) || 0;
+}
+export {
+  g as calculateCenteredTarget,
+  h as calculateUpdatedTarget,
+  z as getClientSize,
+  a as getOffsetPosition,
+  e as getOffsetSize,
+  d as getScrollPosition,
+  S as getScrollSize
+};