@ianicdev/datatables2 0.11.6 → 0.12.0

package/dist/index-vAe2qE0y.js

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