@ianicdev/datatables2 0.10.6 → 0.10.7

package/dist/Datepicker-DZj1h3YE.js

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