@ianicdev/datatables2 0.8.10 → 0.8.12

package/dist/Datepicker-DFx2oByi.js

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