@ianicdev/datatables2 0.9.0 → 0.9.1

package/dist/Datepicker-D0Yzqhky.js

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