@ianicdev/datatables2 0.11.6 → 0.11.7

package/dist/cellRender-u5Pfy695.js

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