@ianicdev/datatables2 0.10.9 → 0.11.0

package/dist/index-BjbhnehN.js

@@ -0,0 +1,4477 @@
+import { ref as W, inject as _e, computed as I, toRef as B, shallowRef as J, watch as re, createVNode as f, normalizeStyle as xe, normalizeClass as oe, createElementVNode as b, mergeProps as L, withDirectives as He, vShow as Ct, Fragment as ce, toDisplayString as bt, mergeModels as Lt, useModel as Vt, createBlock as ke, openBlock as le, withCtx as Ie, createElementBlock as ze, renderList as Ht, unref as M, 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 ie, p as G, b as yl, d as hl, f as kt, I as at, h as de, 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 Ae, 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-j8j4naMl.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 = _e("table_props"), n = I(() => a(t.id)), l = I(() => n.value.search?.query), i = I(() => {
+    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 = I(() => n.value.hardFilters?.query), s = I(() => 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, C = Math.floor(r + (o - r) * d(Me(_, 0, 1)));
+    if (u[l] = C, _ >= 1 && Math.abs(C - 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 = _e(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: B(() => 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 = G({
+  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 = ie()({
+  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 = I(() => e.direction === "horizontal"), {
+      resizeRef: m,
+      contentRect: g
+    } = kt(), {
+      resizeRef: y,
+      contentRect: h
+    } = kt(), x = qn(), _ = I(() => ({
+      container: m.el,
+      duration: 200,
+      easing: "easeOutQuart"
+    })), C = I(() => c.selected.value.length ? c.items.value.findIndex((w) => w.id === c.selected.value[0]) : -1), k = I(() => c.selected.value.length ? c.items.value.findIndex((w) => w.id === c.selected.value[c.selected.value.length - 1]) : -1);
+    if (at) {
+      let w = -1;
+      re(() => [c.selected.value, g.value, h.value, r.value], () => {
+        cancelAnimationFrame(w), w = 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 && C.value >= 0 && y.el) {
+            const v = y.el.children[k.value];
+            F(v, e.centerActive);
+          }
+        });
+      });
+    }
+    const T = J(!1);
+    function F(w, v) {
+      let P = 0;
+      v ? P = Yn({
+        containerElement: m.el,
+        isHorizontal: r.value,
+        selectedElement: w
+      }) : P = Xn({
+        containerElement: m.el,
+        isHorizontal: r.value,
+        isRtl: n.value,
+        selectedElement: w
+      }), H(P);
+    }
+    function H(w) {
+      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(w - P) < 16)) {
+        if (r.value && n.value && m.el) {
+          const {
+            scrollWidth: O,
+            offsetWidth: j
+          } = m.el;
+          w = O - j - w;
+        }
+        r.value ? x.horizontal(w, _.value) : x(w, _.value);
+      }
+    }
+    function A(w) {
+      const {
+        scrollTop: v,
+        scrollLeft: P
+      } = w.target;
+      u.value = r.value ? P : v;
+    }
+    function p(w) {
+      if (T.value = !0, !(!s.value || !y.el)) {
+        for (const v of w.composedPath())
+          for (const P of y.el.children)
+            if (P === v) {
+              F(P);
+              return;
+            }
+      }
+    }
+    function R(w) {
+      T.value = !1;
+    }
+    let E = !1;
+    function q(w) {
+      !E && !T.value && !(w.relatedTarget && y.el?.contains(w.relatedTarget)) && K(), E = !1;
+    }
+    function te() {
+      E = !0;
+    }
+    function ee(w) {
+      if (!y.el) return;
+      function v(P) {
+        w.preventDefault(), K(P);
+      }
+      r.value ? w.key === "ArrowRight" ? v(n.value ? "prev" : "next") : w.key === "ArrowLeft" && v(n.value ? "next" : "prev") : w.key === "ArrowDown" ? v("next") : w.key === "ArrowUp" && v("prev"), w.key === "Home" ? v("first") : w.key === "End" && v("last");
+    }
+    function U(w, v) {
+      if (!w) return;
+      let P = w;
+      do
+        P = P?.[v === "next" ? "nextElementSibling" : "previousElementSibling"];
+      while (P?.hasAttribute("disabled"));
+      return P;
+    }
+    function K(w) {
+      if (!y.el) return;
+      let v;
+      if (!w)
+        v = pn(y.el)[0];
+      else if (w === "next") {
+        if (v = U(y.el.querySelector(":focus"), w), !v) return K("first");
+      } else if (w === "prev") {
+        if (v = U(y.el.querySelector(":focus"), w), !v) return K("last");
+      } else w === "first" ? (v = y.el.firstElementChild, v?.hasAttribute("disabled") && (v = U(v, "next"))) : w === "last" && (v = y.el.lastElementChild, v?.hasAttribute("disabled") && (v = U(v, "prev")));
+      v && v.focus({
+        preventScroll: !0
+      });
+    }
+    function Z(w) {
+      const v = r.value && n.value ? -1 : 1, P = (w === "prev" ? -v : v) * d.value;
+      let V = u.value + P;
+      if (r.value && n.value && m.el) {
+        const {
+          scrollWidth: O,
+          offsetWidth: j
+        } = m.el;
+        V += O - j;
+      }
+      H(V);
+    }
+    const N = I(() => ({
+      next: c.next,
+      prev: c.prev,
+      select: c.select,
+      isSelected: c.isSelected
+    })), ne = I(() => s.value || Math.abs(u.value) > 0), ue = I(() => {
+      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 ne.value;
+        // Always show on mobile
+        case "mobile":
+          return i.value || ne.value;
+        // https://material.io/components/tabs#scrollable-tabs
+        // Always show arrows when
+        // overflowed on desktop
+        default:
+          return !i.value && ne.value;
+      }
+    }), D = I(() => Math.abs(u.value) > 1), $ = I(() => {
+      if (!m.value || !ne.value) return !1;
+      const w = il(r.value, m.el), v = Qn(r.value, m.el);
+      return w - v - Math.abs(u.value) > 1;
+    });
+    return de(() => f(e.tag, {
+      class: oe(["v-slide-group", {
+        "v-slide-group--vertical": !r.value,
+        "v-slide-group--has-affixes": ue.value,
+        "v-slide-group--is-overflowing": s.value
+      }, l.value, e.class]),
+      style: xe(e.style),
+      tabindex: T.value || c.selected.value.length ? -1 : 0,
+      onFocus: q
+    }, {
+      default: () => [ue.value && b("div", {
+        key: "prev",
+        class: oe(["v-slide-group__prev", {
+          "v-slide-group__prev--disabled": !D.value
+        }]),
+        onMousedown: te,
+        onClick: () => D.value && Z("prev")
+      }, [t.prev?.(N.value) ?? f(tl, null, {
+        default: () => [f(Se, {
+          icon: n.value ? e.nextIcon : e.prevIcon
+        }, null)]
+      })]), b("div", {
+        key: "container",
+        ref: m,
+        class: oe(["v-slide-group__container", e.contentClass]),
+        onScroll: A
+      }, [b("div", {
+        ref: y,
+        class: "v-slide-group__content",
+        onFocusin: p,
+        onFocusout: R,
+        onKeydown: ee
+      }, [t.default?.(N.value)])]), ue.value && b("div", {
+        key: "next",
+        class: oe(["v-slide-group__next", {
+          "v-slide-group__next--disabled": !$.value
+        }]),
+        onMousedown: te,
+        onClick: () => $.value && Z("next")
+      }, [t.next?.(N.value) ?? f(tl, null, {
+        default: () => [f(Se, {
+          icon: n.value ? e.prevIcon : e.nextIcon
+        }, null)]
+      })])]
+    })), {
+      selected: c.selected,
+      scrollTo: Z,
+      scrollOffset: u,
+      focus: K,
+      hasPrev: D,
+      hasNext: $
+    };
+  }
+}), Kl = /* @__PURE__ */ Symbol.for("vuetify:v-chip-group"), Zn = G({
+  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 = ie()({
+  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: B(() => e.baseColor),
+        color: B(() => e.color),
+        disabled: B(() => e.disabled),
+        filter: B(() => e.filter),
+        variant: B(() => e.variant)
+      }
+    }), de(() => {
+      const d = ul.filterProps(e);
+      return f(ul, L(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 = G({
+  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 = ie()({
+  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), x = B(() => e.link !== !1 && h.isLink.value), _ = I(() => !e.disabled && e.link !== !1 && (!!g || e.link || h.isClickable.value)), C = B(() => ({
+      "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: T,
+      variantClasses: F
+    } = kl(() => ({
+      color: !g || g.isSelected.value ? e.color ?? e.baseColor : e.baseColor,
+      variant: e.variant
+    }));
+    function H(p) {
+      n("click", p), _.value && (h.navigate?.(p), g?.toggle());
+    }
+    function A(p) {
+      (p.key === "Enter" || p.key === " ") && (p.preventDefault(), H(p));
+    }
+    return () => {
+      const p = h.isLink.value ? "a" : e.tag, R = !!(e.appendIcon || e.appendAvatar), E = !!(R || 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, L(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: [T.value, e.style],
+        disabled: e.disabled || void 0,
+        draggable: e.draggable,
+        tabindex: _.value ? 0 : void 0,
+        onClick: H,
+        onKeydown: _.value && !x.value && A
+      }), {
+        default: () => [Sl(_.value, "v-chip"), te && f(Cl, {
+          key: "filter"
+        }, {
+          default: () => [He(b("div", {
+            class: "v-chip__filter"
+          }, [l.filter ? f(Ae, {
+            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(Ae, {
+          key: "prepend-defaults",
+          disabled: !ee,
+          defaults: {
+            VAvatar: {
+              image: e.prependAvatar,
+              start: !0
+            },
+            VIcon: {
+              icon: e.prependIcon,
+              start: !0
+            }
+          }
+        }, l.prepend) : b(ce, 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(Ae, {
+          key: "append-defaults",
+          disabled: !R,
+          defaults: {
+            VAvatar: {
+              end: !0,
+              image: e.appendAvatar
+            },
+            VIcon: {
+              end: !0,
+              icon: e.appendIcon
+            }
+          }
+        }, l.append) : b(ce, 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", L({
+          key: "close",
+          class: "v-chip__close",
+          type: "button",
+          "data-testid": "close-chip"
+        }, C.value), [l.close ? f(Ae, {
+          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 = G({
+  color: String,
+  ...Wt(),
+  ...pe(),
+  ...ft(),
+  ...Gt(),
+  ...Jt(),
+  ...Il(),
+  ...ct(),
+  ...Be(),
+  ...Ne()
+}, "VSheet"), na = ie()({
+  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 de(() => f(e.tag, {
+      class: oe(["v-sheet", n.value, l.value, c.value, u.value, o.value, r.value, e.class]),
+      style: xe([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 = _e("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 x = y, _;
+        return h.length && (_ = h.find((C) => C.value === y), _ && (x = _.title)), typeof o.advancedFilter?.valueFormatter == "function" && (x = o.advancedFilter.valueFormatter({
+          item: _,
+          value: y
+        })), x;
+      });
+      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: Ie(() => [
+        f(ea, null, {
+          default: Ie(() => [
+            (le(!0), ze(ce, null, Ht(M(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 = G({
+  text: String,
+  onClick: $e(),
+  ...pe(),
+  ...Ne()
+}, "VLabel"), jl = ie()({
+  name: "VLabel",
+  props: oa(),
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    return de(() => b("label", {
+      class: oe(["v-label", {
+        "v-label--clickable": !!e.onClick
+      }, e.class]),
+      style: xe(e.style),
+      onClick: e.onClick
+    }, [e.text, t.default?.()])), {};
+  }
+}), Gl = /* @__PURE__ */ Symbol.for("vuetify:selection-control-group"), Wl = G({
+  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 = G({
+  ...Wl({
+    defaultsTarget: "VSelectionControl"
+  })
+}, "VSelectionControlGroup");
+ie()({
+  name: "VSelectionControlGroup",
+  props: ia(),
+  emits: {
+    "update:modelValue": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    const n = we(e, "modelValue"), l = je(), i = B(() => e.id || `v-selection-control-group-${l}`), c = B(() => 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: B(() => e.color),
+        disabled: B(() => e.disabled),
+        density: B(() => e.density),
+        error: B(() => e.error),
+        inline: B(() => e.inline),
+        modelValue: n,
+        multiple: B(() => !!e.multiple || e.multiple == null && Array.isArray(n.value)),
+        name: c,
+        falseIcon: B(() => e.falseIcon),
+        trueIcon: B(() => e.trueIcon),
+        readonly: B(() => e.readonly),
+        ripple: B(() => e.ripple),
+        type: B(() => e.type),
+        valueComparator: B(() => e.valueComparator)
+      }
+    }), de(() => b("div", {
+      class: oe(["v-selection-control-group", {
+        "v-selection-control-group--inline": e.inline
+      }, e.class]),
+      style: xe(e.style),
+      role: e.type === "radio" ? "radiogroup" : void 0
+    }, [t.default?.()])), {};
+  }
+});
+const ql = G({
+  label: String,
+  baseColor: String,
+  trueValue: null,
+  falseValue: null,
+  value: null,
+  ...pe(),
+  ...Wl()
+}, "VSelectionControl");
+function ua(e) {
+  const a = _e(Gl, void 0), {
+    densityClasses: t
+  } = It(e), n = we(e, "modelValue"), l = I(() => e.trueValue !== void 0 ? e.trueValue : e.value !== void 0 ? e.value : !0), i = I(() => e.falseValue !== void 0 ? e.falseValue : !1), c = I(() => !!e.multiple || e.multiple == null && Array.isArray(n.value)), s = I({
+    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((x) => !e.valueComparator(x, 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 = I(() => 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 = ie()({
+  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), x = W(), _ = B(() => e.id || `input-${g}`), C = B(() => !e.disabled && !e.readonly);
+    l?.onForceUpdate(() => {
+      x.value && (x.value.checked = s.value);
+    });
+    function k(A) {
+      C.value && (y.value = !0, ot(A.target, ":focus-visible") !== !1 && (h.value = !0));
+    }
+    function T() {
+      y.value = !1, h.value = !1;
+    }
+    function F(A) {
+      A.stopPropagation();
+    }
+    function H(A) {
+      if (!C.value) {
+        x.value && (x.value.checked = s.value);
+        return;
+      }
+      e.readonly && l && Ve(() => l.forceUpdate()), s.value = A.target.checked;
+    }
+    return de(() => {
+      const A = n.label ? n.label({
+        label: e.label,
+        props: {
+          for: _.value
+        }
+      }) : e.label, [p, R] = wl(t), E = b("input", L({
+        ref: x,
+        checked: s.value,
+        disabled: !!e.disabled,
+        id: _.value,
+        onBlur: T,
+        onFocus: k,
+        onInput: H,
+        "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
+      }, R), null);
+      return b("div", L({
+        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: oe(["v-selection-control__wrapper", u.value]),
+        style: xe(d.value)
+      }, [n.default?.({
+        backgroundColorClasses: o,
+        backgroundColorStyles: r
+      }), He(b("div", {
+        class: oe(["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: T,
+          id: _.value
+        }
+      }) ?? b(ce, 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: x
+    };
+  }
+}), sa = G({
+  indeterminate: Boolean,
+  indeterminateIcon: {
+    type: be,
+    default: "$checkboxIndeterminate"
+  },
+  ...ql({
+    falseIcon: "$checkboxOff",
+    trueIcon: "$checkboxOn"
+  })
+}, "VCheckboxBtn"), Jl = ie()({
+  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 = B(() => n.value ? e.indeterminateIcon : e.falseIcon), s = B(() => n.value ? e.indeterminateIcon : e.trueIcon);
+    return de(() => {
+      const u = Ge(sl.filterProps(e), ["modelValue"]);
+      return f(sl, L(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, L({
+      icon: e[`${l}Icon`],
+      "aria-label": o,
+      onClick: u,
+      onKeydown: d,
+      color: i
+    }, c), null);
+  }
+  return {
+    InputIcon: t
+  };
+}
+const ra = G({
+  active: Boolean,
+  color: String,
+  messages: {
+    type: [Array, String],
+    default: () => []
+  },
+  ...pe(),
+  ..._t({
+    transition: {
+      component: Pl,
+      leaveAbsolute: !0,
+      group: !0
+    }
+  })
+}, "VMessages"), ca = ie()({
+  name: "VMessages",
+  props: ra(),
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    const n = I(() => De(e.messages)), {
+      textColorClasses: l,
+      textColorStyles: i
+    } = mt(() => e.color);
+    return de(() => f(Xt, {
+      transition: e.transition,
+      tag: "div",
+      class: oe(["v-messages", l.value, e.class]),
+      style: xe([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 = G({
+  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 = B(() => ({
+    [`${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 = _e(da, null);
+  return {
+    ...a,
+    isReadonly: I(() => !!(e?.readonly ?? a?.isReadonly.value)),
+    isDisabled: I(() => !!(e?.disabled ?? a?.isDisabled.value))
+  };
+}
+const va = /* @__PURE__ */ Symbol.for("vuetify:rules");
+function fa(e) {
+  const a = _e(va, null);
+  if (!e) {
+    if (!a)
+      throw new Error("Could not find Vuetify rules injection");
+    return a.aliases;
+  }
+  return a?.resolve(e) ?? B(e);
+}
+const ma = G({
+  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 = I(() => e.validationValue === void 0 ? n.value : e.validationValue), i = Dt(e), c = fa(() => e.rules), s = W([]), u = J(!0), d = I(() => !!(De(n.value === "" ? null : n.value).length || De(l.value === "" ? null : l.value).length)), o = I(() => e.errorMessages?.length ? De(e.errorMessages).concat(s.value).slice(0, Math.max(0, Number(e.maxErrors))) : s.value), r = I(() => {
+    let T = (e.validateOn ?? i.validateOn?.value) || "input";
+    T === "lazy" && (T = "input lazy"), T === "eager" && (T = "input eager");
+    const F = new Set(T?.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 = I(() => 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 = I(() => ({
+    [`${a}--error`]: m.value === !1,
+    [`${a}--dirty`]: d.value,
+    [`${a}--disabled`]: i.isDisabled.value,
+    [`${a}--readonly`]: i.isReadonly.value
+  })), h = Fl("validation"), x = I(() => e.name ?? M(t));
+  dn(() => {
+    i.register?.({
+      id: x.value,
+      vm: h,
+      validate: k,
+      reset: _,
+      resetValidation: C
+    });
+  }), vn(() => {
+    i.unregister?.(x.value);
+  }), Ye(async () => {
+    r.value.lazy || await k(!r.value.eager), i.update?.(x.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 T = re(() => e.focused, (F) => {
+          F || k(), T();
+        });
+      }
+    });
+  }), $t(() => r.value.blur, () => {
+    re(() => e.focused, (T) => {
+      T || k();
+    });
+  }), re([m, o], () => {
+    i.update?.(x.value, m.value, o.value);
+  });
+  async function _() {
+    n.value = null, await Ve(), await C();
+  }
+  async function C() {
+    u.value = !0, r.value.lazy ? s.value = [] : await k(!r.value.eager);
+  }
+  async function k() {
+    let T = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !1;
+    const F = [];
+    g.value = !0;
+    for (const H of c.value) {
+      if (F.length >= Number(e.maxErrors ?? 1))
+        break;
+      const p = await (typeof H == "function" ? H : () => H)(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 = T, s.value;
+  }
+  return {
+    errorMessages: o,
+    isDirty: d,
+    isDisabled: i.isDisabled,
+    isReadonly: i.isReadonly,
+    isPristine: u,
+    isValid: m,
+    isValidating: g,
+    reset: _,
+    resetValidation: C,
+    validate: k,
+    validationClasses: y
+  };
+}
+const Ql = G({
+  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 = ie()({
+  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 = I(() => e.id || `input-${o}`), {
+      errorMessages: m,
+      isDirty: g,
+      isDisabled: y,
+      isReadonly: h,
+      isPristine: x,
+      isValid: _,
+      isValidating: C,
+      reset: k,
+      resetValidation: T,
+      validate: F,
+      validationClasses: H
+    } = ga(e, "v-input", r), A = I(() => e.errorMessages?.length || !x.value && m.value.length ? m.value : e.hint && (e.persistentHint || e.focused) ? e.hint : e.messages), p = B(() => A.value.length > 0), R = B(() => !e.hideDetails || e.hideDetails === "auto" && (p.value || !!n.details)), E = I(() => R.value ? `${r.value}-messages` : void 0), q = I(() => ({
+      id: r,
+      messagesId: E,
+      isDirty: g,
+      isDisabled: y,
+      isReadonly: h,
+      isPristine: x,
+      isValid: _,
+      isValidating: C,
+      hasDetails: R,
+      reset: k,
+      resetValidation: T,
+      validate: F
+    })), te = B(() => e.error || e.disabled ? void 0 : e.focused ? e.color : e.baseColor), ee = B(() => {
+      if (e.iconColor)
+        return e.iconColor === !0 ? te.value : e.iconColor;
+    });
+    return de(() => {
+      const U = !!(n.prepend || e.prependIcon), K = !!(n.append || e.appendIcon);
+      return b("div", {
+        class: oe(["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, H.value, e.class]),
+        style: xe([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)]), K && 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)]), R.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: T,
+      validate: F,
+      isValid: _,
+      errorMessages: m
+    };
+  }
+}), ya = G({
+  active: Boolean,
+  disabled: Boolean,
+  max: [Number, String],
+  value: {
+    type: [Number, String],
+    default: 0
+  },
+  ...pe(),
+  ..._t({
+    transition: {
+      component: Pl
+    }
+  })
+}, "VCounter"), ha = ie()({
+  name: "VCounter",
+  functional: !0,
+  props: ya(),
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    const n = B(() => e.max ? `${e.value} / ${e.max}` : String(e.value));
+    return de(() => f(Xt, {
+      transition: e.transition
+    }, {
+      default: () => [He(b("div", {
+        class: oe(["v-counter", {
+          "text-error": e.max && !e.disabled && parseFloat(e.value) > parseFloat(e.max)
+        }, e.class]),
+        style: xe(e.style)
+      }, [t.default ? t.default({
+        counter: n.value,
+        max: e.max,
+        value: e.value
+      }) : n.value]), [[Ct, e.active]])]
+    })), {};
+  }
+}), ba = G({
+  floating: Boolean,
+  ...pe()
+}, "VFieldLabel"), ht = ie()({
+  name: "VFieldLabel",
+  props: ba(),
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    return de(() => f(jl, {
+      class: oe(["v-field-label", {
+        "v-field-label--floating": e.floating
+      }, e.class]),
+      style: xe(e.style)
+    }, t)), {};
+  }
+}), pa = ["underlined", "outlined", "filled", "solo", "solo-inverted", "solo-filled", "plain"], Zl = G({
+  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 = ie()({
+  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 = B(() => e.dirty || e.active), h = B(() => !!(e.label || l.label)), x = B(() => !e.singleLine && h.value), _ = je(), C = I(() => e.id || `input-${_}`), k = B(() => e.details ? `${C.value}-messages` : void 0), T = W(), F = W(), H = W(), A = I(() => ["plain", "underlined"].includes(e.variant)), p = I(() => e.error || e.disabled ? void 0 : y.value && u.value ? e.color : e.baseColor), R = I(() => {
+      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, (Z) => {
+      if (x.value && !gl()) {
+        const N = T.value.$el, ne = F.value.$el;
+        requestAnimationFrame(() => {
+          const ue = xn(N), D = ne.getBoundingClientRect(), $ = D.x - ue.x, w = D.y - ue.y - (ue.height / 2 - D.height / 2), v = D.width / 0.75, P = Math.abs(v - ue.width) > 1 ? {
+            maxWidth: lt(v)
+          } : void 0, V = getComputedStyle(N), O = getComputedStyle(ne), j = parseFloat(V.transitionDuration) * 1e3 || 150, ve = parseFloat(O.getPropertyValue("--v-field-label-scale")), me = O.getPropertyValue("color");
+          N.style.visibility = "visible", ne.style.visibility = "hidden", In(N, {
+            transform: `translate(${$}px, ${w}px) scale(${ve})`,
+            color: me,
+            ...P
+          }, {
+            duration: j,
+            easing: wn,
+            direction: Z ? "normal" : "reverse"
+          }).finished.then(() => {
+            N.style.removeProperty("visibility"), ne.style.removeProperty("visibility");
+          });
+        });
+      }
+    }, {
+      flush: "post"
+    });
+    const U = I(() => ({
+      isActive: y,
+      isFocused: u,
+      controlRef: H,
+      iconColor: R,
+      blur: o,
+      focus: d
+    }));
+    function K(Z) {
+      Z.target !== document.activeElement && Z.preventDefault();
+    }
+    return de(() => {
+      const Z = e.variant === "outlined", N = !!(l["prepend-inner"] || e.prependInnerIcon), ne = !!(e.clearable || l.clear) && !e.disabled, ue = !!(l["append-inner"] || e.appendInnerIcon || ne), D = () => l.label ? l.label({
+        ...U.value,
+        label: e.label,
+        props: {
+          for: C.value
+        }
+      }) : e.label;
+      return b("div", L({
+        class: ["v-field", {
+          "v-field--active": y.value,
+          "v-field--appended": ue,
+          "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": N,
+          "v-field--reverse": e.reverse,
+          "v-field--single-line": e.singleLine,
+          "v-field--no-label": !D(),
+          [`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: K
+      }, 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
+      }), N && 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: R.value
+      }, null)]), b("div", {
+        class: "v-field__field",
+        "data-no-activator": ""
+      }, [["filled", "solo", "solo-inverted", "solo-filled"].includes(e.variant) && x.value && f(ht, {
+        key: "floating-label",
+        ref: F,
+        class: oe([te.value]),
+        floating: !0,
+        for: C.value,
+        "aria-hidden": !y.value,
+        style: xe(ee.value)
+      }, {
+        default: () => [D()]
+      }), h.value && f(ht, {
+        key: "label",
+        ref: T,
+        id: e.labelId,
+        for: C.value,
+        "aria-hidden": x.value && y.value
+      }, {
+        default: () => [D()]
+      }), l.default?.({
+        ...U.value,
+        props: {
+          id: C.value,
+          class: "v-field__input",
+          "aria-describedby": k.value
+        },
+        focus: d,
+        blur: o
+      }) ?? b("div", {
+        id: C.value,
+        class: "v-field__input",
+        "aria-describedby": k.value
+      }, null)]), ne && f(Cl, {
+        key: "clear"
+      }, {
+        default: () => [He(b("div", {
+          class: "v-field__clearable",
+          onMousedown: ($) => {
+            $.preventDefault(), $.stopPropagation();
+          }
+        }, [f(Ae, {
+          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]])]
+      }), ue && 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: R.value
+      }, null)]), b("div", {
+        class: oe(["v-field__outline", te.value]),
+        style: xe(ee.value)
+      }, [Z && b(ce, null, [b("div", {
+        class: "v-field__outline__start"
+      }, null), x.value && b("div", {
+        class: "v-field__outline__notch"
+      }, [f(ht, {
+        ref: F,
+        floating: !0,
+        for: C.value,
+        "aria-hidden": !y.value
+      }, {
+        default: () => [D()]
+      })]), b("div", {
+        class: "v-field__outline__end"
+      }, null)]), A.value && x.value && f(ht, {
+        ref: F,
+        floating: !0,
+        for: C.value,
+        "aria-hidden": !y.value
+      }, {
+        default: () => [D()]
+      })])]);
+    }), {
+      controlRef: H,
+      fieldIconColor: R
+    };
+  }
+}), ka = G({
+  autocomplete: String
+}, "autocomplete");
+function en(e) {
+  const a = je(), t = J(0), n = B(() => e.autocomplete === "suppress"), l = B(() => {
+    if (e.name)
+      return n.value ? `${e.name}-${a}-${t.value}` : e.name;
+  }), i = B(() => 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 = G({
+  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 = ie()({
+  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 = I(() => typeof e.counterValue == "function" ? e.counterValue(i.value) : typeof e.counterValue == "number" ? e.counterValue : (i.value ?? "").toString().length), r = I(() => {
+      if (t.maxlength) return t.maxlength;
+      if (!(!e.counter || typeof e.counter != "number" && typeof e.counter != "string"))
+        return e.counter;
+    }), m = I(() => ["plain", "underlined"].includes(e.variant)), g = W(), y = W(), h = W(), x = en(e), _ = I(() => Ca.includes(e.type) || e.persistentPlaceholder || c.value || e.active);
+    function C() {
+      x.isSuppressing.value && x.update(), c.value || s(), Ve(() => {
+        h.value !== document.activeElement && h.value?.focus();
+      });
+    }
+    function k(A) {
+      n("mousedown:control", A), A.target !== h.value && (C(), A.preventDefault());
+    }
+    function T(A) {
+      n("click:control", A);
+    }
+    function F(A, p) {
+      A.stopPropagation(), C(), Ve(() => {
+        p(), _l(e["onClick:clear"], A);
+      });
+    }
+    function H(A) {
+      const p = A.target;
+      if (!(e.modelModifiers?.trim && ["text", "search", "password", "tel", "url"].includes(e.type))) {
+        i.value = p.value;
+        return;
+      }
+      const R = p.value, E = p.selectionStart, q = p.selectionEnd;
+      i.value = R, Ve(() => {
+        let te = 0;
+        R.trimStart().length === p.value.length && (te = R.length - p.value.length), E != null && (p.selectionStart = E - te), q != null && (p.selectionEnd = q - te);
+      });
+    }
+    return de(() => {
+      const A = !!(l.counter || e.counter !== !1 && e.counter != null), p = !!(A || l.details), [R, E] = wl(t), {
+        modelValue: q,
+        ...te
+      } = rl.filterProps(e), ee = cl.filterProps(e);
+      return f(rl, L({
+        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
+      }, R, te, {
+        centerAffix: !m.value,
+        focused: c.value
+      }), {
+        ...l,
+        default: (U) => {
+          let {
+            id: K,
+            isDisabled: Z,
+            isDirty: N,
+            isReadonly: ne,
+            isValid: ue,
+            hasDetails: D,
+            reset: $
+          } = U;
+          return f(cl, L({
+            ref: y,
+            onMousedown: k,
+            onClick: T,
+            "onClick:clear": (w) => F(w, $),
+            role: e.role
+          }, Ge(ee, ["onClick:clear"]), {
+            id: K.value,
+            labelId: `${K.value}-label`,
+            active: _.value || N.value,
+            dirty: N.value || e.dirty,
+            disabled: Z.value,
+            focused: c.value,
+            details: D.value,
+            error: ue.value === !1
+          }), {
+            ...l,
+            default: (w) => {
+              let {
+                props: {
+                  class: v,
+                  ...P
+                },
+                controlRef: V
+              } = w;
+              const O = b("input", L({
+                ref: (j) => h.value = V.value = j,
+                value: i.value,
+                onInput: H,
+                autofocus: e.autofocus,
+                readonly: ne.value,
+                disabled: Z.value,
+                name: x.fieldName.value,
+                autocomplete: x.fieldAutocomplete.value,
+                placeholder: e.placeholder,
+                size: 1,
+                role: e.role,
+                type: e.type,
+                onFocus: s,
+                onBlur: u,
+                "aria-labelledby": `${K.value}-label`
+              }, P, E), null);
+              return b(ce, 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: oe(v),
+                "data-no-activator": ""
+              }, [l.default({
+                id: K
+              }), O]) : fn(O, {
+                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(ce, null, [l.details?.(U), A && b(ce, 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 = G({
+  renderless: Boolean,
+  ...pe()
+}, "VVirtualScrollItem"), xa = ie()({
+  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);
+    }), de(() => e.renderless ? b(ce, null, [l.default?.({
+      itemRef: i
+    })]) : b("div", L({
+      ref: i,
+      class: ["v-virtual-scroll__item", e.class],
+      style: e.style
+    }, t), [l.default?.()]));
+  }
+}), Ia = -1, wa = 1, Et = 100, _a = G({
+  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 = I(() => u.value === document.documentElement ? t.height.value : m.value?.height || parseInt(e.height) || 0), y = I(() => !!(u.value && d.value && g.value && n.value));
+  let h = Array.from({
+    length: a.value.length
+  }), x = Array.from({
+    length: a.value.length
+  });
+  const _ = J(0);
+  let C = -1;
+  function k(D) {
+    return h[D] || n.value;
+  }
+  const T = _n(() => {
+    const D = performance.now();
+    x[0] = 0;
+    const $ = a.value.length;
+    for (let w = 1; w <= $; w++)
+      x[w] = (x[w - 1] || 0) + k(w - 1);
+    _.value = Math.max(_.value, performance.now() - D);
+  }, _), F = re(y, (D) => {
+    D && (F(), o = d.value.offsetTop, T.immediate(), Z(), ~C && Ve(() => {
+      at && window.requestAnimationFrame(() => {
+        ne(C), C = -1;
+      });
+    }));
+  });
+  nt(() => {
+    T.clear();
+  });
+  function H(D, $) {
+    const w = h[D], v = n.value;
+    n.value = v ? Math.min(n.value, $) : $, (w !== $ || v !== n.value) && (h[D] = $, T());
+  }
+  function A(D) {
+    D = Me(D, 0, a.value.length);
+    const $ = Math.floor(D), w = D % 1, v = $ + 1, P = x[$] || 0, V = x[v] || P;
+    return P + (V - P) * w;
+  }
+  function p(D) {
+    return Aa(x, D);
+  }
+  let R = 0, E = 0, q = 0;
+  re(g, (D, $) => {
+    Z(), D < $ && requestAnimationFrame(() => {
+      E = 0, Z();
+    });
+  });
+  let te = -1;
+  function ee() {
+    if (!u.value || !d.value) return;
+    const D = u.value.scrollTop, $ = performance.now();
+    $ - q > 500 ? (E = Math.sign(D - R), o = d.value.offsetTop) : E = D - R, R = D, q = $, window.clearTimeout(te), te = window.setTimeout(U, 500), Z();
+  }
+  function U() {
+    !u.value || !d.value || (E = 0, q = 0, window.clearTimeout(te), Z());
+  }
+  let K = -1;
+  function Z() {
+    cancelAnimationFrame(K), K = requestAnimationFrame(N);
+  }
+  function N() {
+    if (!u.value || !g.value || !n.value) return;
+    const D = R - o, $ = Math.sign(E), w = Math.max(0, D - Et), v = Me(p(w), 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
+      ($ !== Ia || v < l.value) && ($ !== wa || V > i.value)
+    ) {
+      const O = A(l.value) - A(v), j = A(V) - A(i.value);
+      Math.max(O, j) > 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 ne(D) {
+    const $ = A(D);
+    !u.value || D && !$ ? C = D : u.value.scrollTop = $;
+  }
+  const ue = I(() => a.value.slice(l.value, i.value).map((D, $) => {
+    const w = $ + l.value;
+    return {
+      raw: D,
+      index: w,
+      key: El(D, e.itemKey, w)
+    };
+  }));
+  return re(a, () => {
+    h = Array.from({
+      length: a.value.length
+    }), x = Array.from({
+      length: a.value.length
+    }), T.immediate(), Z();
+  }, {
+    deep: 1
+  }), {
+    calculateVisibleItems: Z,
+    containerRef: u,
+    markerRef: d,
+    computedItems: ue,
+    paddingTop: c,
+    paddingBottom: s,
+    scrollToIndex: ne,
+    handleScroll: ee,
+    handleScrollend: U,
+    handleItemResize: H
+  };
+}
+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 = G({
+  items: {
+    type: Array,
+    default: () => []
+  },
+  renderless: Boolean,
+  ..._a(),
+  ...pe(),
+  ...ft()
+}, "VVirtualScroll"), tn = ie()({
+  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, B(() => 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);
+    }), de(() => {
+      const h = y.value.map((x) => f(xa, {
+        key: x.key,
+        renderless: e.renderless,
+        "onUpdate:height": (_) => o(x.index, _)
+      }, {
+        default: (_) => t.default?.({
+          item: x.raw,
+          index: x.index,
+          ..._
+        })
+      }));
+      return e.renderless ? b(ce, 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: oe(["v-virtual-scroll", e.class]),
+        onScrollPassive: u,
+        onScrollend: d,
+        style: xe([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 = G({
+  closeText: {
+    type: String,
+    default: "$vuetify.close"
+  },
+  openText: {
+    type: String,
+    default: "$vuetify.open"
+  }
+}, "autocomplete");
+function nn(e, a) {
+  const t = je(), n = I(() => `menu-${t}`), l = B(() => mn(a)), i = B(() => n.value);
+  return {
+    menuId: n,
+    ariaExpanded: l,
+    ariaControls: i
+  };
+}
+const an = G({
+  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 = G({
+  ...an(),
+  ...Ge(Tt({
+    modelValue: null,
+    role: "combobox"
+  }), ["validationValue", "dirty"]),
+  ..._t({
+    transition: {
+      component: Nl
+    }
+  })
+}, "VSelect"), Co = ie()({
+  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 O = d(V);
+      return e.multiple ? O : O[0] ?? null;
+    }), r = I(() => typeof e.counterValue == "function" ? e.counterValue(o.value) : typeof e.counterValue == "number" ? e.counterValue : o.value.length), m = Dt(e), g = en(e), y = I(() => o.value.map((V) => V.value)), h = J(!1), x = B(() => e.closableChips && !m.isReadonly.value && !m.isDisabled.value), {
+      InputIcon: _
+    } = Ft(e);
+    let C = "", k = 0, T;
+    const F = I(() => e.hideSelected ? s.value.filter((V) => !o.value.some((O) => (e.valueComparator || We)(O, V))) : s.value), H = I(() => e.hideNoData && !F.value.length || m.isReadonly.value || m.isDisabled.value), A = we(e, "menu"), p = I({
+      get: () => A.value,
+      set: (V) => {
+        A.value && !V && i.value?.ΨopenChildren.size || V && H.value || (A.value = V);
+      }
+    }), {
+      menuId: R,
+      ariaExpanded: E,
+      ariaControls: q
+    } = nn(e, p), te = I(() => ({
+      ...e.menuProps,
+      activatorProps: {
+        ...e.menuProps?.activatorProps || {},
+        "aria-haspopup": "listbox"
+        // Set aria-haspopup to 'listbox'
+      }
+    })), ee = W(), U = ln(ee, l);
+    function K(V) {
+      e.openOnClear && (p.value = !0);
+    }
+    function Z() {
+      H.value || (p.value = !p.value);
+    }
+    function N(V) {
+      St(V) && ne(V);
+    }
+    function ne(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 = [], K();
+        return;
+      }
+      V.key === "Home" ? ee.value?.focus("first") : V.key === "End" && ee.value?.focus("last");
+      const O = 1e3;
+      if (!St(V)) return;
+      const j = performance.now();
+      j - T > O && (C = "", k = 0), C += V.key.toLowerCase(), T = j;
+      const ve = F.value;
+      function me() {
+        let z = ge();
+        return z || C.at(-1) === C.at(-2) && (C = C.slice(0, -1), k++, z = ge(), z) || (k = 0, z = ge(), z) ? z : (C = V.key.toLowerCase(), ge());
+      }
+      function ge() {
+        for (let z = k; z < ve.length; z++) {
+          const ye = ve[z];
+          if (ye.title.toLowerCase().startsWith(C))
+            return [ye, z];
+        }
+      }
+      const Fe = me();
+      if (!Fe) return;
+      const [X, fe] = Fe;
+      k = fe, ee.value?.focus(fe), e.multiple || (o.value = [X]);
+    }
+    function ue(V) {
+      let O = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !0;
+      if (!V.props.disabled)
+        if (e.multiple) {
+          const j = o.value.findIndex((me) => (e.valueComparator || We)(me.value, V.value)), ve = O ?? !~j;
+          if (~j) {
+            const me = ve ? [...o.value, V] : [...o.value];
+            me.splice(j, 1), o.value = me;
+          } else ve && (o.value = [...o.value, V]);
+        } else {
+          const j = O !== !1;
+          o.value = j ? [V] : [], Ve(() => {
+            p.value = !1;
+          });
+        }
+    }
+    function D(V) {
+      ee.value?.$el.contains(V.relatedTarget) || (p.value = !1);
+    }
+    function $() {
+      e.eager && c.value?.calculateVisibleItems();
+    }
+    function w() {
+      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 O = s.value.find((j) => j.title === V);
+        O && ue(O);
+      } else l.value && (l.value.value = "");
+    }
+    return re(p, () => {
+      if (!e.hideSelected && p.value && o.value.length) {
+        const V = F.value.findIndex((O) => o.value.some((j) => (e.valueComparator || We)(j.value, O.value)));
+        at && !e.noAutoScroll && window.requestAnimationFrame(() => {
+          V >= 0 && c.value?.scrollToIndex(V);
+        });
+      }
+    }), re(s, (V, O) => {
+      p.value || h.value && e.hideNoData && !O.length && V.length && (p.value = !0);
+    }), de(() => {
+      const V = !!(e.chips || t.chip), O = !!(!e.hideNoData || F.value.length || t["prepend-item"] || t["append-item"] || t["no-data"]), j = o.value.length > 0, ve = Ke.filterProps(e), me = j || !h.value && e.label && !e.persistentPlaceholder ? void 0 : e.placeholder;
+      return f(Ke, L({
+        ref: l
+      }, ve, {
+        modelValue: o.value.map((ge) => ge.props.title).join(", "),
+        name: void 0,
+        "onUpdate:modelValue": P,
+        focused: h.value,
+        "onUpdate:focused": (ge) => h.value = ge,
+        validationValue: o.externalValue,
+        counterValue: r.value,
+        dirty: j,
+        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: me,
+        "onClick:clear": K,
+        "onMousedown:control": Z,
+        onBlur: D,
+        onKeydown: ne,
+        "aria-expanded": E.value,
+        "aria-controls": q.value
+      }), {
+        ...t,
+        default: (ge) => {
+          let {
+            id: Fe
+          } = ge;
+          return b(ce, null, [b("select", {
+            hidden: !0,
+            multiple: e.multiple,
+            name: g.fieldName.value
+          }, [s.value.map((X) => b("option", {
+            key: X.value,
+            value: X.value,
+            selected: y.value.includes(X.value)
+          }, null))]), f(Rl, L({
+            id: R.value,
+            ref: i,
+            modelValue: p.value,
+            "onUpdate:modelValue": (X) => p.value = X,
+            activator: "parent",
+            contentClass: "v-select__content",
+            disabled: H.value,
+            eager: e.eager,
+            maxHeight: 310,
+            openOnClick: !1,
+            closeOnContentClick: !1,
+            transition: e.transition,
+            onAfterEnter: $,
+            onAfterLeave: w
+          }, te.value), {
+            default: () => [O && f(Yt, L({
+              ref: ee,
+              selected: y.value,
+              selectStrategy: e.multiple ? "independent" : "single-independent",
+              onMousedown: (X) => X.preventDefault(),
+              onKeydown: N,
+              onFocusin: v,
+              tabindex: "-1",
+              selectable: !!F.value.length,
+              "aria-live": "polite",
+              "aria-labelledby": `${Fe.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: (X) => {
+                  let {
+                    item: fe,
+                    index: z,
+                    itemRef: ye
+                  } = X;
+                  const S = An(fe.props), Y = L(fe.props, {
+                    ref: ye,
+                    key: fe.value,
+                    onClick: () => ue(fe, null),
+                    "aria-posinset": z + 1,
+                    "aria-setsize": F.value.length
+                  });
+                  return fe.type === "divider" ? t.divider?.({
+                    props: fe.raw,
+                    index: z
+                  }) ?? f(Le, L(fe.props, {
+                    key: `divider-${z}`
+                  }), null) : fe.type === "subheader" ? t.subheader?.({
+                    props: fe.raw,
+                    index: z
+                  }) ?? f(Ml, L(fe.props, {
+                    key: `subheader-${z}`
+                  }), null) : t.item?.({
+                    item: fe,
+                    index: z,
+                    props: Y
+                  }) ?? f(it, L(Y, {
+                    role: "option"
+                  }), {
+                    prepend: (Q) => {
+                      let {
+                        isSelected: ae
+                      } = Q;
+                      return b(ce, null, [e.multiple && !e.hideSelected ? f(Jl, {
+                        key: fe.value,
+                        modelValue: ae,
+                        ripple: !1,
+                        tabindex: "-1",
+                        "aria-hidden": !0,
+                        onClick: (Ce) => Ce.preventDefault()
+                      }, null) : void 0, S.prependAvatar && f(Xe, {
+                        image: S.prependAvatar
+                      }, null), S.prependIcon && f(Se, {
+                        icon: S.prependIcon
+                      }, null)]);
+                    }
+                  });
+                }
+              }), t["append-item"]?.()]
+            })]
+          }), o.value.map((X, fe) => {
+            function z(Q) {
+              Q.stopPropagation(), Q.preventDefault(), ue(X, !1);
+            }
+            const ye = L(st.filterProps(X.props), {
+              "onClick:close": z,
+              onKeydown(Q) {
+                Q.key !== "Enter" && Q.key !== " " || (Q.preventDefault(), Q.stopPropagation(), z(Q));
+              },
+              onMousedown(Q) {
+                Q.preventDefault(), Q.stopPropagation();
+              },
+              modelValue: !0,
+              "onUpdate:modelValue": void 0
+            }), S = V ? !!t.chip : !!t.selection, Y = S ? $l(V ? t.chip({
+              item: X,
+              index: fe,
+              props: ye
+            }) : t.selection({
+              item: X,
+              index: fe
+            })) : void 0;
+            if (!(S && !Y))
+              return b("div", {
+                key: X.value,
+                class: "v-select__selection"
+              }, [V ? t.chip ? f(Ae, {
+                key: "chip-defaults",
+                defaults: {
+                  VChip: {
+                    closable: x.value,
+                    size: "small",
+                    text: X.title
+                  }
+                }
+              }, {
+                default: () => [Y]
+              }) : f(st, L({
+                key: "chip",
+                closable: x.value,
+                size: "small",
+                text: X.title,
+                disabled: X.props.disabled
+              }, ye), null) : Y ?? b("span", {
+                class: "v-select__selection-text"
+              }, [X.title, e.multiple && fe < o.value.length - 1 && b("span", {
+                class: "v-select__selection-comma"
+              }, [vl(",")])])]);
+          })]);
+        },
+        "append-inner": function() {
+          for (var ge = arguments.length, Fe = new Array(ge), X = 0; X < ge; X++)
+            Fe[X] = arguments[X];
+          return b(ce, null, [t["append-inner"]?.(...Fe), 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: Fe[0].iconColor.value
+          }, null)]);
+        }
+      });
+    }), gt({
+      isFocused: h,
+      menu: p,
+      select: ue
+    }, 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 = G({
+  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 C of _) {
+          const k = El(o, C), T = t?.customKeyFilter?.[C];
+          if (g = T ? T(k, a, d) : l(k, a, d), g !== -1 && g !== !1)
+            T ? r[C] = Ot(g, a) : m[C] = 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, x = Object.keys(r).length;
+      if (!h && !x || t?.filterMode === "union" && x !== c && !h || t?.filterMode === "intersection" && (x !== 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 = I(() => n?.transform ? M(a).map((u) => [u, n.transform(u)]) : M(a));
+  Rt(() => {
+    const u = typeof t == "function" ? t() : M(t), d = typeof u != "string" && typeof u != "number" ? "" : String(u), o = Oa(c.value, d, {
+      customKeyFilter: {
+        ...e.customKeyFilter,
+        ...M(n?.customKeyFilter)
+      },
+      default: e.customFilter,
+      filterKeys: e.filterKeys,
+      filterMode: e.filterMode,
+      noFilter: e.noFilter
+    }), r = M(a), m = [], g = /* @__PURE__ */ new Map();
+    o.forEach((y) => {
+      let {
+        index: h,
+        matches: x
+      } = y;
+      const _ = r[h];
+      m.push(_), g.set(_.value, x);
+    }), 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: oe(`${e}__unmask`)
+    }, [a.slice(i, n[0])]), b("span", {
+      class: oe(`${e}__mask`)
+    }, [a.slice(n[0], n[1])])];
+    return l === t.length - 1 && c.push(b("span", {
+      class: oe(`${e}__unmask`)
+    }, [a.slice(n[1])])), b(ce, null, [c]);
+  });
+}
+const $a = G({
+  autoSelectFirst: {
+    type: [Boolean, String]
+  },
+  clearOnSelect: Boolean,
+  search: String,
+  ...Ea({
+    filterKeys: ["title"]
+  }),
+  ...an(),
+  ...Ge(Tt({
+    modelValue: null,
+    role: "combobox"
+  }), ["validationValue", "dirty"])
+}, "VAutocomplete"), Na = ie()({
+  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: x
+    } = mt(() => l.value?.color), {
+      InputIcon: _
+    } = Ft(e), C = we(e, "search", ""), k = we(e, "modelValue", [], (S) => g(S === null ? [null] : De(S)), (S) => {
+      const Y = y(S);
+      return e.multiple ? Y : Y[0] ?? null;
+    }), T = I(() => typeof e.counterValue == "function" ? e.counterValue(k.value) : typeof e.counterValue == "number" ? e.counterValue : k.value.length), F = Dt(e), {
+      filteredItems: H,
+      getMatches: A
+    } = Ra(e, m, () => r.value ?? (c.value ? "" : C.value)), p = I(() => e.hideSelected && r.value === null ? H.value.filter((S) => !k.value.some((Y) => Y.value === S.value)) : H.value), R = B(() => e.closableChips && !F.isReadonly.value && !F.isDisabled.value), E = I(() => !!(e.chips || t.chip)), q = I(() => E.value || !!t.selection), te = I(() => k.value.map((S) => S.props.value)), ee = I(() => p.value.find((S) => S.type === "item" && !S.props.disabled)), U = I(() => (e.autoSelectFirst === !0 || e.autoSelectFirst === "exact" && C.value === ee.value?.title) && p.value.length > 0 && !c.value && !s.value), K = I(() => e.hideNoData && !p.value.length || F.isReadonly.value || F.isDisabled.value), Z = we(e, "menu"), N = I({
+      get: () => Z.value,
+      set: (S) => {
+        Z.value && !S && u.value?.ΨopenChildren.size || S && K.value || (Z.value = S);
+      }
+    }), {
+      menuId: ne,
+      ariaExpanded: ue,
+      ariaControls: D
+    } = nn(e, N), $ = W(), w = ln($, l);
+    function v(S) {
+      e.openOnClear && (N.value = !0), C.value = "";
+    }
+    function P() {
+      K.value || (N.value = !0);
+    }
+    function V(S) {
+      K.value || (i.value && (S.preventDefault(), S.stopPropagation()), N.value = !N.value);
+    }
+    function O(S) {
+      (St(S) || S.key === "Backspace") && l.value?.focus();
+    }
+    function j(S) {
+      if (F.isReadonly.value) return;
+      const Y = l.value?.selectionStart, Q = k.value.length;
+      if (["Enter", "ArrowDown", "ArrowUp"].includes(S.key) && S.preventDefault(), ["Enter", "ArrowDown"].includes(S.key) && (N.value = !0), ["Escape"].includes(S.key) && (N.value = !1), U.value && ["Enter", "Tab"].includes(S.key) && ee.value && !k.value.some((ae) => {
+        let {
+          value: Ce
+        } = ae;
+        return Ce === ee.value.value;
+      }) && ye(ee.value), S.key === "ArrowDown" && U.value && $.value?.focus("next"), ["Backspace", "Delete"].includes(S.key)) {
+        if (!e.multiple && q.value && k.value.length > 0 && !C.value) return ye(k.value[0], !1);
+        if (~o.value) {
+          S.preventDefault();
+          const ae = o.value;
+          ye(k.value[o.value], !1), o.value = ae >= Q - 1 ? Q - 2 : ae;
+        } else S.key === "Backspace" && !C.value && (o.value = Q - 1);
+        return;
+      }
+      if (e.multiple)
+        if (S.key === "ArrowLeft") {
+          if (o.value < 0 && Y && Y > 0) return;
+          const ae = o.value > -1 ? o.value - 1 : Q - 1;
+          if (k.value[ae])
+            o.value = ae;
+          else {
+            const Ce = C.value?.length ?? null;
+            o.value = -1, l.value?.setSelectionRange(Ce, Ce);
+          }
+        } else if (S.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(S) && (o.value = -1);
+    }
+    function ve(S) {
+      if (ot(l.value, ":autofill") || ot(l.value, ":-webkit-autofill")) {
+        const Y = m.value.find((Q) => Q.title === S.target.value);
+        Y && ye(Y);
+      }
+    }
+    function me() {
+      e.eager && d.value?.calculateVisibleItems();
+    }
+    function ge() {
+      i.value && (c.value = !0, l.value?.focus()), r.value = null;
+    }
+    function Fe(S) {
+      i.value = !0, setTimeout(() => {
+        s.value = !0;
+      });
+    }
+    function X(S) {
+      s.value = !1;
+    }
+    function fe(S) {
+      (S == null || S === "" && !e.multiple && !q.value) && (k.value = []);
+    }
+    const z = J(!1);
+    function ye(S) {
+      let Y = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : !0;
+      if (!(!S || S.props.disabled))
+        if (e.multiple) {
+          const Q = k.value.findIndex((Ce) => (e.valueComparator || We)(Ce.value, S.value)), ae = Y ?? !~Q;
+          if (~Q) {
+            const Ce = ae ? [...k.value, S] : [...k.value];
+            Ce.splice(Q, 1), k.value = Ce;
+          } else ae && (k.value = [...k.value, S]);
+          e.clearOnSelect && (C.value = "");
+        } else {
+          const Q = Y !== !1;
+          k.value = Q ? [S] : [], r.value = c.value ? "" : C.value ?? "", C.value = Q && !q.value ? S.title : "", Ve(() => {
+            N.value = !1, c.value = !0;
+          });
+        }
+    }
+    return re(i, (S, Y) => {
+      S !== Y && (S ? (z.value = !0, C.value = e.multiple || q.value ? "" : String(k.value.at(-1)?.props.title ?? ""), c.value = !0, Ve(() => z.value = !1)) : (!e.multiple && C.value == null && (k.value = []), N.value = !1, !c.value && C.value && (r.value = C.value), C.value = "", o.value = -1));
+    }), re(C, (S) => {
+      !i.value || z.value || (S && (N.value = !0), c.value = !S);
+    }), re(N, (S) => {
+      if (!e.hideSelected && S && k.value.length && c.value) {
+        const Y = p.value.findIndex((Q) => k.value.some((ae) => Q.value === ae.value));
+        at && window.requestAnimationFrame(() => {
+          Y >= 0 && d.value?.scrollToIndex(Y);
+        });
+      }
+      S && (r.value = null);
+    }), re(m, (S, Y) => {
+      N.value || i.value && !Y.length && S.length && (N.value = !0);
+    }), de(() => {
+      const S = !!(!e.hideNoData || p.value.length || t["prepend-item"] || t["append-item"] || t["no-data"]), Y = k.value.length > 0, Q = Ke.filterProps(e);
+      return f(Ke, L({
+        ref: l
+      }, Q, {
+        modelValue: C.value,
+        "onUpdate:modelValue": [(ae) => C.value = ae, fe],
+        focused: i.value,
+        "onUpdate:focused": (ae) => i.value = ae,
+        validationValue: k.externalValue,
+        counterValue: T.value,
+        dirty: Y,
+        onChange: ve,
+        class: ["v-autocomplete", `v-autocomplete--${e.multiple ? "multiple" : "single"}`, {
+          "v-autocomplete--active-menu": N.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: Y ? void 0 : e.placeholder,
+        "onClick:clear": v,
+        "onMousedown:control": P,
+        onKeydown: j,
+        "aria-expanded": ue.value,
+        "aria-controls": D.value
+      }), {
+        ...t,
+        default: (ae) => {
+          let {
+            id: Ce
+          } = ae;
+          return b(ce, null, [f(Rl, L({
+            id: ne.value,
+            ref: u,
+            modelValue: N.value,
+            "onUpdate:modelValue": (he) => N.value = he,
+            activator: "parent",
+            contentClass: "v-autocomplete__content",
+            disabled: K.value,
+            eager: e.eager,
+            maxHeight: 310,
+            openOnClick: !1,
+            closeOnContentClick: !1,
+            onAfterEnter: me,
+            onAfterLeave: ge
+          }, e.menuProps), {
+            default: () => [S && f(Yt, L({
+              ref: $,
+              filterable: !0,
+              selected: te.value,
+              selectStrategy: e.multiple ? "independent" : "single-independent",
+              onMousedown: (he) => he.preventDefault(),
+              onKeydown: O,
+              onFocusin: Fe,
+              onFocusout: X,
+              tabindex: "-1",
+              selectable: !!p.value.length,
+              "aria-live": "polite",
+              "aria-labelledby": `${Ce.value}-label`,
+              "aria-multiselectable": e.multiple,
+              color: e.itemColor ?? e.color
+            }, w, 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 = L(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, L(se.props, {
+                    key: `divider-${Ee}`
+                  }), null) : se.type === "subheader" ? t.subheader?.({
+                    props: se.raw,
+                    index: Ee
+                  }) ?? f(Ml, L(se.props, {
+                    key: `subheader-${Ee}`
+                  }), null) : t.item?.({
+                    item: se,
+                    index: Ee,
+                    props: et
+                  }) ?? f(it, L(et, {
+                    role: "option"
+                  }), {
+                    prepend: (tt) => {
+                      let {
+                        isSelected: Pe
+                      } = tt;
+                      return b(ce, null, [e.multiple && !e.hideSelected ? f(Jl, {
+                        key: se.value,
+                        modelValue: Pe,
+                        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(Pe) {
+              Pe.stopPropagation(), Pe.preventDefault(), ye(he, !1);
+            }
+            const yt = L(st.filterProps(he.props), {
+              "onClick:close": Ee,
+              onKeydown(Pe) {
+                Pe.key !== "Enter" && Pe.key !== " " || (Pe.preventDefault(), Pe.stopPropagation(), Ee(Pe));
+              },
+              onMousedown(Pe) {
+                Pe.preventDefault(), Pe.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: oe(["v-autocomplete__selection", se === o.value && ["v-autocomplete__selection--selected", h.value]]),
+                style: xe(se === o.value ? x.value : {})
+              }, [E.value ? t.chip ? f(Ae, {
+                key: "chip-defaults",
+                defaults: {
+                  VChip: {
+                    closable: R.value,
+                    size: "small",
+                    text: he.title
+                  }
+                }
+              }, {
+                default: () => [tt]
+              }) : f(st, L({
+                key: "chip",
+                closable: R.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(ce, 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: N,
+      search: C,
+      filteredItems: H,
+      select: ye
+    }, l);
+  }
+}), La = G({
+  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 = ie()({
+  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 de(() => {
+      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, L({
+        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", L({
+            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 = G({
+  fullscreen: Boolean,
+  scrollable: Boolean,
+  ...Ge(On({
+    captureFocus: !0,
+    origin: "center center",
+    scrollStrategy: "block",
+    transition: {
+      component: Nl
+    },
+    zIndex: 2400,
+    retainFocus: !0
+  }), ["disableInitialFocus"])
+}, "VDialog"), on = ie()({
+  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
+      }));
+    }), de(() => {
+      const d = al.filterProps(e), o = L({
+        "aria-haspopup": "dialog"
+      }, e.activatorProps), r = L({
+        tabindex: -1
+      }, e.contentProps);
+      return f(al, L({
+        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(Ae, {
+            root: "VDialog"
+          }, {
+            default: () => [n.default?.(...g)]
+          });
+        }
+      });
+    }), gt({}, c);
+  }
+}), Ua = G({
+  ...pe(),
+  ...Be()
+}, "VCardActions"), un = ie()({
+  name: "VCardActions",
+  props: Ua(),
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    return zt({
+      VBtn: {
+        slim: !0,
+        variant: "text"
+      }
+    }), de(() => f(e.tag, {
+      class: oe(["v-card-actions", e.class]),
+      style: xe(e.style)
+    }, t)), {};
+  }
+}), Ka = G({
+  opacity: [Number, String],
+  ...pe(),
+  ...Be()
+}, "VCardSubtitle"), ja = ie()({
+  name: "VCardSubtitle",
+  props: Ka(),
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    return de(() => f(e.tag, {
+      class: oe(["v-card-subtitle", e.class]),
+      style: xe([{
+        "--v-card-subtitle-opacity": e.opacity
+      }, e.style])
+    }, t)), {};
+  }
+}), Zt = Rn("v-card-title"), Ga = G({
+  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 = ie()({
+  name: "VCardItem",
+  props: Ga(),
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    return de(() => {
+      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: oe(["v-card-item", e.class]),
+        style: xe(e.style)
+      }, {
+        default: () => [l && b("div", {
+          key: "prepend",
+          class: "v-card-item__prepend"
+        }, [t.prepend ? f(Ae, {
+          key: "prepend-defaults",
+          disabled: !n,
+          defaults: {
+            VAvatar: {
+              density: e.density,
+              image: e.prependAvatar
+            },
+            VIcon: {
+              density: e.density,
+              icon: e.prependIcon
+            }
+          }
+        }, t.prepend) : b(ce, 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(Ae, {
+          key: "append-defaults",
+          disabled: !i,
+          defaults: {
+            VAvatar: {
+              density: e.density,
+              image: e.appendAvatar
+            },
+            VIcon: {
+              density: e.density,
+              icon: e.appendIcon
+            }
+          }
+        }, t.append) : b(ce, 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 = G({
+  opacity: [Number, String],
+  ...pe(),
+  ...Be()
+}, "VCardText"), el = ie()({
+  name: "VCardText",
+  props: qa(),
+  setup(e, a) {
+    let {
+      slots: t
+    } = a;
+    return de(() => f(e.tag, {
+      class: oe(["v-card-text", e.class]),
+      style: xe([{
+        "--v-card-text-opacity": e.opacity
+      }, e.style])
+    }, t)), {};
+  }
+}), Ja = G({
+  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 = ie()({
+  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), x = pl(e, t), _ = J(void 0);
+    return re(() => e.loading, (C, k) => {
+      _.value = !C && typeof k == "string" ? k : typeof C == "boolean" ? void 0 : C;
+    }, {
+      immediate: !0
+    }), de(() => {
+      const C = e.link !== !1 && x.isLink.value, k = !e.disabled && e.link !== !1 && (e.link || x.isClickable.value), T = C ? "a" : e.tag, F = !!(n.title || e.title != null), H = !!(n.subtitle || e.subtitle != null), A = F || H, p = !!(n.append || e.appendAvatar || e.appendIcon), R = !!(n.prepend || e.prependAvatar || e.prependIcon), E = !!(n.image || e.image), q = A || R || p, te = !!(n.text || e.text != null);
+      return He(f(T, L(x.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 && x.navigate,
+        tabindex: e.disabled ? -1 : void 0
+      }), {
+        default: () => [E && b("div", {
+          key: "image",
+          class: "v-card__image"
+        }, [n.image ? f(Ae, {
+          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 = G({
+  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 = ie()({
+  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 = I(() => c.isDisabled.value || c.isReadonly.value), u = J(e.focused), {
+      decimalSeparator: d
+    } = Ze(), o = I(() => 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 O = P == null ? String(v) : v.toFixed(P);
+      if (u.value && V)
+        return Number(O).toString().replace(".", o.value);
+      if (e.minFractionDigits === null || P !== null && P < e.minFractionDigits)
+        return O.replace(".", o.value);
+      let [j, ve] = O.split(".");
+      return ve = (ve ?? "").padEnd(e.minFractionDigits, "0").replace(new RegExp(`(?<=\\d{${e.minFractionDigits}})0+$`, "g"), ""), [j, ve].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 = I({
+      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));
+      }
+    }), x = I(() => {
+      if (y.value === null) return !1;
+      const v = Number(g.value?.replace(o.value, "."));
+      return v !== Me(v, e.min, e.max);
+    }), _ = I(() => s.value ? !1 : (m.value ?? 0) + e.step <= e.max), C = I(() => s.value ? !1 : (m.value ?? 0) - e.step >= e.min), k = I(() => e.hideInput ? "stacked" : e.controlVariant), T = B(() => k.value === "split" ? "$plus" : "$collapse"), F = B(() => k.value === "split" ? "$minus" : "$expand"), H = B(() => k.value === "split" ? "default" : "small"), A = B(() => k.value === "stacked" ? "auto" : "100%"), p = {
+      props: {
+        onClick: U,
+        onPointerup: K,
+        onPointerdown: Z,
+        onPointercancel: K
+      }
+    }, R = {
+      props: {
+        onClick: U,
+        onPointerup: K,
+        onPointerdown: N,
+        onPointercancel: K
+      }
+    };
+    re(() => e.precision, () => ue()), re(() => e.minFractionDigits, () => ue()), Ye(() => {
+      ne();
+    });
+    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)) : C.value && (h.value = r(m.value - e.step, P));
+    }
+    function te(v) {
+      if (!v.data) return;
+      const P = v.target, {
+        value: V,
+        selectionStart: O,
+        selectionEnd: j
+      } = P ?? {}, ve = V ? V.slice(0, O) + v.data + V.slice(j) : v.data, me = $n(ve, e.precision, o.value);
+      if (new RegExp(`^-?\\d*${Nn(o.value)}?\\d*$`).test(ve) || (v.preventDefault(), P.value = me, Ve(() => h.value = me)), e.precision != null) {
+        if (ve.split(o.value)[1]?.length > e.precision) {
+          v.preventDefault(), P.value = me, Ve(() => h.value = me);
+          const ge = (O ?? 0) + v.data.length;
+          P.setSelectionRange(ge, ge);
+        }
+        e.precision === 0 && ve.endsWith(o.value) && (v.preventDefault(), P.value = me, Ve(() => h.value = me));
+      }
+    }
+    async function ee(v) {
+      ["Enter", "ArrowLeft", "ArrowRight", "Backspace", "Delete", "Tab"].includes(v.key) || v.ctrlKey || ["ArrowDown", "ArrowUp"].includes(v.key) && (v.preventDefault(), v.stopPropagation(), ne(), await Ve(), v.key === "ArrowDown" ? q(!1) : q());
+    }
+    function U(v) {
+      v.stopPropagation();
+    }
+    function K(v) {
+      v.currentTarget?.releasePointerCapture(v.pointerId), v.preventDefault(), i();
+    }
+    function Z(v) {
+      v.currentTarget?.setPointerCapture(v.pointerId), v.preventDefault(), v.stopPropagation(), l("up");
+    }
+    function N(v) {
+      v.currentTarget?.setPointerCapture(v.pointerId), v.preventDefault(), v.stopPropagation(), l("down");
+    }
+    function ne() {
+      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 ue() {
+      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 $() {
+      D();
+    }
+    function w() {
+      ne();
+    }
+    return de(() => {
+      const {
+        modelValue: v,
+        type: P,
+        ...V
+      } = Ke.filterProps(e);
+      function O() {
+        return t.increment ? f(Ae, {
+          key: "increment-defaults",
+          defaults: {
+            VBtn: {
+              disabled: !_.value,
+              height: A.value,
+              size: H.value,
+              icon: T.value,
+              variant: "text"
+            }
+          }
+        }, {
+          default: () => [t.increment(p)]
+        }) : f(qe, {
+          "aria-hidden": "true",
+          "data-testid": "increment",
+          disabled: !_.value,
+          height: A.value,
+          icon: T.value,
+          key: "increment-btn",
+          onClick: U,
+          onPointerdown: Z,
+          onPointerup: K,
+          onPointercancel: K,
+          size: H.value,
+          variant: "text",
+          tabindex: "-1"
+        }, null);
+      }
+      function j() {
+        return t.decrement ? f(Ae, {
+          key: "decrement-defaults",
+          defaults: {
+            VBtn: {
+              disabled: !C.value,
+              height: A.value,
+              size: H.value,
+              icon: F.value,
+              variant: "text"
+            }
+          }
+        }, {
+          default: () => [t.decrement(R)]
+        }) : f(qe, {
+          "aria-hidden": "true",
+          "data-testid": "decrement",
+          disabled: !C.value,
+          height: A.value,
+          icon: F.value,
+          key: "decrement-btn",
+          onClick: U,
+          onPointerdown: N,
+          onPointerup: K,
+          onPointercancel: K,
+          size: H.value,
+          variant: "text",
+          tabindex: "-1"
+        }, null);
+      }
+      function ve() {
+        return b("div", {
+          class: "v-number-input__control"
+        }, [j(), f(Le, {
+          vertical: k.value !== "stacked"
+        }, null), O()]);
+      }
+      function me() {
+        return !e.hideInput && !e.inset ? f(Le, {
+          vertical: !0
+        }, null) : void 0;
+      }
+      const ge = k.value === "split" ? b("div", {
+        class: "v-number-input__control"
+      }, [f(Le, {
+        vertical: !0
+      }, null), O()]) : e.reverse || k.value === "hidden" ? void 0 : b(ce, null, [me(), ve()]), Fe = t["append-inner"] || ge, X = k.value === "split" ? b("div", {
+        class: "v-number-input__control"
+      }, [j(), f(Le, {
+        vertical: !0
+      }, null)]) : e.reverse && k.value !== "hidden" ? b(ce, null, [ve(), me()]) : void 0, fe = t["prepend-inner"] || X;
+      return f(Ke, L({
+        ref: n
+      }, V, {
+        modelValue: h.value,
+        "onUpdate:modelValue": (z) => h.value = z,
+        focused: u.value,
+        "onUpdate:focused": (z) => u.value = z,
+        validationValue: m.value,
+        error: e.error || x.value || void 0,
+        onBeforeinput: te,
+        onFocus: $,
+        onBlur: w,
+        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": Fe ? function() {
+          for (var z = arguments.length, ye = new Array(z), S = 0; S < z; S++)
+            ye[S] = arguments[S];
+          return b(ce, null, [t["append-inner"]?.(...ye), ge]);
+        } : void 0,
+        "prepend-inner": fe ? function() {
+          for (var z = arguments.length, ye = new Array(z), S = 0; S < z; S++)
+            ye[S] = arguments[S];
+          return b(ce, null, [X, 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 = _e("table_props"), n = _e("datatablesPluginOptions"), l = Vt(e, "modelValue"), i = a, c = {
+      textfield: Ke,
+      select: Na,
+      number: eo,
+      datepicker: Te(
+        () => import("./Datepicker-BO2Ixl4r.js")
+      ),
+      comparison: Te(
+        () => import("./Comparison-C2hZMBq4.js")
+      )
+    }, s = I(() => 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: Ie(() => [
+        f(Zt, { class: "d-flex justify-space-between align-center" }, {
+          default: Ie(() => [
+            b("div", to, bt(d.$t("$datatables.advancedFilters")), 1),
+            f(qe, {
+              icon: M(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: Ie(() => [
+            (le(!0), ze(ce, null, Ht(M(s), (r, m) => (le(), ze("div", {
+              id: `advanced-filter-${r.key}`,
+              key: `filter-${m}`,
+              class: oe(`advanced-filter advanced-filter--${r.key}`)
+            }, [
+              (le(), ke(Oe(u(r.advancedFilter?.component)), L({
+                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: Ie(() => [
+            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 = _e("table_props"), s = _e("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: Ie(({ isActive: g }) => [
+            f(r, {
+              modelValue: M(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(M(t)).length ? (le(), ke(m, {
+          key: 0,
+          modelValue: M(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 = _e("datatablesPluginOptions"), { t: a } = zn(), { advancedFiltersState: t } = At(), n = W(!1), l = I(() => Object.keys(t.value).length);
+  return { advancedFiltersItems: I(() => [
+    {
+      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(ce, null, Ht(M(a), (s, u) => (le(), ke(qe, L({
+          key: u,
+          icon: "",
+          variant: "text",
+          color: M(n) ? "primary" : "dark",
+          density: "comfortable"
+        }, { ref_for: !0 }, s), {
+          default: Ie(() => [
+            M(n) ? (le(), ke(Ha, {
+              key: 0,
+              color: "primary",
+              content: M(n)
+            }, {
+              default: Ie(() => [
+                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: M(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-CdHQz2KW.js")), t = Te(() => import("./RefreshTable-BNy_MWZg.js")), n = Te(() => import("./Options-DrhE_fto.js")), l = Te(() => import("./index-BU9rb0Q-.js")), i = Te(() => import("./index-DzyBRRkM.js")), c = Te(() => import("./index-zhSEiNN0.js")), s = _e("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 })),
+        M(s).hardFilters.length ? (le(), ke(Oe(M(d).hardFilters ?? M(l)), {
+          key: 1,
+          id: "header-hardFilters"
+        })) : Re("", !0),
+        (le(), ke(Oe(M(d).toolbar), { id: "header-toolbar" })),
+        b("div", so, [
+          (le(), ke(Oe(M(d).search ?? M(a)), { id: "header-search" })),
+          e.responsiveHeader ? Re("", !0) : (le(), ke(Oe(M(d).columns ?? M(i)), {
+            key: 0,
+            "component-refs": { columns: M(u) }
+          }, null, 8, ["component-refs"])),
+          e.responsiveHeader ? Re("", !0) : (le(), ke(Oe(M(d).download ?? M(c)), { key: 1 })),
+          e.responsiveHeader ? Re("", !0) : (le(), ke(Oe(M(d).refreshTable ?? M(t)), { key: 2 })),
+          (le(), ke(Oe(M(d).options ?? M(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 = I(() => 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(
+      (x) => x.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 x = await l(JSON.stringify(e.headers ?? []));
+        h !== x && 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-DHHVRPoA.js")), l = Te(() => import("./TableServer-D4Q_9dET.js")), { storeOptions: i } = rn(), { saveTableOptions: c } = At(), s = Vt(e, "modelValue"), u = _e("table_props"), d = _e("datatablesPluginOptions"), o = W(null), r = W(!1), m = W(!1), g = W(!1), y = t, h = Pt(), { dataStateGet: x, tableDataState: _, checkTableState: C } = co(u), { addTable: k, restoreData: T } = h, F = W(!1);
+    Kn(o, (A) => {
+      const p = A[0], { width: R } = p.contentRect;
+      F.value = R < 950;
+    });
+    const H = I(() => {
+      const A = u.options?.header;
+      return A === void 0 || typeof A == "object" && A !== null;
+    });
+    return Ye(async () => {
+      k({ table_id: u.id }), await C();
+      const A = x();
+      if (A)
+        T({ table_id: u.id, data: A });
+      else {
+        const R = _.value.options.columns;
+        R.selected = u.headers.filter((E) => !E.hidden).map((E) => E.key), R.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 R = ro;
+      return M(m) ? (le(), ze("div", vo, [
+        f(sn, null, {
+          default: Ie(() => [
+            M(H) ? (le(), ke(Zt, { key: 0 }, {
+              default: Ie(() => [
+                f(R, { "responsive-header": M(F) }, null, 8, ["responsive-header"])
+              ]),
+              _: 1
+            })) : Re("", !0),
+            f(el, { class: "pa-0" }, {
+              default: Ie(() => [
+                M(g) ? (le(), ke(Oe(M(u).api ? M(l) : M(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: M(r),
+          "onUpdate:modelValue": p[1] || (p[1] = (E) => pt(r) ? r.value = E : null),
+          "max-width": "350",
+          persistent: ""
+        }, {
+          default: Ie(() => [
+            f(Yt, {
+              class: "py-2",
+              color: "primary",
+              elevation: "12",
+              rounded: "lg"
+            }, {
+              default: Ie(() => [
+                f(it, {
+                  "prepend-icon": M(d).header.icons.download,
+                  title: A.$t("$datatables.preparing_download_file")
+                }, {
+                  prepend: Ie(() => [
+                    b("div", fo, [
+                      f(Se, {
+                        color: "primary",
+                        size: "x-large"
+                      })
+                    ])
+                  ]),
+                  append: Ie(() => [
+                    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}-${M(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
+};