@ianicdev/datatables2 0.13.3 → 0.14.1

package/dist/index-BIU6vg82.js

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