@ianicdev/datatables2 0.8.11 → 0.8.13

package/dist/cellRender-L5NaGvf8.js

@@ -0,0 +1,2269 @@
+import { shallowRef as ie, computed as V, unref as q, watchEffect as He, toRef as C, provide as Y, toRaw as ne, inject as Q, ref as j, toValue as Dt, watch as de, onBeforeUpdate as Tt, createVNode as k, normalizeStyle as we, normalizeClass as G, createElementVNode as S, mergeProps as B, nextTick as Te, capitalize as Ct, Fragment as U, createTextVNode as Ce, withModifiers as re, toDisplayString as _t, toRefs as Bt, defineComponent as Lt, h as Ot } from "vue";
+import { aP as At, U as Et, p as _, N as z, aA as ee, K as J, aQ as ue, _ as je, J as Ge, af as he, aR as Nt, T as Z, aS as se, g as $, a0 as Rt, h as ke, aj as ce, a as xe, al as $t, aT as oe, u as K, a9 as W, x as Mt, y as Ie, m as Ke, as as Ht, A as jt, E as We, f as ae, b as ze, G as Gt, I as L, aU as _e, aV as Kt, ax as A, aW as Wt, o as zt, P as Ue, L as Ut, D as Jt, ao as Ve, d as Be, H as ye, a1 as Se, k as Qt, aa as Xt, l as Yt, n as Zt, F as qt } from "./dataTables-qd_2hmGP.js";
+import { V as Je, a as ea, b as Fe, u as ta, c as aa } from "./index-Dt2Z193z.js";
+function Le(e, t, a) {
+  return Object.keys(e).filter((l) => At(l) && l.endsWith(t)).reduce((l, n) => (l[n.slice(0, -t.length)] = (r) => Et(e[n], r, a(r)), l), {});
+}
+const la = (e, t, a) => {
+  if (e == null || t == null) return -1;
+  if (!t.length) return 0;
+  e = e.toString().toLocaleLowerCase(), t = t.toString().toLocaleLowerCase();
+  const l = [];
+  let n = e.indexOf(t);
+  for (; ~n; )
+    l.push([n, n + t.length]), n = e.indexOf(t, n + t.length);
+  return l.length ? l : -1;
+};
+function pe(e, t) {
+  if (!(e == null || typeof e == "boolean" || e === -1))
+    return typeof e == "number" ? [[e, e + t.length]] : Array.isArray(e[0]) ? e : [e];
+}
+const na = _({
+  customFilter: Function,
+  customKeyFilter: Object,
+  filterKeys: [Array, String],
+  filterMode: {
+    type: String,
+    default: "intersection"
+  },
+  noFilter: Boolean
+}, "filter");
+function ra(e, t, a) {
+  const l = [], n = a?.default ?? la, r = a?.filterKeys ? z(a.filterKeys) : !1, o = Object.keys(a?.customKeyFilter ?? {}).length;
+  if (!e?.length) return l;
+  let u = null;
+  e: for (let s = 0; s < e.length; s++) {
+    const [i, f = i] = z(e[s]), m = {}, d = {};
+    let c = -1;
+    if ((t || o > 0) && !a?.noFilter) {
+      let y = !1;
+      if (typeof i == "object") {
+        if (i.type === "divider" || i.type === "subheader") {
+          u?.type === "divider" && i.type === "subheader" && l.push(u), u = {
+            index: s,
+            matches: {},
+            type: i.type
+          };
+          continue;
+        }
+        const F = r || Object.keys(f);
+        y = F.length === o;
+        for (const h of F) {
+          const I = ee(f, h), D = a?.customKeyFilter?.[h];
+          if (c = D ? D(I, t, i) : n(I, t, i), c !== -1 && c !== !1)
+            D ? m[h] = pe(c, t) : d[h] = pe(c, t);
+          else if (a?.filterMode === "every")
+            continue e;
+        }
+      } else
+        c = n(i, t, i), c !== -1 && c !== !1 && (d.title = pe(c, t));
+      const b = Object.keys(d).length, v = Object.keys(m).length;
+      if (!b && !v || a?.filterMode === "union" && v !== o && !b || a?.filterMode === "intersection" && (v !== o || !b && o > 0 && !y)) continue;
+    }
+    u && (l.push(u), u = null), l.push({
+      index: s,
+      matches: {
+        ...d,
+        ...m
+      }
+    });
+  }
+  return l;
+}
+function sa(e, t, a, l) {
+  const n = ie([]), r = ie(/* @__PURE__ */ new Map()), o = V(() => l?.transform ? q(t).map((s) => [s, l.transform(s)]) : q(t));
+  He(() => {
+    const s = typeof a == "function" ? a() : q(a), i = typeof s != "string" && typeof s != "number" ? "" : String(s), f = ra(o.value, i, {
+      customKeyFilter: {
+        ...e.customKeyFilter,
+        ...q(l?.customKeyFilter)
+      },
+      default: e.customFilter,
+      filterKeys: e.filterKeys,
+      filterMode: e.filterMode,
+      noFilter: e.noFilter
+    }), m = q(t), d = [], c = /* @__PURE__ */ new Map();
+    f.forEach((y) => {
+      let {
+        index: b,
+        matches: v
+      } = y;
+      const F = m[b];
+      d.push(F), c.set(F.value, v);
+    }), n.value = d, r.value = c;
+  });
+  function u(s) {
+    return r.value.get(s.value);
+  }
+  return {
+    filteredItems: n,
+    filteredMatches: r,
+    getMatches: u
+  };
+}
+const oa = _({
+  expandOnClick: Boolean,
+  showExpand: Boolean,
+  expanded: {
+    type: Array,
+    default: () => []
+  }
+}, "DataTable-expand"), Qe = Symbol.for("vuetify:datatable:expanded");
+function ia(e) {
+  const t = C(() => e.expandOnClick), a = J(e, "expanded", e.expanded, (u) => new Set(u), (u) => [...u.values()]);
+  function l(u, s) {
+    const i = new Set(a.value), f = ne(u.value);
+    if (s)
+      i.add(f);
+    else {
+      const m = [...a.value].find((d) => ne(d) === f);
+      i.delete(m);
+    }
+    a.value = i;
+  }
+  function n(u) {
+    const s = ne(u.value);
+    return [...a.value].some((i) => ne(i) === s);
+  }
+  function r(u) {
+    l(u, !n(u));
+  }
+  const o = {
+    expand: l,
+    expanded: a,
+    expandOnClick: t,
+    isExpanded: n,
+    toggleExpand: r
+  };
+  return Y(Qe, o), o;
+}
+function Xe() {
+  const e = Q(Qe);
+  if (!e) throw new Error("foo");
+  return e;
+}
+const ua = _({
+  groupBy: {
+    type: Array,
+    default: () => []
+  }
+}, "DataTable-group"), Ye = Symbol.for("vuetify:data-table-group");
+function da(e) {
+  return {
+    groupBy: J(e, "groupBy")
+  };
+}
+function ca(e) {
+  const {
+    disableSort: t,
+    groupBy: a,
+    sortBy: l
+  } = e, n = j(/* @__PURE__ */ new Set()), r = V(() => a.value.map((f) => ({
+    ...f,
+    order: f.order ?? !1
+  })).concat(t?.value ? [] : l.value));
+  function o(f) {
+    return n.value.has(f.id);
+  }
+  function u(f) {
+    const m = new Set(n.value);
+    o(f) ? m.delete(f.id) : m.add(f.id), n.value = m;
+  }
+  function s(f) {
+    function m(d) {
+      const c = [];
+      for (const y of d.items)
+        "type" in y && y.type === "group" ? c.push(...m(y)) : c.push(y);
+      return [...new Set(c)];
+    }
+    return m({
+      items: f
+    });
+  }
+  const i = {
+    sortByWithGroups: r,
+    toggleGroup: u,
+    opened: n,
+    groupBy: a,
+    extractRows: s,
+    isGroupOpen: o
+  };
+  return Y(Ye, i), i;
+}
+function Ze() {
+  const e = Q(Ye);
+  if (!e) throw new Error("Missing group!");
+  return e;
+}
+function fa(e, t) {
+  if (!e.length) return [];
+  const a = /* @__PURE__ */ new Map();
+  for (const l of e) {
+    const n = ue(l.raw, t);
+    a.has(n) || a.set(n, []), a.get(n).push(l);
+  }
+  return a;
+}
+function qe(e, t) {
+  let a = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0, l = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : "root";
+  if (!t.length) return [];
+  const n = fa(e, t[0]), r = [], o = t.slice(1);
+  return n.forEach((u, s) => {
+    const i = t[0], f = `${l}_${i}_${s}`;
+    r.push({
+      depth: a,
+      id: f,
+      key: i,
+      value: s,
+      items: o.length ? qe(u, o, a + 1, f) : u,
+      type: "group"
+    });
+  }), r;
+}
+function et(e, t, a) {
+  const l = [];
+  for (const n of e)
+    "type" in n && n.type === "group" ? (n.value != null && l.push(n), (t.has(n.id) || n.value == null) && (l.push(...et(n.items, t, a)), a && l.push({
+      ...n,
+      type: "group-summary"
+    }))) : l.push(n);
+  return l;
+}
+function va(e, t, a, l) {
+  return {
+    flatItems: V(() => {
+      if (!t.value.length) return e.value;
+      const r = qe(e.value, t.value.map((o) => o.key));
+      return et(r, a.value, Dt(l));
+    })
+  };
+}
+function ga(e) {
+  let {
+    page: t,
+    itemsPerPage: a,
+    sortBy: l,
+    groupBy: n,
+    search: r
+  } = e;
+  const o = je("VDataTable"), u = () => ({
+    page: t.value,
+    itemsPerPage: a.value,
+    sortBy: l.value,
+    groupBy: n.value,
+    search: r.value
+  });
+  let s = null;
+  de(u, (i) => {
+    Ge(s, i) || (s && s.search !== i.search && (t.value = 1), o.emit("update:options", i), s = i);
+  }, {
+    deep: !0,
+    immediate: !0
+  });
+}
+const ma = _({
+  page: {
+    type: [Number, String],
+    default: 1
+  },
+  itemsPerPage: {
+    type: [Number, String],
+    default: 10
+  }
+}, "DataTable-paginate"), tt = Symbol.for("vuetify:data-table-pagination");
+function ba(e) {
+  const t = J(e, "page", void 0, (l) => Number(l ?? 1)), a = J(e, "itemsPerPage", void 0, (l) => Number(l ?? 10));
+  return {
+    page: t,
+    itemsPerPage: a
+  };
+}
+function ha(e) {
+  const {
+    page: t,
+    itemsPerPage: a,
+    itemsLength: l
+  } = e, n = V(() => a.value === -1 ? 0 : a.value * (t.value - 1)), r = V(() => a.value === -1 ? l.value : Math.min(l.value, n.value + a.value)), o = V(() => a.value === -1 || l.value === 0 ? 1 : Math.ceil(l.value / a.value));
+  de([t, o], () => {
+    t.value > o.value && (t.value = o.value);
+  });
+  function u(d) {
+    a.value = d, t.value = 1;
+  }
+  function s() {
+    t.value = he(t.value + 1, 1, o.value);
+  }
+  function i() {
+    t.value = he(t.value - 1, 1, o.value);
+  }
+  function f(d) {
+    t.value = he(d, 1, o.value);
+  }
+  const m = {
+    page: t,
+    itemsPerPage: a,
+    startIndex: n,
+    stopIndex: r,
+    pageCount: o,
+    itemsLength: l,
+    nextPage: s,
+    prevPage: i,
+    setPage: f,
+    setItemsPerPage: u
+  };
+  return Y(tt, m), m;
+}
+function ya() {
+  const e = Q(tt);
+  if (!e) throw new Error("Missing pagination!");
+  return e;
+}
+function pa(e) {
+  const t = je("usePaginatedItems"), {
+    items: a,
+    startIndex: l,
+    stopIndex: n,
+    itemsPerPage: r
+  } = e, o = V(() => r.value <= 0 ? a.value : a.value.slice(l.value, n.value));
+  return de(o, (u) => {
+    t.emit("update:currentItems", u);
+  }, {
+    immediate: !0
+  }), {
+    paginatedItems: o
+  };
+}
+const xa = {
+  showSelectAll: !1,
+  allSelected: () => [],
+  select: (e) => {
+    let {
+      items: t,
+      value: a
+    } = e;
+    return new Set(a ? [t[0]?.value] : []);
+  },
+  selectAll: (e) => {
+    let {
+      selected: t
+    } = e;
+    return t;
+  }
+}, at = {
+  showSelectAll: !0,
+  allSelected: (e) => {
+    let {
+      currentPage: t
+    } = e;
+    return t;
+  },
+  select: (e) => {
+    let {
+      items: t,
+      value: a,
+      selected: l
+    } = e;
+    for (const n of t)
+      a ? l.add(n.value) : l.delete(n.value);
+    return l;
+  },
+  selectAll: (e) => {
+    let {
+      value: t,
+      currentPage: a,
+      selected: l
+    } = e;
+    return at.select({
+      items: a,
+      value: t,
+      selected: l
+    });
+  }
+}, Sa = {
+  showSelectAll: !0,
+  allSelected: (e) => {
+    let {
+      allItems: t
+    } = e;
+    return t;
+  },
+  select: (e) => {
+    let {
+      items: t,
+      value: a,
+      selected: l
+    } = e;
+    for (const n of t)
+      a ? l.add(n.value) : l.delete(n.value);
+    return l;
+  },
+  selectAll: (e) => {
+    let {
+      value: t,
+      allItems: a
+    } = e;
+    return new Set(t ? a.map((l) => l.value) : []);
+  }
+}, Pa = _({
+  showSelect: Boolean,
+  selectStrategy: {
+    type: [String, Object],
+    default: "page"
+  },
+  modelValue: {
+    type: Array,
+    default: () => []
+  },
+  valueComparator: Function
+}, "DataTable-select"), lt = Symbol.for("vuetify:data-table-selection");
+function wa(e, t) {
+  let {
+    allItems: a,
+    currentPage: l
+  } = t;
+  const n = J(e, "modelValue", e.modelValue, (h) => {
+    const I = e.valueComparator;
+    return I ? new Set(z(h).map((D) => a.value.find((P) => I(D, P.value))?.value ?? D)) : new Set(z(h).map((D) => Nt(D) ? a.value.find((P) => D === P.value)?.value ?? D : a.value.find((P) => Ge(D, P.value))?.value ?? D));
+  }, (h) => [...h.values()]), r = V(() => a.value.filter((h) => h.selectable)), o = V(() => l.value.filter((h) => h.selectable)), u = V(() => {
+    if (typeof e.selectStrategy == "object") return e.selectStrategy;
+    switch (e.selectStrategy) {
+      case "single":
+        return xa;
+      case "all":
+        return Sa;
+      case "page":
+      default:
+        return at;
+    }
+  }), s = ie(null);
+  function i(h) {
+    return z(h).every((I) => n.value.has(I.value));
+  }
+  function f(h) {
+    return z(h).some((I) => n.value.has(I.value));
+  }
+  function m(h, I) {
+    const D = u.value.select({
+      items: h,
+      value: I,
+      selected: new Set(n.value)
+    });
+    n.value = D;
+  }
+  function d(h, I, D) {
+    const P = [];
+    if (I = I ?? l.value.findIndex((O) => O.value === h.value), e.selectStrategy !== "single" && D?.shiftKey && s.value !== null) {
+      const [O, N] = [s.value, I].sort((p, x) => p - x);
+      P.push(...l.value.slice(O, N + 1).filter((p) => p.selectable));
+    } else
+      P.push(h), s.value = I;
+    m(P, !i([h]));
+  }
+  function c(h) {
+    const I = u.value.selectAll({
+      value: h,
+      allItems: r.value,
+      currentPage: o.value,
+      selected: new Set(n.value)
+    });
+    n.value = I;
+  }
+  const y = V(() => n.value.size > 0), b = V(() => {
+    const h = u.value.allSelected({
+      allItems: r.value,
+      currentPage: o.value
+    });
+    return !!h.length && i(h);
+  }), v = C(() => u.value.showSelectAll), F = {
+    toggleSelect: d,
+    select: m,
+    selectAll: c,
+    isSelected: i,
+    isSomeSelected: f,
+    someSelected: y,
+    allSelected: b,
+    showSelectAll: v,
+    lastSelectedIndex: s,
+    selectStrategy: u
+  };
+  return Y(lt, F), F;
+}
+function fe() {
+  const e = Q(lt);
+  if (!e) throw new Error("Missing selection!");
+  return e;
+}
+const ka = _({
+  sortBy: {
+    type: Array,
+    default: () => []
+  },
+  customKeySort: Object,
+  multiSort: Boolean,
+  mustSort: Boolean
+}, "DataTable-sort"), nt = Symbol.for("vuetify:data-table-sort");
+function Ia(e) {
+  const t = J(e, "sortBy"), a = C(() => e.mustSort), l = C(() => e.multiSort);
+  return {
+    sortBy: t,
+    mustSort: a,
+    multiSort: l
+  };
+}
+function Va(e) {
+  const {
+    sortBy: t,
+    mustSort: a,
+    multiSort: l,
+    page: n
+  } = e, r = (s) => {
+    if (s.key == null) return;
+    let i = t.value.map((m) => ({
+      ...m
+    })) ?? [];
+    const f = i.find((m) => m.key === s.key);
+    f ? f.order === "desc" ? a.value && i.length === 1 ? f.order = "asc" : i = i.filter((m) => m.key !== s.key) : f.order = "desc" : l.value ? i.push({
+      key: s.key,
+      order: "asc"
+    }) : i = [{
+      key: s.key,
+      order: "asc"
+    }], t.value = i, n && (n.value = 1);
+  };
+  function o(s) {
+    return !!t.value.find((i) => i.key === s.key);
+  }
+  const u = {
+    sortBy: t,
+    toggleSort: r,
+    isSorted: o
+  };
+  return Y(nt, u), u;
+}
+function rt() {
+  const e = Q(nt);
+  if (!e) throw new Error("Missing sort!");
+  return e;
+}
+function Fa(e, t, a, l) {
+  const n = Z();
+  return {
+    sortedItems: V(() => a.value.length ? Da(t.value, a.value, n.current.value, {
+      transform: l?.transform,
+      sortFunctions: {
+        ...e.customKeySort,
+        ...l?.sortFunctions?.value
+      },
+      sortRawFunctions: l?.sortRawFunctions?.value
+    }) : t.value)
+  };
+}
+function Da(e, t, a, l) {
+  const n = new Intl.Collator(a, {
+    sensitivity: "accent",
+    usage: "sort"
+  });
+  return e.map((o) => [o, l?.transform ? l.transform(o) : o]).sort((o, u) => {
+    for (let s = 0; s < t.length; s++) {
+      let i = !1;
+      const f = t[s].key, m = t[s].order ?? "asc";
+      if (m === !1) continue;
+      let d = ue(o[1], f), c = ue(u[1], f), y = o[0].raw, b = u[0].raw;
+      if (m === "desc" && ([d, c] = [c, d], [y, b] = [b, y]), l?.sortRawFunctions?.[f]) {
+        const v = l.sortRawFunctions[f](y, b);
+        if (v == null) continue;
+        if (i = !0, v) return v;
+      }
+      if (l?.sortFunctions?.[f]) {
+        const v = l.sortFunctions[f](d, c);
+        if (v == null) continue;
+        if (i = !0, v) return v;
+      }
+      if (!i && (d instanceof Date && c instanceof Date && (d = d.getTime(), c = c.getTime()), [d, c] = [d, c].map((v) => v != null ? v.toString().toLocaleLowerCase() : v), d !== c))
+        return se(d) && se(c) ? 0 : se(d) ? -1 : se(c) ? 1 : !isNaN(d) && !isNaN(c) ? Number(d) - Number(c) : n.compare(d, c);
+    }
+    return 0;
+  }).map((o) => {
+    let [u] = o;
+    return u;
+  });
+}
+function Ta() {
+  const e = j([]);
+  Tt(() => e.value = []);
+  function t(a, l) {
+    e.value[l] = a;
+  }
+  return {
+    refs: e,
+    updateRef: t
+  };
+}
+const Ca = _({
+  activeColor: String,
+  start: {
+    type: [Number, String],
+    default: 1
+  },
+  modelValue: {
+    type: Number,
+    default: (e) => e.start
+  },
+  disabled: Boolean,
+  length: {
+    type: [Number, String],
+    default: 1,
+    validator: (e) => e % 1 === 0
+  },
+  totalVisible: [Number, String],
+  firstIcon: {
+    type: L,
+    default: "$first"
+  },
+  prevIcon: {
+    type: L,
+    default: "$prev"
+  },
+  nextIcon: {
+    type: L,
+    default: "$next"
+  },
+  lastIcon: {
+    type: L,
+    default: "$last"
+  },
+  ariaLabel: {
+    type: String,
+    default: "$vuetify.pagination.ariaLabel.root"
+  },
+  pageAriaLabel: {
+    type: String,
+    default: "$vuetify.pagination.ariaLabel.page"
+  },
+  currentPageAriaLabel: {
+    type: String,
+    default: "$vuetify.pagination.ariaLabel.currentPage"
+  },
+  firstAriaLabel: {
+    type: String,
+    default: "$vuetify.pagination.ariaLabel.first"
+  },
+  previousAriaLabel: {
+    type: String,
+    default: "$vuetify.pagination.ariaLabel.previous"
+  },
+  nextAriaLabel: {
+    type: String,
+    default: "$vuetify.pagination.ariaLabel.next"
+  },
+  lastAriaLabel: {
+    type: String,
+    default: "$vuetify.pagination.ariaLabel.last"
+  },
+  ellipsis: {
+    type: String,
+    default: "..."
+  },
+  showFirstLastPage: Boolean,
+  ...Gt(),
+  ...ze(),
+  ...ae(),
+  ...We(),
+  ...jt(),
+  ...Ht(),
+  ...Ke({
+    tag: "nav"
+  }),
+  ...Ie(),
+  ...Mt({
+    variant: "text"
+  })
+}, "VPagination"), Oe = $()({
+  name: "VPagination",
+  props: Ca(),
+  emits: {
+    "update:modelValue": (e) => !0,
+    first: (e) => !0,
+    prev: (e) => !0,
+    next: (e) => !0,
+    last: (e) => !0
+  },
+  setup(e, t) {
+    let {
+      slots: a,
+      emit: l
+    } = t;
+    const n = J(e, "modelValue"), {
+      t: r,
+      n: o
+    } = Z(), {
+      isRtl: u
+    } = Rt(), {
+      themeClasses: s
+    } = ke(e), {
+      width: i
+    } = ce(), f = ie(-1);
+    xe(void 0, {
+      scoped: !0
+    });
+    const {
+      resizeRef: m
+    } = $t((p) => {
+      if (!p.length) return;
+      const {
+        target: x,
+        contentRect: g
+      } = p[0], w = x.querySelector(".v-pagination__list > *");
+      if (!w) return;
+      const T = g.width, R = w.offsetWidth + parseFloat(getComputedStyle(w).marginRight) * 2;
+      f.value = b(T, R);
+    }), d = V(() => parseInt(e.length, 10)), c = V(() => parseInt(e.start, 10)), y = V(() => e.totalVisible != null ? parseInt(e.totalVisible, 10) : f.value >= 0 ? f.value : b(i.value, 58));
+    function b(p, x) {
+      const g = e.showFirstLastPage ? 5 : 3;
+      return Math.max(0, Math.floor(
+        // Round to two decimal places to avoid floating point errors
+        Number(((p - x * g) / x).toFixed(2))
+      ));
+    }
+    const v = V(() => {
+      if (d.value <= 0 || isNaN(d.value) || d.value > Number.MAX_SAFE_INTEGER) return [];
+      if (y.value <= 0) return [];
+      if (y.value === 1) return [n.value];
+      if (d.value <= y.value)
+        return oe(d.value, c.value);
+      const p = y.value % 2 === 0, x = p ? y.value / 2 : Math.floor(y.value / 2), g = p ? x : x + 1, w = d.value - x;
+      if (g - n.value >= 0)
+        return [...oe(Math.max(1, y.value - 1), c.value), e.ellipsis, d.value];
+      if (n.value - w >= (p ? 1 : 0)) {
+        const T = y.value - 1, R = d.value - T + c.value;
+        return [c.value, e.ellipsis, ...oe(T, R)];
+      } else {
+        const T = Math.max(1, y.value - 2), R = T === 1 ? n.value : n.value - Math.ceil(T / 2) + c.value;
+        return [c.value, e.ellipsis, ...oe(T, R), e.ellipsis, d.value];
+      }
+    });
+    function F(p, x, g) {
+      p.preventDefault(), n.value = x, g && l(g, x);
+    }
+    const {
+      refs: h,
+      updateRef: I
+    } = Ta();
+    xe({
+      VPaginationBtn: {
+        color: C(() => e.color),
+        border: C(() => e.border),
+        density: C(() => e.density),
+        size: C(() => e.size),
+        variant: C(() => e.variant),
+        rounded: C(() => e.rounded),
+        elevation: C(() => e.elevation)
+      }
+    });
+    const D = V(() => v.value.map((p, x) => {
+      const g = (w) => I(w, x);
+      if (typeof p == "string")
+        return {
+          isActive: !1,
+          key: `ellipsis-${x}`,
+          page: p,
+          props: {
+            ref: g,
+            ellipsis: !0,
+            icon: !0,
+            disabled: !0
+          }
+        };
+      {
+        const w = p === n.value;
+        return {
+          isActive: w,
+          key: p,
+          page: o(p),
+          props: {
+            ref: g,
+            ellipsis: !1,
+            icon: !0,
+            disabled: !!e.disabled || Number(e.length) < 2,
+            color: w ? e.activeColor : e.color,
+            "aria-current": w,
+            "aria-label": r(w ? e.currentPageAriaLabel : e.pageAriaLabel, p),
+            onClick: (T) => F(T, p)
+          }
+        };
+      }
+    })), P = V(() => {
+      const p = !!e.disabled || n.value <= c.value, x = !!e.disabled || n.value >= c.value + d.value - 1;
+      return {
+        first: e.showFirstLastPage ? {
+          icon: u.value ? e.lastIcon : e.firstIcon,
+          onClick: (g) => F(g, c.value, "first"),
+          disabled: p,
+          "aria-label": r(e.firstAriaLabel),
+          "aria-disabled": p
+        } : void 0,
+        prev: {
+          icon: u.value ? e.nextIcon : e.prevIcon,
+          onClick: (g) => F(g, n.value - 1, "prev"),
+          disabled: p,
+          "aria-label": r(e.previousAriaLabel),
+          "aria-disabled": p
+        },
+        next: {
+          icon: u.value ? e.prevIcon : e.nextIcon,
+          onClick: (g) => F(g, n.value + 1, "next"),
+          disabled: x,
+          "aria-label": r(e.nextAriaLabel),
+          "aria-disabled": x
+        },
+        last: e.showFirstLastPage ? {
+          icon: u.value ? e.firstIcon : e.lastIcon,
+          onClick: (g) => F(g, c.value + d.value - 1, "last"),
+          disabled: x,
+          "aria-label": r(e.lastAriaLabel),
+          "aria-disabled": x
+        } : void 0
+      };
+    });
+    function O() {
+      const p = n.value - c.value;
+      h.value[p]?.$el.focus();
+    }
+    function N(p) {
+      p.key === _e.left && !e.disabled && n.value > Number(e.start) ? (n.value = n.value - 1, Te(O)) : p.key === _e.right && !e.disabled && n.value < c.value + d.value - 1 && (n.value = n.value + 1, Te(O));
+    }
+    return K(() => k(e.tag, {
+      ref: m,
+      class: G(["v-pagination", s.value, e.class]),
+      style: we(e.style),
+      role: "navigation",
+      "aria-label": r(e.ariaLabel),
+      onKeydown: N,
+      "data-test": "v-pagination-root"
+    }, {
+      default: () => [S("ul", {
+        class: "v-pagination__list"
+      }, [e.showFirstLastPage && S("li", {
+        key: "first",
+        class: "v-pagination__first",
+        "data-test": "v-pagination-first"
+      }, [a.first ? a.first(P.value.first) : k(W, B({
+        _as: "VPaginationBtn"
+      }, P.value.first), null)]), S("li", {
+        key: "prev",
+        class: "v-pagination__prev",
+        "data-test": "v-pagination-prev"
+      }, [a.prev ? a.prev(P.value.prev) : k(W, B({
+        _as: "VPaginationBtn"
+      }, P.value.prev), null)]), D.value.map((p, x) => S("li", {
+        key: p.key,
+        class: G(["v-pagination__item", {
+          "v-pagination__item--is-active": p.isActive
+        }]),
+        "data-test": "v-pagination-item"
+      }, [a.item ? a.item(p) : k(W, B({
+        _as: "VPaginationBtn"
+      }, p.props), {
+        default: () => [p.page]
+      })])), S("li", {
+        key: "next",
+        class: "v-pagination__next",
+        "data-test": "v-pagination-next"
+      }, [a.next ? a.next(P.value.next) : k(W, B({
+        _as: "VPaginationBtn"
+      }, P.value.next), null)]), e.showFirstLastPage && S("li", {
+        key: "last",
+        class: "v-pagination__last",
+        "data-test": "v-pagination-last"
+      }, [a.last ? a.last(P.value.last) : k(W, B({
+        _as: "VPaginationBtn"
+      }, P.value.last), null)])])]
+    })), {};
+  }
+}), st = _({
+  prevIcon: {
+    type: L,
+    default: "$prev"
+  },
+  nextIcon: {
+    type: L,
+    default: "$next"
+  },
+  firstIcon: {
+    type: L,
+    default: "$first"
+  },
+  lastIcon: {
+    type: L,
+    default: "$last"
+  },
+  itemsPerPageText: {
+    type: String,
+    default: "$vuetify.dataFooter.itemsPerPageText"
+  },
+  pageText: {
+    type: String,
+    default: "$vuetify.dataFooter.pageText"
+  },
+  firstPageLabel: {
+    type: String,
+    default: "$vuetify.dataFooter.firstPage"
+  },
+  prevPageLabel: {
+    type: String,
+    default: "$vuetify.dataFooter.prevPage"
+  },
+  nextPageLabel: {
+    type: String,
+    default: "$vuetify.dataFooter.nextPage"
+  },
+  lastPageLabel: {
+    type: String,
+    default: "$vuetify.dataFooter.lastPage"
+  },
+  itemsPerPageOptions: {
+    type: Array,
+    default: () => [{
+      value: 10,
+      title: "10"
+    }, {
+      value: 25,
+      title: "25"
+    }, {
+      value: 50,
+      title: "50"
+    }, {
+      value: 100,
+      title: "100"
+    }, {
+      value: -1,
+      title: "$vuetify.dataFooter.itemsPerPageAll"
+    }]
+  },
+  showCurrentPage: Boolean
+}, "VDataTableFooter"), Ae = $()({
+  name: "VDataTableFooter",
+  props: st(),
+  setup(e, t) {
+    let {
+      slots: a
+    } = t;
+    const {
+      t: l
+    } = Z(), {
+      page: n,
+      pageCount: r,
+      startIndex: o,
+      stopIndex: u,
+      itemsLength: s,
+      itemsPerPage: i,
+      setItemsPerPage: f
+    } = ya(), m = V(() => e.itemsPerPageOptions.map((d) => typeof d == "number" ? {
+      value: d,
+      title: d === -1 ? l("$vuetify.dataFooter.itemsPerPageAll") : String(d)
+    } : {
+      ...d,
+      title: isNaN(Number(d.title)) ? l(d.title) : d.title
+    }));
+    return K(() => {
+      const d = Oe.filterProps(e);
+      return S("div", {
+        class: "v-data-table-footer"
+      }, [a.prepend?.(), S("div", {
+        class: "v-data-table-footer__items-per-page"
+      }, [S("span", {
+        "aria-label": l(e.itemsPerPageText)
+      }, [l(e.itemsPerPageText)]), k(Je, {
+        items: m.value,
+        modelValue: i.value,
+        "onUpdate:modelValue": (c) => f(Number(c)),
+        density: "compact",
+        variant: "outlined",
+        hideDetails: !0
+      }, null)]), S("div", {
+        class: "v-data-table-footer__info"
+      }, [S("div", null, [l(e.pageText, s.value ? o.value + 1 : 0, u.value, s.value)])]), S("div", {
+        class: "v-data-table-footer__pagination"
+      }, [k(Oe, B({
+        modelValue: n.value,
+        "onUpdate:modelValue": (c) => n.value = c,
+        density: "comfortable",
+        firstAriaLabel: e.firstPageLabel,
+        lastAriaLabel: e.lastPageLabel,
+        length: r.value,
+        nextAriaLabel: e.nextPageLabel,
+        previousAriaLabel: e.prevPageLabel,
+        rounded: !0,
+        showFirstLastPage: !0,
+        totalVisible: e.showCurrentPage ? 1 : 0,
+        variant: "plain"
+      }, d), null)])]);
+    }), {};
+  }
+}), te = Kt({
+  align: {
+    type: String,
+    default: "start"
+  },
+  fixed: {
+    type: [Boolean, String],
+    default: !1
+  },
+  fixedOffset: [Number, String],
+  fixedEndOffset: [Number, String],
+  height: [Number, String],
+  lastFixed: Boolean,
+  firstFixedEnd: Boolean,
+  noPadding: Boolean,
+  indent: [Number, String],
+  empty: Boolean,
+  tag: String,
+  width: [Number, String],
+  maxWidth: [Number, String],
+  nowrap: Boolean
+}, (e, t) => {
+  let {
+    slots: a
+  } = t;
+  const l = e.tag ?? "td", n = typeof e.fixed == "string" ? e.fixed : e.fixed ? "start" : "none";
+  return k(l, {
+    class: G(["v-data-table__td", {
+      "v-data-table-column--fixed": n === "start",
+      "v-data-table-column--fixed-end": n === "end",
+      "v-data-table-column--last-fixed": e.lastFixed,
+      "v-data-table-column--first-fixed-end": e.firstFixedEnd,
+      "v-data-table-column--no-padding": e.noPadding,
+      "v-data-table-column--nowrap": e.nowrap,
+      "v-data-table-column--empty": e.empty
+    }, `v-data-table-column--align-${e.align}`]),
+    style: {
+      height: A(e.height),
+      width: A(e.width),
+      maxWidth: A(e.maxWidth),
+      left: n === "start" ? A(e.fixedOffset || null) : void 0,
+      right: n === "end" ? A(e.fixedEndOffset || null) : void 0,
+      paddingInlineStart: e.indent ? A(e.indent) : void 0
+    }
+  }, {
+    default: () => [a.default?.()]
+  });
+}), _a = _({
+  headers: Array
+}, "DataTable-header"), ot = Symbol.for("vuetify:data-table-headers"), it = {
+  title: "",
+  sortable: !1
+}, Ba = {
+  ...it,
+  width: 48
+};
+function La() {
+  const t = (arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : []).map((a) => ({
+    element: a,
+    priority: 0
+  }));
+  return {
+    enqueue: (a, l) => {
+      let n = !1;
+      for (let r = 0; r < t.length; r++)
+        if (t[r].priority > l) {
+          t.splice(r, 0, {
+            element: a,
+            priority: l
+          }), n = !0;
+          break;
+        }
+      n || t.push({
+        element: a,
+        priority: l
+      });
+    },
+    size: () => t.length,
+    count: () => {
+      let a = 0;
+      if (!t.length) return 0;
+      const l = Math.floor(t[0].priority);
+      for (let n = 0; n < t.length; n++)
+        Math.floor(t[n].priority) === l && (a += 1);
+      return a;
+    },
+    dequeue: () => t.shift()
+  };
+}
+function Pe(e) {
+  let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  if (!e.children)
+    t.push(e);
+  else
+    for (const a of e.children)
+      Pe(a, t);
+  return t;
+}
+function ut(e) {
+  let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : /* @__PURE__ */ new Set();
+  for (const a of e)
+    a.key && t.add(a.key), a.children && ut(a.children, t);
+  return t;
+}
+function Oa(e) {
+  if (e.key) {
+    if (e.key === "data-table-group") return it;
+    if (["data-table-expand", "data-table-select"].includes(e.key)) return Ba;
+  }
+}
+function De(e) {
+  let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+  return e.children ? Math.max(t, ...e.children.map((a) => De(a, t + 1))) : t;
+}
+function Aa(e) {
+  let t = !1;
+  function a(r, o) {
+    let u = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "none";
+    if (r)
+      if (u !== "none" && (r.fixed = u), r.fixed === !0 && (r.fixed = "start"), r.fixed === o)
+        if (r.children)
+          if (o === "start")
+            for (let s = r.children.length - 1; s >= 0; s--)
+              a(r.children[s], o, o);
+          else
+            for (let s = 0; s < r.children.length; s++)
+              a(r.children[s], o, o);
+        else
+          !t && o === "start" ? r.lastFixed = !0 : !t && o === "end" ? r.firstFixedEnd = !0 : isNaN(Number(r.width)) ? Wt(`Multiple fixed columns should have a static width (key: ${r.key})`) : r.minWidth = Math.max(Number(r.width) || 0, Number(r.minWidth) || 0), t = !0;
+      else if (r.children)
+        if (o === "start")
+          for (let s = r.children.length - 1; s >= 0; s--)
+            a(r.children[s], o);
+        else
+          for (let s = 0; s < r.children.length; s++)
+            a(r.children[s], o);
+      else
+        t = !1;
+  }
+  for (let r = e.length - 1; r >= 0; r--)
+    a(e[r], "start");
+  for (let r = 0; r < e.length; r++)
+    a(e[r], "end");
+  let l = 0;
+  for (let r = 0; r < e.length; r++)
+    l = dt(e[r], l);
+  let n = 0;
+  for (let r = e.length - 1; r >= 0; r--)
+    n = ct(e[r], n);
+}
+function dt(e) {
+  let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+  if (!e) return t;
+  if (e.children) {
+    e.fixedOffset = t;
+    for (const a of e.children)
+      t = dt(a, t);
+  } else e.fixed && e.fixed !== "end" && (e.fixedOffset = t, t += parseFloat(e.width || "0") || 0);
+  return t;
+}
+function ct(e) {
+  let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+  if (!e) return t;
+  if (e.children) {
+    e.fixedEndOffset = t;
+    for (const a of e.children)
+      t = ct(a, t);
+  } else e.fixed === "end" && (e.fixedEndOffset = t, t += parseFloat(e.width || "0") || 0);
+  return t;
+}
+function Ea(e, t) {
+  const a = [];
+  let l = 0;
+  const n = La(e);
+  for (; n.size() > 0; ) {
+    let o = n.count();
+    const u = [];
+    let s = 1;
+    for (; o > 0; ) {
+      const {
+        element: i,
+        priority: f
+      } = n.dequeue(), m = t - l - De(i);
+      if (u.push({
+        ...i,
+        rowspan: m ?? 1,
+        colspan: i.children ? Pe(i).length : 1
+      }), i.children)
+        for (const d of i.children) {
+          const c = f % 1 + s / Math.pow(10, l + 2);
+          n.enqueue(d, l + m + c);
+        }
+      s += 1, o -= 1;
+    }
+    l += 1, a.push(u);
+  }
+  return {
+    columns: e.map((o) => Pe(o)).flat(),
+    headers: a
+  };
+}
+function ft(e) {
+  const t = [];
+  for (const a of e) {
+    const l = {
+      ...Oa(a),
+      ...a
+    }, n = l.key ?? (typeof l.value == "string" ? l.value : null), r = l.value ?? n ?? null, o = {
+      ...l,
+      key: n,
+      value: r,
+      sortable: l.sortable ?? (l.key != null || !!l.sort),
+      children: l.children ? ft(l.children) : void 0
+    };
+    t.push(o);
+  }
+  return t;
+}
+function Na(e, t) {
+  const a = j([]), l = j([]), n = j({}), r = j({}), o = j({});
+  He(() => {
+    const i = (e.headers || Object.keys(e.items[0] ?? {}).map((b) => ({
+      key: b,
+      title: Ct(b)
+    }))).slice(), f = ut(i);
+    t?.groupBy?.value.length && !f.has("data-table-group") && i.unshift({
+      key: "data-table-group",
+      title: "Group"
+    }), t?.showSelect?.value && !f.has("data-table-select") && i.unshift({
+      key: "data-table-select"
+    }), t?.showExpand?.value && !f.has("data-table-expand") && i.push({
+      key: "data-table-expand"
+    });
+    const m = ft(i);
+    Aa(m);
+    const d = Math.max(...m.map((b) => De(b))) + 1, c = Ea(m, d);
+    a.value = c.headers, l.value = c.columns;
+    const y = c.headers.flat(1);
+    for (const b of y)
+      b.key && (b.sortable && (b.sort && (n.value[b.key] = b.sort), b.sortRaw && (r.value[b.key] = b.sortRaw)), b.filter && (o.value[b.key] = b.filter));
+  });
+  const u = {
+    headers: a,
+    columns: l,
+    sortFunctions: n,
+    sortRawFunctions: r,
+    filterFunctions: o
+  };
+  return Y(ot, u), u;
+}
+function ve() {
+  const e = Q(ot);
+  if (!e) throw new Error("Missing headers!");
+  return e;
+}
+const vt = _({
+  color: String,
+  disableSort: Boolean,
+  fixedHeader: Boolean,
+  multiSort: Boolean,
+  sortAscIcon: {
+    type: L,
+    default: "$sortAsc"
+  },
+  sortDescIcon: {
+    type: L,
+    default: "$sortDesc"
+  },
+  headerProps: {
+    type: Object
+  },
+  /** @deprecated */
+  sticky: Boolean,
+  ...ae(),
+  ...Ve(),
+  ...Jt()
+}, "VDataTableHeaders"), Ee = $()({
+  name: "VDataTableHeaders",
+  props: vt(),
+  setup(e, t) {
+    let {
+      slots: a
+    } = t;
+    const {
+      t: l
+    } = Z(), {
+      toggleSort: n,
+      sortBy: r,
+      isSorted: o
+    } = rt(), {
+      someSelected: u,
+      allSelected: s,
+      selectAll: i,
+      showSelectAll: f
+    } = fe(), {
+      columns: m,
+      headers: d
+    } = ve(), {
+      loaderClasses: c
+    } = zt(e);
+    function y(x, g) {
+      if (!(e.sticky || e.fixedHeader) && !x.fixed) return;
+      const w = typeof x.fixed == "string" ? x.fixed : x.fixed ? "start" : "none";
+      return {
+        position: "sticky",
+        left: w === "start" ? A(x.fixedOffset) : void 0,
+        right: w === "end" ? A(x.fixedEndOffset) : void 0,
+        top: e.sticky || e.fixedHeader ? `calc(var(--v-table-header-height) * ${g})` : void 0
+      };
+    }
+    function b(x, g) {
+      x.key === "Enter" && !e.disableSort && n(g);
+    }
+    function v(x) {
+      const g = r.value.find((w) => w.key === x.key);
+      return g ? g.order === "asc" ? e.sortAscIcon : e.sortDescIcon : e.sortAscIcon;
+    }
+    const {
+      backgroundColorClasses: F,
+      backgroundColorStyles: h
+    } = Ue(() => e.color), {
+      displayClasses: I,
+      mobile: D
+    } = ce(e), P = V(() => ({
+      headers: d.value,
+      columns: m.value,
+      toggleSort: n,
+      isSorted: o,
+      sortBy: r.value,
+      someSelected: u.value,
+      allSelected: s.value,
+      selectAll: i,
+      getSortIcon: v
+    })), O = V(() => ["v-data-table__th", {
+      "v-data-table__th--sticky": e.sticky || e.fixedHeader
+    }, I.value, c.value]), N = (x) => {
+      let {
+        column: g,
+        x: w,
+        y: T
+      } = x;
+      const R = g.key === "data-table-select" || g.key === "data-table-expand", le = g.key === "data-table-group" && g.width === 0 && !g.title, me = B(e.headerProps ?? {}, g.headerProps ?? {});
+      return k(te, B({
+        tag: "th",
+        align: g.align,
+        class: [{
+          "v-data-table__th--sortable": g.sortable && !e.disableSort,
+          "v-data-table__th--sorted": o(g),
+          "v-data-table__th--fixed": g.fixed
+        }, ...O.value],
+        style: {
+          width: A(g.width),
+          minWidth: A(g.minWidth),
+          maxWidth: A(g.maxWidth),
+          ...y(g, T)
+        },
+        colspan: g.colspan,
+        rowspan: g.rowspan,
+        fixed: g.fixed,
+        nowrap: g.nowrap,
+        lastFixed: g.lastFixed,
+        firstFixedEnd: g.firstFixedEnd,
+        noPadding: R,
+        empty: le,
+        tabindex: g.sortable ? 0 : void 0,
+        onClick: g.sortable ? () => n(g) : void 0,
+        onKeydown: g.sortable ? (M) => b(M, g) : void 0
+      }, me), {
+        default: () => {
+          const M = `header.${g.key}`, X = {
+            column: g,
+            selectAll: i,
+            isSorted: o,
+            toggleSort: n,
+            sortBy: r.value,
+            someSelected: u.value,
+            allSelected: s.value,
+            getSortIcon: v
+          };
+          return a[M] ? a[M](X) : le ? "" : g.key === "data-table-select" ? a["header.data-table-select"]?.(X) ?? (f.value && k(Fe, {
+            density: e.density,
+            modelValue: s.value,
+            indeterminate: u.value && !s.value,
+            "onUpdate:modelValue": i
+          }, null)) : S("div", {
+            class: "v-data-table-header__content"
+          }, [S("span", null, [g.title]), g.sortable && !e.disableSort && k(Be, {
+            key: "icon",
+            class: "v-data-table-header__sort-icon",
+            icon: v(g)
+          }, null), e.multiSort && o(g) && S("div", {
+            key: "badge",
+            class: G(["v-data-table-header__sort-badge", ...F.value]),
+            style: we(h.value)
+          }, [r.value.findIndex((be) => be.key === g.key) + 1])]);
+        }
+      });
+    }, p = () => {
+      const x = V(() => m.value.filter((w) => w?.sortable && !e.disableSort)), g = V(() => {
+        if (m.value.find((T) => T.key === "data-table-select") != null)
+          return s.value ? "$checkboxOn" : u.value ? "$checkboxIndeterminate" : "$checkboxOff";
+      });
+      return k(te, B({
+        tag: "th",
+        class: [...O.value],
+        colspan: d.value.length + 1
+      }, e.headerProps), {
+        default: () => [S("div", {
+          class: "v-data-table-header__content"
+        }, [k(Je, {
+          chips: !0,
+          class: "v-data-table__td-sort-select",
+          clearable: !0,
+          density: "default",
+          items: x.value,
+          label: l("$vuetify.dataTable.sortBy"),
+          multiple: e.multiSort,
+          variant: "underlined",
+          "onClick:clear": () => r.value = [],
+          appendIcon: g.value,
+          "onClick:append": () => i(!s.value)
+        }, {
+          chip: (w) => k(ea, {
+            onClick: w.item.raw?.sortable ? () => n(w.item.raw) : void 0,
+            onMousedown: (T) => {
+              T.preventDefault(), T.stopPropagation();
+            }
+          }, {
+            default: () => [w.item.title, k(Be, {
+              class: G(["v-data-table__td-sort-icon", o(w.item.raw) && "v-data-table__td-sort-icon-active"]),
+              icon: v(w.item.raw),
+              size: "small"
+            }, null)]
+          })
+        })])]
+      });
+    };
+    K(() => D.value ? S("tr", null, [k(p, null, null)]) : S(U, null, [a.headers ? a.headers(P.value) : d.value.map((x, g) => S("tr", null, [x.map((w, T) => k(N, {
+      column: w,
+      x: T,
+      y: g
+    }, null))])), e.loading && S("tr", {
+      class: "v-data-table-progress"
+    }, [S("th", {
+      colspan: m.value.length
+    }, [k(Ut, {
+      name: "v-data-table-progress",
+      absolute: !0,
+      active: !0,
+      color: typeof e.loading == "boolean" ? void 0 : e.loading,
+      indeterminate: !0
+    }, {
+      default: a.loader
+    })])])]));
+  }
+}), gt = _({
+  item: {
+    type: Object,
+    required: !0
+  },
+  groupCollapseIcon: {
+    type: L,
+    default: "$tableGroupCollapse"
+  },
+  groupExpandIcon: {
+    type: L,
+    default: "$tableGroupExpand"
+  },
+  ...ae()
+}, "VDataTableGroupHeaderRow"), Ra = $()({
+  name: "VDataTableGroupHeaderRow",
+  props: gt(),
+  setup(e, t) {
+    let {
+      slots: a
+    } = t;
+    const {
+      isGroupOpen: l,
+      toggleGroup: n,
+      extractRows: r
+    } = Ze(), {
+      isSelected: o,
+      isSomeSelected: u,
+      select: s
+    } = fe(), {
+      columns: i
+    } = ve(), f = V(() => r([e.item])), m = C(() => i.value.length - (i.value.some((d) => d.key === "data-table-select") ? 1 : 0));
+    return () => S("tr", {
+      class: "v-data-table-group-header-row",
+      style: {
+        "--v-data-table-group-header-row-depth": e.item.depth
+      }
+    }, [i.value.map((d) => {
+      if (d.key === "data-table-group") {
+        const c = l(e.item) ? e.groupCollapseIcon : e.groupExpandIcon, y = () => n(e.item);
+        return a["data-table-group"]?.({
+          item: e.item,
+          count: f.value.length,
+          props: {
+            icon: c,
+            onClick: y
+          }
+        }) ?? k(te, {
+          class: "v-data-table-group-header-row__column",
+          colspan: m.value
+        }, {
+          default: () => [k(W, {
+            size: "small",
+            variant: "text",
+            icon: c,
+            onClick: y
+          }, null), S("span", null, [e.item.value]), S("span", null, [Ce("("), f.value.length, Ce(")")])]
+        });
+      } else if (d.key === "data-table-select") {
+        const c = o(f.value), y = u(f.value) && !c, b = (v) => s(f.value, v);
+        return a["data-table-select"]?.({
+          props: {
+            modelValue: c,
+            indeterminate: y,
+            "onUpdate:modelValue": b
+          }
+        }) ?? k(te, {
+          class: "v-data-table__td--select-row",
+          noPadding: !0
+        }, {
+          default: () => [k(Fe, {
+            density: e.density,
+            modelValue: c,
+            indeterminate: y,
+            "onUpdate:modelValue": b
+          }, null)]
+        });
+      }
+      return "";
+    })]);
+  }
+}), mt = _({
+  index: Number,
+  item: Object,
+  cellProps: [Object, Function],
+  collapseIcon: {
+    type: L,
+    default: "$collapse"
+  },
+  expandIcon: {
+    type: L,
+    default: "$expand"
+  },
+  onClick: ye(),
+  onContextmenu: ye(),
+  onDblclick: ye(),
+  ...ae(),
+  ...Ve()
+}, "VDataTableRow"), $a = $()({
+  name: "VDataTableRow",
+  props: mt(),
+  setup(e, t) {
+    let {
+      slots: a
+    } = t;
+    const {
+      displayClasses: l,
+      mobile: n
+    } = ce(e, "v-data-table__tr"), {
+      isSelected: r,
+      toggleSelect: o,
+      someSelected: u,
+      allSelected: s,
+      selectAll: i
+    } = fe(), {
+      isExpanded: f,
+      toggleExpand: m
+    } = Xe(), {
+      toggleSort: d,
+      sortBy: c,
+      isSorted: y
+    } = rt(), {
+      columns: b
+    } = ve();
+    K(() => S("tr", {
+      class: G(["v-data-table__tr", {
+        "v-data-table__tr--clickable": !!(e.onClick || e.onContextmenu || e.onDblclick)
+      }, l.value]),
+      onClick: e.onClick,
+      onContextmenu: e.onContextmenu,
+      onDblclick: e.onDblclick
+    }, [e.item && b.value.map((v, F) => {
+      const h = e.item, I = `item.${v.key}`, D = `header.${v.key}`, P = {
+        index: e.index,
+        item: h.raw,
+        internalItem: h,
+        value: ue(h.columns, v.key),
+        column: v,
+        isSelected: r,
+        toggleSelect: o,
+        isExpanded: f,
+        toggleExpand: m
+      }, O = {
+        column: v,
+        selectAll: i,
+        isSorted: y,
+        toggleSort: d,
+        sortBy: c.value,
+        someSelected: u.value,
+        allSelected: s.value,
+        getSortIcon: () => ""
+      }, N = typeof e.cellProps == "function" ? e.cellProps({
+        index: P.index,
+        item: P.item,
+        internalItem: P.internalItem,
+        value: P.value,
+        column: v
+      }) : e.cellProps, p = typeof v.cellProps == "function" ? v.cellProps({
+        index: P.index,
+        item: P.item,
+        internalItem: P.internalItem,
+        value: P.value
+      }) : v.cellProps, x = v.key === "data-table-select" || v.key === "data-table-expand", g = v.key === "data-table-group" && v.width === 0 && !v.title;
+      return k(te, B({
+        align: v.align,
+        indent: v.intent,
+        class: {
+          "v-data-table__td--expanded-row": v.key === "data-table-expand",
+          "v-data-table__td--select-row": v.key === "data-table-select"
+        },
+        fixed: v.fixed,
+        fixedOffset: v.fixedOffset,
+        fixedEndOffset: v.fixedEndOffset,
+        lastFixed: v.lastFixed,
+        firstFixedEnd: v.firstFixedEnd,
+        maxWidth: n.value ? void 0 : v.maxWidth,
+        noPadding: x,
+        empty: g,
+        nowrap: v.nowrap,
+        width: n.value ? void 0 : v.width
+      }, N, p), {
+        default: () => {
+          if (v.key === "data-table-select")
+            return a["item.data-table-select"]?.({
+              ...P,
+              props: {
+                disabled: !h.selectable,
+                modelValue: r([h]),
+                onClick: re(() => o(h), ["stop"])
+              }
+            }) ?? k(Fe, {
+              disabled: !h.selectable,
+              density: e.density,
+              modelValue: r([h]),
+              onClick: re((T) => o(h, e.index, T), ["stop"])
+            }, null);
+          if (v.key === "data-table-expand")
+            return a["item.data-table-expand"]?.({
+              ...P,
+              props: {
+                icon: f(h) ? e.collapseIcon : e.expandIcon,
+                size: "small",
+                variant: "text",
+                onClick: re(() => m(h), ["stop"])
+              }
+            }) ?? k(W, {
+              icon: f(h) ? e.collapseIcon : e.expandIcon,
+              size: "small",
+              variant: "text",
+              onClick: re(() => m(h), ["stop"])
+            }, null);
+          if (a[I] && !n.value) return a[I](P);
+          const w = _t(P.value);
+          return n.value ? S(U, null, [S("div", {
+            class: "v-data-table__td-title"
+          }, [a[D]?.(O) ?? v.title]), S("div", {
+            class: "v-data-table__td-value"
+          }, [a[I]?.(P) ?? w])]) : w;
+        }
+      });
+    })]));
+  }
+}), bt = _({
+  loading: [Boolean, String],
+  loadingText: {
+    type: String,
+    default: "$vuetify.dataIterator.loadingText"
+  },
+  hideNoData: Boolean,
+  items: {
+    type: Array,
+    default: () => []
+  },
+  noDataText: {
+    type: String,
+    default: "$vuetify.noDataText"
+  },
+  rowProps: [Object, Function],
+  cellProps: [Object, Function],
+  ...Se(mt(), ["collapseIcon", "expandIcon", "density"]),
+  ...Se(gt(), ["groupCollapseIcon", "groupExpandIcon", "density"]),
+  ...Ve()
+}, "VDataTableRows"), Ne = $()({
+  name: "VDataTableRows",
+  inheritAttrs: !1,
+  props: bt(),
+  setup(e, t) {
+    let {
+      attrs: a,
+      slots: l
+    } = t;
+    const {
+      columns: n
+    } = ve(), {
+      expandOnClick: r,
+      toggleExpand: o,
+      isExpanded: u
+    } = Xe(), {
+      isSelected: s,
+      toggleSelect: i
+    } = fe(), {
+      toggleGroup: f,
+      isGroupOpen: m
+    } = Ze(), {
+      t: d
+    } = Z(), {
+      mobile: c
+    } = ce(e);
+    return K(() => {
+      const y = Se(e, ["groupCollapseIcon", "groupExpandIcon", "density"]);
+      return e.loading && (!e.items.length || l.loading) ? S("tr", {
+        class: "v-data-table-rows-loading",
+        key: "loading"
+      }, [S("td", {
+        colspan: n.value.length
+      }, [l.loading?.() ?? d(e.loadingText)])]) : !e.loading && !e.items.length && !e.hideNoData ? S("tr", {
+        class: "v-data-table-rows-no-data",
+        key: "no-data"
+      }, [S("td", {
+        colspan: n.value.length
+      }, [l["no-data"]?.() ?? d(e.noDataText)])]) : S(U, null, [e.items.map((b, v) => {
+        if (b.type === "group") {
+          const I = {
+            index: v,
+            item: b,
+            columns: n.value,
+            isExpanded: u,
+            toggleExpand: o,
+            isSelected: s,
+            toggleSelect: i,
+            toggleGroup: f,
+            isGroupOpen: m
+          };
+          return l["group-header"] ? l["group-header"](I) : k(Ra, B({
+            key: `group-header_${b.id}`,
+            item: b
+          }, Le(a, ":groupHeader", () => I), y), l);
+        }
+        if (b.type === "group-summary") {
+          const I = {
+            index: v,
+            item: b,
+            columns: n.value,
+            toggleGroup: f
+          };
+          return l["group-summary"]?.(I) ?? "";
+        }
+        const F = {
+          index: v,
+          item: b.raw,
+          internalItem: b,
+          columns: n.value,
+          isExpanded: u,
+          toggleExpand: o,
+          isSelected: s,
+          toggleSelect: i
+        }, h = {
+          ...F,
+          props: B({
+            key: `item_${b.key ?? b.index}`,
+            onClick: r.value ? () => {
+              o(b);
+            } : void 0,
+            index: v,
+            item: b,
+            cellProps: e.cellProps,
+            collapseIcon: e.collapseIcon,
+            expandIcon: e.expandIcon,
+            density: e.density,
+            mobile: c.value
+          }, Le(a, ":row", () => F), typeof e.rowProps == "function" ? e.rowProps({
+            item: F.item,
+            index: F.index,
+            internalItem: F.internalItem
+          }) : e.rowProps)
+        };
+        return S(U, {
+          key: h.props.key
+        }, [l.item ? l.item(h) : k($a, h.props, l), u(b) && l["expanded-row"]?.(F)]);
+      })]);
+    }), {};
+  }
+}), ht = _({
+  fixedHeader: Boolean,
+  fixedFooter: Boolean,
+  height: [Number, String],
+  hover: Boolean,
+  striped: {
+    type: String,
+    default: null,
+    validator: (e) => ["even", "odd"].includes(e)
+  },
+  ...ze(),
+  ...ae(),
+  ...Ke(),
+  ...Ie()
+}, "VTable"), Re = $()({
+  name: "VTable",
+  props: ht(),
+  setup(e, t) {
+    let {
+      slots: a,
+      emit: l
+    } = t;
+    const {
+      themeClasses: n
+    } = ke(e), {
+      densityClasses: r
+    } = Qt(e);
+    return K(() => k(e.tag, {
+      class: G(["v-table", {
+        "v-table--fixed-height": !!e.height,
+        "v-table--fixed-header": e.fixedHeader,
+        "v-table--fixed-footer": e.fixedFooter,
+        "v-table--has-top": !!a.top,
+        "v-table--has-bottom": !!a.bottom,
+        "v-table--hover": e.hover,
+        "v-table--striped-even": e.striped === "even",
+        "v-table--striped-odd": e.striped === "odd"
+      }, n.value, r.value, e.class]),
+      style: we(e.style)
+    }, {
+      default: () => [a.top?.(), a.default ? S("div", {
+        class: "v-table__wrapper",
+        style: {
+          height: A(e.height)
+        }
+      }, [S("table", null, [a.default()])]) : a.wrapper?.(), a.bottom?.()]
+    })), {};
+  }
+}), Ma = _({
+  items: {
+    type: Array,
+    default: () => []
+  },
+  itemValue: {
+    type: [String, Array, Function],
+    default: "id"
+  },
+  itemSelectable: {
+    type: [String, Array, Function],
+    default: null
+  },
+  rowProps: [Object, Function],
+  cellProps: [Object, Function],
+  returnObject: Boolean
+}, "DataTable-items");
+function Ha(e, t, a, l) {
+  const n = e.returnObject ? t : ee(t, e.itemValue), r = ee(t, e.itemSelectable, !0), o = l.reduce((u, s) => (s.key != null && (u[s.key] = ee(t, s.value)), u), {});
+  return {
+    type: "item",
+    key: e.returnObject ? ee(t, e.itemValue) : n,
+    index: a,
+    value: n,
+    selectable: r,
+    columns: o,
+    raw: t
+  };
+}
+function ja(e, t, a) {
+  return t.map((l, n) => Ha(e, l, n, a));
+}
+function Ga(e, t) {
+  return {
+    items: V(() => ja(e, e.items, t.value))
+  };
+}
+const Ka = _({
+  ...bt(),
+  hideDefaultBody: Boolean,
+  hideDefaultFooter: Boolean,
+  hideDefaultHeader: Boolean,
+  width: [String, Number],
+  search: String,
+  ...oa(),
+  ...ua(),
+  ..._a(),
+  ...Ma(),
+  ...Pa(),
+  ...ka(),
+  ...vt(),
+  ...ht()
+}, "DataTable"), Wa = _({
+  ...ma(),
+  ...Ka(),
+  ...na(),
+  ...st()
+}, "VDataTable"), qa = $()({
+  name: "VDataTable",
+  props: Wa(),
+  emits: {
+    "update:modelValue": (e) => !0,
+    "update:page": (e) => !0,
+    "update:itemsPerPage": (e) => !0,
+    "update:sortBy": (e) => !0,
+    "update:options": (e) => !0,
+    "update:groupBy": (e) => !0,
+    "update:expanded": (e) => !0,
+    "update:currentItems": (e) => !0
+  },
+  setup(e, t) {
+    let {
+      attrs: a,
+      slots: l
+    } = t;
+    const {
+      groupBy: n
+    } = da(e), {
+      sortBy: r,
+      multiSort: o,
+      mustSort: u
+    } = Ia(e), {
+      page: s,
+      itemsPerPage: i
+    } = ba(e), {
+      disableSort: f
+    } = Bt(e), {
+      columns: m,
+      headers: d,
+      sortFunctions: c,
+      sortRawFunctions: y,
+      filterFunctions: b
+    } = Na(e, {
+      groupBy: n,
+      showSelect: C(() => e.showSelect),
+      showExpand: C(() => e.showExpand)
+    }), {
+      items: v
+    } = Ga(e, m), F = C(() => e.search), {
+      filteredItems: h
+    } = sa(e, v, F, {
+      transform: (H) => H.columns,
+      customKeyFilter: b
+    }), {
+      toggleSort: I
+    } = Va({
+      sortBy: r,
+      multiSort: o,
+      mustSort: u,
+      page: s
+    }), {
+      sortByWithGroups: D,
+      opened: P,
+      extractRows: O,
+      isGroupOpen: N,
+      toggleGroup: p
+    } = ca({
+      groupBy: n,
+      sortBy: r,
+      disableSort: f
+    }), {
+      sortedItems: x
+    } = Fa(e, h, D, {
+      transform: (H) => ({
+        ...H.raw,
+        ...H.columns
+      }),
+      sortFunctions: c,
+      sortRawFunctions: y
+    }), {
+      flatItems: g
+    } = va(x, n, P, () => !!l["group-summary"]), w = V(() => g.value.length), {
+      startIndex: T,
+      stopIndex: R,
+      pageCount: le,
+      setItemsPerPage: me
+    } = ha({
+      page: s,
+      itemsPerPage: i,
+      itemsLength: w
+    }), {
+      paginatedItems: M
+    } = pa({
+      items: g,
+      startIndex: T,
+      stopIndex: R,
+      itemsPerPage: i
+    }), X = V(() => O(M.value)), {
+      isSelected: be,
+      select: yt,
+      selectAll: pt,
+      toggleSelect: xt,
+      someSelected: St,
+      allSelected: Pt
+    } = wa(e, {
+      allItems: v,
+      currentPage: X
+    }), {
+      isExpanded: wt,
+      toggleExpand: kt
+    } = ia(e);
+    ga({
+      page: s,
+      itemsPerPage: i,
+      sortBy: r,
+      groupBy: n,
+      search: F
+    }), xe({
+      VDataTableRows: {
+        hideNoData: C(() => e.hideNoData),
+        noDataText: C(() => e.noDataText),
+        loading: C(() => e.loading),
+        loadingText: C(() => e.loadingText)
+      }
+    });
+    const E = V(() => ({
+      page: s.value,
+      itemsPerPage: i.value,
+      sortBy: r.value,
+      pageCount: le.value,
+      toggleSort: I,
+      setItemsPerPage: me,
+      someSelected: St.value,
+      allSelected: Pt.value,
+      isSelected: be,
+      select: yt,
+      selectAll: pt,
+      toggleSelect: xt,
+      isExpanded: wt,
+      toggleExpand: kt,
+      isGroupOpen: N,
+      toggleGroup: p,
+      items: X.value.map((H) => H.raw),
+      internalItems: X.value,
+      groupedItems: M.value,
+      columns: m.value,
+      headers: d.value
+    }));
+    return K(() => {
+      const H = Ae.filterProps(e), It = Ee.filterProps(e), Vt = Ne.filterProps(e), Ft = Re.filterProps(e);
+      return k(Re, B({
+        class: ["v-data-table", {
+          "v-data-table--show-select": e.showSelect,
+          "v-data-table--loading": e.loading
+        }, e.class],
+        style: e.style
+      }, Ft, {
+        fixedHeader: e.fixedHeader || e.sticky
+      }), {
+        top: () => l.top?.(E.value),
+        default: () => l.default ? l.default(E.value) : S(U, null, [l.colgroup?.(E.value), !e.hideDefaultHeader && S("thead", {
+          key: "thead"
+        }, [k(Ee, It, l)]), l.thead?.(E.value), !e.hideDefaultBody && S("tbody", null, [l["body.prepend"]?.(E.value), l.body ? l.body(E.value) : k(Ne, B(a, Vt, {
+          items: M.value
+        }), l), l["body.append"]?.(E.value)]), l.tbody?.(E.value), l.tfoot?.(E.value)]),
+        bottom: () => l.bottom ? l.bottom(E.value) : !e.hideDefaultFooter && S(U, null, [k(Xt, null, null), k(Ae, H, {
+          prepend: l["footer.prepend"]
+        })])
+      });
+    }), {};
+  }
+}), za = {
+  actions: "button@2",
+  article: "heading, paragraph",
+  avatar: "avatar",
+  button: "button",
+  card: "image, heading",
+  "card-avatar": "image, list-item-avatar",
+  chip: "chip",
+  "date-picker": "list-item, heading, divider, date-picker-options, date-picker-days, actions",
+  "date-picker-options": "text, avatar@2",
+  "date-picker-days": "avatar@28",
+  divider: "divider",
+  heading: "heading",
+  image: "image",
+  "list-item": "text",
+  "list-item-avatar": "avatar, text",
+  "list-item-two-line": "sentences",
+  "list-item-avatar-two-line": "avatar, sentences",
+  "list-item-three-line": "paragraph",
+  "list-item-avatar-three-line": "avatar, paragraph",
+  ossein: "ossein",
+  paragraph: "text@3",
+  sentences: "text@2",
+  subtitle: "text",
+  table: "table-heading, table-thead, table-tbody, table-tfoot",
+  "table-heading": "chip, text",
+  "table-thead": "heading@6",
+  "table-tbody": "table-row-divider@6",
+  "table-row-divider": "table-row, divider",
+  "table-row": "text@6",
+  "table-tfoot": "text@2, avatar@2",
+  text: "text"
+};
+function Ua(e) {
+  let t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  return S("div", {
+    class: G(["v-skeleton-loader__bone", `v-skeleton-loader__${e}`])
+  }, [t]);
+}
+function $e(e) {
+  const [t, a] = e.split("@");
+  return Array.from({
+    length: a
+  }).map(() => ge(t));
+}
+function ge(e) {
+  let t = [];
+  if (!e) return t;
+  const a = za[e];
+  if (e !== a) {
+    if (e.includes(",")) return Me(e);
+    if (e.includes("@")) return $e(e);
+    a.includes(",") ? t = Me(a) : a.includes("@") ? t = $e(a) : a && t.push(ge(a));
+  }
+  return [Ua(e, t)];
+}
+function Me(e) {
+  return e.replace(/\s/g, "").split(",").map(ge);
+}
+const Ja = _({
+  boilerplate: Boolean,
+  color: String,
+  loading: Boolean,
+  loadingText: {
+    type: String,
+    default: "$vuetify.loading"
+  },
+  type: {
+    type: [String, Array],
+    default: "ossein"
+  },
+  ...qt(),
+  ...We(),
+  ...Ie()
+}, "VSkeletonLoader"), el = $()({
+  name: "VSkeletonLoader",
+  inheritAttrs: !1,
+  props: Ja(),
+  setup(e, t) {
+    let {
+      attrs: a,
+      slots: l
+    } = t;
+    const {
+      backgroundColorClasses: n,
+      backgroundColorStyles: r
+    } = Ue(() => e.color), {
+      dimensionStyles: o
+    } = Yt(e), {
+      elevationClasses: u
+    } = Zt(e), {
+      themeClasses: s
+    } = ke(e), {
+      t: i
+    } = Z(), f = V(() => ge(z(e.type).join(",")));
+    return K(() => {
+      const m = !l.default || e.loading, d = e.boilerplate || !m ? {} : {
+        ariaLive: "polite",
+        ariaLabel: i(e.loadingText),
+        role: "alert"
+      };
+      return m ? S("div", B({
+        class: ["v-skeleton-loader", {
+          "v-skeleton-loader--boilerplate": e.boilerplate
+        }, s.value, n.value, u.value],
+        style: [r.value, o.value]
+      }, d, a), [f.value]) : S(U, null, [l.default?.()]);
+    }), {};
+  }
+});
+function Qa(e, t, a) {
+  switch (a) {
+    case ">":
+      return e > t;
+    case "<":
+      return e < t;
+    case ">=":
+      return e >= t;
+    case "<=":
+      return e <= t;
+    case "=":
+      return e === t;
+    default:
+      throw new Error(`Invalid operator: ${a}`);
+  }
+}
+function tl() {
+  const { advancedFiltersState: e, hardFiltersState: t } = ta(), a = Q("table_props"), l = j(), n = V(() => {
+    const r = Object.values(t.value).filter((s) => s.args).map((s) => s.args).reduce((s, i) => ({ ...s, ...i }), {}), o = { ...e.value, ...r };
+    let u = l.value;
+    return o && Object.keys(o).forEach((s) => {
+      const i = o[s].value, f = o[s]?.comparison ?? "=";
+      i && (u = u.filter((m) => {
+        const d = a.headers.find((b) => (b.advancedFilter?.key ?? b.key) === s);
+        let c = aa(m);
+        Object.hasOwn(d, "filterReturnValue") && typeof d.filterReturnValue == "function" && (c[s] = d.filterReturnValue({
+          value: m[s],
+          item: m
+        }));
+        let y = s.split(".").reduce((b, v) => b && b[v], c);
+        if (typeof y == "number")
+          return Qa(y, i, f);
+        if (typeof y == "string")
+          return Array.isArray(i) ? i.map((b) => b.toLowerCase()).includes(y.toLowerCase()) : y?.toLowerCase().includes(i.toLowerCase());
+      }));
+    }), u;
+  });
+  return de(
+    () => a.data,
+    async (r, o) => {
+      const u = r ?? [], s = o ?? [];
+      JSON.stringify(u) !== JSON.stringify(s) && (l.value = r);
+    },
+    { deep: !0, immediate: !0 }
+  ), { tableData: l, filteredData: n };
+}
+const al = Lt({
+  props: {
+    render: {
+      type: [Function, Object, String, Number, Date],
+      required: !0
+    },
+    props: {
+      type: Object,
+      default: () => ({})
+    },
+    params: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  setup: (e) => () => {
+    const t = { ...e.props, ...e.params };
+    return typeof e.render == "function" ? e.render(t) : typeof e.render == "object" && e.render !== null ? Ot(e.render, t) : e.render;
+  }
+});
+export {
+  al as C,
+  qa as V,
+  el as a,
+  Ia as b,
+  da as c,
+  ba as d,
+  Na as e,
+  Ga as f,
+  ca as g,
+  ha as h,
+  va as i,
+  wa as j,
+  ia as k,
+  ga as l,
+  Ae as m,
+  Ee as n,
+  Ne as o,
+  Va as p,
+  Re as q,
+  st as r,
+  Ka as s,
+  ma as t,
+  tl as u
+};