@ianicdev/datatables2 0.10.9 → 0.11.1

package/dist/index-CsgCe_gz.js

@@ -0,0 +1,4482 @@
+import { ref as W, inject as Pe, computed as w, toRef as T, shallowRef as J, watch as re, createVNode as f, normalizeStyle as Ie, normalizeClass as ce, createElementVNode as b, mergeProps as R, withDirectives as He, vShow as Ct, Fragment as de, toDisplayString as bt, mergeModels as Lt, useModel as Vt, createBlock as ke, openBlock as le, withCtx as xe, createElementBlock as ze, renderList as Ht, unref as N, useId as je, provide as Ue, onScopeDispose as nt, nextTick as Ve, onBeforeMount as dn, onBeforeUnmount as vn, onMounted as Ye, cloneVNode as fn, watchEffect as Rt, toValue as mn, createTextVNode as vl, defineAsyncComponent as Te, resolveDynamicComponent as Oe, createCommentVNode as Re, isRef as pt, defineComponent as fl } from "vue";
+import { defineStore as ml } from "pinia";
+import { u as xt, m as Mt, P as gl, c as Me, a as gn, e as yn, r as hn, g as oe, p as j, b as yl, d as hl, f as kt, I as at, h as ve, V as tl, i as Se, j as bl, k as Be, l as bn, n as pe, o as be, q as pn, s as Qe, t as zt, v as Ut, w as Ne, x as We, R as Je, y as Ze, z as Kt, A as It, B as jt, C as rt, D as kn, E as we, F as ll, G as pl, H as kl, J as Sl, K as Cl, L as Fe, M as Xe, N as Sn, O as Vl, Q as ct, S as Cn, T as Gt, U as dt, W as Wt, X as $e, Y as wt, Z as vt, _ as qt, $ as xl, a0 as Il, a1 as Jt, a2 as ft, a3 as wl, a4 as De, a5 as mt, a6 as ot, a7 as Ge, a8 as _l, a9 as Xt, aa as _t, ab as Pl, ac as Al, ad as Fl, ae as $t, af as Vn, ag as Dl, ah as xn, ai as In, aj as lt, ak as Tl, al as Bl, am as wn, an as nl, ao as gt, ap as _n, aq as El, ar as Pn, as as Ol, at as Rl, au as Yt, av as it, aw as An, ax as Le, ay as Ml, az as $l, aA as Nl, aB as St, aC as Fn, aD as Dn, aE as Tn, aF as Bn, aG as En, aH as al, aI as On, aJ as Rn, aK as Mn, aL as qe, aM as $n, aN as Nn, aO as Ln, aP as Hn } from "./dataTables-EUusYEBd.js";
+import { useI18n as zn } from "vue-i18n";
+import { createSharedComposable as Un, useResizeObserver as Kn } from "@vueuse/core";
+const Pt = ml("datatables", () => {
+  const e = W([]), a = ({ table_id: u }) => {
+    const d = e.value.findIndex(
+      (r) => r.id === u
+    ), o = {
+      search: {
+        query: ""
+      },
+      advancedFilters: {
+        query: {}
+      },
+      hardFilters: {
+        query: {}
+      },
+      options: {
+        hash: null,
+        columns: {},
+        state: {}
+      }
+    };
+    d !== -1 && e.value.splice(d, 1), e.value.push({ id: u, ...o });
+  }, t = async (u) => {
+    const o = new TextEncoder().encode(u), r = await crypto.subtle.digest("SHA-256", o);
+    return Array.from(new Uint8Array(r)).map((y) => y.toString(16).padStart(2, "0")).join("");
+  }, n = ({ table_id: u, headers: d }) => {
+    t(JSON.stringify(d ?? [])).then((o) => {
+      l({ table_id: u, name: "options", value: { hash: o } });
+    });
+  }, l = ({ table_id: u, name: d, value: o }) => {
+    e.value = e.value.map((r) => {
+      if (r.id === u && r.hasOwnProperty(d)) {
+        const m = r[d];
+        if (m && typeof o == "object")
+          for (const g in o)
+            g in m && (m[g] = o[g]);
+      }
+      return r;
+    });
+  };
+  return {
+    // Store Data
+    tables: e,
+    // Store Methods
+    addTable: a,
+    setData: l,
+    restoreData: ({ table_id: u, data: d }) => {
+      e.value = e.value.map((o) => (o.id === u && (o = d), o));
+    },
+    getCurrentTable: (u) => e.value.find((d) => d.id === u),
+    // Hash
+    hashString: t,
+    setTableHash: n
+  };
+});
+function At() {
+  const { setData: e, getCurrentTable: a } = Pt(), t = Pe("table_props"), n = w(() => a(t.id)), l = w(() => n.value.search?.query), i = w(() => {
+    if (!t?.headers.length) return null;
+    const d = n.value.options?.columns.selected ?? [];
+    return (n.value.options?.columns.sorted ?? []).filter((m) => d.includes(m)).map(
+      (m) => t.headers.find((g) => g.key === m)
+    );
+  }), c = w(() => n.value.hardFilters?.query), s = w(() => n.value.advancedFilters?.query);
+  return {
+    tableState: n,
+    searchState: l,
+    advancedFiltersState: s,
+    hardFiltersState: c,
+    headersState: i,
+    saveTableOptions: (d) => {
+      e({
+        table_id: t.id,
+        name: "options",
+        value: {
+          state: d
+        }
+      });
+    }
+  };
+}
+const jn = /* @__PURE__ */ Symbol.for("vuetify:goto");
+function Gn() {
+  return {
+    container: void 0,
+    duration: 300,
+    layout: !1,
+    offset: 0,
+    easing: "easeInOutCubic",
+    patterns: yn
+  };
+}
+function Wn(e) {
+  return Qt(e) ?? (document.scrollingElement || document.body);
+}
+function Qt(e) {
+  return typeof e == "string" ? document.querySelector(e) : hn(e);
+}
+function Bt(e, a, t) {
+  if (typeof e == "number") return a && t ? -e : e;
+  let n = Qt(e), l = 0;
+  for (; n; )
+    l += a ? n.offsetLeft : n.offsetTop, n = n.offsetParent;
+  return l;
+}
+async function ol(e, a, t, n) {
+  const l = t ? "scrollLeft" : "scrollTop", i = Mt(n?.options ?? Gn(), a), c = n?.rtl.value, s = (typeof e == "number" ? e : Qt(e)) ?? 0, u = i.container === "parent" && s instanceof HTMLElement ? s.parentElement : Wn(i.container), d = gl() ? i.patterns.instant : typeof i.easing == "function" ? i.easing : i.patterns[i.easing];
+  if (!d) throw new TypeError(`Easing function "${i.easing}" not found.`);
+  let o;
+  if (typeof s == "number")
+    o = Bt(s, t, c);
+  else if (o = Bt(s, t, c) - Bt(u, t, c), i.layout) {
+    const y = window.getComputedStyle(s).getPropertyValue("--v-layout-top");
+    y && (o -= parseInt(y, 10));
+  }
+  o += i.offset, o = Jn(u, o, !!c, !!t);
+  const r = u[l] ?? 0;
+  if (o === r) return Promise.resolve(o);
+  const m = performance.now();
+  return new Promise((g) => requestAnimationFrame(function y(h) {
+    const _ = (h - m) / i.duration, x = Math.floor(r + (o - r) * d(Me(_, 0, 1)));
+    if (u[l] = x, _ >= 1 && Math.abs(x - u[l]) < 10)
+      return g(o);
+    if (_ > 2)
+      return gn("Scroll target is not reachable"), g(u[l]);
+    requestAnimationFrame(y);
+  }));
+}
+function qn() {
+  let e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+  const a = Pe(jn), {
+    isRtl: t
+  } = xt();
+  if (!a) throw new Error("[Vuetify] Could not find injected goto instance");
+  const n = {
+    ...a,
+    // can be set via VLocaleProvider
+    rtl: T(() => a.rtl.value || t.value)
+  };
+  async function l(i, c) {
+    return ol(i, Mt(e, c), !1, n);
+  }
+  return l.horizontal = async (i, c) => ol(i, Mt(e, c), !0, n), l;
+}
+function Jn(e, a, t, n) {
+  const {
+    scrollWidth: l,
+    scrollHeight: i
+  } = e, [c, s] = e === document.scrollingElement ? [window.innerWidth, window.innerHeight] : [e.offsetWidth, e.offsetHeight];
+  let u, d;
+  return n ? t ? (u = -(l - c), d = 0) : (u = 0, d = l - c) : (u = 0, d = i + -s), Me(a, u, d);
+}
+function Xn(e) {
+  let {
+    selectedElement: a,
+    containerElement: t,
+    isRtl: n,
+    isHorizontal: l
+  } = e;
+  const i = ut(l, t), c = Ll(l, n, t), s = ut(l, a), u = Hl(l, a), d = s * 0.4;
+  return c > u ? u - d : c + i < u + s ? u - i + s + d : c;
+}
+function Yn(e) {
+  let {
+    selectedElement: a,
+    containerElement: t,
+    isHorizontal: n
+  } = e;
+  const l = ut(n, t), i = Hl(n, a), c = ut(n, a);
+  return i - l / 2 + c / 2;
+}
+function il(e, a) {
+  return a?.[e ? "scrollWidth" : "scrollHeight"] || 0;
+}
+function Qn(e, a) {
+  return a?.[e ? "clientWidth" : "clientHeight"] || 0;
+}
+function Ll(e, a, t) {
+  if (!t)
+    return 0;
+  const {
+    scrollLeft: n,
+    offsetWidth: l,
+    scrollWidth: i
+  } = t;
+  return e ? a ? i - l + n : n : t.scrollTop;
+}
+function ut(e, a) {
+  return a?.[e ? "offsetWidth" : "offsetHeight"] || 0;
+}
+function Hl(e, a) {
+  return a?.[e ? "offsetLeft" : "offsetTop"] || 0;
+}
+const zl = /* @__PURE__ */ Symbol.for("vuetify:v-slide-group"), Ul = j({
+  centerActive: Boolean,
+  scrollToActive: {
+    type: Boolean,
+    default: !0
+  },
+  contentClass: null,
+  direction: {
+    type: String,
+    default: "horizontal"
+  },
+  symbol: {
+    type: null,
+    default: zl
+  },
+  nextIcon: {
+    type: be,
+    default: "$next"
+  },
+  prevIcon: {
+    type: be,
+    default: "$prev"
+  },
+  showArrows: {
+    type: [Boolean, String],
+    validator: (e) => typeof e == "boolean" || ["always", "desktop", "mobile", "never"].includes(e)
+  },
+  ...pe(),
+  ...bn({
+    mobile: null
+  }),
+  ...Be(),
+  ...bl({
+    selectedClass: "v-slide-group-item--active"
+  })
+}, "VSlideGroup"), ul = oe()({
+  name: "VSlideGroup",
+  props: Ul(),
+  emits: {
+    "update:modelValue": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    const {
+      isRtl: n
+    } = xt(), {
+      displayClasses: l,
+      mobile: i
+    } = yl(e), c = hl(e, e.symbol), s = J(!1), u = J(0), d = J(0), o = J(0), r = w(() => e.direction === "horizontal"), {
+      resizeRef: m,
+      contentRect: g
+    } = kt(), {
+      resizeRef: y,
+      contentRect: h
+    } = kt(), I = qn(), _ = w(() => ({
+      container: m.el,
+      duration: 200,
+      easing: "easeOutQuart"
+    })), x = w(() => c.selected.value.length ? c.items.value.findIndex((S) => S.id === c.selected.value[0]) : -1), k = w(() => c.selected.value.length ? c.items.value.findIndex((S) => S.id === c.selected.value[c.selected.value.length - 1]) : -1);
+    if (at) {
+      let S = -1;
+      re(() => [c.selected.value, g.value, h.value, r.value], () => {
+        cancelAnimationFrame(S), S = requestAnimationFrame(() => {
+          if (g.value && h.value) {
+            const v = r.value ? "width" : "height";
+            d.value = g.value[v], o.value = h.value[v], s.value = d.value + 1 < o.value;
+          }
+          if (e.scrollToActive && x.value >= 0 && y.el) {
+            const v = y.el.children[k.value];
+            F(v, e.centerActive);
+          }
+        });
+      });
+    }
+    const B = J(!1);
+    function F(S, v) {
+      let P = 0;
+      v ? P = Yn({
+        containerElement: m.el,
+        isHorizontal: r.value,
+        selectedElement: S
+      }) : P = Xn({
+        containerElement: m.el,
+        isHorizontal: r.value,
+        isRtl: n.value,
+        selectedElement: S
+      }), L(P);
+    }
+    function L(S) {
+      if (!at || !m.el) return;
+      const v = ut(r.value, m.el), P = Ll(r.value, n.value, m.el);
+      if (!(il(r.value, m.el) <= v || // Prevent scrolling by only a couple of pixels, which doesn't look smooth
+      Math.abs(S - P) < 16)) {
+        if (r.value && n.value && m.el) {
+          const {
+            scrollWidth: $,
+            offsetWidth: K
+          } = m.el;
+          S = $ - K - S;
+        }
+        r.value ? I.horizontal(S, _.value) : I(S, _.value);
+      }
+    }
+    function A(S) {
+      const {
+        scrollTop: v,
+        scrollLeft: P
+      } = S.target;
+      u.value = r.value ? P : v;
+    }
+    function p(S) {
+      if (B.value = !0, !(!s.value || !y.el)) {
+        for (const v of S.composedPath())
+          for (const P of y.el.children)
+            if (P === v) {
+              F(P);
+              return;
+            }
+      }
+    }
+    function M(S) {
+      B.value = !1;
+    }
+    let E = !1;
+    function q(S) {
+      !E && !B.value && !(S.relatedTarget && y.el?.contains(S.relatedTarget)) && z(), E = !1;
+    }
+    function te() {
+      E = !0;
+    }
+    function ee(S) {
+      if (!y.el) return;
+      function v(P) {
+        S.preventDefault(), z(P);
+      }
+      r.value ? S.key === "ArrowRight" ? v(n.value ? "prev" : "next") : S.key === "ArrowLeft" && v(n.value ? "next" : "prev") : S.key === "ArrowDown" ? v("next") : S.key === "ArrowUp" && v("prev"), S.key === "Home" ? v("first") : S.key === "End" && v("last");
+    }
+    function U(S, v) {
+      if (!S) return;
+      let P = S;
+      do
+        P = P?.[v === "next" ? "nextElementSibling" : "previousElementSibling"];
+      while (P?.hasAttribute("disabled"));
+      return P;
+    }
+    function z(S) {
+      if (!y.el) return;
+      let v;
+      if (!S)
+        v = pn(y.el)[0];
+      else if (S === "next") {
+        if (v = U(y.el.querySelector(":focus"), S), !v) return z("first");
+      } else if (S === "prev") {
+        if (v = U(y.el.querySelector(":focus"), S), !v) return z("last");
+      } else S === "first" ? (v = y.el.firstElementChild, v?.hasAttribute("disabled") && (v = U(v, "next"))) : S === "last" && (v = y.el.lastElementChild, v?.hasAttribute("disabled") && (v = U(v, "prev")));
+      v && v.focus({
+        preventScroll: !0
+      });
+    }
+    function ie(S) {
+      const v = r.value && n.value ? -1 : 1, P = (S === "prev" ? -v : v) * d.value;
+      let V = u.value + P;
+      if (r.value && n.value && m.el) {
+        const {
+          scrollWidth: $,
+          offsetWidth: K
+        } = m.el;
+        V += $ - K;
+      }
+      L(V);
+    }
+    const G = w(() => ({
+      next: c.next,
+      prev: c.prev,
+      select: c.select,
+      isSelected: c.isSelected
+    })), X = w(() => s.value || Math.abs(u.value) > 0), ne = w(() => {
+      switch (e.showArrows) {
+        case "never":
+          return !1;
+        // Always show arrows on desktop & mobile
+        case "always":
+          return !0;
+        // Always show arrows on desktop
+        case "desktop":
+          return !i.value;
+        // Show arrows on mobile when overflowing.
+        // This matches the default 2.2 behavior
+        case !0:
+          return X.value;
+        // Always show on mobile
+        case "mobile":
+          return i.value || X.value;
+        // https://material.io/components/tabs#scrollable-tabs
+        // Always show arrows when
+        // overflowed on desktop
+        default:
+          return !i.value && X.value;
+      }
+    }), D = w(() => Math.abs(u.value) > 1), O = w(() => {
+      if (!m.value || !X.value) return !1;
+      const S = il(r.value, m.el), v = Qn(r.value, m.el);
+      return S - v - Math.abs(u.value) > 1;
+    });
+    return ve(() => f(e.tag, {
+      class: ce(["v-slide-group", {
+        "v-slide-group--vertical": !r.value,
+        "v-slide-group--has-affixes": ne.value,
+        "v-slide-group--is-overflowing": s.value
+      }, l.value, e.class]),
+      style: Ie(e.style),
+      tabindex: B.value || c.selected.value.length ? -1 : 0,
+      onFocus: q
+    }, {
+      default: () => [ne.value && b("div", {
+        key: "prev",
+        class: ce(["v-slide-group__prev", {
+          "v-slide-group__prev--disabled": !D.value
+        }]),
+        onMousedown: te,
+        onClick: () => D.value && ie("prev")
+      }, [t.prev?.(G.value) ?? f(tl, null, {
+        default: () => [f(Se, {
+          icon: n.value ? e.nextIcon : e.prevIcon
+        }, null)]
+      })]), b("div", {
+        key: "container",
+        ref: m,
+        class: ce(["v-slide-group__container", e.contentClass]),
+        onScroll: A
+      }, [b("div", {
+        ref: y,
+        class: "v-slide-group__content",
+        onFocusin: p,
+        onFocusout: M,
+        onKeydown: ee
+      }, [t.default?.(G.value)])]), ne.value && b("div", {
+        key: "next",
+        class: ce(["v-slide-group__next", {
+          "v-slide-group__next--disabled": !O.value
+        }]),
+        onMousedown: te,
+        onClick: () => O.value && ie("next")
+      }, [t.next?.(G.value) ?? f(tl, null, {
+        default: () => [f(Se, {
+          icon: n.value ? e.prevIcon : e.nextIcon
+        }, null)]
+      })])]
+    })), {
+      selected: c.selected,
+      scrollTo: ie,
+      scrollOffset: u,
+      focus: z,
+      hasPrev: D,
+      hasNext: O
+    };
+  }
+}), Kl = /* @__PURE__ */ Symbol.for("vuetify:v-chip-group"), Zn = j({
+  baseColor: String,
+  column: Boolean,
+  filter: Boolean,
+  valueComparator: {
+    type: Function,
+    default: We
+  },
+  ...Ul({
+    scrollToActive: !1
+  }),
+  ...pe(),
+  ...bl({
+    selectedClass: "v-chip--selected"
+  }),
+  ...Be(),
+  ...Ne(),
+  ...Ut({
+    variant: "tonal"
+  })
+}, "VChipGroup"), ea = oe()({
+  name: "VChipGroup",
+  props: Zn(),
+  emits: {
+    "update:modelValue": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    const {
+      themeClasses: n
+    } = Qe(e), {
+      isSelected: l,
+      select: i,
+      next: c,
+      prev: s,
+      selected: u
+    } = hl(e, Kl);
+    return zt({
+      VChip: {
+        baseColor: T(() => e.baseColor),
+        color: T(() => e.color),
+        disabled: T(() => e.disabled),
+        filter: T(() => e.filter),
+        variant: T(() => e.variant)
+      }
+    }), ve(() => {
+      const d = ul.filterProps(e);
+      return f(ul, R(d, {
+        class: ["v-chip-group", {
+          "v-chip-group--column": e.column
+        }, n.value, e.class],
+        style: e.style
+      }), {
+        default: () => [t.default?.({
+          isSelected: l,
+          select: i,
+          next: c,
+          prev: s,
+          selected: u.value
+        })]
+      });
+    }), {};
+  }
+}), ta = j({
+  activeClass: String,
+  appendAvatar: String,
+  appendIcon: be,
+  baseColor: String,
+  closable: Boolean,
+  closeIcon: {
+    type: be,
+    default: "$delete"
+  },
+  closeLabel: {
+    type: String,
+    default: "$vuetify.close"
+  },
+  draggable: Boolean,
+  filter: Boolean,
+  filterIcon: {
+    type: be,
+    default: "$complete"
+  },
+  label: Boolean,
+  link: {
+    type: Boolean,
+    default: void 0
+  },
+  pill: Boolean,
+  prependAvatar: String,
+  prependIcon: be,
+  ripple: {
+    type: [Boolean, Object],
+    default: !0
+  },
+  text: {
+    type: [String, Number, Boolean],
+    default: void 0
+  },
+  modelValue: {
+    type: Boolean,
+    default: !0
+  },
+  onClick: $e(),
+  onClickOnce: $e(),
+  ...Wt(),
+  ...pe(),
+  ...dt(),
+  ...Gt(),
+  ...Cn(),
+  ...ct(),
+  ...Vl(),
+  ...Sn(),
+  ...Be({
+    tag: "span"
+  }),
+  ...Ne(),
+  ...Ut({
+    variant: "tonal"
+  })
+}, "VChip"), st = oe()({
+  name: "VChip",
+  directives: {
+    vRipple: Je
+  },
+  props: ta(),
+  emits: {
+    "click:close": (e) => !0,
+    "update:modelValue": (e) => !0,
+    "group:selected": (e) => !0,
+    click: (e) => !0
+  },
+  setup(e, a) {
+    let {
+      attrs: t,
+      emit: n,
+      slots: l
+    } = a;
+    const {
+      t: i
+    } = Ze(), {
+      borderClasses: c
+    } = Kt(e), {
+      densityClasses: s
+    } = It(e), {
+      elevationClasses: u
+    } = jt(e), {
+      roundedClasses: d
+    } = rt(e), {
+      sizeClasses: o
+    } = kn(e), {
+      themeClasses: r
+    } = Qe(e), m = we(e, "modelValue"), g = ll(e, Kl, !1), y = ll(e, zl, !1), h = pl(e, t), I = T(() => e.link !== !1 && h.isLink.value), _ = w(() => !e.disabled && e.link !== !1 && (!!g || e.link || h.isClickable.value)), x = T(() => ({
+      "aria-label": i(e.closeLabel),
+      disabled: e.disabled,
+      onClick(p) {
+        p.preventDefault(), p.stopPropagation(), m.value = !1, n("click:close", p);
+      }
+    }));
+    re(m, (p) => {
+      p ? (g?.register(), y?.register()) : (g?.unregister(), y?.unregister());
+    });
+    const {
+      colorClasses: k,
+      colorStyles: B,
+      variantClasses: F
+    } = kl(() => ({
+      color: !g || g.isSelected.value ? e.color ?? e.baseColor : e.baseColor,
+      variant: e.variant
+    }));
+    function L(p) {
+      n("click", p), _.value && (h.navigate?.(p), g?.toggle());
+    }
+    function A(p) {
+      (p.key === "Enter" || p.key === " ") && (p.preventDefault(), L(p));
+    }
+    return () => {
+      const p = h.isLink.value ? "a" : e.tag, M = !!(e.appendIcon || e.appendAvatar), E = !!(M || l.append), q = !!(l.close || e.closable), te = !!(l.filter || e.filter) && g, ee = !!(e.prependIcon || e.prependAvatar), U = !!(ee || l.prepend);
+      return m.value && He(f(p, R(h.linkProps, {
+        class: ["v-chip", {
+          "v-chip--disabled": e.disabled,
+          "v-chip--label": e.label,
+          "v-chip--link": _.value,
+          "v-chip--filter": te,
+          "v-chip--pill": e.pill,
+          [`${e.activeClass}`]: e.activeClass && h.isActive?.value
+        }, r.value, c.value, k.value, s.value, u.value, d.value, o.value, F.value, g?.selectedClass.value, e.class],
+        style: [B.value, e.style],
+        disabled: e.disabled || void 0,
+        draggable: e.draggable,
+        tabindex: _.value ? 0 : void 0,
+        onClick: L,
+        onKeydown: _.value && !I.value && A
+      }), {
+        default: () => [Sl(_.value, "v-chip"), te && f(Cl, {
+          key: "filter"
+        }, {
+          default: () => [He(b("div", {
+            class: "v-chip__filter"
+          }, [l.filter ? f(Fe, {
+            key: "filter-defaults",
+            disabled: !e.filterIcon,
+            defaults: {
+              VIcon: {
+                icon: e.filterIcon
+              }
+            }
+          }, l.filter) : f(Se, {
+            key: "filter-icon",
+            icon: e.filterIcon
+          }, null)]), [[Ct, g.isSelected.value]])]
+        }), U && b("div", {
+          key: "prepend",
+          class: "v-chip__prepend"
+        }, [l.prepend ? f(Fe, {
+          key: "prepend-defaults",
+          disabled: !ee,
+          defaults: {
+            VAvatar: {
+              image: e.prependAvatar,
+              start: !0
+            },
+            VIcon: {
+              icon: e.prependIcon,
+              start: !0
+            }
+          }
+        }, l.prepend) : b(de, null, [e.prependIcon && f(Se, {
+          key: "prepend-icon",
+          icon: e.prependIcon,
+          start: !0
+        }, null), e.prependAvatar && f(Xe, {
+          key: "prepend-avatar",
+          image: e.prependAvatar,
+          start: !0
+        }, null)])]), b("div", {
+          class: "v-chip__content",
+          "data-no-activator": ""
+        }, [l.default?.({
+          isSelected: g?.isSelected.value,
+          selectedClass: g?.selectedClass.value,
+          select: g?.select,
+          toggle: g?.toggle,
+          value: g?.value.value,
+          disabled: e.disabled
+        }) ?? bt(e.text)]), E && b("div", {
+          key: "append",
+          class: "v-chip__append"
+        }, [l.append ? f(Fe, {
+          key: "append-defaults",
+          disabled: !M,
+          defaults: {
+            VAvatar: {
+              end: !0,
+              image: e.appendAvatar
+            },
+            VIcon: {
+              end: !0,
+              icon: e.appendIcon
+            }
+          }
+        }, l.append) : b(de, null, [e.appendIcon && f(Se, {
+          key: "append-icon",
+          end: !0,
+          icon: e.appendIcon
+        }, null), e.appendAvatar && f(Xe, {
+          key: "append-avatar",
+          end: !0,
+          image: e.appendAvatar
+        }, null)])]), q && b("button", R({
+          key: "close",
+          class: "v-chip__close",
+          type: "button",
+          "data-testid": "close-chip"
+        }, x.value), [l.close ? f(Fe, {
+          key: "close-defaults",
+          defaults: {
+            VIcon: {
+              icon: e.closeIcon,
+              size: "x-small"
+            }
+          }
+        }, l.close) : f(Se, {
+          key: "close-icon",
+          icon: e.closeIcon,
+          size: "x-small"
+        }, null)])]
+      }), [[Je, _.value && e.ripple, null]]);
+    };
+  }
+}), la = j({
+  color: String,
+  ...Wt(),
+  ...pe(),
+  ...ft(),
+  ...Gt(),
+  ...Jt(),
+  ...Il(),
+  ...ct(),
+  ...Be(),
+  ...Ne()
+}, "VSheet"), na = oe()({
+  name: "VSheet",
+  props: la(),
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    const {
+      themeClasses: n
+    } = Qe(e), {
+      backgroundColorClasses: l,
+      backgroundColorStyles: i
+    } = wt(() => e.color), {
+      borderClasses: c
+    } = Kt(e), {
+      dimensionStyles: s
+    } = vt(e), {
+      elevationClasses: u
+    } = jt(e), {
+      locationStyles: d
+    } = qt(e), {
+      positionClasses: o
+    } = xl(e), {
+      roundedClasses: r
+    } = rt(e);
+    return ve(() => f(e.tag, {
+      class: ce(["v-sheet", n.value, l.value, c.value, u.value, o.value, r.value, e.class]),
+      style: Ie([i.value, s.value, d.value, e.style])
+    }, t)), {};
+  }
+}), aa = {
+  __name: "Selected",
+  props: {
+    modelValue: {},
+    modelModifiers: {}
+  },
+  emits: /* @__PURE__ */ Lt("save", ["update:modelValue"]),
+  setup(e, { emit: a }) {
+    const { advancedFiltersState: t } = At(), n = Pe("table_props"), l = Vt(e, "modelValue"), i = (u, d) => {
+      const o = n.headers.find((y) => (y.advancedFilter?.key ?? y.key) === d), r = u.comparison === "=" ? ":" : " " + u.comparison, m = Array.isArray(u.value) ? u.value : [u.value], g = m.filter((y, h) => !(o.advancedFilter?.component === "datepicker" && h !== 0 && h !== m.length - 1)).map((y) => {
+        const h = o.advancedFilter?.options?.items ?? [];
+        let I = y, _;
+        return h.length && (_ = h.find((x) => x.value === y), _ && (I = _.title)), typeof o.advancedFilter?.valueFormatter == "function" && (I = o.advancedFilter.valueFormatter({
+          item: _,
+          value: y
+        })), I;
+      });
+      return `${o.title}${r} ${g.join(", ")}`;
+    }, c = (u) => {
+      l.value[u] = { comparison: "=", value: null }, s("save");
+    }, s = a;
+    return (u, d) => (le(), ke(na, null, {
+      default: xe(() => [
+        f(ea, null, {
+          default: xe(() => [
+            (le(!0), ze(de, null, Ht(N(t), (o, r) => (le(), ke(st, {
+              key: r,
+              class: "my-0",
+              text: i(o, r),
+              closable: "",
+              value: o,
+              density: "comfortable",
+              "onClick:close": (m) => c(r)
+            }, null, 8, ["text", "value", "onClick:close"]))), 128))
+          ]),
+          _: 1
+        })
+      ]),
+      _: 1
+    }));
+  }
+}, oa = j({
+  text: String,
+  onClick: $e(),
+  ...pe(),
+  ...Ne()
+}, "VLabel"), jl = oe()({
+  name: "VLabel",
+  props: oa(),
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    return ve(() => b("label", {
+      class: ce(["v-label", {
+        "v-label--clickable": !!e.onClick
+      }, e.class]),
+      style: Ie(e.style),
+      onClick: e.onClick
+    }, [e.text, t.default?.()])), {};
+  }
+}), Gl = /* @__PURE__ */ Symbol.for("vuetify:selection-control-group"), Wl = j({
+  color: String,
+  disabled: {
+    type: Boolean,
+    default: null
+  },
+  defaultsTarget: String,
+  error: Boolean,
+  id: String,
+  inline: Boolean,
+  falseIcon: be,
+  trueIcon: be,
+  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: We
+  },
+  ...pe(),
+  ...dt(),
+  ...Ne()
+}, "SelectionControlGroup"), ia = j({
+  ...Wl({
+    defaultsTarget: "VSelectionControl"
+  })
+}, "VSelectionControlGroup");
+oe()({
+  name: "VSelectionControlGroup",
+  props: ia(),
+  emits: {
+    "update:modelValue": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    const n = we(e, "modelValue"), l = je(), i = T(() => e.id || `v-selection-control-group-${l}`), c = T(() => e.name || i.value), s = /* @__PURE__ */ new Set();
+    return Ue(Gl, {
+      modelValue: n,
+      forceUpdate: () => {
+        s.forEach((u) => u());
+      },
+      onForceUpdate: (u) => {
+        s.add(u), nt(() => {
+          s.delete(u);
+        });
+      }
+    }), zt({
+      [e.defaultsTarget]: {
+        color: T(() => e.color),
+        disabled: T(() => e.disabled),
+        density: T(() => e.density),
+        error: T(() => e.error),
+        inline: T(() => e.inline),
+        modelValue: n,
+        multiple: T(() => !!e.multiple || e.multiple == null && Array.isArray(n.value)),
+        name: c,
+        falseIcon: T(() => e.falseIcon),
+        trueIcon: T(() => e.trueIcon),
+        readonly: T(() => e.readonly),
+        ripple: T(() => e.ripple),
+        type: T(() => e.type),
+        valueComparator: T(() => e.valueComparator)
+      }
+    }), ve(() => b("div", {
+      class: ce(["v-selection-control-group", {
+        "v-selection-control-group--inline": e.inline
+      }, e.class]),
+      style: Ie(e.style),
+      role: e.type === "radio" ? "radiogroup" : void 0
+    }, [t.default?.()])), {};
+  }
+});
+const ql = j({
+  label: String,
+  baseColor: String,
+  trueValue: null,
+  falseValue: null,
+  value: null,
+  ...pe(),
+  ...Wl()
+}, "VSelectionControl");
+function ua(e) {
+  const a = Pe(Gl, void 0), {
+    densityClasses: t
+  } = It(e), n = we(e, "modelValue"), l = w(() => e.trueValue !== void 0 ? e.trueValue : e.value !== void 0 ? e.value : !0), i = w(() => e.falseValue !== void 0 ? e.falseValue : !1), c = w(() => !!e.multiple || e.multiple == null && Array.isArray(n.value)), s = w({
+    get() {
+      const g = a ? a.modelValue.value : n.value;
+      return c.value ? De(g).some((y) => e.valueComparator(y, l.value)) : e.valueComparator(g, l.value);
+    },
+    set(g) {
+      if (e.readonly) return;
+      const y = g ? l.value : i.value;
+      let h = y;
+      c.value && (h = g ? [...De(n.value), y] : De(n.value).filter((I) => !e.valueComparator(I, l.value))), a ? a.modelValue.value = h : n.value = h;
+    }
+  }), {
+    textColorClasses: u,
+    textColorStyles: d
+  } = mt(() => {
+    if (!(e.error || e.disabled))
+      return s.value ? e.color : e.baseColor;
+  }), {
+    backgroundColorClasses: o,
+    backgroundColorStyles: r
+  } = wt(() => s.value && !e.error && !e.disabled ? e.color : e.baseColor), m = w(() => s.value ? e.trueIcon : e.falseIcon);
+  return {
+    group: a,
+    densityClasses: t,
+    trueValue: l,
+    falseValue: i,
+    model: s,
+    textColorClasses: u,
+    textColorStyles: d,
+    backgroundColorClasses: o,
+    backgroundColorStyles: r,
+    icon: m
+  };
+}
+const sl = oe()({
+  name: "VSelectionControl",
+  directives: {
+    vRipple: Je
+  },
+  inheritAttrs: !1,
+  props: ql(),
+  emits: {
+    "update:modelValue": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      attrs: t,
+      slots: n
+    } = a;
+    const {
+      group: l,
+      densityClasses: i,
+      icon: c,
+      model: s,
+      textColorClasses: u,
+      textColorStyles: d,
+      backgroundColorClasses: o,
+      backgroundColorStyles: r,
+      trueValue: m
+    } = ua(e), g = je(), y = J(!1), h = J(!1), I = W(), _ = T(() => e.id || `input-${g}`), x = T(() => !e.disabled && !e.readonly);
+    l?.onForceUpdate(() => {
+      I.value && (I.value.checked = s.value);
+    });
+    function k(A) {
+      x.value && (y.value = !0, ot(A.target, ":focus-visible") !== !1 && (h.value = !0));
+    }
+    function B() {
+      y.value = !1, h.value = !1;
+    }
+    function F(A) {
+      A.stopPropagation();
+    }
+    function L(A) {
+      if (!x.value) {
+        I.value && (I.value.checked = s.value);
+        return;
+      }
+      e.readonly && l && Ve(() => l.forceUpdate()), s.value = A.target.checked;
+    }
+    return ve(() => {
+      const A = n.label ? n.label({
+        label: e.label,
+        props: {
+          for: _.value
+        }
+      }) : e.label, [p, M] = wl(t), E = b("input", R({
+        ref: I,
+        checked: s.value,
+        disabled: !!e.disabled,
+        id: _.value,
+        onBlur: B,
+        onFocus: k,
+        onInput: L,
+        "aria-disabled": !!e.disabled,
+        "aria-label": e.label,
+        type: e.type,
+        value: m.value,
+        name: e.name,
+        "aria-checked": e.type === "checkbox" ? s.value : void 0
+      }, M), null);
+      return b("div", R({
+        class: ["v-selection-control", {
+          "v-selection-control--dirty": s.value,
+          "v-selection-control--disabled": e.disabled,
+          "v-selection-control--error": e.error,
+          "v-selection-control--focused": y.value,
+          "v-selection-control--focus-visible": h.value,
+          "v-selection-control--inline": e.inline
+        }, i.value, e.class]
+      }, p, {
+        style: e.style
+      }), [b("div", {
+        class: ce(["v-selection-control__wrapper", u.value]),
+        style: Ie(d.value)
+      }, [n.default?.({
+        backgroundColorClasses: o,
+        backgroundColorStyles: r
+      }), He(b("div", {
+        class: ce(["v-selection-control__input"])
+      }, [n.input?.({
+        model: s,
+        textColorClasses: u,
+        textColorStyles: d,
+        backgroundColorClasses: o,
+        backgroundColorStyles: r,
+        inputNode: E,
+        icon: c.value,
+        props: {
+          onFocus: k,
+          onBlur: B,
+          id: _.value
+        }
+      }) ?? b(de, null, [c.value && f(Se, {
+        key: "icon",
+        icon: c.value
+      }, null), E])]), [[Je, !e.disabled && !e.readonly && e.ripple, null, {
+        center: !0,
+        circle: !0
+      }]])]), A && f(jl, {
+        for: _.value,
+        onClick: F
+      }, {
+        default: () => [A]
+      })]);
+    }), {
+      isFocused: y,
+      input: I
+    };
+  }
+}), sa = j({
+  indeterminate: Boolean,
+  indeterminateIcon: {
+    type: be,
+    default: "$checkboxIndeterminate"
+  },
+  ...ql({
+    falseIcon: "$checkboxOff",
+    trueIcon: "$checkboxOn"
+  })
+}, "VCheckboxBtn"), Jl = oe()({
+  name: "VCheckboxBtn",
+  props: sa(),
+  emits: {
+    "update:modelValue": (e) => !0,
+    "update:indeterminate": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    const n = we(e, "indeterminate"), l = we(e, "modelValue");
+    function i(u) {
+      n.value && (n.value = !1);
+    }
+    const c = T(() => n.value ? e.indeterminateIcon : e.falseIcon), s = T(() => n.value ? e.indeterminateIcon : e.trueIcon);
+    return ve(() => {
+      const u = Ge(sl.filterProps(e), ["modelValue"]);
+      return f(sl, R(u, {
+        modelValue: l.value,
+        "onUpdate:modelValue": [(d) => l.value = d, i],
+        class: ["v-checkbox-btn", e.class],
+        style: e.style,
+        type: "checkbox",
+        falseIcon: c.value,
+        trueIcon: s.value,
+        "aria-checked": n.value ? "mixed" : void 0
+      }), t);
+    }), {};
+  }
+});
+function Ft(e) {
+  const {
+    t: a
+  } = Ze();
+  function t(n) {
+    let {
+      name: l,
+      color: i,
+      ...c
+    } = n;
+    const s = {
+      prepend: "prependAction",
+      prependInner: "prependAction",
+      append: "appendAction",
+      appendInner: "appendAction",
+      clear: "clear"
+    }[l], u = e[`onClick:${l}`];
+    function d(r) {
+      r.key !== "Enter" && r.key !== " " || (r.preventDefault(), r.stopPropagation(), _l(u, new PointerEvent("click", r)));
+    }
+    const o = u && s ? a(`$vuetify.input.${s}`, e.label ?? "") : void 0;
+    return f(Se, R({
+      icon: e[`${l}Icon`],
+      "aria-label": o,
+      onClick: u,
+      onKeydown: d,
+      color: i
+    }, c), null);
+  }
+  return {
+    InputIcon: t
+  };
+}
+const ra = j({
+  active: Boolean,
+  color: String,
+  messages: {
+    type: [Array, String],
+    default: () => []
+  },
+  ...pe(),
+  ..._t({
+    transition: {
+      component: Pl,
+      leaveAbsolute: !0,
+      group: !0
+    }
+  })
+}, "VMessages"), ca = oe()({
+  name: "VMessages",
+  props: ra(),
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    const n = w(() => De(e.messages)), {
+      textColorClasses: l,
+      textColorStyles: i
+    } = mt(() => e.color);
+    return ve(() => f(Xt, {
+      transition: e.transition,
+      tag: "div",
+      class: ce(["v-messages", l.value, e.class]),
+      style: Ie([i.value, e.style])
+    }, {
+      default: () => [e.active && n.value.map((c, s) => b("div", {
+        class: "v-messages__message",
+        key: `${s}-${n.value}`
+      }, [t.message ? t.message({
+        message: c
+      }) : c]))]
+    })), {};
+  }
+}), Xl = j({
+  focused: Boolean,
+  "onUpdate:focused": $e()
+}, "focus");
+function Yl(e) {
+  let a = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : Al();
+  const t = we(e, "focused"), n = T(() => ({
+    [`${a}--focused`]: t.value
+  }));
+  function l() {
+    t.value = !0;
+  }
+  function i() {
+    t.value = !1;
+  }
+  return {
+    focusClasses: n,
+    isFocused: t,
+    focus: l,
+    blur: i
+  };
+}
+const da = /* @__PURE__ */ Symbol.for("vuetify:form");
+function Dt(e) {
+  const a = Pe(da, null);
+  return {
+    ...a,
+    isReadonly: w(() => !!(e?.readonly ?? a?.isReadonly.value)),
+    isDisabled: w(() => !!(e?.disabled ?? a?.isDisabled.value))
+  };
+}
+const va = /* @__PURE__ */ Symbol.for("vuetify:rules");
+function fa(e) {
+  const a = Pe(va, null);
+  if (!e) {
+    if (!a)
+      throw new Error("Could not find Vuetify rules injection");
+    return a.aliases;
+  }
+  return a?.resolve(e) ?? T(e);
+}
+const ma = j({
+  disabled: {
+    type: Boolean,
+    default: null
+  },
+  error: Boolean,
+  errorMessages: {
+    type: [Array, String],
+    default: () => []
+  },
+  maxErrors: {
+    type: [Number, String],
+    default: 1
+  },
+  name: String,
+  label: String,
+  readonly: {
+    type: Boolean,
+    default: null
+  },
+  rules: {
+    type: Array,
+    default: () => []
+  },
+  modelValue: null,
+  validateOn: String,
+  validationValue: null,
+  ...Xl()
+}, "validation");
+function ga(e) {
+  let a = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : Al(), t = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : je();
+  const n = we(e, "modelValue"), l = w(() => e.validationValue === void 0 ? n.value : e.validationValue), i = Dt(e), c = fa(() => e.rules), s = W([]), u = J(!0), d = w(() => !!(De(n.value === "" ? null : n.value).length || De(l.value === "" ? null : l.value).length)), o = w(() => e.errorMessages?.length ? De(e.errorMessages).concat(s.value).slice(0, Math.max(0, Number(e.maxErrors))) : s.value), r = w(() => {
+    let B = (e.validateOn ?? i.validateOn?.value) || "input";
+    B === "lazy" && (B = "input lazy"), B === "eager" && (B = "input eager");
+    const F = new Set(B?.split(" ") ?? []);
+    return {
+      input: F.has("input"),
+      blur: F.has("blur") || F.has("input") || F.has("invalid-input"),
+      invalidInput: F.has("invalid-input"),
+      lazy: F.has("lazy"),
+      eager: F.has("eager")
+    };
+  }), m = w(() => e.error || e.errorMessages?.length ? !1 : e.rules.length ? u.value ? s.value.length || r.value.lazy ? null : !0 : !s.value.length : !0), g = J(!1), y = w(() => ({
+    [`${a}--error`]: m.value === !1,
+    [`${a}--dirty`]: d.value,
+    [`${a}--disabled`]: i.isDisabled.value,
+    [`${a}--readonly`]: i.isReadonly.value
+  })), h = Fl("validation"), I = w(() => e.name ?? N(t));
+  dn(() => {
+    i.register?.({
+      id: I.value,
+      vm: h,
+      validate: k,
+      reset: _,
+      resetValidation: x
+    });
+  }), vn(() => {
+    i.unregister?.(I.value);
+  }), Ye(async () => {
+    r.value.lazy || await k(!r.value.eager), i.update?.(I.value, m.value, o.value);
+  }), $t(() => r.value.input || r.value.invalidInput && m.value === !1, () => {
+    re(l, () => {
+      if (l.value != null)
+        k();
+      else if (e.focused) {
+        const B = re(() => e.focused, (F) => {
+          F || k(), B();
+        });
+      }
+    });
+  }), $t(() => r.value.blur, () => {
+    re(() => e.focused, (B) => {
+      B || k();
+    });
+  }), re([m, o], () => {
+    i.update?.(I.value, m.value, o.value);
+  });
+  async function _() {
+    n.value = null, await Ve(), await x();
+  }
+  async function x() {
+    u.value = !0, r.value.lazy ? s.value = [] : await k(!r.value.eager);
+  }
+  async function k() {
+    let B = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !1;
+    const F = [];
+    g.value = !0;
+    for (const L of c.value) {
+      if (F.length >= Number(e.maxErrors ?? 1))
+        break;
+      const p = await (typeof L == "function" ? L : () => L)(l.value);
+      if (p !== !0) {
+        if (p !== !1 && typeof p != "string") {
+          console.warn(`${p} is not a valid value. Rule functions must return boolean true or a string.`);
+          continue;
+        }
+        F.push(p || "");
+      }
+    }
+    return s.value = F, g.value = !1, u.value = B, s.value;
+  }
+  return {
+    errorMessages: o,
+    isDirty: d,
+    isDisabled: i.isDisabled,
+    isReadonly: i.isReadonly,
+    isPristine: u,
+    isValid: m,
+    isValidating: g,
+    reset: _,
+    resetValidation: x,
+    validate: k,
+    validationClasses: y
+  };
+}
+const Ql = j({
+  id: String,
+  appendIcon: be,
+  baseColor: String,
+  centerAffix: {
+    type: Boolean,
+    default: !0
+  },
+  color: String,
+  glow: Boolean,
+  iconColor: [Boolean, String],
+  prependIcon: be,
+  hideDetails: [Boolean, String],
+  hideSpinButtons: Boolean,
+  hint: String,
+  persistentHint: Boolean,
+  messages: {
+    type: [Array, String],
+    default: () => []
+  },
+  direction: {
+    type: String,
+    default: "horizontal",
+    validator: (e) => ["horizontal", "vertical"].includes(e)
+  },
+  "onClick:prepend": $e(),
+  "onClick:append": $e(),
+  ...pe(),
+  ...dt(),
+  ...Vn(ft(), ["maxWidth", "minWidth", "width"]),
+  ...Ne(),
+  ...ma()
+}, "VInput"), rl = oe()({
+  name: "VInput",
+  props: {
+    ...Ql()
+  },
+  emits: {
+    "update:modelValue": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      attrs: t,
+      slots: n,
+      emit: l
+    } = a;
+    const {
+      densityClasses: i
+    } = It(e), {
+      dimensionStyles: c
+    } = vt(e), {
+      themeClasses: s
+    } = Qe(e), {
+      rtlClasses: u
+    } = xt(), {
+      InputIcon: d
+    } = Ft(e), o = je(), r = w(() => e.id || `input-${o}`), {
+      errorMessages: m,
+      isDirty: g,
+      isDisabled: y,
+      isReadonly: h,
+      isPristine: I,
+      isValid: _,
+      isValidating: x,
+      reset: k,
+      resetValidation: B,
+      validate: F,
+      validationClasses: L
+    } = ga(e, "v-input", r), A = w(() => e.errorMessages?.length || !I.value && m.value.length ? m.value : e.hint && (e.persistentHint || e.focused) ? e.hint : e.messages), p = T(() => A.value.length > 0), M = T(() => !e.hideDetails || e.hideDetails === "auto" && (p.value || !!n.details)), E = w(() => M.value ? `${r.value}-messages` : void 0), q = w(() => ({
+      id: r,
+      messagesId: E,
+      isDirty: g,
+      isDisabled: y,
+      isReadonly: h,
+      isPristine: I,
+      isValid: _,
+      isValidating: x,
+      hasDetails: M,
+      reset: k,
+      resetValidation: B,
+      validate: F
+    })), te = T(() => e.error || e.disabled ? void 0 : e.focused ? e.color : e.baseColor), ee = T(() => {
+      if (e.iconColor)
+        return e.iconColor === !0 ? te.value : e.iconColor;
+    });
+    return ve(() => {
+      const U = !!(n.prepend || e.prependIcon), z = !!(n.append || e.appendIcon);
+      return b("div", {
+        class: ce(["v-input", `v-input--${e.direction}`, {
+          "v-input--center-affix": e.centerAffix,
+          "v-input--focused": e.focused,
+          "v-input--glow": e.glow,
+          "v-input--hide-spin-buttons": e.hideSpinButtons
+        }, i.value, s.value, u.value, L.value, e.class]),
+        style: Ie([c.value, e.style])
+      }, [U && b("div", {
+        key: "prepend",
+        class: "v-input__prepend"
+      }, [n.prepend ? n.prepend(q.value) : e.prependIcon && f(d, {
+        key: "prepend-icon",
+        name: "prepend",
+        color: ee.value
+      }, null)]), n.default && b("div", {
+        class: "v-input__control"
+      }, [n.default?.(q.value)]), z && b("div", {
+        key: "append",
+        class: "v-input__append"
+      }, [n.append ? n.append(q.value) : e.appendIcon && f(d, {
+        key: "append-icon",
+        name: "append",
+        color: ee.value
+      }, null)]), M.value && b("div", {
+        id: E.value,
+        class: "v-input__details",
+        role: "alert",
+        "aria-live": "polite"
+      }, [f(ca, {
+        active: p.value,
+        messages: A.value
+      }, {
+        message: n.message
+      }), n.details?.(q.value)])]);
+    }), {
+      reset: k,
+      resetValidation: B,
+      validate: F,
+      isValid: _,
+      errorMessages: m
+    };
+  }
+}), ya = j({
+  active: Boolean,
+  disabled: Boolean,
+  max: [Number, String],
+  value: {
+    type: [Number, String],
+    default: 0
+  },
+  ...pe(),
+  ..._t({
+    transition: {
+      component: Pl
+    }
+  })
+}, "VCounter"), ha = oe()({
+  name: "VCounter",
+  functional: !0,
+  props: ya(),
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    const n = T(() => e.max ? `${e.value} / ${e.max}` : String(e.value));
+    return ve(() => f(Xt, {
+      transition: e.transition
+    }, {
+      default: () => [He(b("div", {
+        class: ce(["v-counter", {
+          "text-error": e.max && !e.disabled && parseFloat(e.value) > parseFloat(e.max)
+        }, e.class]),
+        style: Ie(e.style)
+      }, [t.default ? t.default({
+        counter: n.value,
+        max: e.max,
+        value: e.value
+      }) : n.value]), [[Ct, e.active]])]
+    })), {};
+  }
+}), ba = j({
+  floating: Boolean,
+  ...pe()
+}, "VFieldLabel"), ht = oe()({
+  name: "VFieldLabel",
+  props: ba(),
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    return ve(() => f(jl, {
+      class: ce(["v-field-label", {
+        "v-field-label--floating": e.floating
+      }, e.class]),
+      style: Ie(e.style)
+    }, t)), {};
+  }
+}), pa = ["underlined", "outlined", "filled", "solo", "solo-inverted", "solo-filled", "plain"], Zl = j({
+  appendInnerIcon: be,
+  bgColor: String,
+  clearable: Boolean,
+  clearIcon: {
+    type: be,
+    default: "$clear"
+  },
+  active: Boolean,
+  centerAffix: {
+    type: Boolean,
+    default: void 0
+  },
+  color: String,
+  baseColor: String,
+  dirty: Boolean,
+  disabled: {
+    type: Boolean,
+    default: null
+  },
+  glow: Boolean,
+  error: Boolean,
+  flat: Boolean,
+  iconColor: [Boolean, String],
+  label: String,
+  persistentClear: Boolean,
+  prependInnerIcon: be,
+  reverse: Boolean,
+  singleLine: Boolean,
+  variant: {
+    type: String,
+    default: "filled",
+    validator: (e) => pa.includes(e)
+  },
+  "onClick:clear": $e(),
+  "onClick:appendInner": $e(),
+  "onClick:prependInner": $e(),
+  ...pe(),
+  ...Bl(),
+  ...ct(),
+  ...Ne()
+}, "VField"), cl = oe()({
+  name: "VField",
+  inheritAttrs: !1,
+  props: {
+    id: String,
+    details: Boolean,
+    labelId: String,
+    ...Xl(),
+    ...Zl()
+  },
+  emits: {
+    "update:focused": (e) => !0,
+    "update:modelValue": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      attrs: t,
+      emit: n,
+      slots: l
+    } = a;
+    const {
+      themeClasses: i
+    } = Qe(e), {
+      loaderClasses: c
+    } = Dl(e), {
+      focusClasses: s,
+      isFocused: u,
+      focus: d,
+      blur: o
+    } = Yl(e), {
+      InputIcon: r
+    } = Ft(e), {
+      roundedClasses: m
+    } = rt(e), {
+      rtlClasses: g
+    } = xt(), y = T(() => e.dirty || e.active), h = T(() => !!(e.label || l.label)), I = T(() => !e.singleLine && h.value), _ = je(), x = w(() => e.id || `input-${_}`), k = T(() => e.details ? `${x.value}-messages` : void 0), B = W(), F = W(), L = W(), A = w(() => ["plain", "underlined"].includes(e.variant)), p = w(() => e.error || e.disabled ? void 0 : y.value && u.value ? e.color : e.baseColor), M = w(() => {
+      if (!(!e.iconColor || e.glow && !u.value))
+        return e.iconColor === !0 ? p.value : e.iconColor;
+    }), {
+      backgroundColorClasses: E,
+      backgroundColorStyles: q
+    } = wt(() => e.bgColor), {
+      textColorClasses: te,
+      textColorStyles: ee
+    } = mt(p);
+    re(y, (X) => {
+      if (I.value && !gl()) {
+        const ne = B.value.$el, D = F.value.$el;
+        requestAnimationFrame(() => {
+          const O = xn(ne), S = D.getBoundingClientRect(), v = S.x - O.x, P = S.y - O.y - (O.height / 2 - S.height / 2), V = S.width / 0.75, $ = Math.abs(V - O.width) > 1 ? {
+            maxWidth: lt(V)
+          } : void 0, K = getComputedStyle(ne), ue = getComputedStyle(D), ge = parseFloat(K.transitionDuration) * 1e3 || 150, fe = parseFloat(ue.getPropertyValue("--v-field-label-scale")), _e = ue.getPropertyValue("color");
+          ne.style.visibility = "visible", D.style.visibility = "hidden", In(ne, {
+            transform: `translate(${v}px, ${P}px) scale(${fe})`,
+            color: _e,
+            ...$
+          }, {
+            duration: ge,
+            easing: wn,
+            direction: X ? "normal" : "reverse"
+          }).finished.then(() => {
+            ne.style.removeProperty("visibility"), D.style.removeProperty("visibility");
+          });
+        });
+      }
+    }, {
+      flush: "post"
+    });
+    const U = w(() => ({
+      isActive: y,
+      isFocused: u,
+      controlRef: L,
+      iconColor: M,
+      blur: o,
+      focus: d
+    })), z = T(() => {
+      const X = !y.value;
+      return {
+        "aria-hidden": X,
+        for: X ? void 0 : x.value
+      };
+    }), ie = T(() => {
+      const X = I.value && y.value;
+      return {
+        "aria-hidden": X,
+        for: X ? void 0 : x.value
+      };
+    });
+    function G(X) {
+      X.target !== document.activeElement && X.preventDefault();
+    }
+    return ve(() => {
+      const X = e.variant === "outlined", ne = !!(l["prepend-inner"] || e.prependInnerIcon), D = !!(e.clearable || l.clear) && !e.disabled, O = !!(l["append-inner"] || e.appendInnerIcon || D), S = () => l.label ? l.label({
+        ...U.value,
+        label: e.label,
+        props: {
+          for: x.value
+        }
+      }) : e.label;
+      return b("div", R({
+        class: ["v-field", {
+          "v-field--active": y.value,
+          "v-field--appended": O,
+          "v-field--center-affix": e.centerAffix ?? !A.value,
+          "v-field--disabled": e.disabled,
+          "v-field--dirty": e.dirty,
+          "v-field--error": e.error,
+          "v-field--glow": e.glow,
+          "v-field--flat": e.flat,
+          "v-field--has-background": !!e.bgColor,
+          "v-field--persistent-clear": e.persistentClear,
+          "v-field--prepended": ne,
+          "v-field--reverse": e.reverse,
+          "v-field--single-line": e.singleLine,
+          "v-field--no-label": !S(),
+          [`v-field--variant-${e.variant}`]: !0
+        }, i.value, E.value, s.value, c.value, m.value, g.value, e.class],
+        style: [q.value, e.style],
+        onClick: G
+      }, t), [b("div", {
+        class: "v-field__overlay"
+      }, null), f(Tl, {
+        name: "v-field",
+        active: !!e.loading,
+        color: e.error ? "error" : typeof e.loading == "string" ? e.loading : e.color
+      }, {
+        default: l.loader
+      }), ne && b("div", {
+        key: "prepend",
+        class: "v-field__prepend-inner"
+      }, [l["prepend-inner"] ? l["prepend-inner"](U.value) : e.prependInnerIcon && f(r, {
+        key: "prepend-icon",
+        name: "prependInner",
+        color: M.value
+      }, null)]), b("div", {
+        class: "v-field__field",
+        "data-no-activator": ""
+      }, [["filled", "solo", "solo-inverted", "solo-filled"].includes(e.variant) && I.value && f(ht, R({
+        key: "floating-label",
+        ref: F,
+        class: [te.value],
+        floating: !0
+      }, z.value, {
+        style: ee.value
+      }), {
+        default: () => [S()]
+      }), h.value && f(ht, R({
+        key: "label",
+        ref: B,
+        id: e.labelId
+      }, ie.value), {
+        default: () => [S()]
+      }), l.default?.({
+        ...U.value,
+        props: {
+          id: x.value,
+          class: "v-field__input",
+          "aria-describedby": k.value
+        },
+        focus: d,
+        blur: o
+      }) ?? b("div", {
+        id: x.value,
+        class: "v-field__input",
+        "aria-describedby": k.value
+      }, null)]), D && f(Cl, {
+        key: "clear"
+      }, {
+        default: () => [He(b("div", {
+          class: "v-field__clearable",
+          onMousedown: (v) => {
+            v.preventDefault(), v.stopPropagation();
+          }
+        }, [f(Fe, {
+          defaults: {
+            VIcon: {
+              icon: e.clearIcon
+            }
+          }
+        }, {
+          default: () => [l.clear ? l.clear({
+            ...U.value,
+            props: {
+              onFocus: d,
+              onBlur: o,
+              onClick: e["onClick:clear"],
+              tabindex: -1
+            }
+          }) : f(r, {
+            name: "clear",
+            onFocus: d,
+            onBlur: o,
+            tabindex: -1
+          }, null)]
+        })]), [[Ct, e.dirty]])]
+      }), O && b("div", {
+        key: "append",
+        class: "v-field__append-inner"
+      }, [l["append-inner"] ? l["append-inner"](U.value) : e.appendInnerIcon && f(r, {
+        key: "append-icon",
+        name: "appendInner",
+        color: M.value
+      }, null)]), b("div", {
+        class: ce(["v-field__outline", te.value]),
+        style: Ie(ee.value)
+      }, [X && b(de, null, [b("div", {
+        class: "v-field__outline__start"
+      }, null), I.value && b("div", {
+        class: "v-field__outline__notch"
+      }, [f(ht, R({
+        ref: F,
+        floating: !0
+      }, z.value), {
+        default: () => [S()]
+      })]), b("div", {
+        class: "v-field__outline__end"
+      }, null)]), A.value && I.value && f(ht, R({
+        ref: F,
+        floating: !0
+      }, z.value), {
+        default: () => [S()]
+      })])]);
+    }), {
+      controlRef: L,
+      fieldIconColor: M
+    };
+  }
+}), ka = j({
+  autocomplete: String
+}, "autocomplete");
+function en(e) {
+  const a = je(), t = J(0), n = T(() => e.autocomplete === "suppress"), l = T(() => {
+    if (e.name)
+      return n.value ? `${e.name}-${a}-${t.value}` : e.name;
+  }), i = T(() => n.value ? "off" : e.autocomplete);
+  return {
+    isSuppressing: n,
+    fieldAutocomplete: i,
+    fieldName: l,
+    update: () => t.value = (/* @__PURE__ */ new Date()).getTime()
+  };
+}
+function Sa(e) {
+  function a(t, n) {
+    if (!e.autofocus || !t) return;
+    const l = n[0].target;
+    (l.matches("input,textarea") ? l : l.querySelector("input,textarea"))?.focus();
+  }
+  return {
+    onIntersect: a
+  };
+}
+const Ca = ["color", "file", "time", "date", "datetime-local", "week", "month"], Tt = j({
+  autofocus: Boolean,
+  counter: [Boolean, Number, String],
+  counterValue: [Number, Function],
+  prefix: String,
+  placeholder: String,
+  persistentPlaceholder: Boolean,
+  persistentCounter: Boolean,
+  suffix: String,
+  role: String,
+  type: {
+    type: String,
+    default: "text"
+  },
+  modelModifiers: Object,
+  ...ka(),
+  ...Ge(Ql(), ["direction"]),
+  ...Zl()
+}, "VTextField"), Ke = oe()({
+  name: "VTextField",
+  directives: {
+    vIntersect: nl
+  },
+  inheritAttrs: !1,
+  props: Tt(),
+  emits: {
+    "click:control": (e) => !0,
+    "mousedown:control": (e) => !0,
+    "update:focused": (e) => !0,
+    "update:modelValue": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      attrs: t,
+      emit: n,
+      slots: l
+    } = a;
+    const i = we(e, "modelValue"), {
+      isFocused: c,
+      focus: s,
+      blur: u
+    } = Yl(e), {
+      onIntersect: d
+    } = Sa(e), o = w(() => typeof e.counterValue == "function" ? e.counterValue(i.value) : typeof e.counterValue == "number" ? e.counterValue : (i.value ?? "").toString().length), r = w(() => {
+      if (t.maxlength) return t.maxlength;
+      if (!(!e.counter || typeof e.counter != "number" && typeof e.counter != "string"))
+        return e.counter;
+    }), m = w(() => ["plain", "underlined"].includes(e.variant)), g = W(), y = W(), h = W(), I = en(e), _ = w(() => Ca.includes(e.type) || e.persistentPlaceholder || c.value || e.active);
+    function x() {
+      I.isSuppressing.value && I.update(), c.value || s(), Ve(() => {
+        h.value !== document.activeElement && h.value?.focus();
+      });
+    }
+    function k(A) {
+      n("mousedown:control", A), A.target !== h.value && (x(), A.preventDefault());
+    }
+    function B(A) {
+      n("click:control", A);
+    }
+    function F(A, p) {
+      A.stopPropagation(), x(), Ve(() => {
+        p(), _l(e["onClick:clear"], A);
+      });
+    }
+    function L(A) {
+      const p = A.target;
+      if (!(e.modelModifiers?.trim && ["text", "search", "password", "tel", "url"].includes(e.type))) {
+        i.value = p.value;
+        return;
+      }
+      const M = p.value, E = p.selectionStart, q = p.selectionEnd;
+      i.value = M, Ve(() => {
+        let te = 0;
+        M.trimStart().length === p.value.length && (te = M.length - p.value.length), E != null && (p.selectionStart = E - te), q != null && (p.selectionEnd = q - te);
+      });
+    }
+    return ve(() => {
+      const A = !!(l.counter || e.counter !== !1 && e.counter != null), p = !!(A || l.details), [M, E] = wl(t), {
+        modelValue: q,
+        ...te
+      } = rl.filterProps(e), ee = cl.filterProps(e);
+      return f(rl, R({
+        ref: g,
+        modelValue: i.value,
+        "onUpdate:modelValue": (U) => i.value = U,
+        class: ["v-text-field", {
+          "v-text-field--prefixed": e.prefix,
+          "v-text-field--suffixed": e.suffix,
+          "v-input--plain-underlined": m.value
+        }, e.class],
+        style: e.style
+      }, M, te, {
+        centerAffix: !m.value,
+        focused: c.value
+      }), {
+        ...l,
+        default: (U) => {
+          let {
+            id: z,
+            isDisabled: ie,
+            isDirty: G,
+            isReadonly: X,
+            isValid: ne,
+            hasDetails: D,
+            reset: O
+          } = U;
+          return f(cl, R({
+            ref: y,
+            onMousedown: k,
+            onClick: B,
+            "onClick:clear": (S) => F(S, O),
+            role: e.role
+          }, Ge(ee, ["onClick:clear"]), {
+            id: z.value,
+            labelId: `${z.value}-label`,
+            active: _.value || G.value,
+            dirty: G.value || e.dirty,
+            disabled: ie.value,
+            focused: c.value,
+            details: D.value,
+            error: ne.value === !1
+          }), {
+            ...l,
+            default: (S) => {
+              let {
+                props: {
+                  class: v,
+                  ...P
+                },
+                controlRef: V
+              } = S;
+              const $ = b("input", R({
+                ref: (K) => h.value = V.value = K,
+                value: i.value,
+                onInput: L,
+                autofocus: e.autofocus,
+                readonly: X.value,
+                disabled: ie.value,
+                name: I.fieldName.value,
+                autocomplete: I.fieldAutocomplete.value,
+                placeholder: e.placeholder,
+                size: 1,
+                role: e.role,
+                type: e.type,
+                onFocus: s,
+                onBlur: u,
+                "aria-labelledby": `${z.value}-label`
+              }, P, E), null);
+              return b(de, null, [e.prefix && b("span", {
+                class: "v-text-field__prefix"
+              }, [b("span", {
+                class: "v-text-field__prefix__text"
+              }, [e.prefix])]), He(l.default ? b("div", {
+                class: ce(v),
+                "data-no-activator": ""
+              }, [l.default({
+                id: z
+              }), $]) : fn($, {
+                class: v
+              }), [[nl, d, null, {
+                once: !0
+              }]]), e.suffix && b("span", {
+                class: "v-text-field__suffix"
+              }, [b("span", {
+                class: "v-text-field__suffix__text"
+              }, [e.suffix])])]);
+            }
+          });
+        },
+        details: p ? (U) => b(de, null, [l.details?.(U), A && b(de, null, [b("span", null, null), f(ha, {
+          active: e.persistentCounter || c.value,
+          value: o.value,
+          max: r.value,
+          disabled: e.disabled
+        }, l.counter)])]) : void 0
+      });
+    }), gt({}, g, y, h);
+  }
+}), Va = j({
+  renderless: Boolean,
+  ...pe()
+}, "VVirtualScrollItem"), xa = oe()({
+  name: "VVirtualScrollItem",
+  inheritAttrs: !1,
+  props: Va(),
+  emits: {
+    "update:height": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      attrs: t,
+      emit: n,
+      slots: l
+    } = a;
+    const {
+      resizeRef: i,
+      contentRect: c
+    } = kt(void 0, "border");
+    re(() => c.value?.height, (s) => {
+      s != null && n("update:height", s);
+    }), ve(() => e.renderless ? b(de, null, [l.default?.({
+      itemRef: i
+    })]) : b("div", R({
+      ref: i,
+      class: ["v-virtual-scroll__item", e.class],
+      style: e.style
+    }, t), [l.default?.()]));
+  }
+}), Ia = -1, wa = 1, Et = 100, _a = j({
+  itemHeight: {
+    type: [Number, String],
+    default: null
+  },
+  itemKey: {
+    type: [String, Array, Function],
+    default: null
+  },
+  height: [Number, String]
+}, "virtual");
+function Pa(e, a) {
+  const t = yl(), n = J(0);
+  Rt(() => {
+    n.value = parseFloat(e.itemHeight || 0);
+  });
+  const l = J(0), i = J(Math.ceil(
+    // Assume 16px items filling the entire screen height if
+    // not provided. This is probably incorrect but it minimises
+    // the chance of ending up with empty space at the bottom.
+    // The default value is set here to avoid poisoning getSize()
+    (parseInt(e.height) || t.height.value) / (n.value || 16)
+  ) || 1), c = J(0), s = J(0), u = W(), d = W();
+  let o = 0;
+  const {
+    resizeRef: r,
+    contentRect: m
+  } = kt();
+  Rt(() => {
+    r.value = u.value;
+  });
+  const g = w(() => u.value === document.documentElement ? t.height.value : m.value?.height || parseInt(e.height) || 0), y = w(() => !!(u.value && d.value && g.value && n.value));
+  let h = Array.from({
+    length: a.value.length
+  }), I = Array.from({
+    length: a.value.length
+  });
+  const _ = J(0);
+  let x = -1;
+  function k(D) {
+    return h[D] || n.value;
+  }
+  const B = _n(() => {
+    const D = performance.now();
+    I[0] = 0;
+    const O = a.value.length;
+    for (let S = 1; S <= O; S++)
+      I[S] = (I[S - 1] || 0) + k(S - 1);
+    _.value = Math.max(_.value, performance.now() - D);
+  }, _), F = re(y, (D) => {
+    D && (F(), o = d.value.offsetTop, B.immediate(), ie(), ~x && Ve(() => {
+      at && window.requestAnimationFrame(() => {
+        X(x), x = -1;
+      });
+    }));
+  });
+  nt(() => {
+    B.clear();
+  });
+  function L(D, O) {
+    const S = h[D], v = n.value;
+    n.value = v ? Math.min(n.value, O) : O, (S !== O || v !== n.value) && (h[D] = O, B());
+  }
+  function A(D) {
+    D = Me(D, 0, a.value.length);
+    const O = Math.floor(D), S = D % 1, v = O + 1, P = I[O] || 0, V = I[v] || P;
+    return P + (V - P) * S;
+  }
+  function p(D) {
+    return Aa(I, D);
+  }
+  let M = 0, E = 0, q = 0;
+  re(g, (D, O) => {
+    ie(), D < O && requestAnimationFrame(() => {
+      E = 0, ie();
+    });
+  });
+  let te = -1;
+  function ee() {
+    if (!u.value || !d.value) return;
+    const D = u.value.scrollTop, O = performance.now();
+    O - q > 500 ? (E = Math.sign(D - M), o = d.value.offsetTop) : E = D - M, M = D, q = O, window.clearTimeout(te), te = window.setTimeout(U, 500), ie();
+  }
+  function U() {
+    !u.value || !d.value || (E = 0, q = 0, window.clearTimeout(te), ie());
+  }
+  let z = -1;
+  function ie() {
+    cancelAnimationFrame(z), z = requestAnimationFrame(G);
+  }
+  function G() {
+    if (!u.value || !g.value || !n.value) return;
+    const D = M - o, O = Math.sign(E), S = Math.max(0, D - Et), v = Me(p(S), 0, a.value.length), P = D + g.value + Et, V = Me(p(P) + 1, v + 1, a.value.length);
+    if (
+      // Only update the side we're scrolling towards,
+      // the other side will be updated incidentally
+      (O !== Ia || v < l.value) && (O !== wa || V > i.value)
+    ) {
+      const $ = A(l.value) - A(v), K = A(V) - A(i.value);
+      Math.max($, K) > Et ? (l.value = v, i.value = V) : (v <= 0 && (l.value = v), V >= a.value.length && (i.value = V));
+    }
+    c.value = A(l.value), s.value = A(a.value.length) - A(i.value);
+  }
+  function X(D) {
+    const O = A(D);
+    !u.value || D && !O ? x = D : u.value.scrollTop = O;
+  }
+  const ne = w(() => a.value.slice(l.value, i.value).map((D, O) => {
+    const S = O + l.value;
+    return {
+      raw: D,
+      index: S,
+      key: El(D, e.itemKey, S)
+    };
+  }));
+  return re(a, () => {
+    h = Array.from({
+      length: a.value.length
+    }), I = Array.from({
+      length: a.value.length
+    }), B.immediate(), ie();
+  }, {
+    deep: 1
+  }), {
+    calculateVisibleItems: ie,
+    containerRef: u,
+    markerRef: d,
+    computedItems: ne,
+    paddingTop: c,
+    paddingBottom: s,
+    scrollToIndex: X,
+    handleScroll: ee,
+    handleScrollend: U,
+    handleItemResize: L
+  };
+}
+function Aa(e, a) {
+  let t = e.length - 1, n = 0, l = 0, i = null, c = -1;
+  if (e[t] < a)
+    return t;
+  for (; n <= t; )
+    if (l = n + t >> 1, i = e[l], i > a)
+      t = l - 1;
+    else if (i < a)
+      c = l, n = l + 1;
+    else return i === a ? l : n;
+  return c;
+}
+const Fa = j({
+  items: {
+    type: Array,
+    default: () => []
+  },
+  renderless: Boolean,
+  ..._a(),
+  ...pe(),
+  ...ft()
+}, "VVirtualScroll"), tn = oe()({
+  name: "VVirtualScroll",
+  props: Fa(),
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    const n = Fl("VVirtualScroll"), {
+      dimensionStyles: l
+    } = vt(e), {
+      calculateVisibleItems: i,
+      containerRef: c,
+      markerRef: s,
+      handleScroll: u,
+      handleScrollend: d,
+      handleItemResize: o,
+      scrollToIndex: r,
+      paddingTop: m,
+      paddingBottom: g,
+      computedItems: y
+    } = Pa(e, T(() => e.items));
+    return $t(() => e.renderless, () => {
+      function h() {
+        const _ = (arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !1) ? "addEventListener" : "removeEventListener";
+        c.value === document.documentElement ? (document[_]("scroll", u, {
+          passive: !0
+        }), document[_]("scrollend", d)) : (c.value?.[_]("scroll", u, {
+          passive: !0
+        }), c.value?.[_]("scrollend", d));
+      }
+      Ye(() => {
+        c.value = Pn(n.vnode.el, !0), h(!0);
+      }), nt(h);
+    }), ve(() => {
+      const h = y.value.map((I) => f(xa, {
+        key: I.key,
+        renderless: e.renderless,
+        "onUpdate:height": (_) => o(I.index, _)
+      }, {
+        default: (_) => t.default?.({
+          item: I.raw,
+          index: I.index,
+          ..._
+        })
+      }));
+      return e.renderless ? b(de, null, [b("div", {
+        ref: s,
+        class: "v-virtual-scroll__spacer",
+        style: {
+          paddingTop: lt(m.value)
+        }
+      }, null), h, b("div", {
+        class: "v-virtual-scroll__spacer",
+        style: {
+          paddingBottom: lt(g.value)
+        }
+      }, null)]) : b("div", {
+        ref: c,
+        class: ce(["v-virtual-scroll", e.class]),
+        onScrollPassive: u,
+        onScrollend: d,
+        style: Ie([l.value, e.style])
+      }, [b("div", {
+        ref: s,
+        class: "v-virtual-scroll__container",
+        style: {
+          paddingTop: lt(m.value),
+          paddingBottom: lt(g.value)
+        }
+      }, [h])]);
+    }), {
+      calculateVisibleItems: i,
+      scrollToIndex: r
+    };
+  }
+});
+function ln(e, a) {
+  const t = J(!1);
+  let n;
+  function l(s) {
+    cancelAnimationFrame(n), t.value = !0, n = requestAnimationFrame(() => {
+      n = requestAnimationFrame(() => {
+        t.value = !1;
+      });
+    });
+  }
+  async function i() {
+    await new Promise((s) => requestAnimationFrame(s)), await new Promise((s) => requestAnimationFrame(s)), await new Promise((s) => requestAnimationFrame(s)), await new Promise((s) => {
+      if (t.value) {
+        const u = re(t, () => {
+          u(), s();
+        });
+      } else s();
+    });
+  }
+  async function c(s) {
+    if (s.key === "Tab" && a.value?.focus(), !["PageDown", "PageUp", "Home", "End"].includes(s.key)) return;
+    const u = e.value?.$el;
+    if (!u) return;
+    (s.key === "Home" || s.key === "End") && u.scrollTo({
+      top: s.key === "Home" ? 0 : u.scrollHeight,
+      behavior: "smooth"
+    }), await i();
+    const d = u.querySelectorAll(":scope > :not(.v-virtual-scroll__spacer)");
+    if (s.key === "PageDown" || s.key === "Home") {
+      const o = u.getBoundingClientRect().top;
+      for (const r of d)
+        if (r.getBoundingClientRect().top >= o) {
+          r.focus();
+          break;
+        }
+    } else {
+      const o = u.getBoundingClientRect().bottom;
+      for (const r of [...d].reverse())
+        if (r.getBoundingClientRect().bottom <= o) {
+          r.focus();
+          break;
+        }
+    }
+  }
+  return {
+    onScrollPassive: l,
+    onKeydown: c
+  };
+}
+const Da = j({
+  closeText: {
+    type: String,
+    default: "$vuetify.close"
+  },
+  openText: {
+    type: String,
+    default: "$vuetify.open"
+  }
+}, "autocomplete");
+function nn(e, a) {
+  const t = je(), n = w(() => `menu-${t}`), l = T(() => mn(a)), i = T(() => n.value);
+  return {
+    menuId: n,
+    ariaExpanded: l,
+    ariaControls: i
+  };
+}
+const an = j({
+  chips: Boolean,
+  closableChips: Boolean,
+  eager: Boolean,
+  hideNoData: Boolean,
+  hideSelected: Boolean,
+  listProps: {
+    type: Object
+  },
+  menu: Boolean,
+  menuIcon: {
+    type: be,
+    default: "$dropdown"
+  },
+  menuProps: {
+    type: Object
+  },
+  multiple: Boolean,
+  noDataText: {
+    type: String,
+    default: "$vuetify.noDataText"
+  },
+  openOnClear: Boolean,
+  itemColor: String,
+  noAutoScroll: Boolean,
+  ...Da(),
+  ...Fn({
+    itemChildren: !1
+  })
+}, "Select"), Ta = j({
+  ...an(),
+  ...Ge(Tt({
+    modelValue: null,
+    role: "combobox"
+  }), ["validationValue", "dirty"]),
+  ..._t({
+    transition: {
+      component: Nl
+    }
+  })
+}, "VSelect"), Co = oe()({
+  name: "VSelect",
+  props: Ta(),
+  emits: {
+    "update:focused": (e) => !0,
+    "update:modelValue": (e) => !0,
+    "update:menu": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    const {
+      t: n
+    } = Ze(), l = W(), i = W(), c = W(), {
+      items: s,
+      transformIn: u,
+      transformOut: d
+    } = Ol(e), o = we(e, "modelValue", [], (V) => u(V === null ? [null] : De(V)), (V) => {
+      const $ = d(V);
+      return e.multiple ? $ : $[0] ?? null;
+    }), r = w(() => typeof e.counterValue == "function" ? e.counterValue(o.value) : typeof e.counterValue == "number" ? e.counterValue : o.value.length), m = Dt(e), g = en(e), y = w(() => o.value.map((V) => V.value)), h = J(!1), I = T(() => e.closableChips && !m.isReadonly.value && !m.isDisabled.value), {
+      InputIcon: _
+    } = Ft(e);
+    let x = "", k = 0, B;
+    const F = w(() => e.hideSelected ? s.value.filter((V) => !o.value.some(($) => (e.valueComparator || We)($, V))) : s.value), L = w(() => e.hideNoData && !F.value.length || m.isReadonly.value || m.isDisabled.value), A = we(e, "menu"), p = w({
+      get: () => A.value,
+      set: (V) => {
+        A.value && !V && i.value?.ΨopenChildren.size || V && L.value || (A.value = V);
+      }
+    }), {
+      menuId: M,
+      ariaExpanded: E,
+      ariaControls: q
+    } = nn(e, p), te = w(() => ({
+      ...e.menuProps,
+      activatorProps: {
+        ...e.menuProps?.activatorProps || {},
+        "aria-haspopup": "listbox"
+        // Set aria-haspopup to 'listbox'
+      }
+    })), ee = W(), U = ln(ee, l);
+    function z(V) {
+      e.openOnClear && (p.value = !0);
+    }
+    function ie() {
+      L.value || (p.value = !p.value);
+    }
+    function G(V) {
+      St(V) && X(V);
+    }
+    function X(V) {
+      if (!V.key || m.isReadonly.value) return;
+      if (["Enter", " ", "ArrowDown", "ArrowUp", "Home", "End"].includes(V.key) && V.preventDefault(), ["Enter", "ArrowDown", " "].includes(V.key) && (p.value = !0), ["Escape", "Tab"].includes(V.key) && (p.value = !1), e.clearable && V.key === "Backspace") {
+        V.preventDefault(), o.value = [], z();
+        return;
+      }
+      V.key === "Home" ? ee.value?.focus("first") : V.key === "End" && ee.value?.focus("last");
+      const $ = 1e3;
+      if (!St(V)) return;
+      const K = performance.now();
+      K - B > $ && (x = "", k = 0), x += V.key.toLowerCase(), B = K;
+      const ue = F.value;
+      function ge() {
+        let H = fe();
+        return H || x.at(-1) === x.at(-2) && (x = x.slice(0, -1), k++, H = fe(), H) || (k = 0, H = fe(), H) ? H : (x = V.key.toLowerCase(), fe());
+      }
+      function fe() {
+        for (let H = k; H < ue.length; H++) {
+          const ye = ue[H];
+          if (ye.title.toLowerCase().startsWith(x))
+            return [ye, H];
+        }
+      }
+      const _e = ge();
+      if (!_e) return;
+      const [Y, me] = _e;
+      k = me, ee.value?.focus(me), e.multiple || (o.value = [Y]);
+    }
+    function ne(V) {
+      let $ = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !0;
+      if (!V.props.disabled)
+        if (e.multiple) {
+          const K = o.value.findIndex((ge) => (e.valueComparator || We)(ge.value, V.value)), ue = $ ?? !~K;
+          if (~K) {
+            const ge = ue ? [...o.value, V] : [...o.value];
+            ge.splice(K, 1), o.value = ge;
+          } else ue && (o.value = [...o.value, V]);
+        } else {
+          const K = $ !== !1;
+          o.value = K ? [V] : [], Ve(() => {
+            p.value = !1;
+          });
+        }
+    }
+    function D(V) {
+      ee.value?.$el.contains(V.relatedTarget) || (p.value = !1);
+    }
+    function O() {
+      e.eager && c.value?.calculateVisibleItems();
+    }
+    function S() {
+      h.value && l.value?.focus();
+    }
+    function v(V) {
+      h.value = !0;
+    }
+    function P(V) {
+      if (V == null) o.value = [];
+      else if (ot(l.value, ":autofill") || ot(l.value, ":-webkit-autofill")) {
+        const $ = s.value.find((K) => K.title === V);
+        $ && ne($);
+      } else l.value && (l.value.value = "");
+    }
+    return re(p, () => {
+      if (!e.hideSelected && p.value && o.value.length) {
+        const V = F.value.findIndex(($) => o.value.some((K) => (e.valueComparator || We)(K.value, $.value)));
+        at && !e.noAutoScroll && window.requestAnimationFrame(() => {
+          V >= 0 && c.value?.scrollToIndex(V);
+        });
+      }
+    }), re(s, (V, $) => {
+      p.value || h.value && e.hideNoData && !$.length && V.length && (p.value = !0);
+    }), ve(() => {
+      const V = !!(e.chips || t.chip), $ = !!(!e.hideNoData || F.value.length || t["prepend-item"] || t["append-item"] || t["no-data"]), K = o.value.length > 0, ue = Ke.filterProps(e), ge = K || !h.value && e.label && !e.persistentPlaceholder ? void 0 : e.placeholder;
+      return f(Ke, R({
+        ref: l
+      }, ue, {
+        modelValue: o.value.map((fe) => fe.props.title).join(", "),
+        name: void 0,
+        "onUpdate:modelValue": P,
+        focused: h.value,
+        "onUpdate:focused": (fe) => h.value = fe,
+        validationValue: o.externalValue,
+        counterValue: r.value,
+        dirty: K,
+        class: ["v-select", {
+          "v-select--active-menu": p.value,
+          "v-select--chips": !!e.chips,
+          [`v-select--${e.multiple ? "multiple" : "single"}`]: !0,
+          "v-select--selected": o.value.length,
+          "v-select--selection-slot": !!t.selection
+        }, e.class],
+        style: e.style,
+        inputmode: "none",
+        placeholder: ge,
+        "onClick:clear": z,
+        "onMousedown:control": ie,
+        onBlur: D,
+        onKeydown: X,
+        "aria-expanded": E.value,
+        "aria-controls": q.value
+      }), {
+        ...t,
+        default: (fe) => {
+          let {
+            id: _e
+          } = fe;
+          return b(de, null, [b("select", {
+            hidden: !0,
+            multiple: e.multiple,
+            name: g.fieldName.value
+          }, [s.value.map((Y) => b("option", {
+            key: Y.value,
+            value: Y.value,
+            selected: y.value.includes(Y.value)
+          }, null))]), f(Rl, R({
+            id: M.value,
+            ref: i,
+            modelValue: p.value,
+            "onUpdate:modelValue": (Y) => p.value = Y,
+            activator: "parent",
+            contentClass: "v-select__content",
+            disabled: L.value,
+            eager: e.eager,
+            maxHeight: 310,
+            openOnClick: !1,
+            closeOnContentClick: !1,
+            transition: e.transition,
+            onAfterEnter: O,
+            onAfterLeave: S
+          }, te.value), {
+            default: () => [$ && f(Yt, R({
+              ref: ee,
+              selected: y.value,
+              selectStrategy: e.multiple ? "independent" : "single-independent",
+              onMousedown: (Y) => Y.preventDefault(),
+              onKeydown: G,
+              onFocusin: v,
+              tabindex: "-1",
+              selectable: !!F.value.length,
+              "aria-live": "polite",
+              "aria-labelledby": `${_e.value}-label`,
+              "aria-multiselectable": e.multiple,
+              color: e.itemColor ?? e.color
+            }, U, e.listProps), {
+              default: () => [t["prepend-item"]?.(), !F.value.length && !e.hideNoData && (t["no-data"]?.() ?? f(it, {
+                key: "no-data",
+                title: n(e.noDataText)
+              }, null)), f(tn, {
+                ref: c,
+                renderless: !0,
+                items: F.value,
+                itemKey: "value"
+              }, {
+                default: (Y) => {
+                  let {
+                    item: me,
+                    index: H,
+                    itemRef: ye
+                  } = Y;
+                  const C = An(me.props), Q = R(me.props, {
+                    ref: ye,
+                    key: me.value,
+                    onClick: () => ne(me, null),
+                    "aria-posinset": H + 1,
+                    "aria-setsize": F.value.length
+                  });
+                  return me.type === "divider" ? t.divider?.({
+                    props: me.raw,
+                    index: H
+                  }) ?? f(Le, R(me.props, {
+                    key: `divider-${H}`
+                  }), null) : me.type === "subheader" ? t.subheader?.({
+                    props: me.raw,
+                    index: H
+                  }) ?? f(Ml, R(me.props, {
+                    key: `subheader-${H}`
+                  }), null) : t.item?.({
+                    item: me,
+                    index: H,
+                    props: Q
+                  }) ?? f(it, R(Q, {
+                    role: "option"
+                  }), {
+                    prepend: (Z) => {
+                      let {
+                        isSelected: ae
+                      } = Z;
+                      return b(de, null, [e.multiple && !e.hideSelected ? f(Jl, {
+                        key: me.value,
+                        modelValue: ae,
+                        ripple: !1,
+                        tabindex: "-1",
+                        "aria-hidden": !0,
+                        onClick: (Ce) => Ce.preventDefault()
+                      }, null) : void 0, C.prependAvatar && f(Xe, {
+                        image: C.prependAvatar
+                      }, null), C.prependIcon && f(Se, {
+                        icon: C.prependIcon
+                      }, null)]);
+                    }
+                  });
+                }
+              }), t["append-item"]?.()]
+            })]
+          }), o.value.map((Y, me) => {
+            function H(Z) {
+              Z.stopPropagation(), Z.preventDefault(), ne(Y, !1);
+            }
+            const ye = R(st.filterProps(Y.props), {
+              "onClick:close": H,
+              onKeydown(Z) {
+                Z.key !== "Enter" && Z.key !== " " || (Z.preventDefault(), Z.stopPropagation(), H(Z));
+              },
+              onMousedown(Z) {
+                Z.preventDefault(), Z.stopPropagation();
+              },
+              modelValue: !0,
+              "onUpdate:modelValue": void 0
+            }), C = V ? !!t.chip : !!t.selection, Q = C ? $l(V ? t.chip({
+              item: Y,
+              index: me,
+              props: ye
+            }) : t.selection({
+              item: Y,
+              index: me
+            })) : void 0;
+            if (!(C && !Q))
+              return b("div", {
+                key: Y.value,
+                class: "v-select__selection"
+              }, [V ? t.chip ? f(Fe, {
+                key: "chip-defaults",
+                defaults: {
+                  VChip: {
+                    closable: I.value,
+                    size: "small",
+                    text: Y.title
+                  }
+                }
+              }, {
+                default: () => [Q]
+              }) : f(st, R({
+                key: "chip",
+                closable: I.value,
+                size: "small",
+                text: Y.title,
+                disabled: Y.props.disabled
+              }, ye), null) : Q ?? b("span", {
+                class: "v-select__selection-text"
+              }, [Y.title, e.multiple && me < o.value.length - 1 && b("span", {
+                class: "v-select__selection-comma"
+              }, [vl(",")])])]);
+          })]);
+        },
+        "append-inner": function() {
+          for (var fe = arguments.length, _e = new Array(fe), Y = 0; Y < fe; Y++)
+            _e[Y] = arguments[Y];
+          return b(de, null, [t["append-inner"]?.(..._e), e.menuIcon ? f(Se, {
+            class: "v-select__menu-icon",
+            color: l.value?.fieldIconColor,
+            icon: e.menuIcon,
+            "aria-hidden": !0
+          }, null) : void 0, e.appendInnerIcon && f(_, {
+            key: "append-icon",
+            name: "appendInner",
+            color: _e[0].iconColor.value
+          }, null)]);
+        }
+      });
+    }), gt({
+      isFocused: h,
+      menu: p,
+      select: ne
+    }, l);
+  }
+}), Ba = (e, a, t) => {
+  if (e == null || a == null) return -1;
+  if (!a.length) return 0;
+  e = e.toString().toLocaleLowerCase(), a = a.toString().toLocaleLowerCase();
+  const n = [];
+  let l = e.indexOf(a);
+  for (; ~l; )
+    n.push([l, l + a.length]), l = e.indexOf(a, l + a.length);
+  return n.length ? n : -1;
+};
+function Ot(e, a) {
+  if (!(e == null || typeof e == "boolean" || e === -1))
+    return typeof e == "number" ? [[e, e + a.length]] : Array.isArray(e[0]) ? e : [e];
+}
+const Ea = j({
+  customFilter: Function,
+  customKeyFilter: Object,
+  filterKeys: [Array, String],
+  filterMode: {
+    type: String,
+    default: "intersection"
+  },
+  noFilter: Boolean
+}, "filter");
+function Oa(e, a, t) {
+  const n = [], l = t?.default ?? Ba, i = t?.filterKeys ? De(t.filterKeys) : !1, c = Object.keys(t?.customKeyFilter ?? {}).length;
+  if (!e?.length) return n;
+  let s = null;
+  e: for (let u = 0; u < e.length; u++) {
+    const [d, o = d] = De(e[u]), r = {}, m = {};
+    let g = -1;
+    if ((a || c > 0) && !t?.noFilter) {
+      let y = !1;
+      if (typeof d == "object") {
+        if (d.type === "divider" || d.type === "subheader") {
+          s?.type === "divider" && d.type === "subheader" && n.push(s), s = {
+            index: u,
+            matches: {},
+            type: d.type
+          };
+          continue;
+        }
+        const _ = i || Object.keys(o);
+        y = _.length === c;
+        for (const x of _) {
+          const k = El(o, x), B = t?.customKeyFilter?.[x];
+          if (g = B ? B(k, a, d) : l(k, a, d), g !== -1 && g !== !1)
+            B ? r[x] = Ot(g, a) : m[x] = Ot(g, a);
+          else if (t?.filterMode === "every")
+            continue e;
+        }
+      } else
+        g = l(d, a, d), g !== -1 && g !== !1 && (m.title = Ot(g, a));
+      const h = Object.keys(m).length, I = Object.keys(r).length;
+      if (!h && !I || t?.filterMode === "union" && I !== c && !h || t?.filterMode === "intersection" && (I !== c || !h && c > 0 && !y)) continue;
+    }
+    s && (n.push(s), s = null), n.push({
+      index: u,
+      matches: {
+        ...m,
+        ...r
+      }
+    });
+  }
+  return n;
+}
+function Ra(e, a, t, n) {
+  const l = J([]), i = J(/* @__PURE__ */ new Map()), c = w(() => n?.transform ? N(a).map((u) => [u, n.transform(u)]) : N(a));
+  Rt(() => {
+    const u = typeof t == "function" ? t() : N(t), d = typeof u != "string" && typeof u != "number" ? "" : String(u), o = Oa(c.value, d, {
+      customKeyFilter: {
+        ...e.customKeyFilter,
+        ...N(n?.customKeyFilter)
+      },
+      default: e.customFilter,
+      filterKeys: e.filterKeys,
+      filterMode: e.filterMode,
+      noFilter: e.noFilter
+    }), r = N(a), m = [], g = /* @__PURE__ */ new Map();
+    o.forEach((y) => {
+      let {
+        index: h,
+        matches: I
+      } = y;
+      const _ = r[h];
+      m.push(_), g.set(_.value, I);
+    }), l.value = m, i.value = g;
+  });
+  function s(u) {
+    return i.value.get(u.value);
+  }
+  return {
+    filteredItems: l,
+    filteredMatches: i,
+    getMatches: s
+  };
+}
+function Ma(e, a, t) {
+  return t == null || !t.length ? a : t.map((n, l) => {
+    const i = l === 0 ? 0 : t[l - 1][1], c = [b("span", {
+      class: ce(`${e}__unmask`)
+    }, [a.slice(i, n[0])]), b("span", {
+      class: ce(`${e}__mask`)
+    }, [a.slice(n[0], n[1])])];
+    return l === t.length - 1 && c.push(b("span", {
+      class: ce(`${e}__unmask`)
+    }, [a.slice(n[1])])), b(de, null, [c]);
+  });
+}
+const $a = j({
+  autoSelectFirst: {
+    type: [Boolean, String]
+  },
+  clearOnSelect: Boolean,
+  search: String,
+  ...Ea({
+    filterKeys: ["title"]
+  }),
+  ...an(),
+  ...Ge(Tt({
+    modelValue: null,
+    role: "combobox"
+  }), ["validationValue", "dirty"])
+}, "VAutocomplete"), Na = oe()({
+  name: "VAutocomplete",
+  props: $a(),
+  emits: {
+    "update:focused": (e) => !0,
+    "update:search": (e) => !0,
+    "update:modelValue": (e) => !0,
+    "update:menu": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    const {
+      t: n
+    } = Ze(), l = W(), i = J(!1), c = J(!0), s = J(!1), u = W(), d = W(), o = J(-1), r = J(null), {
+      items: m,
+      transformIn: g,
+      transformOut: y
+    } = Ol(e), {
+      textColorClasses: h,
+      textColorStyles: I
+    } = mt(() => l.value?.color), {
+      InputIcon: _
+    } = Ft(e), x = we(e, "search", ""), k = we(e, "modelValue", [], (C) => g(C === null ? [null] : De(C)), (C) => {
+      const Q = y(C);
+      return e.multiple ? Q : Q[0] ?? null;
+    }), B = w(() => typeof e.counterValue == "function" ? e.counterValue(k.value) : typeof e.counterValue == "number" ? e.counterValue : k.value.length), F = Dt(e), {
+      filteredItems: L,
+      getMatches: A
+    } = Ra(e, m, () => r.value ?? (c.value ? "" : x.value)), p = w(() => e.hideSelected && r.value === null ? L.value.filter((C) => !k.value.some((Q) => Q.value === C.value)) : L.value), M = T(() => e.closableChips && !F.isReadonly.value && !F.isDisabled.value), E = w(() => !!(e.chips || t.chip)), q = w(() => E.value || !!t.selection), te = w(() => k.value.map((C) => C.props.value)), ee = w(() => p.value.find((C) => C.type === "item" && !C.props.disabled)), U = w(() => (e.autoSelectFirst === !0 || e.autoSelectFirst === "exact" && x.value === ee.value?.title) && p.value.length > 0 && !c.value && !s.value), z = w(() => e.hideNoData && !p.value.length || F.isReadonly.value || F.isDisabled.value), ie = we(e, "menu"), G = w({
+      get: () => ie.value,
+      set: (C) => {
+        ie.value && !C && u.value?.ΨopenChildren.size || C && z.value || (ie.value = C);
+      }
+    }), {
+      menuId: X,
+      ariaExpanded: ne,
+      ariaControls: D
+    } = nn(e, G), O = W(), S = ln(O, l);
+    function v(C) {
+      e.openOnClear && (G.value = !0), x.value = "";
+    }
+    function P() {
+      z.value || (G.value = !0);
+    }
+    function V(C) {
+      z.value || (i.value && (C.preventDefault(), C.stopPropagation()), G.value = !G.value);
+    }
+    function $(C) {
+      (St(C) || C.key === "Backspace") && l.value?.focus();
+    }
+    function K(C) {
+      if (F.isReadonly.value) return;
+      const Q = l.value?.selectionStart, Z = k.value.length;
+      if (["Enter", "ArrowDown", "ArrowUp"].includes(C.key) && C.preventDefault(), ["Enter", "ArrowDown"].includes(C.key) && (G.value = !0), ["Escape"].includes(C.key) && (G.value = !1), U.value && ["Enter", "Tab"].includes(C.key) && ee.value && !k.value.some((ae) => {
+        let {
+          value: Ce
+        } = ae;
+        return Ce === ee.value.value;
+      }) && ye(ee.value), C.key === "ArrowDown" && U.value && O.value?.focus("next"), ["Backspace", "Delete"].includes(C.key)) {
+        if (!e.multiple && q.value && k.value.length > 0 && !x.value) return ye(k.value[0], !1);
+        if (~o.value) {
+          C.preventDefault();
+          const ae = o.value;
+          ye(k.value[o.value], !1), o.value = ae >= Z - 1 ? Z - 2 : ae;
+        } else C.key === "Backspace" && !x.value && (o.value = Z - 1);
+        return;
+      }
+      if (e.multiple)
+        if (C.key === "ArrowLeft") {
+          if (o.value < 0 && Q && Q > 0) return;
+          const ae = o.value > -1 ? o.value - 1 : Z - 1;
+          if (k.value[ae])
+            o.value = ae;
+          else {
+            const Ce = x.value?.length ?? null;
+            o.value = -1, l.value?.setSelectionRange(Ce, Ce);
+          }
+        } else if (C.key === "ArrowRight") {
+          if (o.value < 0) return;
+          const ae = o.value + 1;
+          k.value[ae] ? o.value = ae : (o.value = -1, l.value?.setSelectionRange(0, 0));
+        } else ~o.value && St(C) && (o.value = -1);
+    }
+    function ue(C) {
+      if (ot(l.value, ":autofill") || ot(l.value, ":-webkit-autofill")) {
+        const Q = m.value.find((Z) => Z.title === C.target.value);
+        Q && ye(Q);
+      }
+    }
+    function ge() {
+      e.eager && d.value?.calculateVisibleItems();
+    }
+    function fe() {
+      i.value && (c.value = !0, l.value?.focus()), r.value = null;
+    }
+    function _e(C) {
+      i.value = !0, setTimeout(() => {
+        s.value = !0;
+      });
+    }
+    function Y(C) {
+      s.value = !1;
+    }
+    function me(C) {
+      (C == null || C === "" && !e.multiple && !q.value) && (k.value = []);
+    }
+    const H = J(!1);
+    function ye(C) {
+      let Q = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !0;
+      if (!(!C || C.props.disabled))
+        if (e.multiple) {
+          const Z = k.value.findIndex((Ce) => (e.valueComparator || We)(Ce.value, C.value)), ae = Q ?? !~Z;
+          if (~Z) {
+            const Ce = ae ? [...k.value, C] : [...k.value];
+            Ce.splice(Z, 1), k.value = Ce;
+          } else ae && (k.value = [...k.value, C]);
+          e.clearOnSelect && (x.value = "");
+        } else {
+          const Z = Q !== !1;
+          k.value = Z ? [C] : [], r.value = c.value ? "" : x.value ?? "", x.value = Z && !q.value ? C.title : "", Ve(() => {
+            G.value = !1, c.value = !0;
+          });
+        }
+    }
+    return re(i, (C, Q) => {
+      C !== Q && (C ? (H.value = !0, x.value = e.multiple || q.value ? "" : String(k.value.at(-1)?.props.title ?? ""), c.value = !0, Ve(() => H.value = !1)) : (!e.multiple && x.value == null && (k.value = []), G.value = !1, !c.value && x.value && (r.value = x.value), x.value = "", o.value = -1));
+    }), re(x, (C) => {
+      !i.value || H.value || (C && (G.value = !0), c.value = !C);
+    }), re(G, (C) => {
+      if (!e.hideSelected && C && k.value.length && c.value) {
+        const Q = p.value.findIndex((Z) => k.value.some((ae) => Z.value === ae.value));
+        at && window.requestAnimationFrame(() => {
+          Q >= 0 && d.value?.scrollToIndex(Q);
+        });
+      }
+      C && (r.value = null);
+    }), re(m, (C, Q) => {
+      G.value || i.value && !Q.length && C.length && (G.value = !0);
+    }), ve(() => {
+      const C = !!(!e.hideNoData || p.value.length || t["prepend-item"] || t["append-item"] || t["no-data"]), Q = k.value.length > 0, Z = Ke.filterProps(e);
+      return f(Ke, R({
+        ref: l
+      }, Z, {
+        modelValue: x.value,
+        "onUpdate:modelValue": [(ae) => x.value = ae, me],
+        focused: i.value,
+        "onUpdate:focused": (ae) => i.value = ae,
+        validationValue: k.externalValue,
+        counterValue: B.value,
+        dirty: Q,
+        onChange: ue,
+        class: ["v-autocomplete", `v-autocomplete--${e.multiple ? "multiple" : "single"}`, {
+          "v-autocomplete--active-menu": G.value,
+          "v-autocomplete--chips": !!e.chips,
+          "v-autocomplete--selection-slot": !!q.value,
+          "v-autocomplete--selecting-index": o.value > -1
+        }, e.class],
+        style: e.style,
+        readonly: F.isReadonly.value,
+        placeholder: Q ? void 0 : e.placeholder,
+        "onClick:clear": v,
+        "onMousedown:control": P,
+        onKeydown: K,
+        "aria-expanded": ne.value,
+        "aria-controls": D.value
+      }), {
+        ...t,
+        default: (ae) => {
+          let {
+            id: Ce
+          } = ae;
+          return b(de, null, [f(Rl, R({
+            id: X.value,
+            ref: u,
+            modelValue: G.value,
+            "onUpdate:modelValue": (he) => G.value = he,
+            activator: "parent",
+            contentClass: "v-autocomplete__content",
+            disabled: z.value,
+            eager: e.eager,
+            maxHeight: 310,
+            openOnClick: !1,
+            closeOnContentClick: !1,
+            onAfterEnter: ge,
+            onAfterLeave: fe
+          }, e.menuProps), {
+            default: () => [C && f(Yt, R({
+              ref: O,
+              filterable: !0,
+              selected: te.value,
+              selectStrategy: e.multiple ? "independent" : "single-independent",
+              onMousedown: (he) => he.preventDefault(),
+              onKeydown: $,
+              onFocusin: _e,
+              onFocusout: Y,
+              tabindex: "-1",
+              selectable: !!p.value.length,
+              "aria-live": "polite",
+              "aria-labelledby": `${Ce.value}-label`,
+              "aria-multiselectable": e.multiple,
+              color: e.itemColor ?? e.color
+            }, S, e.listProps), {
+              default: () => [t["prepend-item"]?.(), !p.value.length && !e.hideNoData && (t["no-data"]?.() ?? f(it, {
+                key: "no-data",
+                title: n(e.noDataText)
+              }, null)), f(tn, {
+                ref: d,
+                renderless: !0,
+                items: p.value,
+                itemKey: "value"
+              }, {
+                default: (he) => {
+                  let {
+                    item: se,
+                    index: Ee,
+                    itemRef: yt
+                  } = he;
+                  const et = R(se.props, {
+                    ref: yt,
+                    key: se.value,
+                    active: U.value && se === ee.value ? !0 : void 0,
+                    onClick: () => ye(se, null),
+                    "aria-posinset": Ee + 1,
+                    "aria-setsize": p.value.length
+                  });
+                  return se.type === "divider" ? t.divider?.({
+                    props: se.raw,
+                    index: Ee
+                  }) ?? f(Le, R(se.props, {
+                    key: `divider-${Ee}`
+                  }), null) : se.type === "subheader" ? t.subheader?.({
+                    props: se.raw,
+                    index: Ee
+                  }) ?? f(Ml, R(se.props, {
+                    key: `subheader-${Ee}`
+                  }), null) : t.item?.({
+                    item: se,
+                    index: Ee,
+                    props: et
+                  }) ?? f(it, R(et, {
+                    role: "option"
+                  }), {
+                    prepend: (tt) => {
+                      let {
+                        isSelected: Ae
+                      } = tt;
+                      return b(de, null, [e.multiple && !e.hideSelected ? f(Jl, {
+                        key: se.value,
+                        modelValue: Ae,
+                        ripple: !1,
+                        tabindex: "-1",
+                        "aria-hidden": !0,
+                        onClick: (cn) => cn.preventDefault()
+                      }, null) : void 0, se.props.prependAvatar && f(Xe, {
+                        image: se.props.prependAvatar
+                      }, null), se.props.prependIcon && f(Se, {
+                        icon: se.props.prependIcon
+                      }, null)]);
+                    },
+                    title: () => c.value ? se.title : Ma("v-autocomplete", se.title, A(se)?.title)
+                  });
+                }
+              }), t["append-item"]?.()]
+            })]
+          }), k.value.map((he, se) => {
+            function Ee(Ae) {
+              Ae.stopPropagation(), Ae.preventDefault(), ye(he, !1);
+            }
+            const yt = R(st.filterProps(he.props), {
+              "onClick:close": Ee,
+              onKeydown(Ae) {
+                Ae.key !== "Enter" && Ae.key !== " " || (Ae.preventDefault(), Ae.stopPropagation(), Ee(Ae));
+              },
+              onMousedown(Ae) {
+                Ae.preventDefault(), Ae.stopPropagation();
+              },
+              modelValue: !0,
+              "onUpdate:modelValue": void 0
+            }), et = E.value ? !!t.chip : !!t.selection, tt = et ? $l(E.value ? t.chip({
+              item: he,
+              index: se,
+              props: yt
+            }) : t.selection({
+              item: he,
+              index: se
+            })) : void 0;
+            if (!(et && !tt))
+              return b("div", {
+                key: he.value,
+                class: ce(["v-autocomplete__selection", se === o.value && ["v-autocomplete__selection--selected", h.value]]),
+                style: Ie(se === o.value ? I.value : {})
+              }, [E.value ? t.chip ? f(Fe, {
+                key: "chip-defaults",
+                defaults: {
+                  VChip: {
+                    closable: M.value,
+                    size: "small",
+                    text: he.title
+                  }
+                }
+              }, {
+                default: () => [tt]
+              }) : f(st, R({
+                key: "chip",
+                closable: M.value,
+                size: "small",
+                text: he.title,
+                disabled: he.props.disabled
+              }, yt), null) : tt ?? b("span", {
+                class: "v-autocomplete__selection-text"
+              }, [he.title, e.multiple && se < k.value.length - 1 && b("span", {
+                class: "v-autocomplete__selection-comma"
+              }, [vl(",")])])]);
+          })]);
+        },
+        "append-inner": function() {
+          for (var ae = arguments.length, Ce = new Array(ae), he = 0; he < ae; he++)
+            Ce[he] = arguments[he];
+          return b(de, null, [t["append-inner"]?.(...Ce), e.menuIcon ? f(Se, {
+            class: "v-autocomplete__menu-icon",
+            color: l.value?.fieldIconColor,
+            icon: e.menuIcon,
+            onMousedown: V,
+            onClick: Dn,
+            "aria-hidden": !0,
+            tabindex: "-1"
+          }, null) : void 0, e.appendInnerIcon && f(_, {
+            key: "append-icon",
+            name: "appendInner",
+            color: Ce[0].iconColor.value
+          }, null)]);
+        }
+      });
+    }), gt({
+      isFocused: i,
+      isPristine: c,
+      menu: G,
+      search: x,
+      filteredItems: L,
+      select: ye
+    }, l);
+  }
+}), La = j({
+  bordered: Boolean,
+  color: String,
+  content: [Number, String],
+  dot: Boolean,
+  floating: Boolean,
+  icon: be,
+  inline: Boolean,
+  label: {
+    type: String,
+    default: "$vuetify.badge"
+  },
+  max: [Number, String],
+  modelValue: {
+    type: Boolean,
+    default: !0
+  },
+  offsetX: [Number, String],
+  offsetY: [Number, String],
+  textColor: String,
+  ...pe(),
+  ...Jt({
+    location: "top end"
+  }),
+  ...ct(),
+  ...Be(),
+  ...Ne(),
+  ..._t({
+    transition: "scale-rotate-transition"
+  }),
+  ...ft()
+}, "VBadge"), Ha = oe()({
+  name: "VBadge",
+  inheritAttrs: !1,
+  props: La(),
+  setup(e, a) {
+    const {
+      backgroundColorClasses: t,
+      backgroundColorStyles: n
+    } = wt(() => e.color), {
+      roundedClasses: l
+    } = rt(e), {
+      t: i
+    } = Ze(), {
+      textColorClasses: c,
+      textColorStyles: s
+    } = mt(() => e.textColor), {
+      themeClasses: u
+    } = Tn(), {
+      locationStyles: d
+    } = qt(e, !0, (r) => (e.floating ? e.dot ? 2 : 4 : e.dot ? 8 : 12) + (["top", "bottom"].includes(r) ? Number(e.offsetY ?? 0) : ["left", "right"].includes(r) ? Number(e.offsetX ?? 0) : 0)), {
+      dimensionStyles: o
+    } = vt(e);
+    return ve(() => {
+      const r = Number(e.content), m = !e.max || isNaN(r) ? e.content : r <= Number(e.max) ? r : `${e.max}+`, [g, y] = Bn(a.attrs, ["aria-atomic", "aria-label", "aria-live", "role", "title"]);
+      return f(e.tag, R({
+        class: ["v-badge", {
+          "v-badge--bordered": e.bordered,
+          "v-badge--dot": e.dot,
+          "v-badge--floating": e.floating,
+          "v-badge--inline": e.inline
+        }, e.class]
+      }, y, {
+        style: e.style
+      }), {
+        default: () => [b("div", {
+          class: "v-badge__wrapper"
+        }, [a.slots.default?.(), f(Xt, {
+          transition: e.transition
+        }, {
+          default: () => [He(b("span", R({
+            class: ["v-badge__badge", u.value, t.value, l.value, c.value],
+            style: [n.value, s.value, o.value, e.inline ? {} : d.value],
+            "aria-atomic": "true",
+            "aria-label": i(e.label, r),
+            "aria-live": "polite",
+            role: "status"
+          }, g), [e.dot ? void 0 : a.slots.badge ? a.slots.badge?.() : e.icon ? f(Se, {
+            icon: e.icon
+          }, null) : m]), [[Ct, e.modelValue]])]
+        })])]
+      });
+    }), {};
+  }
+}), za = j({
+  fullscreen: Boolean,
+  scrollable: Boolean,
+  ...Ge(On({
+    captureFocus: !0,
+    origin: "center center",
+    scrollStrategy: "block",
+    transition: {
+      component: Nl
+    },
+    zIndex: 2400,
+    retainFocus: !0
+  }), ["disableInitialFocus"])
+}, "VDialog"), on = oe()({
+  name: "VDialog",
+  props: za(),
+  emits: {
+    "update:modelValue": (e) => !0,
+    afterEnter: () => !0,
+    afterLeave: () => !0
+  },
+  setup(e, a) {
+    let {
+      emit: t,
+      slots: n
+    } = a;
+    const l = we(e, "modelValue"), {
+      scopeId: i
+    } = En(), c = W();
+    function s() {
+      t("afterEnter"), (e.scrim || e.retainFocus) && c.value?.contentEl && !c.value.contentEl.contains(document.activeElement) && c.value.contentEl.focus({
+        preventScroll: !0
+      });
+    }
+    function u() {
+      t("afterLeave");
+    }
+    return re(l, async (d) => {
+      d || (await Ve(), c.value.activatorEl?.focus({
+        preventScroll: !0
+      }));
+    }), ve(() => {
+      const d = al.filterProps(e), o = R({
+        "aria-haspopup": "dialog"
+      }, e.activatorProps), r = R({
+        tabindex: -1
+      }, e.contentProps);
+      return f(al, R({
+        ref: c,
+        class: ["v-dialog", {
+          "v-dialog--fullscreen": e.fullscreen,
+          "v-dialog--scrollable": e.scrollable
+        }, e.class],
+        style: e.style
+      }, d, {
+        modelValue: l.value,
+        "onUpdate:modelValue": (m) => l.value = m,
+        "aria-modal": "true",
+        activatorProps: o,
+        contentProps: r,
+        height: e.fullscreen ? void 0 : e.height,
+        width: e.fullscreen ? void 0 : e.width,
+        maxHeight: e.fullscreen ? void 0 : e.maxHeight,
+        maxWidth: e.fullscreen ? void 0 : e.maxWidth,
+        role: "dialog",
+        onAfterEnter: s,
+        onAfterLeave: u
+      }, i), {
+        activator: n.activator,
+        default: function() {
+          for (var m = arguments.length, g = new Array(m), y = 0; y < m; y++)
+            g[y] = arguments[y];
+          return f(Fe, {
+            root: "VDialog"
+          }, {
+            default: () => [n.default?.(...g)]
+          });
+        }
+      });
+    }), gt({}, c);
+  }
+}), Ua = j({
+  ...pe(),
+  ...Be()
+}, "VCardActions"), un = oe()({
+  name: "VCardActions",
+  props: Ua(),
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    return zt({
+      VBtn: {
+        slim: !0,
+        variant: "text"
+      }
+    }), ve(() => f(e.tag, {
+      class: ce(["v-card-actions", e.class]),
+      style: Ie(e.style)
+    }, t)), {};
+  }
+}), Ka = j({
+  opacity: [Number, String],
+  ...pe(),
+  ...Be()
+}, "VCardSubtitle"), ja = oe()({
+  name: "VCardSubtitle",
+  props: Ka(),
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    return ve(() => f(e.tag, {
+      class: ce(["v-card-subtitle", e.class]),
+      style: Ie([{
+        "--v-card-subtitle-opacity": e.opacity
+      }, e.style])
+    }, t)), {};
+  }
+}), Zt = Rn("v-card-title"), Ga = j({
+  appendAvatar: String,
+  appendIcon: be,
+  prependAvatar: String,
+  prependIcon: be,
+  subtitle: {
+    type: [String, Number, Boolean],
+    default: void 0
+  },
+  title: {
+    type: [String, Number, Boolean],
+    default: void 0
+  },
+  ...pe(),
+  ...dt(),
+  ...Be()
+}, "VCardItem"), Wa = oe()({
+  name: "VCardItem",
+  props: Ga(),
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    return ve(() => {
+      const n = !!(e.prependAvatar || e.prependIcon), l = !!(n || t.prepend), i = !!(e.appendAvatar || e.appendIcon), c = !!(i || t.append), s = !!(e.title != null || t.title), u = !!(e.subtitle != null || t.subtitle);
+      return f(e.tag, {
+        class: ce(["v-card-item", e.class]),
+        style: Ie(e.style)
+      }, {
+        default: () => [l && b("div", {
+          key: "prepend",
+          class: "v-card-item__prepend"
+        }, [t.prepend ? f(Fe, {
+          key: "prepend-defaults",
+          disabled: !n,
+          defaults: {
+            VAvatar: {
+              density: e.density,
+              image: e.prependAvatar
+            },
+            VIcon: {
+              density: e.density,
+              icon: e.prependIcon
+            }
+          }
+        }, t.prepend) : b(de, null, [e.prependAvatar && f(Xe, {
+          key: "prepend-avatar",
+          density: e.density,
+          image: e.prependAvatar
+        }, null), e.prependIcon && f(Se, {
+          key: "prepend-icon",
+          density: e.density,
+          icon: e.prependIcon
+        }, null)])]), b("div", {
+          class: "v-card-item__content"
+        }, [s && f(Zt, {
+          key: "title"
+        }, {
+          default: () => [t.title?.() ?? bt(e.title)]
+        }), u && f(ja, {
+          key: "subtitle"
+        }, {
+          default: () => [t.subtitle?.() ?? bt(e.subtitle)]
+        }), t.default?.()]), c && b("div", {
+          key: "append",
+          class: "v-card-item__append"
+        }, [t.append ? f(Fe, {
+          key: "append-defaults",
+          disabled: !i,
+          defaults: {
+            VAvatar: {
+              density: e.density,
+              image: e.appendAvatar
+            },
+            VIcon: {
+              density: e.density,
+              icon: e.appendIcon
+            }
+          }
+        }, t.append) : b(de, null, [e.appendIcon && f(Se, {
+          key: "append-icon",
+          density: e.density,
+          icon: e.appendIcon
+        }, null), e.appendAvatar && f(Xe, {
+          key: "append-avatar",
+          density: e.density,
+          image: e.appendAvatar
+        }, null)])])]
+      });
+    }), {};
+  }
+}), qa = j({
+  opacity: [Number, String],
+  ...pe(),
+  ...Be()
+}, "VCardText"), el = oe()({
+  name: "VCardText",
+  props: qa(),
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    return ve(() => f(e.tag, {
+      class: ce(["v-card-text", e.class]),
+      style: Ie([{
+        "--v-card-text-opacity": e.opacity
+      }, e.style])
+    }, t)), {};
+  }
+}), Ja = j({
+  appendAvatar: String,
+  appendIcon: be,
+  disabled: Boolean,
+  flat: Boolean,
+  hover: Boolean,
+  image: String,
+  link: {
+    type: Boolean,
+    default: void 0
+  },
+  prependAvatar: String,
+  prependIcon: be,
+  ripple: {
+    type: [Boolean, Object],
+    default: !0
+  },
+  subtitle: {
+    type: [String, Number, Boolean],
+    default: void 0
+  },
+  text: {
+    type: [String, Number, Boolean],
+    default: void 0
+  },
+  title: {
+    type: [String, Number, Boolean],
+    default: void 0
+  },
+  ...Wt(),
+  ...pe(),
+  ...dt(),
+  ...ft(),
+  ...Gt(),
+  ...Bl(),
+  ...Jt(),
+  ...Il(),
+  ...ct(),
+  ...Vl(),
+  ...Be(),
+  ...Ne(),
+  ...Ut({
+    variant: "elevated"
+  })
+}, "VCard"), sn = oe()({
+  name: "VCard",
+  directives: {
+    vRipple: Je
+  },
+  props: Ja(),
+  setup(e, a) {
+    let {
+      attrs: t,
+      slots: n
+    } = a;
+    const {
+      themeClasses: l
+    } = Qe(e), {
+      borderClasses: i
+    } = Kt(e), {
+      colorClasses: c,
+      colorStyles: s,
+      variantClasses: u
+    } = kl(e), {
+      densityClasses: d
+    } = It(e), {
+      dimensionStyles: o
+    } = vt(e), {
+      elevationClasses: r
+    } = jt(e), {
+      loaderClasses: m
+    } = Dl(e), {
+      locationStyles: g
+    } = qt(e), {
+      positionClasses: y
+    } = xl(e), {
+      roundedClasses: h
+    } = rt(e), I = pl(e, t), _ = J(void 0);
+    return re(() => e.loading, (x, k) => {
+      _.value = !x && typeof k == "string" ? k : typeof x == "boolean" ? void 0 : x;
+    }, {
+      immediate: !0
+    }), ve(() => {
+      const x = e.link !== !1 && I.isLink.value, k = !e.disabled && e.link !== !1 && (e.link || I.isClickable.value), B = x ? "a" : e.tag, F = !!(n.title || e.title != null), L = !!(n.subtitle || e.subtitle != null), A = F || L, p = !!(n.append || e.appendAvatar || e.appendIcon), M = !!(n.prepend || e.prependAvatar || e.prependIcon), E = !!(n.image || e.image), q = A || M || p, te = !!(n.text || e.text != null);
+      return He(f(B, R(I.linkProps, {
+        class: ["v-card", {
+          "v-card--disabled": e.disabled,
+          "v-card--flat": e.flat,
+          "v-card--hover": e.hover && !(e.disabled || e.flat),
+          "v-card--link": k
+        }, l.value, i.value, c.value, d.value, r.value, m.value, y.value, h.value, u.value, e.class],
+        style: [s.value, o.value, g.value, e.style],
+        onClick: k && I.navigate,
+        tabindex: e.disabled ? -1 : void 0
+      }), {
+        default: () => [E && b("div", {
+          key: "image",
+          class: "v-card__image"
+        }, [n.image ? f(Fe, {
+          key: "image-defaults",
+          disabled: !e.image,
+          defaults: {
+            VImg: {
+              cover: !0,
+              src: e.image
+            }
+          }
+        }, n.image) : f(Mn, {
+          key: "image-img",
+          cover: !0,
+          src: e.image
+        }, null)]), f(Tl, {
+          name: "v-card",
+          active: !!e.loading,
+          color: _.value
+        }, {
+          default: n.loader
+        }), q && f(Wa, {
+          key: "item",
+          prependAvatar: e.prependAvatar,
+          prependIcon: e.prependIcon,
+          title: e.title,
+          subtitle: e.subtitle,
+          appendAvatar: e.appendAvatar,
+          appendIcon: e.appendIcon
+        }, {
+          default: n.item,
+          prepend: n.prepend,
+          title: n.title,
+          subtitle: n.subtitle,
+          append: n.append
+        }), te && f(el, {
+          key: "text"
+        }, {
+          default: () => [n.text?.() ?? e.text]
+        }), n.default?.(), n.actions && f(un, null, {
+          default: n.actions
+        }), Sl(k, "v-card")]
+      }), [[Je, k && e.ripple]]);
+    }), {};
+  }
+}), Xa = 50, Ya = 500;
+function Qa(e) {
+  let {
+    toggleUpDown: a
+  } = e, t = -1, n = -1;
+  nt(i);
+  function l(s) {
+    i(), c(s), window.addEventListener("pointerup", i), document.addEventListener("blur", i), t = window.setTimeout(() => {
+      n = window.setInterval(() => c(s), Xa);
+    }, Ya);
+  }
+  function i() {
+    window.clearTimeout(t), window.clearInterval(n), window.removeEventListener("pointerup", i), document.removeEventListener("blur", i);
+  }
+  nt(i);
+  function c(s) {
+    a(s === "up");
+  }
+  return {
+    holdStart: l,
+    holdStop: i
+  };
+}
+const Za = j({
+  controlVariant: {
+    type: String,
+    default: "default"
+  },
+  inset: Boolean,
+  hideInput: Boolean,
+  modelValue: {
+    type: Number,
+    default: null
+  },
+  min: {
+    type: Number,
+    default: Number.MIN_SAFE_INTEGER
+  },
+  max: {
+    type: Number,
+    default: Number.MAX_SAFE_INTEGER
+  },
+  step: {
+    type: Number,
+    default: 1
+  },
+  precision: {
+    type: Number,
+    default: 0
+  },
+  minFractionDigits: {
+    type: Number,
+    default: null
+  },
+  decimalSeparator: {
+    type: String,
+    validator: (e) => !e || e.length === 1
+  },
+  ...Ge(Tt(), ["modelValue", "validationValue"])
+}, "VNumberInput"), eo = oe()({
+  name: "VNumberInput",
+  props: {
+    ...Za()
+  },
+  emits: {
+    "update:focused": (e) => !0,
+    "update:modelValue": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    const n = W(), {
+      holdStart: l,
+      holdStop: i
+    } = Qa({
+      toggleUpDown: q
+    }), c = Dt(e), s = w(() => c.isDisabled.value || c.isReadonly.value), u = J(e.focused), {
+      decimalSeparator: d
+    } = Ze(), o = w(() => e.decimalSeparator?.[0] || d.value);
+    function r(v) {
+      let P = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : e.precision, V = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : !0;
+      const $ = P == null ? String(v) : v.toFixed(P);
+      if (u.value && V)
+        return Number($).toString().replace(".", o.value);
+      if (e.minFractionDigits === null || P !== null && P < e.minFractionDigits)
+        return $.replace(".", o.value);
+      let [K, ue] = $.split(".");
+      return ue = (ue ?? "").padEnd(e.minFractionDigits, "0").replace(new RegExp(`(?<=\\d{${e.minFractionDigits}})0+$`, "g"), ""), [K, ue].filter(Boolean).join(o.value);
+    }
+    const m = we(e, "modelValue", null, (v) => v ?? null, (v) => v == null ? v ?? null : Me(Number(v), e.min, e.max)), g = J(null), y = J(null);
+    re(m, (v) => {
+      u.value && !s.value && Number(g.value?.replace(o.value, ".")) === v || (v == null ? (g.value = null, y.value = null) : isNaN(v) || (g.value = r(v), y.value = Number(g.value.replace(o.value, "."))));
+    }, {
+      immediate: !0
+    });
+    const h = w({
+      get: () => g.value,
+      set(v) {
+        if (v === null || v === "") {
+          m.value = null, g.value = null, y.value = null;
+          return;
+        }
+        const P = Number(v.replace(o.value, "."));
+        isNaN(P) || (g.value = v, y.value = P, P <= e.max && P >= e.min && (m.value = P));
+      }
+    }), I = w(() => {
+      if (y.value === null) return !1;
+      const v = Number(g.value?.replace(o.value, "."));
+      return v !== Me(v, e.min, e.max);
+    }), _ = w(() => s.value ? !1 : (m.value ?? 0) + e.step <= e.max), x = w(() => s.value ? !1 : (m.value ?? 0) - e.step >= e.min), k = w(() => e.hideInput ? "stacked" : e.controlVariant), B = T(() => k.value === "split" ? "$plus" : "$collapse"), F = T(() => k.value === "split" ? "$minus" : "$expand"), L = T(() => k.value === "split" ? "default" : "small"), A = T(() => k.value === "stacked" ? "auto" : "100%"), p = {
+      props: {
+        onClick: U,
+        onPointerup: z,
+        onPointerdown: ie,
+        onPointercancel: z
+      }
+    }, M = {
+      props: {
+        onClick: U,
+        onPointerup: z,
+        onPointerdown: G,
+        onPointercancel: z
+      }
+    };
+    re(() => e.precision, () => ne()), re(() => e.minFractionDigits, () => ne()), Ye(() => {
+      X();
+    });
+    function E(v) {
+      if (v == null) return 0;
+      const P = v.toString(), V = P.indexOf(".");
+      return ~V ? P.length - V : 0;
+    }
+    function q() {
+      let v = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !0;
+      if (s.value) return;
+      if (m.value == null) {
+        h.value = r(Me(0, e.min, e.max));
+        return;
+      }
+      let P = Math.max(E(m.value), E(e.step));
+      e.precision != null && (P = Math.max(P, e.precision)), v ? _.value && (h.value = r(m.value + e.step, P)) : x.value && (h.value = r(m.value - e.step, P));
+    }
+    function te(v) {
+      if (!v.data) return;
+      const P = v.target, {
+        value: V,
+        selectionStart: $,
+        selectionEnd: K
+      } = P ?? {}, ue = V ? V.slice(0, $) + v.data + V.slice(K) : v.data, ge = $n(ue, e.precision, o.value);
+      if (new RegExp(`^-?\\d*${Nn(o.value)}?\\d*$`).test(ue) || (v.preventDefault(), P.value = ge, Ve(() => h.value = ge)), e.precision != null) {
+        if (ue.split(o.value)[1]?.length > e.precision) {
+          v.preventDefault(), P.value = ge, Ve(() => h.value = ge);
+          const fe = ($ ?? 0) + v.data.length;
+          P.setSelectionRange(fe, fe);
+        }
+        e.precision === 0 && ue.endsWith(o.value) && (v.preventDefault(), P.value = ge, Ve(() => h.value = ge));
+      }
+    }
+    async function ee(v) {
+      ["Enter", "ArrowLeft", "ArrowRight", "Backspace", "Delete", "Tab"].includes(v.key) || v.ctrlKey || ["ArrowDown", "ArrowUp"].includes(v.key) && (v.preventDefault(), v.stopPropagation(), X(), await Ve(), v.key === "ArrowDown" ? q(!1) : q());
+    }
+    function U(v) {
+      v.stopPropagation();
+    }
+    function z(v) {
+      v.currentTarget?.releasePointerCapture(v.pointerId), v.preventDefault(), i();
+    }
+    function ie(v) {
+      v.currentTarget?.setPointerCapture(v.pointerId), v.preventDefault(), v.stopPropagation(), l("up");
+    }
+    function G(v) {
+      v.currentTarget?.setPointerCapture(v.pointerId), v.preventDefault(), v.stopPropagation(), l("down");
+    }
+    function X() {
+      if (s.value || !n.value) return;
+      const v = n.value.value, P = Number(v.replace(o.value, "."));
+      v && !isNaN(P) ? h.value = r(Me(P, e.min, e.max)) : h.value = null;
+    }
+    function ne() {
+      s.value || (h.value = m.value !== null && !isNaN(m.value) ? r(m.value, e.precision, !1) : null);
+    }
+    function D() {
+      if (!s.value) {
+        if (m.value === null || isNaN(m.value)) {
+          h.value = null;
+          return;
+        }
+        h.value = m.value.toString().replace(".", o.value);
+      }
+    }
+    function O() {
+      D();
+    }
+    function S() {
+      X();
+    }
+    return ve(() => {
+      const {
+        modelValue: v,
+        type: P,
+        ...V
+      } = Ke.filterProps(e);
+      function $() {
+        return t.increment ? f(Fe, {
+          key: "increment-defaults",
+          defaults: {
+            VBtn: {
+              disabled: !_.value,
+              height: A.value,
+              size: L.value,
+              icon: B.value,
+              variant: "text"
+            }
+          }
+        }, {
+          default: () => [t.increment(p)]
+        }) : f(qe, {
+          "aria-hidden": "true",
+          "data-testid": "increment",
+          disabled: !_.value,
+          height: A.value,
+          icon: B.value,
+          key: "increment-btn",
+          onClick: U,
+          onPointerdown: ie,
+          onPointerup: z,
+          onPointercancel: z,
+          size: L.value,
+          variant: "text",
+          tabindex: "-1"
+        }, null);
+      }
+      function K() {
+        return t.decrement ? f(Fe, {
+          key: "decrement-defaults",
+          defaults: {
+            VBtn: {
+              disabled: !x.value,
+              height: A.value,
+              size: L.value,
+              icon: F.value,
+              variant: "text"
+            }
+          }
+        }, {
+          default: () => [t.decrement(M)]
+        }) : f(qe, {
+          "aria-hidden": "true",
+          "data-testid": "decrement",
+          disabled: !x.value,
+          height: A.value,
+          icon: F.value,
+          key: "decrement-btn",
+          onClick: U,
+          onPointerdown: G,
+          onPointerup: z,
+          onPointercancel: z,
+          size: L.value,
+          variant: "text",
+          tabindex: "-1"
+        }, null);
+      }
+      function ue() {
+        return b("div", {
+          class: "v-number-input__control"
+        }, [K(), f(Le, {
+          vertical: k.value !== "stacked"
+        }, null), $()]);
+      }
+      function ge() {
+        return !e.hideInput && !e.inset ? f(Le, {
+          vertical: !0
+        }, null) : void 0;
+      }
+      const fe = k.value === "split" ? b("div", {
+        class: "v-number-input__control"
+      }, [f(Le, {
+        vertical: !0
+      }, null), $()]) : e.reverse || k.value === "hidden" ? void 0 : b(de, null, [ge(), ue()]), _e = t["append-inner"] || fe, Y = k.value === "split" ? b("div", {
+        class: "v-number-input__control"
+      }, [K(), f(Le, {
+        vertical: !0
+      }, null)]) : e.reverse && k.value !== "hidden" ? b(de, null, [ue(), ge()]) : void 0, me = t["prepend-inner"] || Y;
+      return f(Ke, R({
+        ref: n
+      }, V, {
+        modelValue: h.value,
+        "onUpdate:modelValue": (H) => h.value = H,
+        focused: u.value,
+        "onUpdate:focused": (H) => u.value = H,
+        validationValue: m.value,
+        error: e.error || I.value || void 0,
+        onBeforeinput: te,
+        onFocus: O,
+        onBlur: S,
+        onKeydown: ee,
+        class: ["v-number-input", {
+          "v-number-input--default": k.value === "default",
+          "v-number-input--hide-input": e.hideInput,
+          "v-number-input--inset": e.inset,
+          "v-number-input--reverse": e.reverse,
+          "v-number-input--split": k.value === "split",
+          "v-number-input--stacked": k.value === "stacked"
+        }, e.class],
+        style: e.style,
+        inputmode: "decimal"
+      }), {
+        ...t,
+        "append-inner": _e ? function() {
+          for (var H = arguments.length, ye = new Array(H), C = 0; C < H; C++)
+            ye[C] = arguments[C];
+          return b(de, null, [t["append-inner"]?.(...ye), fe]);
+        } : void 0,
+        "prepend-inner": me ? function() {
+          for (var H = arguments.length, ye = new Array(H), C = 0; C < H; C++)
+            ye[C] = arguments[C];
+          return b(de, null, [Y, t["prepend-inner"]?.(...ye)]);
+        } : void 0
+      });
+    }), gt({}, n);
+  }
+}), to = { class: "text-medium-emphasis ps-2" }, lo = ["id"], no = {
+  __name: "index",
+  props: {
+    modelValue: {},
+    modelModifiers: {}
+  },
+  emits: /* @__PURE__ */ Lt(["closeDialog", "save"], ["update:modelValue"]),
+  setup(e, { emit: a }) {
+    const t = Pe("table_props"), n = Pe("datatablesPluginOptions"), l = Vt(e, "modelValue"), i = a, c = {
+      textfield: Ke,
+      select: Na,
+      number: eo,
+      datepicker: Te(
+        () => import("./Datepicker-CvoUCd6e.js")
+      ),
+      comparison: Te(
+        () => import("./Comparison-C4t1CoQN.js")
+      )
+    }, s = w(() => t.headers.filter((d) => d.advancedFilter !== !1 && !d.hidden)), u = (d) => d ? typeof d == "string" ? c[d] : d : c.textfield;
+    return re(
+      s,
+      (d) => {
+        d.forEach((o) => {
+          const r = o.advancedFilter?.key ?? o.key;
+          Object.hasOwn(l.value, r) || (l.value[r] = {
+            comparison: "=",
+            value: null
+          });
+        });
+      },
+      { immediate: !0 }
+    ), Ye(async () => {
+      await t.options.advancedFilters?.onMounted();
+    }), (d, o) => (le(), ke(sn, { rounded: "lg" }, {
+      default: xe(() => [
+        f(Zt, { class: "d-flex justify-space-between align-center" }, {
+          default: xe(() => [
+            b("div", to, bt(d.$t("$datatables.advancedFilters")), 1),
+            f(qe, {
+              icon: N(n).header.icons.close,
+              variant: "text",
+              onClick: o[0] || (o[0] = (r) => i("closeDialog"))
+            }, null, 8, ["icon"])
+          ]),
+          _: 1
+        }),
+        f(Le),
+        f(el, { class: "overflow-auto pt-8" }, {
+          default: xe(() => [
+            (le(!0), ze(de, null, Ht(N(s), (r, m) => (le(), ze("div", {
+              id: `advanced-filter-${r.key}`,
+              key: `filter-${m}`,
+              class: ce(`advanced-filter advanced-filter--${r.key}`)
+            }, [
+              (le(), ke(Oe(u(r.advancedFilter?.component)), R({
+                modelValue: l.value[r.advancedFilter?.key ?? r.key].value,
+                "onUpdate:modelValue": (g) => l.value[r.advancedFilter?.key ?? r.key].value = g,
+                comparison: l.value[r.advancedFilter?.key ?? r.key].comparison,
+                "onUpdate:comparison": (g) => l.value[r.advancedFilter?.key ?? r.key].comparison = g
+              }, { ref_for: !0 }, r.advancedFilter?.options, {
+                label: r.title,
+                variant: "underlined",
+                clearable: ""
+              }), null, 16, ["modelValue", "onUpdate:modelValue", "comparison", "onUpdate:comparison", "label"]))
+            ], 10, lo))), 128))
+          ]),
+          _: 1
+        }),
+        f(Le, { class: "mt-2" }),
+        f(un, { class: "my-2 d-flex justify-end" }, {
+          default: xe(() => [
+            f(qe, {
+              class: "text-none",
+              text: d.$t("$datatables.cancel"),
+              onClick: o[1] || (o[1] = (r) => i("closeDialog"))
+            }, null, 8, ["text"]),
+            f(qe, {
+              class: "text-none",
+              color: "primary",
+              text: d.$t("$datatables.submit"),
+              variant: "flat",
+              onClick: o[2] || (o[2] = (r) => i("save"))
+            }, null, 8, ["text"])
+          ]),
+          _: 1
+        })
+      ]),
+      _: 1
+    }));
+  }
+};
+function dl(e) {
+  return JSON.parse(JSON.stringify(e));
+}
+function Nt(e, a) {
+  if (e === a) return !0;
+  if (e == null || a == null || typeof e != typeof a) return !1;
+  if (e instanceof Date && a instanceof Date)
+    return e.getTime() === a.getTime();
+  if (e instanceof RegExp && a instanceof RegExp)
+    return e.toString() === a.toString();
+  if (Array.isArray(e) && Array.isArray(a)) {
+    if (e.length !== a.length) return !1;
+    for (let t = 0; t < e.length; t++)
+      if (!Nt(e[t], a[t])) return !1;
+    return !0;
+  }
+  if (typeof e == "object" && typeof a == "object") {
+    const t = Object.keys(e), n = Object.keys(a);
+    if (t.length !== n.length) return !1;
+    for (const l of t) {
+      if (!n.includes(l)) return !1;
+      const i = e[l], c = a[l];
+      if (!Nt(i, c)) return !1;
+    }
+    return !0;
+  }
+  return !1;
+}
+const ao = {
+  __name: "Dialog",
+  props: {
+    modelValue: { required: !0 },
+    modelModifiers: {}
+  },
+  emits: ["update:modelValue"],
+  setup(e) {
+    const a = Pt(), { advancedFiltersState: t } = At(), { setData: n } = a, l = Vt(e, "modelValue"), i = W({}), c = Pe("table_props"), s = Pe("busEmits"), u = () => {
+      const d = Object.entries(i.value).filter(([, o]) => {
+        const r = o.value;
+        return Array.isArray(r) || typeof r == "string" ? r.length > 0 : r != null && r !== "";
+      }).reduce((o, [r, m]) => (o[r] = m, o), {});
+      Nt(d, t.value) || (n({
+        table_id: c.id,
+        name: "advancedFilters",
+        value: { query: dl(d) }
+      }), s("advancedFilters:update", d)), l.value = !1;
+    };
+    return Ye(() => {
+      i.value = dl(t.value);
+    }), (d, o) => {
+      const r = no, m = aa;
+      return le(), ze("div", null, [
+        f(on, {
+          modelValue: l.value,
+          "onUpdate:modelValue": o[1] || (o[1] = (g) => l.value = g),
+          "max-width": "550",
+          "retain-focus": !1
+        }, {
+          default: xe(({ isActive: g }) => [
+            f(r, {
+              modelValue: N(i),
+              "onUpdate:modelValue": o[0] || (o[0] = (y) => pt(i) ? i.value = y : null),
+              onSave: u,
+              onCloseDialog: (y) => g.value = !1
+            }, null, 8, ["modelValue", "onCloseDialog"])
+          ]),
+          _: 1
+        }, 8, ["modelValue"]),
+        Object.keys(N(t)).length ? (le(), ke(m, {
+          key: 0,
+          modelValue: N(i),
+          "onUpdate:modelValue": o[2] || (o[2] = (g) => pt(i) ? i.value = g : null),
+          onSave: u
+        }, null, 8, ["modelValue"])) : Re("", !0)
+      ]);
+    };
+  }
+};
+function oo() {
+  const e = Pe("datatablesPluginOptions"), { t: a } = zn(), { advancedFiltersState: t } = At(), n = W(!1), l = w(() => Object.keys(t.value).length);
+  return { advancedFiltersItems: w(() => [
+    {
+      title: `${a("$datatables.advancedFilters")}`,
+      onClick: () => n.value = !0,
+      prependIcon: e.header.icons.advancedFilters
+    }
+  ]), advancedFiltersDialog: n, activeAdvancedFilters: l };
+}
+const io = /* @__PURE__ */ fl({
+  __name: "index",
+  setup(e) {
+    const { advancedFiltersItems: a, advancedFiltersDialog: t, activeAdvancedFilters: n } = oo();
+    return (l, i) => {
+      const c = ao;
+      return le(), ze("div", null, [
+        (le(!0), ze(de, null, Ht(N(a), (s, u) => (le(), ke(qe, R({
+          key: u,
+          icon: "",
+          variant: "text",
+          color: N(n) ? "primary" : "dark",
+          density: "comfortable"
+        }, { ref_for: !0 }, s), {
+          default: xe(() => [
+            N(n) ? (le(), ke(Ha, {
+              key: 0,
+              color: "primary",
+              content: N(n)
+            }, {
+              default: xe(() => [
+                f(Se, {
+                  icon: s.prependIcon
+                }, null, 8, ["icon"])
+              ]),
+              _: 2
+            }, 1032, ["content"])) : (le(), ke(Se, {
+              key: 1,
+              icon: s.prependIcon
+            }, null, 8, ["icon"]))
+          ]),
+          _: 2
+        }, 1040, ["color"]))), 128)),
+        f(c, {
+          modelValue: N(t),
+          "onUpdate:modelValue": i[0] || (i[0] = (s) => pt(t) ? t.value = s : null)
+        }, null, 8, ["modelValue"])
+      ]);
+    };
+  }
+}), uo = {
+  class: "d-flex align-center",
+  style: { gap: "0.75rem" }
+}, so = { class: "ms-auto" }, ro = /* @__PURE__ */ fl({
+  __name: "index",
+  props: {
+    responsiveHeader: { type: Boolean }
+  },
+  setup(e) {
+    const a = Te(() => import("./Search-DCvbaw38.js")), t = Te(() => import("./RefreshTable-03hYqy0d.js")), n = Te(() => import("./Options-DtOz8dqa.js")), l = Te(() => import("./index-DG3Vs3j9.js")), i = Te(() => import("./index-B_fG3b5A.js")), c = Te(() => import("./index-BTwaqzMN.js")), s = Pe("table_props"), u = W(null), d = s.options?.header?.components ?? {};
+    return (o, r) => {
+      const m = io;
+      return le(), ze("div", uo, [
+        e.responsiveHeader ? Re("", !0) : (le(), ke(m, { key: 0 })),
+        N(s).hardFilters.length ? (le(), ke(Oe(N(d).hardFilters ?? N(l)), {
+          key: 1,
+          id: "header-hardFilters"
+        })) : Re("", !0),
+        (le(), ke(Oe(N(d).toolbar), { id: "header-toolbar" })),
+        b("div", so, [
+          (le(), ke(Oe(N(d).search ?? N(a)), { id: "header-search" })),
+          e.responsiveHeader ? Re("", !0) : (le(), ke(Oe(N(d).columns ?? N(i)), {
+            key: 0,
+            "component-refs": { columns: N(u) }
+          }, null, 8, ["component-refs"])),
+          e.responsiveHeader ? Re("", !0) : (le(), ke(Oe(N(d).download ?? N(c)), { key: 1 })),
+          e.responsiveHeader ? Re("", !0) : (le(), ke(Oe(N(d).refreshTable ?? N(t)), { key: 2 })),
+          (le(), ke(Oe(N(d).options ?? N(n)), { "responsive-header": e.responsiveHeader }, null, 8, ["responsive-header"]))
+        ])
+      ]);
+    };
+  }
+});
+function co(e) {
+  const a = Pt(), { getCurrentTable: t, setTableHash: n, hashString: l } = a, i = W(!1), c = 5, s = w(() => t(e.id));
+  re(
+    s,
+    async (g) => {
+      g.options.hash && await u(g);
+    },
+    {
+      deep: !0
+    }
+  );
+  const u = async (g) => {
+    if (i.value) return;
+    i.value = !0, await Ve();
+    const y = d(), h = y.findIndex(
+      (I) => I.id === e.id
+    );
+    h > -1 ? y[h] = g : y.push(g), localStorage.setItem("datatables-state", JSON.stringify(y)), i.value = !1;
+  }, d = () => {
+    const g = localStorage.getItem("datatables-state");
+    return JSON.parse(g ?? "[]");
+  }, o = () => d().find((h) => h.id === e.id);
+  return {
+    saving: i,
+    dataStateGet: o,
+    tableDataState: s,
+    checkTableState: async () => {
+      const g = localStorage.getItem("datatables-state-v");
+      parseInt(g) !== parseInt(c) && (localStorage.removeItem("datatables-state"), localStorage.setItem("datatables-state-v", c));
+      const h = o()?.options.hash;
+      if (h) {
+        const I = await l(JSON.stringify(e.headers ?? []));
+        h !== I && localStorage.removeItem("datatables-state");
+      }
+      n({ table_id: e.id, headers: e.headers });
+    },
+    deleteDataStorage: () => {
+      localStorage.removeItem("datatables-state"), localStorage.removeItem("datatables-state-v");
+    }
+  };
+}
+const rn = Un(() => {
+  const e = J({}), a = J({});
+  return {
+    storeOptions: {
+      state: e,
+      columns: a
+    },
+    setUserOptions: ({
+      state: l = null,
+      columns: i = null
+    }) => {
+      l && (e.value = l), i && (a.value = i);
+    }
+  };
+}), vo = {
+  key: 0,
+  class: "datatables-v2"
+}, fo = { class: "pe-4" }, mo = {
+  __name: "Blueprint",
+  props: {
+    modelValue: {},
+    modelModifiers: {}
+  },
+  emits: /* @__PURE__ */ Lt(["refreshTable", "refetchData", "advancedFilters:update", "hardFilters:update"], ["update:modelValue"]),
+  setup(e, { expose: a, emit: t }) {
+    const n = Te(() => import("./Table-BdiBnyG7.js")), l = Te(() => import("./TableServer-eOtGylb9.js")), { storeOptions: i } = rn(), { saveTableOptions: c } = At(), s = Vt(e, "modelValue"), u = Pe("table_props"), d = Pe("datatablesPluginOptions"), o = W(null), r = W(!1), m = W(!1), g = W(!1), y = t, h = Pt(), { dataStateGet: I, tableDataState: _, checkTableState: x } = co(u), { addTable: k, restoreData: B } = h, F = W(!1);
+    Kn(o, (A) => {
+      const p = A[0], { width: M } = p.contentRect;
+      F.value = M < 950;
+    });
+    const L = w(() => {
+      const A = u.options?.header;
+      return A === void 0 || typeof A == "object" && A !== null;
+    });
+    return Ye(async () => {
+      k({ table_id: u.id }), await x();
+      const A = I();
+      if (A)
+        B({ table_id: u.id, data: A });
+      else {
+        const M = _.value.options.columns;
+        M.selected = u.headers.filter((E) => !E.hidden).map((E) => E.key), M.sorted = u.headers.map((E) => E.key);
+      }
+      c(Ln(i.state.value, _.value.options.state)), m.value = !0, await Ve(), g.value = !0;
+    }), Ue("busEmits", y), Ue("tableRef", o), Ue("tableState", _), Ue("downloadModal", r), a({ tableRef: o }), (A, p) => {
+      const M = ro;
+      return N(m) ? (le(), ze("div", vo, [
+        f(sn, null, {
+          default: xe(() => [
+            N(L) ? (le(), ke(Zt, { key: 0 }, {
+              default: xe(() => [
+                f(M, { "responsive-header": N(F) }, null, 8, ["responsive-header"])
+              ]),
+              _: 1
+            })) : Re("", !0),
+            f(el, { class: "pa-0" }, {
+              default: xe(() => [
+                N(g) ? (le(), ke(Oe(N(u).api ? N(l) : N(n)), {
+                  key: 0,
+                  ref_key: "tableRef",
+                  ref: o,
+                  modelValue: s.value,
+                  "onUpdate:modelValue": p[0] || (p[0] = (E) => s.value = E)
+                }, null, 8, ["modelValue"])) : Re("", !0)
+              ]),
+              _: 1
+            })
+          ]),
+          _: 1
+        }),
+        f(on, {
+          modelValue: N(r),
+          "onUpdate:modelValue": p[1] || (p[1] = (E) => pt(r) ? r.value = E : null),
+          "max-width": "350",
+          persistent: ""
+        }, {
+          default: xe(() => [
+            f(Yt, {
+              class: "py-2",
+              color: "primary",
+              elevation: "12",
+              rounded: "lg"
+            }, {
+              default: xe(() => [
+                f(it, {
+                  "prepend-icon": N(d).header.icons.download,
+                  title: A.$t("$datatables.preparing_download_file")
+                }, {
+                  prepend: xe(() => [
+                    b("div", fo, [
+                      f(Se, {
+                        color: "primary",
+                        size: "x-large"
+                      })
+                    ])
+                  ]),
+                  append: xe(() => [
+                    f(Hn, {
+                      color: "primary",
+                      indeterminate: "disable-shrink",
+                      size: "16",
+                      width: "2"
+                    })
+                  ]),
+                  _: 1
+                }, 8, ["prepend-icon", "title"])
+              ]),
+              _: 1
+            })
+          ]),
+          _: 1
+        }, 8, ["modelValue"])
+      ])) : Re("", !0);
+    };
+  }
+}, go = ml("datatablesHooks", () => {
+  const e = W({});
+  return {
+    hooks: e,
+    registerHook: (n, l) => {
+      Object.assign(e.value, { [n]: l });
+    },
+    triggerHook: (n, l) => {
+      e.value.hasOwnProperty(n) && e.value[n](l);
+    }
+  };
+}), yo = {
+  __name: "index",
+  props: {
+    id: {
+      type: String,
+      required: !0
+    },
+    api: {
+      type: Object,
+      default: () => {
+      }
+    },
+    data: {
+      type: Array,
+      default: () => []
+    },
+    options: {
+      type: Object,
+      default: () => ({})
+    },
+    params: {
+      type: Object,
+      default: () => ({})
+    },
+    hardFilters: {
+      type: Array,
+      default: () => []
+    },
+    headers: {
+      type: Array,
+      default: () => []
+    },
+    loading: {
+      type: Boolean,
+      default: !1
+    },
+    locale: {
+      type: String,
+      default: "en"
+    },
+    title: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: ["refreshTable", "refetchData"],
+  setup(e, { expose: a, emit: t }) {
+    const n = e, { triggerHook: l } = go(), { storeOptions: i, setUserOptions: c } = rn(), s = W(null), u = W(0), d = async (m = {}) => {
+      c(m), u.value < 99 && (r("refreshTable"), await Ve(), u.value++);
+    }, o = (m = {}) => {
+      c(m), s.value.tableRef.hasOwnProperty("reloadItems") && (s.value.tableRef.reloadItems(i.state.value), r("refetchData"));
+    }, r = t;
+    return a({ refreshTable: d, refetchData: o, triggerHook: l }), Ue("table_props", n), Ue("triggerHook", l), (m, g) => {
+      const y = mo;
+      return le(), ke(y, {
+        id: e.id,
+        ref_key: "table",
+        ref: s,
+        key: `${e.id}-${N(u)}`,
+        onRefreshTable: d,
+        onRefetchData: o
+      }, null, 8, ["id"]);
+    };
+  }
+}, Vo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: yo
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  Tt as A,
+  Xl as B,
+  eo as C,
+  Vo as D,
+  Co as V,
+  ao as _,
+  Nt as a,
+  st as b,
+  Jl as c,
+  dl as d,
+  Ra as e,
+  Pt as f,
+  sn as g,
+  el as h,
+  Ke as i,
+  oo as j,
+  co as k,
+  go as l,
+  Ea as m,
+  na as n,
+  ea as o,
+  Yl as p,
+  rl as q,
+  sa as r,
+  Ql as s,
+  on as t,
+  At as u,
+  Zt as v,
+  un as w,
+  la as x,
+  Ha as y,
+  Ft as z
+};