@ianicdev/datatables2 0.10.0 → 0.10.1

package/dist/Datepicker--ZUiSi7m.js

@@ -0,0 +1,1411 @@
+import { inject as Ke, reactive as Ze, watch as fe, createVNode as g, mergeProps as F, createElementVNode as w, normalizeStyle as Te, normalizeClass as ie, ref as ce, watchEffect as ge, computed as M, Fragment as Q, shallowRef as oe, toRef as z, createTextVNode as qe, withDirectives as Ge, mergeModels as Qe, useModel as Xe, createBlock as et, openBlock as tt, unref as De, isRef as at } from "vue";
+import G from "moment";
+import { T as ue, c as $e, g as Z, p as U, P as Fe, u as q, e as ve, K as L, aY as Ve, J as nt, a7 as $, ax as me, I as se, W as Be, H as lt, N as ee, S as K, aU as We, ay as xe, aZ as rt, a0 as it, al as ot, ae as ut, ah as dt, a1 as st, aD as ct, a2 as ft, an as vt } from "./dataTables-B-LwTPCL.js";
+import { j as Pe, m as mt, l as yt, g as we, n as ht, o as kt } from "./index-3kLkZg7E.js";
+const gt = Symbol.for("vuetify:date-options");
+function Ne(e, a, l) {
+  const r = Ee(e, a, l), t = [a];
+  for (let i = 1; i < r; i++) {
+    const o = e.addDays(a, i);
+    t.push(o);
+  }
+  return l && t.push(e.endOfDay(l)), t;
+}
+function Ee(e, a, l) {
+  const r = [`${e.toISO(l ?? a).split("T")[0]}T00:00:00Z`, `${e.toISO(a).split("T")[0]}T00:00:00Z`];
+  return typeof e.date() == "string" ? e.getDiff(r[0], r[1], "days") : e.getDiff(e.date(r[0]), e.date(r[1]), "days");
+}
+function bt(e, a) {
+  const l = Ze(typeof e.adapter == "function" ? new e.adapter({
+    locale: e.locale[a.current.value] ?? a.current.value,
+    formats: e.formats
+  }) : e.adapter);
+  return fe(a.current, (r) => {
+    l.locale = e.locale[r] ?? r ?? l.locale;
+  }), l;
+}
+function te() {
+  const e = Ke(gt);
+  if (!e) throw new Error("[Vuetify] Could not find injected date options");
+  const a = ue();
+  return bt(e, a);
+}
+const Dt = $e("v-picker-title"), Re = U({
+  bgColor: String,
+  divided: Boolean,
+  landscape: Boolean,
+  title: String,
+  hideHeader: Boolean,
+  hideTitle: Boolean,
+  ...mt()
+}, "VPicker"), Me = Z()({
+  name: "VPicker",
+  props: Re(),
+  setup(e, a) {
+    let {
+      slots: l
+    } = a;
+    const {
+      backgroundColorClasses: r,
+      backgroundColorStyles: t
+    } = Fe(() => e.color);
+    return q(() => {
+      const i = Pe.filterProps(e), o = !e.hideTitle && !!(e.title || l.title);
+      return g(Pe, F(i, {
+        color: e.bgColor,
+        class: ["v-picker", {
+          "v-picker--divided": e.divided,
+          "v-picker--landscape": e.landscape,
+          "v-picker--with-actions": !!l.actions
+        }, e.class],
+        style: e.style
+      }), {
+        default: () => [!e.hideHeader && w("div", {
+          key: "header",
+          class: ie(["v-picker__header-wrapper", r.value]),
+          style: Te([t.value])
+        }, [o && g(Dt, {
+          key: "picker-title"
+        }, {
+          default: () => [l.title?.() ?? e.title]
+        }), l.header && w("div", {
+          class: "v-picker__header"
+        }, [l.header()])]), w("div", {
+          class: "v-picker__body"
+        }, [l.default?.()]), l.actions && g(ve, {
+          defaults: {
+            VBtn: {
+              slim: !0,
+              variant: "text"
+            }
+          }
+        }, {
+          default: () => [w("div", {
+            class: "v-picker__actions"
+          }, [l.actions()])]
+        })]
+      });
+    }), {};
+  }
+}), Le = U({
+  modelValue: null,
+  color: String,
+  cancelText: {
+    type: String,
+    default: "$vuetify.confirmEdit.cancel"
+  },
+  okText: {
+    type: String,
+    default: "$vuetify.confirmEdit.ok"
+  },
+  disabled: {
+    type: [Boolean, Array],
+    default: void 0
+  },
+  hideActions: Boolean
+}, "VConfirmEdit"), Se = Z()({
+  name: "VConfirmEdit",
+  props: Le(),
+  emits: {
+    cancel: () => !0,
+    save: (e) => !0,
+    "update:modelValue": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      emit: l,
+      slots: r
+    } = a;
+    const t = L(e, "modelValue"), i = ce();
+    ge(() => {
+      i.value = structuredClone(Ve(t.value));
+    });
+    const {
+      t: o
+    } = ue(), u = M(() => nt(t.value, i.value));
+    function d(n) {
+      return typeof e.disabled == "boolean" ? e.disabled : Array.isArray(e.disabled) ? e.disabled.includes(n) : u.value;
+    }
+    const k = M(() => d("save")), f = M(() => d("cancel"));
+    function m() {
+      t.value = i.value, l("save", i.value);
+    }
+    function b() {
+      i.value = structuredClone(Ve(t.value)), l("cancel");
+    }
+    function C(n) {
+      return w(Q, null, [g($, F({
+        disabled: f.value,
+        variant: "text",
+        color: e.color,
+        onClick: b,
+        text: o(e.cancelText)
+      }, n), null), g($, F({
+        disabled: k.value,
+        variant: "text",
+        color: e.color,
+        onClick: m,
+        text: o(e.okText)
+      }, n), null)]);
+    }
+    let Y = !1;
+    return q(() => w(Q, null, [r.default?.({
+      model: i,
+      save: m,
+      cancel: b,
+      isPristine: u.value,
+      get actions() {
+        return Y = !0, C;
+      }
+    }), !e.hideActions && !Y && C()])), {
+      save: m,
+      cancel: b,
+      isPristine: u
+    };
+  }
+}), Ce = $e("v-spacer", "div", "VSpacer"), Ue = U({
+  active: {
+    type: [String, Array],
+    default: void 0
+  },
+  controlHeight: [Number, String],
+  controlVariant: {
+    type: String,
+    default: "docked"
+  },
+  noMonthPicker: Boolean,
+  disabled: {
+    type: [Boolean, String, Array],
+    default: null
+  },
+  nextIcon: {
+    type: se,
+    default: "$next"
+  },
+  prevIcon: {
+    type: se,
+    default: "$prev"
+  },
+  modeIcon: {
+    type: se,
+    default: "$subgroup"
+  },
+  text: String,
+  monthText: String,
+  yearText: String,
+  viewMode: {
+    type: String,
+    default: "month"
+  }
+}, "VDatePickerControls"), Ae = Z()({
+  name: "VDatePickerControls",
+  props: Ue(),
+  emits: {
+    "click:year": () => !0,
+    "click:month": () => !0,
+    "click:prev": () => !0,
+    "click:next": () => !0,
+    "click:prev-year": () => !0,
+    "click:next-year": () => !0
+  },
+  setup(e, a) {
+    let {
+      emit: l,
+      slots: r
+    } = a;
+    const {
+      t
+    } = ue(), i = M(() => Array.isArray(e.disabled) ? e.disabled.includes("text") : !!e.disabled), o = M(() => Array.isArray(e.disabled) ? e.disabled.includes("mode") : !!e.disabled), u = M(() => Array.isArray(e.disabled) ? e.disabled.includes("prev-month") : !!e.disabled), d = M(() => Array.isArray(e.disabled) ? e.disabled.includes("next-month") : !!e.disabled), k = M(() => Array.isArray(e.disabled) ? e.disabled.includes("prev-year") : !!e.disabled), f = M(() => Array.isArray(e.disabled) ? e.disabled.includes("next-year") : !!e.disabled);
+    function m() {
+      l("click:prev");
+    }
+    function b() {
+      l("click:next");
+    }
+    function C() {
+      l("click:prev-year");
+    }
+    function Y() {
+      l("click:next-year");
+    }
+    function n() {
+      l("click:year");
+    }
+    function v() {
+      l("click:month");
+    }
+    return q(() => {
+      const s = {
+        VBtn: {
+          density: "comfortable",
+          variant: "text"
+        }
+      }, D = g($, {
+        "data-testid": "prev-month",
+        disabled: u.value,
+        icon: e.prevIcon,
+        "aria-label": t("$vuetify.datePicker.ariaLabel.previousMonth"),
+        onClick: m
+      }, null), A = g($, {
+        "data-testid": "next-month",
+        disabled: d.value,
+        icon: e.nextIcon,
+        "aria-label": t("$vuetify.datePicker.ariaLabel.nextMonth"),
+        onClick: b
+      }, null), S = g($, {
+        "data-testid": "prev-year",
+        disabled: k.value,
+        icon: e.prevIcon,
+        "aria-label": t("$vuetify.datePicker.ariaLabel.previousYear"),
+        onClick: C
+      }, null), _ = g($, {
+        "data-testid": "next-year",
+        disabled: f.value,
+        icon: e.nextIcon,
+        "aria-label": t("$vuetify.datePicker.ariaLabel.nextYear"),
+        onClick: Y
+      }, null), c = g($, {
+        class: "v-date-picker-controls__only-month-btn",
+        "data-testid": "month-btn",
+        density: "default",
+        disabled: i.value,
+        text: e.monthText,
+        appendIcon: e.modeIcon,
+        rounded: !0,
+        "aria-label": t("$vuetify.datePicker.ariaLabel.selectMonth"),
+        onClick: v
+      }, null), x = g($, {
+        class: "v-date-picker-controls__only-year-btn",
+        "data-testid": "year-btn",
+        density: "default",
+        disabled: o.value,
+        text: e.yearText,
+        appendIcon: e.modeIcon,
+        rounded: !0,
+        "aria-label": t("$vuetify.datePicker.ariaLabel.selectYear"),
+        onClick: n
+      }, null), P = g($, {
+        class: "v-date-picker-controls__year-btn",
+        "data-testid": "year-btn",
+        density: "default",
+        disabled: o.value,
+        text: e.text,
+        appendIcon: e.modeIcon,
+        rounded: !0,
+        "aria-label": t("$vuetify.datePicker.ariaLabel.selectYear"),
+        onClick: n
+      }, null), I = w(Q, null, [g($, {
+        class: "v-date-picker-controls__month-btn",
+        "data-testid": "month-btn",
+        height: "36",
+        disabled: i.value,
+        text: e.text,
+        rounded: !0,
+        "aria-label": t("$vuetify.datePicker.ariaLabel.selectMonth"),
+        onClick: v
+      }, null), g($, {
+        class: "v-date-picker-controls__mode-btn",
+        "data-testid": "year-btn",
+        disabled: o.value,
+        icon: e.modeIcon,
+        "aria-label": t("$vuetify.datePicker.ariaLabel.selectYear"),
+        onClick: n
+      }, null)]), B = {
+        viewMode: e.viewMode,
+        disabled: Array.isArray(e.disabled) ? e.disabled : [],
+        monthYearText: e.text ?? "",
+        monthText: e.monthText ?? "",
+        yearText: e.yearText ?? "",
+        openMonths: v,
+        openYears: n,
+        prevMonth: m,
+        nextMonth: b,
+        prevYear: C,
+        nextYear: Y
+      }, H = w(Q, null, [e.noMonthPicker ? P : I, g(Ce, null, null), w("div", {
+        class: "v-date-picker-controls__month"
+      }, [D, A])]), ae = w(Q, null, [w("div", {
+        class: "v-date-picker-controls__month"
+      }, [D, c, A]), g(Ce, null, null), w("div", {
+        class: "v-date-picker-controls__year"
+      }, [S, x, _])]);
+      return g(ve, {
+        defaults: s
+      }, {
+        default: () => [w("div", {
+          class: ie(["v-date-picker-controls", `v-date-picker-controls--variant-${e.controlVariant}`]),
+          style: {
+            "--v-date-picker-controls-height": me(e.controlHeight)
+          }
+        }, [r.default?.(B) ?? w(Q, null, [e.controlVariant === "modal" && H, e.controlVariant === "docked" && ae])])]
+      });
+    }), {};
+  }
+}), Vt = U({
+  appendIcon: se,
+  color: String,
+  header: String,
+  transition: String,
+  onClick: lt()
+}, "VDatePickerHeader"), Ye = Z()({
+  name: "VDatePickerHeader",
+  props: Vt(),
+  emits: {
+    click: () => !0,
+    "click:append": () => !0
+  },
+  setup(e, a) {
+    let {
+      emit: l,
+      slots: r
+    } = a;
+    const {
+      backgroundColorClasses: t,
+      backgroundColorStyles: i
+    } = Fe(() => e.color);
+    function o() {
+      l("click");
+    }
+    function u() {
+      l("click:append");
+    }
+    return q(() => {
+      const d = !!(r.default || e.header), k = !!(r.append || e.appendIcon);
+      return w("div", {
+        class: ie(["v-date-picker-header", {
+          "v-date-picker-header--clickable": !!e.onClick
+        }, t.value]),
+        style: Te(i.value),
+        onClick: o
+      }, [r.prepend && w("div", {
+        key: "prepend",
+        class: "v-date-picker-header__prepend"
+      }, [r.prepend()]), d && g(Be, {
+        key: "content",
+        name: e.transition
+      }, {
+        default: () => [w("div", {
+          key: e.header,
+          class: "v-date-picker-header__content"
+        }, [r.default?.() ?? e.header])]
+      }), k && w("div", {
+        class: "v-date-picker-header__append"
+      }, [r.append ? g(ve, {
+        key: "append-defaults",
+        disabled: !e.appendIcon,
+        defaults: {
+          VBtn: {
+            icon: e.appendIcon,
+            variant: "text"
+          }
+        }
+      }, {
+        default: () => [r.append?.()]
+      }) : g($, {
+        key: "append-btn",
+        icon: e.appendIcon,
+        variant: "text",
+        onClick: u
+      }, null)])]);
+    }), {};
+  }
+}), xt = U({
+  allowedDates: [Array, Function],
+  disabled: {
+    type: Boolean,
+    default: null
+  },
+  displayValue: null,
+  modelValue: Array,
+  month: [Number, String],
+  max: null,
+  min: null,
+  showAdjacentMonths: Boolean,
+  year: [Number, String],
+  weekdays: {
+    type: Array,
+    default: () => [0, 1, 2, 3, 4, 5, 6]
+  },
+  weeksInMonth: {
+    type: String,
+    default: "dynamic"
+  },
+  firstDayOfWeek: {
+    type: [Number, String],
+    default: void 0
+  },
+  firstDayOfYear: {
+    type: [Number, String],
+    default: void 0
+  },
+  weekdayFormat: String
+}, "calendar");
+function Pt(e) {
+  const a = te(), l = L(e, "modelValue", [], (n) => ee(n).map((v) => a.date(v))), r = M(() => e.displayValue ? a.date(e.displayValue) : l.value.length > 0 ? a.date(l.value[0]) : e.min ? a.date(e.min) : Array.isArray(e.allowedDates) ? a.date(e.allowedDates[0]) : a.date()), t = L(e, "year", void 0, (n) => {
+    const v = n != null ? Number(n) : a.getYear(r.value);
+    return a.startOfYear(a.setYear(a.date(), v));
+  }, (n) => a.getYear(n)), i = L(e, "month", void 0, (n) => {
+    const v = n != null ? Number(n) : a.getMonth(r.value), s = a.setYear(a.startOfMonth(a.date()), a.getYear(t.value));
+    return a.setMonth(s, v);
+  }, (n) => a.getMonth(n)), o = M(() => {
+    const n = a.toJsDate(a.startOfWeek(a.date(), e.firstDayOfWeek)).getDay();
+    return a.getWeekdays(e.firstDayOfWeek, e.weekdayFormat).filter((v, s) => e.weekdays.includes((s + n) % 7));
+  }), u = M(() => {
+    const n = a.getWeekArray(i.value, e.firstDayOfWeek), v = n.flat(), s = 42;
+    if (e.weeksInMonth === "static" && v.length < s) {
+      const D = v[v.length - 1];
+      let A = [];
+      for (let S = 1; S <= s - v.length; S++)
+        A.push(a.addDays(D, S)), S % 7 === 0 && (n.push(A), A = []);
+    }
+    return n;
+  });
+  function d(n, v) {
+    return n.filter((s) => e.weekdays.includes(a.toJsDate(s).getDay())).map((s, D) => {
+      const A = a.toISO(s), S = !a.isSameMonth(s, i.value), _ = a.isSameDay(s, a.startOfMonth(i.value)), c = a.isSameDay(s, a.endOfMonth(i.value)), x = a.isSameDay(s, i.value), P = e.weekdays.length;
+      return {
+        date: s,
+        formatted: a.format(s, "keyboardDate"),
+        isAdjacent: S,
+        isDisabled: Y(s),
+        isEnd: c,
+        isHidden: S && !e.showAdjacentMonths,
+        isSame: x,
+        isSelected: l.value.some((I) => a.isSameDay(s, I)),
+        isStart: _,
+        isToday: a.isSameDay(s, v),
+        isWeekEnd: D % P === P - 1,
+        isWeekStart: D % P === 0,
+        isoDate: A,
+        localized: a.format(s, "dayOfMonth"),
+        month: a.getMonth(s),
+        year: a.getYear(s)
+      };
+    });
+  }
+  const k = M(() => {
+    const n = a.startOfWeek(r.value, e.firstDayOfWeek), v = [];
+    for (let D = 0; D <= 6; D++)
+      v.push(a.addDays(n, D));
+    const s = a.date();
+    return d(v, s);
+  }), f = M(() => {
+    const n = u.value.flat(), v = a.date();
+    return d(n, v);
+  }), m = M(() => u.value.map((n) => n.length ? a.getWeek(n[0], e.firstDayOfWeek, e.firstDayOfYear) : null)), {
+    minDate: b,
+    maxDate: C
+  } = be(e);
+  function Y(n) {
+    if (e.disabled) return !0;
+    const v = a.date(n);
+    return b.value && a.isBefore(a.endOfDay(v), b.value) || C.value && a.isAfter(v, C.value) ? !0 : Array.isArray(e.allowedDates) && e.allowedDates.length > 0 ? !e.allowedDates.some((s) => a.isSameDay(a.date(s), v)) : typeof e.allowedDates == "function" ? !e.allowedDates(v) : !1;
+  }
+  return {
+    displayValue: r,
+    daysInMonth: f,
+    daysInWeek: k,
+    genDays: d,
+    model: l,
+    weeksInMonth: u,
+    weekdayLabels: o,
+    weekNumbers: m
+  };
+}
+function be(e) {
+  const a = te(), l = M(() => {
+    if (!e.min) return null;
+    const o = a.date(e.min);
+    return a.isValid(o) ? o : null;
+  }), r = M(() => {
+    if (!e.max) return null;
+    const o = a.date(e.max);
+    return a.isValid(o) ? o : null;
+  });
+  function t(o) {
+    return l.value && a.isBefore(o, l.value) ? l.value : r.value && a.isAfter(o, r.value) ? r.value : o;
+  }
+  function i(o) {
+    return (!l.value || a.isAfter(o, l.value)) && (!r.value || a.isBefore(o, r.value));
+  }
+  return {
+    minDate: l,
+    maxDate: r,
+    clampDate: t,
+    isInAllowedRange: i
+  };
+}
+const je = U({
+  color: String,
+  hideWeekdays: Boolean,
+  multiple: [Boolean, Number, String],
+  showWeek: Boolean,
+  transition: {
+    type: String,
+    default: "picker-transition"
+  },
+  reverseTransition: {
+    type: String,
+    default: "picker-reverse-transition"
+  },
+  events: {
+    type: [Array, Function, Object],
+    default: () => null
+  },
+  eventColor: {
+    type: [Array, Function, Object, String],
+    default: () => null
+  },
+  ...K(xt(), ["displayValue"])
+}, "VDatePickerMonth"), _e = Z()({
+  name: "VDatePickerMonth",
+  props: je(),
+  emits: {
+    "update:modelValue": (e) => !0,
+    "update:month": (e) => !0,
+    "update:year": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      emit: l,
+      slots: r
+    } = a;
+    const t = ce(), {
+      t: i
+    } = ue(), {
+      daysInMonth: o,
+      model: u,
+      weekNumbers: d,
+      weekdayLabels: k
+    } = Pt(e), f = te(), m = oe(), b = oe(), C = oe(!1), Y = z(() => C.value ? e.reverseTransition : e.transition);
+    e.multiple === "range" && u.value.length > 0 && (m.value = u.value[0], u.value.length > 1 && (b.value = u.value[u.value.length - 1]));
+    const n = M(() => {
+      const c = ["number", "string"].includes(typeof e.multiple) ? Number(e.multiple) : 1 / 0;
+      return u.value.length >= c;
+    });
+    fe(o, (c, x) => {
+      x && (C.value = f.isBefore(c[0].date, x[0].date));
+    });
+    function v(c) {
+      const x = f.startOfDay(c);
+      if (u.value.length === 0 ? m.value = void 0 : u.value.length === 1 && (m.value = u.value[0], b.value = void 0), !m.value)
+        m.value = x, u.value = [m.value];
+      else if (b.value)
+        m.value = c, b.value = void 0, u.value = [m.value];
+      else {
+        if (f.isSameDay(x, m.value)) {
+          m.value = void 0, u.value = [];
+          return;
+        } else f.isBefore(x, m.value) ? (b.value = f.endOfDay(m.value), m.value = x) : b.value = f.endOfDay(x);
+        u.value = Ne(f, m.value, b.value);
+      }
+    }
+    function s(c) {
+      const x = f.format(c.date, "fullDateWithWeekday"), P = c.isToday ? "currentDate" : "selectDate";
+      return i(`$vuetify.datePicker.ariaLabel.${P}`, x);
+    }
+    function D(c) {
+      const x = u.value.findIndex((P) => f.isSameDay(P, c));
+      if (x === -1)
+        u.value = [...u.value, c];
+      else {
+        const P = [...u.value];
+        P.splice(x, 1), u.value = P;
+      }
+    }
+    function A(c) {
+      e.multiple === "range" ? v(c) : e.multiple ? D(c) : u.value = [c];
+    }
+    function S(c) {
+      const {
+        events: x,
+        eventColor: P
+      } = e;
+      let I, B = [];
+      if (Array.isArray(x) ? I = x.includes(c) : x instanceof Function ? I = x(c) || !1 : x ? I = x[c] || !1 : I = !1, I)
+        I !== !0 ? B = ee(I) : typeof P == "string" ? B = [P] : typeof P == "function" ? B = ee(P(c)) : Array.isArray(P) ? B = P : typeof P == "object" && P !== null && (B = ee(P[c]));
+      else return [];
+      return B.length ? B.filter(Boolean).map((H) => typeof H == "string" ? H : "surface-variant") : ["surface-variant"];
+    }
+    function _(c) {
+      const x = S(c);
+      return x.length ? w("div", {
+        class: "v-date-picker-month__events"
+      }, [x.map((P) => g(yt, {
+        dot: !0,
+        color: P
+      }, null))]) : null;
+    }
+    q(() => w("div", {
+      class: "v-date-picker-month",
+      style: {
+        "--v-date-picker-days-in-week": e.weekdays.length
+      }
+    }, [e.showWeek && w("div", {
+      key: "weeks",
+      class: "v-date-picker-month__weeks"
+    }, [!e.hideWeekdays && w("div", {
+      key: "hide-week-days",
+      class: "v-date-picker-month__day"
+    }, [qe(" ")]), d.value.map((c) => w("div", {
+      class: ie(["v-date-picker-month__day", "v-date-picker-month__day--adjacent"])
+    }, [c]))]), g(Be, {
+      name: Y.value
+    }, {
+      default: () => [w("div", {
+        ref: t,
+        key: o.value[0].date?.toString(),
+        class: "v-date-picker-month__days"
+      }, [!e.hideWeekdays && k.value.map((c) => w("div", {
+        class: ie(["v-date-picker-month__day", "v-date-picker-month__weekday"])
+      }, [c])), o.value.map((c, x) => {
+        const P = {
+          props: {
+            class: "v-date-picker-month__day-btn",
+            color: c.isSelected || c.isToday ? e.color : void 0,
+            disabled: c.isDisabled,
+            icon: !0,
+            ripple: !1,
+            variant: c.isSelected ? "flat" : c.isToday ? "outlined" : "text",
+            "aria-label": s(c),
+            "aria-current": c.isToday ? "date" : void 0,
+            onClick: () => A(c.date)
+          },
+          item: c,
+          i: x
+        };
+        return n.value && !c.isSelected && (c.isDisabled = !0), w("div", {
+          class: ie(["v-date-picker-month__day", {
+            "v-date-picker-month__day--adjacent": c.isAdjacent,
+            "v-date-picker-month__day--hide-adjacent": c.isHidden,
+            "v-date-picker-month__day--selected": c.isSelected,
+            "v-date-picker-month__day--week-end": c.isWeekEnd,
+            "v-date-picker-month__day--week-start": c.isWeekStart
+          }]),
+          "data-v-date": c.isDisabled ? void 0 : c.isoDate
+        }, [(e.showAdjacentMonths || !c.isAdjacent) && (r.day?.(P) ?? g($, P.props, {
+          default: () => [c.localized, _(c.isoDate)]
+        }))]);
+      })])]
+    })]));
+  }
+}), He = U({
+  color: String,
+  height: [String, Number],
+  min: null,
+  max: null,
+  modelValue: Number,
+  year: Number,
+  allowedMonths: [Array, Function]
+}, "VDatePickerMonths"), Oe = Z()({
+  name: "VDatePickerMonths",
+  props: He(),
+  emits: {
+    "update:modelValue": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      emit: l,
+      slots: r
+    } = a;
+    const t = te(), i = L(e, "modelValue"), o = M(() => {
+      let d = t.startOfYear(t.date());
+      return e.year && (d = t.setYear(d, e.year)), We(12).map((k) => {
+        const f = t.format(d, "monthShort"), m = t.format(d, "month"), b = !!(!u(k) || e.min && t.isAfter(t.startOfMonth(t.date(e.min)), d) || e.max && t.isAfter(d, t.startOfMonth(t.date(e.max))));
+        return d = t.getNextMonth(d), {
+          isDisabled: b,
+          text: f,
+          label: m,
+          value: k
+        };
+      });
+    });
+    ge(() => {
+      i.value = i.value ?? t.getMonth(t.date());
+    });
+    function u(d) {
+      return Array.isArray(e.allowedMonths) && e.allowedMonths.length ? e.allowedMonths.includes(d) : typeof e.allowedMonths == "function" ? e.allowedMonths(d) : !0;
+    }
+    return q(() => w("div", {
+      class: "v-date-picker-months",
+      style: {
+        height: me(e.height)
+      }
+    }, [w("div", {
+      class: "v-date-picker-months__content"
+    }, [o.value.map((d, k) => {
+      const f = {
+        active: i.value === k,
+        ariaLabel: d.label,
+        color: i.value === k ? e.color : void 0,
+        disabled: d.isDisabled,
+        rounded: !0,
+        text: d.text,
+        variant: i.value === d.value ? "flat" : "text",
+        onClick: () => m(k)
+      };
+      function m(b) {
+        if (i.value === b) {
+          l("update:modelValue", i.value);
+          return;
+        }
+        i.value = b;
+      }
+      return r.month?.({
+        month: d,
+        i: k,
+        props: f
+      }) ?? g($, F({
+        key: "month"
+      }, f), null);
+    })])])), {};
+  }
+}), Je = U({
+  color: String,
+  height: [String, Number],
+  min: null,
+  max: null,
+  modelValue: Number,
+  allowedYears: [Array, Function]
+}, "VDatePickerYears"), pe = Z()({
+  name: "VDatePickerYears",
+  props: Je(),
+  directives: {
+    vIntersect: xe
+  },
+  emits: {
+    "update:modelValue": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      emit: l,
+      slots: r
+    } = a;
+    const t = te(), i = L(e, "modelValue"), o = M(() => {
+      const f = t.getYear(t.date());
+      let m = f - 100, b = f + 52;
+      e.min && (m = t.getYear(t.date(e.min))), e.max && (b = t.getYear(t.date(e.max)));
+      let C = t.startOfYear(t.date());
+      return C = t.setYear(C, m), We(b - m + 1, m).map((Y) => {
+        const n = t.format(C, "year");
+        return C = t.setYear(C, t.getYear(C) + 1), {
+          text: n,
+          value: Y,
+          isDisabled: !k(Y)
+        };
+      });
+    });
+    ge(() => {
+      i.value = i.value ?? t.getYear(t.date());
+    });
+    const u = rt();
+    function d() {
+      u.el?.focus(), u.el?.scrollIntoView({
+        block: "center"
+      });
+    }
+    function k(f) {
+      return Array.isArray(e.allowedYears) && e.allowedYears.length ? e.allowedYears.includes(f) : typeof e.allowedYears == "function" ? e.allowedYears(f) : !0;
+    }
+    return q(() => Ge(w("div", {
+      class: "v-date-picker-years",
+      style: {
+        height: me(e.height)
+      }
+    }, [w("div", {
+      class: "v-date-picker-years__content"
+    }, [o.value.map((f, m) => {
+      const b = {
+        ref: i.value === f.value ? u : void 0,
+        active: i.value === f.value,
+        color: i.value === f.value ? e.color : void 0,
+        rounded: !0,
+        text: f.text,
+        disabled: f.isDisabled,
+        variant: i.value === f.value ? "flat" : "text",
+        onClick: () => {
+          if (i.value === f.value) {
+            l("update:modelValue", i.value);
+            return;
+          }
+          i.value = f.value;
+        }
+      };
+      return r.year?.({
+        year: f,
+        i: m,
+        props: b
+      }) ?? g($, F({
+        key: "month"
+      }, b), null);
+    })])]), [[xe, {
+      handler: d
+    }, null, {
+      once: !0
+    }]])), {};
+  }
+}), ze = U({
+  // TODO: implement in v3.5
+  // calendarIcon: {
+  //   type: String,
+  //   default: '$calendar',
+  // },
+  // keyboardIcon: {
+  //   type: String,
+  //   default: '$edit',
+  // },
+  // inputMode: {
+  //   type: String as PropType<'calendar' | 'keyboard'>,
+  //   default: 'calendar',
+  // },
+  // inputText: {
+  //   type: String,
+  //   default: '$vuetify.datePicker.input.placeholder',
+  // },
+  // inputPlaceholder: {
+  //   type: String,
+  //   default: 'dd/mm/yyyy',
+  // },
+  header: {
+    type: String,
+    default: "$vuetify.datePicker.header"
+  },
+  headerColor: String,
+  headerDateFormat: {
+    type: String,
+    default: "normalDateWithWeekday"
+  },
+  landscapeHeaderWidth: [Number, String],
+  ...Ue(),
+  ...je({
+    weeksInMonth: "static"
+  }),
+  ...K(He(), ["modelValue"]),
+  ...K(Je(), ["modelValue"]),
+  ...Re({
+    title: "$vuetify.datePicker.title"
+  }),
+  modelValue: null
+}, "VDatePicker"), Ie = Z()({
+  name: "VDatePicker",
+  props: ze(),
+  emits: {
+    "update:modelValue": (e) => !0,
+    "update:month": (e) => !0,
+    "update:year": (e) => !0,
+    // 'update:inputMode': (date: any) => true,
+    "update:viewMode": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      emit: l,
+      slots: r
+    } = a;
+    const t = te(), {
+      t: i
+    } = ue(), {
+      rtlClasses: o
+    } = it(), u = L(e, "modelValue", void 0, (h) => ee(h).map((V) => t.date(V)), (h) => e.multiple ? h : h[0]), d = L(e, "viewMode"), {
+      minDate: k,
+      maxDate: f,
+      clampDate: m
+    } = be(e), b = M(() => {
+      const h = t.date(), V = u.value?.[0] ? t.date(u.value[0]) : m(h);
+      return V && t.isValid(V) ? V : h;
+    }), C = z(() => e.headerColor ?? e.color), Y = L(e, "month"), n = M({
+      get: () => Number(Y.value ?? t.getMonth(t.startOfMonth(b.value))),
+      set: (h) => Y.value = h
+    }), v = L(e, "year"), s = M({
+      get: () => Number(v.value ?? t.getYear(t.startOfYear(t.setMonth(b.value, n.value)))),
+      set: (h) => v.value = h
+    }), D = oe(!1), A = M(() => {
+      if (e.multiple && u.value.length > 1)
+        return i("$vuetify.datePicker.itemsSelected", u.value.length);
+      const h = u.value[0] && t.isValid(u.value[0]) ? t.format(t.date(u.value[0]), e.headerDateFormat) : i(e.header);
+      return e.landscape && h.split(" ").length === 3 ? h.replace(" ", `
+`) : h;
+    }), S = z(() => t.parseISO(`${s.value}-${n.value + 1}-01`)), _ = z(() => t.format(S.value, "monthAndYear")), c = z(() => t.format(S.value, "monthShort")), x = z(() => t.format(S.value, "year")), P = z(() => `date-picker-header${D.value ? "-reverse" : ""}-transition`), I = M(() => {
+      if (e.disabled) return !0;
+      const h = [];
+      if (d.value !== "month")
+        h.push("prev-month", "next-month", "prev-year", "next-year");
+      else {
+        let V = t.date();
+        if (V = t.startOfMonth(V), V = t.setMonth(V, n.value), V = t.setYear(V, s.value), k.value) {
+          const O = t.addDays(t.startOfMonth(V), -1), W = t.addDays(t.startOfYear(V), -1);
+          t.isAfter(k.value, O) && h.push("prev-month"), t.isAfter(k.value, W) && h.push("next-year");
+        }
+        if (f.value) {
+          const O = t.addDays(t.endOfMonth(V), 1), W = t.addDays(t.endOfYear(V), 1);
+          t.isAfter(O, f.value) && h.push("next-month"), t.isAfter(W, f.value) && h.push("next-year");
+        }
+      }
+      return h;
+    }), B = M(() => e.allowedYears || ye), H = M(() => e.allowedMonths || he);
+    function ae(h, V) {
+      const O = e.allowedDates;
+      if (typeof O != "function") return !0;
+      const W = 1 + Ee(t, h, V);
+      for (let p = 0; p < W; p++)
+        if (O(t.addDays(h, p))) return !0;
+      return !1;
+    }
+    function ye(h) {
+      if (typeof e.allowedDates == "function") {
+        const V = t.parseISO(`${h}-01-01`);
+        return ae(V, t.endOfYear(V));
+      }
+      if (Array.isArray(e.allowedDates) && e.allowedDates.length) {
+        for (const V of e.allowedDates)
+          if (t.getYear(t.date(V)) === h) return !0;
+        return !1;
+      }
+      return !0;
+    }
+    function he(h) {
+      if (typeof e.allowedDates == "function") {
+        const V = String(h + 1).padStart(2, "0"), O = t.parseISO(`${s.value}-${V}-01`);
+        return ae(O, t.endOfMonth(O));
+      }
+      if (Array.isArray(e.allowedDates) && e.allowedDates.length) {
+        for (const V of e.allowedDates)
+          if (t.getYear(t.date(V)) === s.value && t.getMonth(t.date(V)) === h) return !0;
+        return !1;
+      }
+      return !0;
+    }
+    function ke() {
+      n.value < 11 ? n.value++ : (s.value++, n.value = 0, E()), J();
+    }
+    function de() {
+      n.value > 0 ? n.value-- : (s.value--, n.value = 11, E()), J();
+    }
+    function y() {
+      if (s.value++, f.value) {
+        const h = t.parseISO(`${s.value}-${n.value + 1}-01`);
+        t.isAfter(h, f.value) && (n.value = t.getMonth(f.value));
+      }
+      E();
+    }
+    function T() {
+      if (s.value--, k.value) {
+        const h = t.endOfMonth(t.parseISO(`${s.value}-${n.value + 1}-01`));
+        t.isAfter(k.value, h) && (n.value = t.getMonth(k.value));
+      }
+      E();
+    }
+    function j() {
+      d.value = "month";
+    }
+    function ne() {
+      d.value = d.value === "months" ? "month" : "months";
+    }
+    function N() {
+      d.value = d.value === "year" ? "month" : "year";
+    }
+    function J() {
+      d.value === "months" && ne();
+    }
+    function E() {
+      d.value === "year" && N();
+    }
+    return fe(u, (h, V) => {
+      const O = ee(V), W = ee(h);
+      if (!W.length) return;
+      const p = t.date(O[O.length - 1]), le = t.date(W[W.length - 1]);
+      if (t.isSameDay(p, le)) return;
+      const re = t.getMonth(le), R = t.getYear(le);
+      re !== n.value && (n.value = re, J()), R !== s.value && (s.value = R, E()), D.value = t.isBefore(p, le);
+    }), q(() => {
+      const h = Me.filterProps(e), V = K(Ae.filterProps(e), ["viewMode"]), O = Ye.filterProps(e), W = _e.filterProps(e), p = K(Oe.filterProps(e), ["modelValue"]), le = K(pe.filterProps(e), ["modelValue"]), re = {
+        color: C.value,
+        header: A.value,
+        transition: P.value
+      };
+      return g(Me, F(h, {
+        color: C.value,
+        class: ["v-date-picker", `v-date-picker--${d.value}`, {
+          "v-date-picker--show-week": e.showWeek
+        }, o.value, e.class],
+        style: [{
+          "--v-date-picker-landscape-header-width": me(e.landscapeHeaderWidth)
+        }, e.style]
+      }), {
+        title: () => r.title?.() ?? w("div", {
+          class: "v-date-picker__title"
+        }, [i(e.title)]),
+        header: () => r.header ? g(ve, {
+          defaults: {
+            VDatePickerHeader: {
+              ...re
+            }
+          }
+        }, {
+          default: () => [r.header?.(re)]
+        }) : g(Ye, F({
+          key: "header"
+        }, O, re, {
+          onClick: d.value !== "month" ? j : void 0
+        }), {
+          prepend: r.prepend,
+          append: r.append
+        }),
+        default: () => w(Q, null, [g(Ae, F(V, {
+          disabled: I.value,
+          viewMode: d.value,
+          text: _.value,
+          monthText: c.value,
+          yearText: x.value,
+          "onClick:next": ke,
+          "onClick:prev": de,
+          "onClick:nextYear": y,
+          "onClick:prevYear": T,
+          "onClick:month": ne,
+          "onClick:year": N
+        }), {
+          default: r.controls
+        }), g(ot, {
+          hideOnLeave: !0
+        }, {
+          default: () => [d.value === "months" ? g(Oe, F({
+            key: "date-picker-months"
+          }, p, {
+            modelValue: n.value,
+            "onUpdate:modelValue": [(R) => n.value = R, J],
+            min: k.value,
+            max: f.value,
+            year: s.value,
+            allowedMonths: H.value
+          }), {
+            month: r.month
+          }) : d.value === "year" ? g(pe, F({
+            key: "date-picker-years"
+          }, le, {
+            modelValue: s.value,
+            "onUpdate:modelValue": [(R) => s.value = R, E],
+            min: k.value,
+            max: f.value,
+            allowedYears: B.value
+          }), {
+            year: r.year
+          }) : g(_e, F({
+            key: "date-picker-month"
+          }, W, {
+            modelValue: u.value,
+            "onUpdate:modelValue": (R) => u.value = R,
+            month: n.value,
+            "onUpdate:month": [(R) => n.value = R, J],
+            year: s.value,
+            "onUpdate:year": [(R) => s.value = R, E],
+            min: k.value,
+            max: f.value
+          }), {
+            day: r.day
+          })]
+        })]),
+        actions: r.actions
+      });
+    }), {};
+  }
+});
+class X {
+  constructor(a, l) {
+    this.order = a, this.separator = l;
+  }
+  get format() {
+    return this.order.split("").map((a) => `${a}${a}`).join(this.separator).replace("yy", "yyyy");
+  }
+  static canBeParsed(a) {
+    if (typeof a != "string") return !1;
+    const l = a.toLowerCase();
+    return ["y", "m", "d"].every((r) => l.includes(r)) && ["/", "-", "."].some((r) => a.includes(r));
+  }
+  static parse(a) {
+    if (!X.canBeParsed(a))
+      throw new Error(`[${a}] cannot be parsed into date format specification`);
+    const l = a.toLowerCase().split("").filter((t, i, o) => "dmy".includes(t) && o.indexOf(t) === i).join(""), r = ["/", "-", "."].find((t) => a.includes(t));
+    return new X(l, r);
+  }
+}
+const wt = U({
+  inputFormat: {
+    type: String,
+    validator: (e) => !e || X.canBeParsed(e)
+  }
+}, "date-format");
+function Mt(e, a) {
+  const l = te();
+  function r() {
+    const d = a.value ?? "en-US", k = Intl.DateTimeFormat(d, {
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    }).format(l.toJsDate(l.parseISO("1999-12-07"))).replace(/(07)|(٠٧)|(٢٩)|(۱۶)|(০৭)/, "dd").replace(/(12)|(١٢)|(٠٨)|(۰۹)|(১২)/, "mm").replace(/(1999)|(2542)|(١٩٩٩)|(١٤٢٠)|(۱۳۷۸)|(১৯৯৯)/, "yyyy").replace(/[^ymd\-/.]/g, "").replace(/\.$/, "");
+    return X.canBeParsed(k) ? k : (ut(`Date format inferred from locale [${d}] is invalid: [${k}]`), "mm/dd/yyyy");
+  }
+  const t = z(() => X.canBeParsed(e.inputFormat) ? X.parse(e.inputFormat) : X.parse(r()));
+  function i(d) {
+    function k(D) {
+      const A = D.trim().split(t.value.separator);
+      return {
+        y: Number(A[t.value.order.indexOf("y")]),
+        m: Number(A[t.value.order.indexOf("m")]),
+        d: Number(A[t.value.order.indexOf("d")])
+      };
+    }
+    function f(D) {
+      const {
+        y: A,
+        m: S,
+        d: _
+      } = D;
+      return !A || !S || !_ || S < 1 || S > 12 || _ < 1 || _ > 31 ? null : {
+        year: m(A),
+        month: S,
+        day: _
+      };
+    }
+    function m(D) {
+      const A = l.getYear(l.date());
+      if (D > 100 || A % 100 >= 50)
+        return D;
+      const S = ~~(A / 100) * 100;
+      return D < 50 ? S + D : S - 100 + D;
+    }
+    const b = k(d), C = f(b);
+    if (!C) return null;
+    const {
+      year: Y,
+      month: n,
+      day: v
+    } = C, s = (D) => String(D).padStart(2, "0");
+    return l.parseISO(`${Y}-${s(n)}-${s(v)}`);
+  }
+  function o(d) {
+    return !!i(d);
+  }
+  function u(d) {
+    const k = l.toISO(d).split("T")[0].split("-");
+    return t.value.order.split("").map((f) => k["ymd".indexOf(f)]).join(t.value.separator);
+  }
+  return {
+    isValid: o,
+    parseDate: i,
+    formatDate: u,
+    parserFormat: z(() => t.value.format)
+  };
+}
+const St = U({
+  displayFormat: {
+    type: [Function, String],
+    default: void 0
+  },
+  location: {
+    type: String,
+    default: "bottom start"
+  },
+  menu: Boolean,
+  updateOn: {
+    type: Array,
+    default: () => ["blur", "enter"]
+  },
+  ...wt(),
+  ...vt({
+    mobile: null
+  }),
+  ...kt(),
+  ...Le({
+    hideActions: !0
+  }),
+  ...ht({
+    prependIcon: "$calendar"
+  }),
+  ...K(ze({
+    hideHeader: !0,
+    showAdjacentMonths: !0
+  }), ["active", "location", "rounded", "height", "minHeight", "maxHeight"])
+}, "VDateInput"), Ct = Z()({
+  name: "VDateInput",
+  props: St(),
+  emits: {
+    save: (e) => !0,
+    cancel: () => !0,
+    "update:focused": (e) => !0,
+    "update:modelValue": (e) => !0,
+    "update:menu": (e) => !0
+  },
+  setup(e, a) {
+    let {
+      emit: l,
+      slots: r
+    } = a;
+    const {
+      t,
+      current: i
+    } = ue(), o = te(), {
+      isValid: u,
+      parseDate: d,
+      formatDate: k,
+      parserFormat: f
+    } = Mt(e, i), {
+      mobile: m
+    } = dt(e), {
+      clampDate: b,
+      isInAllowedRange: C
+    } = be(e), Y = () => e.multiple ? [] : null, n = L(e, "modelValue", Y(), (y) => Array.isArray(y) ? y.map((T) => o.toJsDate(T)) : y && o.toJsDate(y), (y) => Array.isArray(y) ? y.map((T) => o.date(T)) : y && o.date(y)), v = L(e, "menu"), s = oe(!1), D = oe(e.focused), A = ce(), S = ce(["save"]);
+    function _(y) {
+      return typeof e.displayFormat == "function" ? e.displayFormat(y) : e.displayFormat ? o.format(y, e.displayFormat ?? "keyboardDate") : k(y);
+    }
+    const c = M(() => {
+      const y = ee(n.value);
+      if (!y.length) return null;
+      if (e.multiple === !0)
+        return t("$vuetify.datePicker.itemsSelected", y.length);
+      if (e.multiple === "range") {
+        const T = y[0], j = y[y.length - 1];
+        return !o.isValid(T) || !o.isValid(j) ? "" : `${_(o.date(T))} - ${_(o.date(j))}`;
+      }
+      return o.isValid(n.value) ? _(o.date(n.value)) : "";
+    }), x = M(() => {
+      if (m.value)
+        return s.value ? "text" : "none";
+    }), P = M(() => !e.disabled && !e.readonly), I = M(() => e.updateOn.length ? !(m.value && s.value) && e.readonly : !0);
+    fe(v, (y) => {
+      y || (s.value = !1, S.value = ["save"]);
+    });
+    function B(y) {
+      y.key === "Enter" && ((!v.value || !D.value) && (v.value = !0), e.updateOn.includes("enter") && !e.readonly && de(y.target));
+    }
+    function H(y) {
+      y.preventDefault(), y.stopPropagation(), v.value && m.value ? s.value = !0 : v.value = !0;
+    }
+    function ae() {
+      l("cancel"), v.value = !1, s.value = !1;
+    }
+    function ye(y) {
+      l("save", y), v.value = !1;
+    }
+    function he(y) {
+      y == null && (n.value = Y());
+    }
+    function ke(y) {
+      e.updateOn.includes("blur") && !e.readonly && de(y.target), m.value && s.value && !D.value && (v.value = !1, s.value = !1);
+    }
+    function de(y) {
+      let {
+        value: T
+      } = y;
+      if (!T.trim())
+        n.value = Y();
+      else if (!e.multiple)
+        u(T) && (n.value = b(d(T)));
+      else {
+        const j = T.trim().split(/\D+-\D+|[^\d\-/.]+/);
+        if (j.every(u))
+          if (e.multiple === "range") {
+            const [ne, N] = j.map(d).map(b).toSorted((J, E) => o.isAfter(J, E) ? 1 : -1);
+            n.value = Ne(o, ne, N);
+          } else
+            n.value = j.map(d).filter(C);
+      }
+    }
+    return q(() => {
+      const y = Se.filterProps(e), T = Ie.filterProps(K(e, ["active", "bgColor", "color", "location", "rounded", "maxWidth", "minWidth", "width"])), j = st(r, ["title", "header", "day", "month", "year"]), ne = we.filterProps(K(e, ["placeholder"]));
+      return g(we, F({
+        ref: A
+      }, ne, {
+        class: e.class,
+        style: e.style,
+        modelValue: c.value,
+        inputmode: x.value,
+        placeholder: e.placeholder ?? f.value,
+        readonly: I.value,
+        onKeydown: P.value ? B : void 0,
+        focused: v.value || D.value,
+        onBlur: ke,
+        validationValue: n.value,
+        "onClick:control": P.value ? H : void 0,
+        "onClick:prepend": P.value ? H : void 0,
+        "onUpdate:modelValue": he,
+        "onUpdate:focused": (N) => D.value = N
+      }), {
+        ...r,
+        default: () => w(Q, null, [g(ct, {
+          modelValue: v.value,
+          "onUpdate:modelValue": (N) => v.value = N,
+          activator: "parent",
+          minWidth: "0",
+          eager: D.value,
+          location: e.location,
+          closeOnContentClick: !1,
+          openOnClick: !1
+        }, {
+          default: () => [g(Se, F(y, {
+            modelValue: n.value,
+            "onUpdate:modelValue": (N) => n.value = N,
+            disabled: S.value,
+            onSave: ye,
+            onCancel: ae
+          }), {
+            default: (N) => {
+              let {
+                actions: J,
+                model: E,
+                save: h,
+                cancel: V,
+                isPristine: O
+              } = N;
+              function W(p) {
+                e.hideActions ? (n.value = p, e.multiple || (v.value = !1)) : E.value = p, l("save", p), S.value = [];
+              }
+              return g(Ie, F(T, {
+                modelValue: e.hideActions ? n.value : E.value,
+                "onUpdate:modelValue": (p) => W(p),
+                onMousedown: (p) => p.preventDefault()
+              }), {
+                ...j,
+                actions: e.hideActions ? void 0 : () => r.actions?.({
+                  save: h,
+                  cancel: V,
+                  isPristine: O
+                }) ?? J()
+              });
+            }
+          })]
+        }), r.default?.()])
+      });
+    }), ft({}, A);
+  }
+}), pt = {
+  __name: "Datepicker",
+  props: /* @__PURE__ */ Qe({
+    returnFormat: {
+      type: String,
+      default: "DD-MM-YYYY"
+    }
+  }, {
+    modelValue: {},
+    modelModifiers: {}
+  }),
+  emits: ["update:modelValue"],
+  setup(e) {
+    const a = Xe(e, "modelValue"), l = e, r = M({
+      get: () => {
+        const t = l.returnFormat, i = Array.isArray(a.value);
+        let o;
+        return i ? o = a.value.filter((u) => G(u, t).isValid()).map((u) => new Date(G(u, t).format())) : G(a.value, t).isValid() && (o = new Date(G(a.value, t).format())), o;
+      },
+      set: (t) => {
+        const i = l.returnFormat;
+        Array.isArray(t) ? a.value = t.filter((u) => G(u).isValid()).map((u) => G(u).format(i)) : a.value = G(t).isValid() ? G(t).format(i) : void 0;
+      }
+    });
+    return (t, i) => (tt(), et(De(Ct), {
+      modelValue: De(r),
+      "onUpdate:modelValue": i[0] || (i[0] = (o) => at(r) ? r.value = o : null)
+    }, null, 8, ["modelValue"]));
+  }
+};
+export {
+  pt as default
+};