@eodash/eodash 5.0.0-alpha.1.8 → 5.0.0-alpha.2

package/dist/EodashDatePicker-DlehqSgz.js

@@ -0,0 +1,1645 @@
+import { g as B, a8 as at, a9 as nt, b as z, aa as lt, p as I, c as v, u as Y, a, ab as j, ac as G, n as R, ad as U, ae as it, r as O, s as Z, O as st, af as pe, a5 as we, m as N, v as ue, C as de, Z as ie, e as ot, a0 as ce, a1 as Ie, t as ve, o as se, ag as Me, w as J, F as X, M as fe, P as Ae, ah as Be, I as q, f as $e, ai as me, aj as rt, ak as ut, y as dt, J as ct, X as vt, _ as ft, a4 as ke, al as mt, $ as yt, am as ht, an as kt, D as re, K as ge, E as gt, ao as ne } from "./asWebComponent-BKe6Spni.js";
+import { V as bt, b as Fe, c as Vt } from "./index-8ch8xKfa.js";
+import { M as ye, m as Oe, i as Ct } from "./index-DIt8GjSR.js";
+import { V as W, e as xt, f as Pt, g as _t, h as St, b as Dt, i as pt, j as wt, L as It, c as Mt, d as At } from "./VBtn-CFPhsIX8.js";
+import { a as oe, c as Bt, d as $t, m as Ye, e as Ft, f as Ot, b as Ne, u as Te } from "./color-D72nEBIR.js";
+import { V as Q, m as Yt, u as Nt } from "./dimensions-BZkmIizV.js";
+import { n as Tt, a as Et, s as Rt, f as Lt } from "./forwardRefs-Bxeu9Obx.js";
+function Ee(e) {
+  let n = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "div", s = arguments.length > 2 ? arguments[2] : void 0;
+  return B()({
+    name: s ?? at(nt(e.replace(/__/g, "-"))),
+    props: {
+      tag: {
+        type: String,
+        default: n
+      },
+      ...z()
+    },
+    setup(r, t) {
+      let {
+        slots: i
+      } = t;
+      return () => lt(r.tag, {
+        class: [e, r.class],
+        style: r.style
+      }, i.default?.());
+    }
+  });
+}
+const Wt = Ee("v-spacer", "div", "VSpacer"), Re = I({
+  active: {
+    type: [String, Array],
+    default: void 0
+  },
+  disabled: {
+    type: [Boolean, String, Array],
+    default: !1
+  },
+  nextIcon: {
+    type: [String],
+    default: "$next"
+  },
+  prevIcon: {
+    type: [String],
+    default: "$prev"
+  },
+  modeIcon: {
+    type: [String],
+    default: "$subgroup"
+  },
+  text: String,
+  viewMode: {
+    type: String,
+    default: "month"
+  }
+}, "VDatePickerControls"), be = B()({
+  name: "VDatePickerControls",
+  props: Re(),
+  emits: {
+    "click:year": () => !0,
+    "click:month": () => !0,
+    "click:prev": () => !0,
+    "click:next": () => !0,
+    "click:text": () => !0
+  },
+  setup(e, n) {
+    let {
+      emit: s
+    } = n;
+    const r = v(() => Array.isArray(e.disabled) ? e.disabled.includes("text") : !!e.disabled), t = v(() => Array.isArray(e.disabled) ? e.disabled.includes("mode") : !!e.disabled), i = v(() => Array.isArray(e.disabled) ? e.disabled.includes("prev") : !!e.disabled), l = v(() => Array.isArray(e.disabled) ? e.disabled.includes("next") : !!e.disabled);
+    function d() {
+      s("click:prev");
+    }
+    function c() {
+      s("click:next");
+    }
+    function u() {
+      s("click:year");
+    }
+    function f() {
+      s("click:month");
+    }
+    return Y(() => a("div", {
+      class: ["v-date-picker-controls"]
+    }, [a(W, {
+      class: "v-date-picker-controls__month-btn",
+      disabled: r.value,
+      text: e.text,
+      variant: "text",
+      rounded: !0,
+      onClick: f
+    }, null), a(W, {
+      key: "mode-btn",
+      class: "v-date-picker-controls__mode-btn",
+      disabled: t.value,
+      density: "comfortable",
+      icon: e.modeIcon,
+      variant: "text",
+      onClick: u
+    }, null), a(Wt, {
+      key: "mode-spacer"
+    }, null), a("div", {
+      key: "month-buttons",
+      class: "v-date-picker-controls__month"
+    }, [a(W, {
+      disabled: i.value,
+      icon: e.prevIcon,
+      variant: "text",
+      onClick: d
+    }, null), a(W, {
+      disabled: l.value,
+      icon: e.nextIcon,
+      variant: "text",
+      onClick: c
+    }, null)])])), {};
+  }
+}), jt = I({
+  appendIcon: String,
+  color: String,
+  header: String,
+  transition: String,
+  onClick: j()
+}, "VDatePickerHeader"), Ve = B()({
+  name: "VDatePickerHeader",
+  props: jt(),
+  emits: {
+    click: () => !0,
+    "click:append": () => !0
+  },
+  setup(e, n) {
+    let {
+      emit: s,
+      slots: r
+    } = n;
+    const {
+      backgroundColorClasses: t,
+      backgroundColorStyles: i
+    } = oe(e, "color");
+    function l() {
+      s("click");
+    }
+    function d() {
+      s("click:append");
+    }
+    return Y(() => {
+      const c = !!(r.default || e.header), u = !!(r.append || e.appendIcon);
+      return a("div", {
+        class: ["v-date-picker-header", {
+          "v-date-picker-header--clickable": !!e.onClick
+        }, t.value],
+        style: i.value,
+        onClick: l
+      }, [r.prepend && a("div", {
+        key: "prepend",
+        class: "v-date-picker-header__prepend"
+      }, [r.prepend()]), c && a(ye, {
+        key: "content",
+        name: e.transition
+      }, {
+        default: () => [a("div", {
+          key: e.header,
+          class: "v-date-picker-header__content"
+        }, [r.default?.() ?? e.header])]
+      }), u && a("div", {
+        class: "v-date-picker-header__append"
+      }, [r.append ? a(Q, {
+        key: "append-defaults",
+        disabled: !e.appendIcon,
+        defaults: {
+          VBtn: {
+            icon: e.appendIcon,
+            variant: "text"
+          }
+        }
+      }, {
+        default: () => [r.append?.()]
+      }) : a(W, {
+        key: "append-btn",
+        icon: e.appendIcon,
+        variant: "text",
+        onClick: d
+      }, null)])]);
+    }), {};
+  }
+}), Ut = I({
+  allowedDates: [Array, Function],
+  disabled: Boolean,
+  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]
+  }
+}, "calendar");
+function zt(e) {
+  const n = G(), s = R(e, "modelValue", [], (m) => U(m)), r = v(() => e.displayValue ? n.date(e.displayValue) : s.value.length > 0 ? n.date(s.value[0]) : e.min ? n.date(e.min) : Array.isArray(e.allowedDates) ? n.date(e.allowedDates[0]) : n.date()), t = R(e, "year", void 0, (m) => {
+    const k = m != null ? Number(m) : n.getYear(r.value);
+    return n.startOfYear(n.setYear(n.date(), k));
+  }, (m) => n.getYear(m)), i = R(e, "month", void 0, (m) => {
+    const k = m != null ? Number(m) : n.getMonth(r.value), y = n.setYear(n.startOfMonth(n.date()), n.getYear(t.value));
+    return n.setMonth(y, k);
+  }, (m) => n.getMonth(m)), l = v(() => {
+    const m = n.getWeekArray(i.value), k = m.flat(), y = 6 * 7;
+    if (k.length < y) {
+      const o = k[k.length - 1];
+      let g = [];
+      for (let b = 1; b <= y - k.length; b++)
+        g.push(n.addDays(o, b)), b % 7 === 0 && (m.push(g), g = []);
+    }
+    return m;
+  });
+  function d(m, k) {
+    return m.filter((y) => e.weekdays.includes(n.toJsDate(y).getDay())).map((y, o) => {
+      const g = n.toISO(y), b = !n.isSameMonth(y, i.value), w = n.isSameDay(y, n.startOfMonth(i.value)), P = n.isSameDay(y, n.endOfMonth(i.value)), x = n.isSameDay(y, i.value);
+      return {
+        date: y,
+        isoDate: g,
+        formatted: n.format(y, "keyboardDate"),
+        year: n.getYear(y),
+        month: n.getMonth(y),
+        isDisabled: V(y),
+        isWeekStart: o % 7 === 0,
+        isWeekEnd: o % 7 === 6,
+        isToday: n.isSameDay(y, k),
+        isAdjacent: b,
+        isHidden: b && !e.showAdjacentMonths,
+        isStart: w,
+        isSelected: s.value.some((_) => n.isSameDay(y, _)),
+        isEnd: P,
+        isSame: x,
+        localized: n.format(y, "dayOfMonth")
+      };
+    });
+  }
+  const c = v(() => {
+    const m = n.startOfWeek(s.value), k = [];
+    for (let g = 0; g <= 6; g++)
+      k.push(n.addDays(m, g));
+    const y = k, o = n.date();
+    return d(y, o);
+  }), u = v(() => {
+    const m = l.value.flat(), k = n.date();
+    return d(m, k);
+  }), f = v(() => l.value.map((m) => m.length ? it(n, m[0]) : null));
+  function V(m) {
+    if (e.disabled)
+      return !0;
+    const k = n.date(m);
+    return e.min && n.isAfter(n.date(e.min), k) || e.max && n.isAfter(k, n.date(e.max)) ? !0 : Array.isArray(e.allowedDates) && e.allowedDates.length > 0 ? !e.allowedDates.some((y) => n.isSameDay(n.date(y), k)) : typeof e.allowedDates == "function" ? !e.allowedDates(k) : !1;
+  }
+  return {
+    displayValue: r,
+    daysInMonth: u,
+    daysInWeek: c,
+    genDays: d,
+    model: s,
+    weeksInMonth: l,
+    weekNumbers: f
+  };
+}
+const Le = I({
+  color: String,
+  hideWeekdays: Boolean,
+  multiple: [Boolean, Number, String],
+  showWeek: Boolean,
+  ...Ut()
+}, "VDatePickerMonth"), Ce = B()({
+  name: "VDatePickerMonth",
+  props: Le(),
+  emits: {
+    "update:modelValue": (e) => !0,
+    "update:month": (e) => !0,
+    "update:year": (e) => !0
+  },
+  setup(e, n) {
+    let {
+      emit: s,
+      slots: r
+    } = n;
+    const t = O(), {
+      daysInMonth: i,
+      model: l,
+      weekNumbers: d
+    } = zt(e), c = G(), u = Z(), f = Z();
+    e.multiple === "range" && l.value.length > 0 && (u.value = l.value[0], l.value.length > 1 && (f.value = l.value[l.value.length - 1]));
+    const V = v(() => {
+      const o = ["number", "string"].includes(typeof e.multiple) ? Number(e.multiple) : 1 / 0;
+      return l.value.length >= o;
+    });
+    function m(o) {
+      const g = c.startOfDay(o);
+      if (!u.value)
+        u.value = g, l.value = [u.value];
+      else if (f.value)
+        u.value = o, f.value = void 0, l.value = [u.value];
+      else {
+        if (c.isSameDay(g, u.value)) {
+          u.value = void 0, l.value = [];
+          return;
+        } else
+          c.isBefore(g, u.value) ? (f.value = c.endOfDay(u.value), u.value = g) : f.value = c.endOfDay(g);
+        const b = c.getDiff(f.value, u.value, "days"), w = [u.value];
+        for (let P = 1; P < b; P++) {
+          const x = c.addDays(u.value, P);
+          w.push(x);
+        }
+        w.push(f.value), l.value = w;
+      }
+    }
+    function k(o) {
+      const g = l.value.findIndex((b) => c.isSameDay(b, o));
+      if (g === -1)
+        l.value = [...l.value, o];
+      else {
+        const b = [...l.value];
+        b.splice(g, 1), l.value = b;
+      }
+    }
+    function y(o) {
+      e.multiple === "range" ? m(o) : e.multiple ? k(o) : l.value = [o];
+    }
+    return () => a("div", {
+      class: "v-date-picker-month"
+    }, [e.showWeek && a("div", {
+      key: "weeks",
+      class: "v-date-picker-month__weeks"
+    }, [!e.hideWeekdays && a("div", {
+      key: "hide-week-days",
+      class: "v-date-picker-month__day"
+    }, [st(" ")]), d.value.map((o) => a("div", {
+      class: ["v-date-picker-month__day", "v-date-picker-month__day--adjacent"]
+    }, [o]))]), a("div", {
+      ref: t,
+      class: "v-date-picker-month__days"
+    }, [!e.hideWeekdays && c.getWeekdays().map((o) => a("div", {
+      class: ["v-date-picker-month__day", "v-date-picker-month__weekday"]
+    }, [o])), i.value.map((o, g) => {
+      const b = {
+        props: {
+          onClick: () => y(o.date)
+        },
+        item: o,
+        i: g
+      };
+      return V.value && !o.isSelected && (o.isDisabled = !0), a("div", {
+        class: ["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) && a(Q, {
+        defaults: {
+          VBtn: {
+            class: "v-date-picker-month__day-btn",
+            color: (o.isSelected || o.isToday) && !o.isDisabled ? e.color : void 0,
+            disabled: o.isDisabled,
+            icon: !0,
+            ripple: !1,
+            text: o.localized,
+            variant: o.isDisabled ? o.isToday ? "outlined" : "text" : o.isToday && !o.isSelected ? "outlined" : "flat",
+            onClick: () => y(o.date)
+          }
+        }
+      }, {
+        default: () => [r.day?.(b) ?? a(W, b.props, null)]
+      })]);
+    })])]);
+  }
+}), We = I({
+  color: String,
+  height: [String, Number],
+  modelValue: Number
+}, "VDatePickerMonths"), xe = B()({
+  name: "VDatePickerMonths",
+  props: We(),
+  emits: {
+    "update:modelValue": (e) => !0
+  },
+  setup(e, n) {
+    let {
+      emit: s,
+      slots: r
+    } = n;
+    const t = G(), i = R(e, "modelValue"), l = v(() => {
+      let d = t.startOfYear(t.date());
+      return pe(12).map((c) => {
+        const u = t.format(d, "monthShort");
+        return d = t.getNextMonth(d), {
+          text: u,
+          value: c
+        };
+      });
+    });
+    return we(() => {
+      i.value = i.value ?? t.getMonth(t.date());
+    }), Y(() => a("div", {
+      class: "v-date-picker-months",
+      style: {
+        height: ue(e.height)
+      }
+    }, [a("div", {
+      class: "v-date-picker-months__content"
+    }, [l.value.map((d, c) => {
+      const u = {
+        active: i.value === c,
+        color: i.value === c ? e.color : void 0,
+        rounded: !0,
+        text: d.text,
+        variant: i.value === d.value ? "flat" : "text",
+        onClick: () => f(c)
+      };
+      function f(V) {
+        if (i.value === V) {
+          s("update:modelValue", i.value);
+          return;
+        }
+        i.value = V;
+      }
+      return r.month?.({
+        month: d,
+        i: c,
+        props: u
+      }) ?? a(W, N({
+        key: "month"
+      }, u), null);
+    })])])), {};
+  }
+}), je = I({
+  color: String,
+  height: [String, Number],
+  min: null,
+  max: null,
+  modelValue: Number
+}, "VDatePickerYears"), Pe = B()({
+  name: "VDatePickerYears",
+  props: je(),
+  emits: {
+    "update:modelValue": (e) => !0
+  },
+  setup(e, n) {
+    let {
+      emit: s,
+      slots: r
+    } = n;
+    const t = G(), i = R(e, "modelValue"), l = v(() => {
+      const c = t.getYear(t.date());
+      let u = c - 100, f = c + 52;
+      e.min && (u = t.getYear(t.date(e.min))), e.max && (f = t.getYear(t.date(e.max)));
+      let V = t.startOfYear(t.date());
+      return V = t.setYear(V, u), pe(f - u + 1, u).map((m) => {
+        const k = t.format(V, "year");
+        return V = t.setYear(V, t.getYear(V) + 1), {
+          text: k,
+          value: m
+        };
+      });
+    });
+    we(() => {
+      i.value = i.value ?? t.getYear(t.date());
+    });
+    const d = O();
+    return de(async () => {
+      await ie(), d.value?.$el.scrollIntoView({
+        block: "center"
+      });
+    }), Y(() => a("div", {
+      class: "v-date-picker-years",
+      style: {
+        height: ue(e.height)
+      }
+    }, [a("div", {
+      class: "v-date-picker-years__content"
+    }, [l.value.map((c, u) => {
+      const f = {
+        ref: i.value === c.value ? d : void 0,
+        active: i.value === c.value,
+        color: i.value === c.value ? e.color : void 0,
+        rounded: !0,
+        text: c.text,
+        variant: i.value === c.value ? "flat" : "text",
+        onClick: () => {
+          if (i.value === c.value) {
+            s("update:modelValue", i.value);
+            return;
+          }
+          i.value = c.value;
+        }
+      };
+      return r.year?.({
+        year: c,
+        i: u,
+        props: f
+      }) ?? a(W, N({
+        key: "month"
+      }, f), null);
+    })])])), {};
+  }
+}), Ht = Ee("v-picker-title"), Ue = I({
+  color: String,
+  ...Bt(),
+  ...z(),
+  ...Yt(),
+  ...$t(),
+  ...xt(),
+  ...Pt(),
+  ...Ye(),
+  ...ot(),
+  ...ce()
+}, "VSheet"), _e = B()({
+  name: "VSheet",
+  props: Ue(),
+  setup(e, n) {
+    let {
+      slots: s
+    } = n;
+    const {
+      themeClasses: r
+    } = Ie(e), {
+      backgroundColorClasses: t,
+      backgroundColorStyles: i
+    } = oe(ve(e, "color")), {
+      borderClasses: l
+    } = Ft(e), {
+      dimensionStyles: d
+    } = Nt(e), {
+      elevationClasses: c
+    } = Ot(e), {
+      locationStyles: u
+    } = _t(e), {
+      positionClasses: f
+    } = St(e), {
+      roundedClasses: V
+    } = Ne(e);
+    return Y(() => a(e.tag, {
+      class: ["v-sheet", r.value, t.value, l.value, c.value, f.value, V.value, e.class],
+      style: [i.value, d.value, u.value, e.style]
+    }, s)), {};
+  }
+}), ze = I({
+  bgColor: String,
+  landscape: Boolean,
+  title: String,
+  hideHeader: Boolean,
+  ...Ue()
+}, "VPicker"), Se = B()({
+  name: "VPicker",
+  props: ze(),
+  setup(e, n) {
+    let {
+      slots: s
+    } = n;
+    const {
+      backgroundColorClasses: r,
+      backgroundColorStyles: t
+    } = oe(ve(e, "color"));
+    return Y(() => {
+      const i = _e.filterProps(e), l = !!(e.title || s.title);
+      return a(_e, N(i, {
+        color: e.bgColor,
+        class: ["v-picker", {
+          "v-picker--landscape": e.landscape,
+          "v-picker--with-actions": !!s.actions
+        }, e.class],
+        style: e.style
+      }), {
+        default: () => [!e.hideHeader && a("div", {
+          key: "header",
+          class: [r.value],
+          style: [t.value]
+        }, [l && a(Ht, {
+          key: "picker-title"
+        }, {
+          default: () => [s.title?.() ?? e.title]
+        }), s.header && a("div", {
+          class: "v-picker__header"
+        }, [s.header()])]), a("div", {
+          class: "v-picker__body"
+        }, [s.default?.()]), s.actions && a(Q, {
+          defaults: {
+            VBtn: {
+              slim: !0,
+              variant: "text"
+            }
+          }
+        }, {
+          default: () => [a("div", {
+            class: "v-picker__actions"
+          }, [s.actions()])]
+        })]
+      });
+    }), {};
+  }
+}), Kt = I({
+  // 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"
+  },
+  ...Re(),
+  ...Le(),
+  ...se(We(), ["modelValue"]),
+  ...se(je(), ["modelValue"]),
+  ...ze({
+    title: "$vuetify.datePicker.title"
+  }),
+  modelValue: null
+}, "VDatePicker"), Jt = B()({
+  name: "VDatePicker",
+  props: Kt(),
+  emits: {
+    "update:modelValue": (e) => !0,
+    "update:month": (e) => !0,
+    "update:year": (e) => !0,
+    // 'update:inputMode': (date: any) => true,
+    "update:viewMode": (e) => !0
+  },
+  setup(e, n) {
+    let {
+      emit: s,
+      slots: r
+    } = n;
+    const t = G(), {
+      t: i
+    } = Me(), l = R(e, "modelValue", void 0, (h) => U(h), (h) => e.multiple ? h : h[0]), d = R(e, "viewMode"), c = v(() => {
+      const h = t.date(l.value?.[0]);
+      return h && t.isValid(h) ? h : t.date();
+    }), u = O(Number(e.month ?? t.getMonth(t.startOfMonth(c.value)))), f = O(Number(e.year ?? t.getYear(t.startOfYear(t.setMonth(c.value, u.value))))), V = Z(!1), m = v(() => e.multiple && l.value.length > 1 ? i("$vuetify.datePicker.itemsSelected", l.value.length) : l.value[0] && t.isValid(l.value[0]) ? t.format(t.date(l.value[0]), "normalDateWithWeekday") : i(e.header)), k = v(() => {
+      let h = t.date();
+      return h = t.setYear(h, f.value), h = t.setMonth(h, u.value), h = t.setDate(h, 1), t.format(h, "monthAndYear");
+    }), y = v(() => `date-picker-header${V.value ? "-reverse" : ""}-transition`), o = v(() => {
+      const h = t.date(e.min);
+      return e.min && t.isValid(h) ? h : null;
+    }), g = v(() => {
+      const h = t.date(e.max);
+      return e.max && t.isValid(h) ? h : null;
+    }), b = v(() => {
+      if (e.disabled)
+        return !0;
+      const h = [];
+      if (d.value !== "month")
+        h.push("prev", "next");
+      else {
+        let M = t.date();
+        if (M = t.setYear(M, f.value), M = t.setMonth(M, u.value), o.value) {
+          const A = t.addDays(t.startOfMonth(M), -1);
+          t.isAfter(o.value, A) && h.push("prev");
+        }
+        if (g.value) {
+          const A = t.addDays(t.endOfMonth(M), 1);
+          t.isAfter(A, g.value) && h.push("next");
+        }
+      }
+      return h;
+    });
+    function w() {
+      u.value < 11 ? u.value++ : (f.value++, u.value = 0, p(f.value)), S(u.value);
+    }
+    function P() {
+      u.value > 0 ? u.value-- : (f.value--, u.value = 11, p(f.value)), S(u.value);
+    }
+    function x() {
+      d.value = "month";
+    }
+    function _() {
+      d.value = d.value === "months" ? "month" : "months";
+    }
+    function C() {
+      d.value = d.value === "year" ? "month" : "year";
+    }
+    function S(h) {
+      d.value === "months" && _(), s("update:month", h);
+    }
+    function p(h) {
+      d.value === "year" && C(), s("update:year", h);
+    }
+    return J(l, (h, M) => {
+      const A = t.date(U(h)[0]), H = t.date(U(M)[0]);
+      V.value = t.isBefore(A, H);
+    }), Y(() => {
+      const h = Se.filterProps(e), M = be.filterProps(e), A = Ve.filterProps(e), H = Ce.filterProps(e), E = se(xe.filterProps(e), ["modelValue"]), $ = se(Pe.filterProps(e), ["modelValue"]), F = {
+        header: m.value,
+        transition: y.value
+      };
+      return a(Se, N(h, {
+        class: ["v-date-picker", `v-date-picker--${d.value}`, {
+          "v-date-picker--show-week": e.showWeek
+        }, e.class],
+        style: e.style
+      }), {
+        title: () => r.title?.() ?? a("div", {
+          class: "v-date-picker__title"
+        }, [i(e.title)]),
+        header: () => r.header ? a(Q, {
+          defaults: {
+            VDatePickerHeader: {
+              ...F
+            }
+          }
+        }, {
+          default: () => [r.header?.(F)]
+        }) : a(Ve, N({
+          key: "header"
+        }, A, F, {
+          onClick: d.value !== "month" ? x : void 0
+        }), {
+          ...r,
+          default: void 0
+        }),
+        default: () => a(X, null, [a(be, N(M, {
+          disabled: b.value,
+          text: k.value,
+          "onClick:next": w,
+          "onClick:prev": P,
+          "onClick:month": _,
+          "onClick:year": C
+        }), null), a(bt, {
+          hideOnLeave: !0
+        }, {
+          default: () => [d.value === "months" ? a(xe, N({
+            key: "date-picker-months"
+          }, E, {
+            modelValue: u.value,
+            "onUpdate:modelValue": [(D) => u.value = D, S],
+            min: o.value,
+            max: g.value
+          }), null) : d.value === "year" ? a(Pe, N({
+            key: "date-picker-years"
+          }, $, {
+            modelValue: f.value,
+            "onUpdate:modelValue": [(D) => f.value = D, p],
+            min: o.value,
+            max: g.value
+          }), null) : a(Ce, N({
+            key: "date-picker-month"
+          }, H, {
+            modelValue: l.value,
+            "onUpdate:modelValue": (D) => l.value = D,
+            month: u.value,
+            "onUpdate:month": [(D) => u.value = D, S],
+            year: f.value,
+            "onUpdate:year": [(D) => f.value = D, p],
+            min: o.value,
+            max: g.value
+          }), null)]
+        })]),
+        actions: r.actions
+      });
+    }), {};
+  }
+}), Xt = I({
+  active: Boolean,
+  max: [Number, String],
+  value: {
+    type: [Number, String],
+    default: 0
+  },
+  ...z(),
+  ...Oe({
+    transition: {
+      component: Fe
+    }
+  })
+}, "VCounter"), qt = B()({
+  name: "VCounter",
+  functional: !0,
+  props: Xt(),
+  setup(e, n) {
+    let {
+      slots: s
+    } = n;
+    const r = v(() => e.max ? `${e.value} / ${e.max}` : String(e.value));
+    return Y(() => a(ye, {
+      transition: e.transition
+    }, {
+      default: () => [fe(a("div", {
+        class: ["v-counter", e.class],
+        style: e.style
+      }, [s.default ? s.default({
+        counter: r.value,
+        max: e.max,
+        value: e.value
+      }) : r.value]), [[Ae, e.active]])]
+    })), {};
+  }
+}), Zt = I({
+  text: String,
+  onClick: j(),
+  ...z(),
+  ...ce()
+}, "VLabel"), Gt = B()({
+  name: "VLabel",
+  props: Zt(),
+  setup(e, n) {
+    let {
+      slots: s
+    } = n;
+    return Y(() => a("label", {
+      class: ["v-label", {
+        "v-label--clickable": !!e.onClick
+      }, e.class],
+      style: e.style,
+      onClick: e.onClick
+    }, [e.text, s.default?.()])), {};
+  }
+}), Qt = I({
+  floating: Boolean,
+  ...z()
+}, "VFieldLabel"), le = B()({
+  name: "VFieldLabel",
+  props: Qt(),
+  setup(e, n) {
+    let {
+      slots: s
+    } = n;
+    return Y(() => a(Gt, {
+      class: ["v-field-label", {
+        "v-field-label--floating": e.floating
+      }, e.class],
+      style: e.style,
+      "aria-hidden": e.floating || void 0
+    }, s)), {};
+  }
+});
+function He(e) {
+  const {
+    t: n
+  } = Me();
+  function s(r) {
+    let {
+      name: t
+    } = r;
+    const i = {
+      prepend: "prependAction",
+      prependInner: "prependAction",
+      append: "appendAction",
+      appendInner: "appendAction",
+      clear: "clear"
+    }[t], l = e[`onClick:${t}`], d = l && i ? n(`$vuetify.input.${i}`, e.label ?? "") : void 0;
+    return a(Dt, {
+      icon: e[`${t}Icon`],
+      "aria-label": d,
+      onClick: l
+    }, null);
+  }
+  return {
+    InputIcon: s
+  };
+}
+const Ke = I({
+  focused: Boolean,
+  "onUpdate:focused": j()
+}, "focus");
+function Je(e) {
+  let n = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : Be();
+  const s = R(e, "focused"), r = v(() => ({
+    [`${n}--focused`]: s.value
+  }));
+  function t() {
+    s.value = !0;
+  }
+  function i() {
+    s.value = !1;
+  }
+  return {
+    focusClasses: r,
+    isFocused: s,
+    focus: t,
+    blur: i
+  };
+}
+const ea = ["underlined", "outlined", "filled", "solo", "solo-inverted", "solo-filled", "plain"], Xe = I({
+  appendInnerIcon: q,
+  bgColor: String,
+  clearable: Boolean,
+  clearIcon: {
+    type: q,
+    default: "$clear"
+  },
+  active: Boolean,
+  centerAffix: {
+    type: Boolean,
+    default: void 0
+  },
+  color: String,
+  baseColor: String,
+  dirty: Boolean,
+  disabled: {
+    type: Boolean,
+    default: null
+  },
+  error: Boolean,
+  flat: Boolean,
+  label: String,
+  persistentClear: Boolean,
+  prependInnerIcon: q,
+  reverse: Boolean,
+  singleLine: Boolean,
+  variant: {
+    type: String,
+    default: "filled",
+    validator: (e) => ea.includes(e)
+  },
+  "onClick:clear": j(),
+  "onClick:appendInner": j(),
+  "onClick:prependInner": j(),
+  ...z(),
+  ...pt(),
+  ...Ye(),
+  ...ce()
+}, "VField"), qe = B()({
+  name: "VField",
+  inheritAttrs: !1,
+  props: {
+    id: String,
+    ...Ke(),
+    ...Xe()
+  },
+  emits: {
+    "update:focused": (e) => !0,
+    "update:modelValue": (e) => !0
+  },
+  setup(e, n) {
+    let {
+      attrs: s,
+      emit: r,
+      slots: t
+    } = n;
+    const {
+      themeClasses: i
+    } = Ie(e), {
+      loaderClasses: l
+    } = wt(e), {
+      focusClasses: d,
+      isFocused: c,
+      focus: u,
+      blur: f
+    } = Je(e), {
+      InputIcon: V
+    } = He(e), {
+      roundedClasses: m
+    } = Ne(e), {
+      rtlClasses: k
+    } = $e(), y = v(() => e.dirty || e.active), o = v(() => !e.singleLine && !!(e.label || t.label)), g = me(), b = v(() => e.id || `input-${g}`), w = v(() => `${b.value}-messages`), P = O(), x = O(), _ = O(), C = v(() => ["plain", "underlined"].includes(e.variant)), {
+      backgroundColorClasses: S,
+      backgroundColorStyles: p
+    } = oe(ve(e, "bgColor")), {
+      textColorClasses: h,
+      textColorStyles: M
+    } = Te(v(() => e.error || e.disabled ? void 0 : y.value && c.value ? e.color : e.baseColor));
+    J(y, ($) => {
+      if (o.value) {
+        const F = P.value.$el, D = x.value.$el;
+        requestAnimationFrame(() => {
+          const L = Tt(F), T = D.getBoundingClientRect(), K = T.x - L.x, ee = T.y - L.y - (L.height / 2 - T.height / 2), te = T.width / 0.75, ae = Math.abs(te - L.width) > 1 ? {
+            maxWidth: ue(te)
+          } : void 0, Ge = getComputedStyle(F), he = getComputedStyle(D), Qe = parseFloat(Ge.transitionDuration) * 1e3 || 150, et = parseFloat(he.getPropertyValue("--v-field-label-scale")), tt = he.getPropertyValue("color");
+          F.style.visibility = "visible", D.style.visibility = "hidden", Et(F, {
+            transform: `translate(${K}px, ${ee}px) scale(${et})`,
+            color: tt,
+            ...ae
+          }, {
+            duration: Qe,
+            easing: Rt,
+            direction: $ ? "normal" : "reverse"
+          }).finished.then(() => {
+            F.style.removeProperty("visibility"), D.style.removeProperty("visibility");
+          });
+        });
+      }
+    }, {
+      flush: "post"
+    });
+    const A = v(() => ({
+      isActive: y,
+      isFocused: c,
+      controlRef: _,
+      blur: f,
+      focus: u
+    }));
+    function H($) {
+      $.target !== document.activeElement && $.preventDefault();
+    }
+    function E($) {
+      $.key !== "Enter" && $.key !== " " || ($.preventDefault(), $.stopPropagation(), e["onClick:clear"]?.(new MouseEvent("click")));
+    }
+    return Y(() => {
+      const $ = e.variant === "outlined", F = !!(t["prepend-inner"] || e.prependInnerIcon), D = !!(e.clearable || t.clear), L = !!(t["append-inner"] || e.appendInnerIcon || D), T = () => t.label ? t.label({
+        ...A.value,
+        label: e.label,
+        props: {
+          for: b.value
+        }
+      }) : e.label;
+      return a("div", N({
+        class: ["v-field", {
+          "v-field--active": y.value,
+          "v-field--appended": L,
+          "v-field--center-affix": e.centerAffix ?? !C.value,
+          "v-field--disabled": e.disabled,
+          "v-field--dirty": e.dirty,
+          "v-field--error": e.error,
+          "v-field--flat": e.flat,
+          "v-field--has-background": !!e.bgColor,
+          "v-field--persistent-clear": e.persistentClear,
+          "v-field--prepended": F,
+          "v-field--reverse": e.reverse,
+          "v-field--single-line": e.singleLine,
+          "v-field--no-label": !T(),
+          [`v-field--variant-${e.variant}`]: !0
+        }, i.value, S.value, d.value, l.value, m.value, k.value, e.class],
+        style: [p.value, e.style],
+        onClick: H
+      }, s), [a("div", {
+        class: "v-field__overlay"
+      }, null), a(It, {
+        name: "v-field",
+        active: !!e.loading,
+        color: e.error ? "error" : typeof e.loading == "string" ? e.loading : e.color
+      }, {
+        default: t.loader
+      }), F && a("div", {
+        key: "prepend",
+        class: "v-field__prepend-inner"
+      }, [e.prependInnerIcon && a(V, {
+        key: "prepend-icon",
+        name: "prependInner"
+      }, null), t["prepend-inner"]?.(A.value)]), a("div", {
+        class: "v-field__field",
+        "data-no-activator": ""
+      }, [["filled", "solo", "solo-inverted", "solo-filled"].includes(e.variant) && o.value && a(le, {
+        key: "floating-label",
+        ref: x,
+        class: [h.value],
+        floating: !0,
+        for: b.value,
+        style: M.value
+      }, {
+        default: () => [T()]
+      }), a(le, {
+        ref: P,
+        for: b.value
+      }, {
+        default: () => [T()]
+      }), t.default?.({
+        ...A.value,
+        props: {
+          id: b.value,
+          class: "v-field__input",
+          "aria-describedby": w.value
+        },
+        focus: u,
+        blur: f
+      })]), D && a(Vt, {
+        key: "clear"
+      }, {
+        default: () => [fe(a("div", {
+          class: "v-field__clearable",
+          onMousedown: (K) => {
+            K.preventDefault(), K.stopPropagation();
+          }
+        }, [a(Q, {
+          defaults: {
+            VIcon: {
+              icon: e.clearIcon
+            }
+          }
+        }, {
+          default: () => [t.clear ? t.clear({
+            ...A.value,
+            props: {
+              onKeydown: E,
+              onFocus: u,
+              onBlur: f,
+              onClick: e["onClick:clear"]
+            }
+          }) : a(V, {
+            name: "clear",
+            onKeydown: E,
+            onFocus: u,
+            onBlur: f
+          }, null)]
+        })]), [[Ae, e.dirty]])]
+      }), L && a("div", {
+        key: "append",
+        class: "v-field__append-inner"
+      }, [t["append-inner"]?.(A.value), e.appendInnerIcon && a(V, {
+        key: "append-icon",
+        name: "appendInner"
+      }, null)]), a("div", {
+        class: ["v-field__outline", h.value],
+        style: M.value
+      }, [$ && a(X, null, [a("div", {
+        class: "v-field__outline__start"
+      }, null), o.value && a("div", {
+        class: "v-field__outline__notch"
+      }, [a(le, {
+        ref: x,
+        floating: !0,
+        for: b.value
+      }, {
+        default: () => [T()]
+      })]), a("div", {
+        class: "v-field__outline__end"
+      }, null)]), C.value && o.value && a(le, {
+        ref: x,
+        floating: !0,
+        for: b.value
+      }, {
+        default: () => [T()]
+      })])]);
+    }), {
+      controlRef: _
+    };
+  }
+});
+function ta(e) {
+  const n = Object.keys(qe.props).filter((s) => !rt(s) && s !== "class" && s !== "style");
+  return ut(e, n);
+}
+const aa = I({
+  active: Boolean,
+  color: String,
+  messages: {
+    type: [Array, String],
+    default: () => []
+  },
+  ...z(),
+  ...Oe({
+    transition: {
+      component: Fe,
+      leaveAbsolute: !0,
+      group: !0
+    }
+  })
+}, "VMessages"), na = B()({
+  name: "VMessages",
+  props: aa(),
+  setup(e, n) {
+    let {
+      slots: s
+    } = n;
+    const r = v(() => U(e.messages)), {
+      textColorClasses: t,
+      textColorStyles: i
+    } = Te(v(() => e.color));
+    return Y(() => a(ye, {
+      transition: e.transition,
+      tag: "div",
+      class: ["v-messages", t.value, e.class],
+      style: [i.value, e.style],
+      role: "alert",
+      "aria-live": "polite"
+    }, {
+      default: () => [e.active && r.value.map((l, d) => a("div", {
+        class: "v-messages__message",
+        key: `${d}-${r.value}`
+      }, [s.message ? s.message({
+        message: l
+      }) : l]))]
+    })), {};
+  }
+}), la = Symbol.for("vuetify:form");
+function ia() {
+  return dt(la, null);
+}
+const sa = I({
+  disabled: {
+    type: Boolean,
+    default: null
+  },
+  error: Boolean,
+  errorMessages: {
+    type: [Array, String],
+    default: () => []
+  },
+  maxErrors: {
+    type: [Number, String],
+    default: 1
+  },
+  name: String,
+  label: String,
+  readonly: {
+    type: Boolean,
+    default: null
+  },
+  rules: {
+    type: Array,
+    default: () => []
+  },
+  modelValue: null,
+  validateOn: String,
+  validationValue: null,
+  ...Ke()
+}, "validation");
+function oa(e) {
+  let n = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : Be(), s = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : me();
+  const r = R(e, "modelValue"), t = v(() => e.validationValue === void 0 ? r.value : e.validationValue), i = ia(), l = O([]), d = Z(!0), c = v(() => !!(U(r.value === "" ? null : r.value).length || U(t.value === "" ? null : t.value).length)), u = v(() => !!(e.disabled ?? i?.isDisabled.value)), f = v(() => !!(e.readonly ?? i?.isReadonly.value)), V = v(() => e.errorMessages?.length ? U(e.errorMessages).concat(l.value).slice(0, Math.max(0, +e.maxErrors)) : l.value), m = v(() => {
+    let x = (e.validateOn ?? i?.validateOn.value) || "input";
+    x === "lazy" && (x = "input lazy");
+    const _ = new Set(x?.split(" ") ?? []);
+    return {
+      blur: _.has("blur") || _.has("input"),
+      input: _.has("input"),
+      submit: _.has("submit"),
+      lazy: _.has("lazy")
+    };
+  }), k = v(() => e.error || e.errorMessages?.length ? !1 : e.rules.length ? d.value ? l.value.length || m.value.lazy ? null : !0 : !l.value.length : !0), y = Z(!1), o = v(() => ({
+    [`${n}--error`]: k.value === !1,
+    [`${n}--dirty`]: c.value,
+    [`${n}--disabled`]: u.value,
+    [`${n}--readonly`]: f.value
+  })), g = v(() => e.name ?? ct(s));
+  vt(() => {
+    i?.register({
+      id: g.value,
+      validate: P,
+      reset: b,
+      resetValidation: w
+    });
+  }), ft(() => {
+    i?.unregister(g.value);
+  }), de(async () => {
+    m.value.lazy || await P(!0), i?.update(g.value, k.value, V.value);
+  }), ke(() => m.value.input, () => {
+    J(t, () => {
+      if (t.value != null)
+        P();
+      else if (e.focused) {
+        const x = J(() => e.focused, (_) => {
+          _ || P(), x();
+        });
+      }
+    });
+  }), ke(() => m.value.blur, () => {
+    J(() => e.focused, (x) => {
+      x || P();
+    });
+  }), J([k, V], () => {
+    i?.update(g.value, k.value, V.value);
+  });
+  async function b() {
+    r.value = null, await ie(), await w();
+  }
+  async function w() {
+    d.value = !0, m.value.lazy ? l.value = [] : await P(!0);
+  }
+  async function P() {
+    let x = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : !1;
+    const _ = [];
+    y.value = !0;
+    for (const C of e.rules) {
+      if (_.length >= +(e.maxErrors ?? 1))
+        break;
+      const p = await (typeof C == "function" ? C : () => C)(t.value);
+      if (p !== !0) {
+        if (p !== !1 && typeof p != "string") {
+          console.warn(`${p} is not a valid value. Rule functions must return boolean true or a string.`);
+          continue;
+        }
+        _.push(p || "");
+      }
+    }
+    return l.value = _, y.value = !1, d.value = x, l.value;
+  }
+  return {
+    errorMessages: V,
+    isDirty: c,
+    isDisabled: u,
+    isReadonly: f,
+    isPristine: d,
+    isValid: k,
+    isValidating: y,
+    reset: b,
+    resetValidation: w,
+    validate: P,
+    validationClasses: o
+  };
+}
+const Ze = I({
+  id: String,
+  appendIcon: q,
+  centerAffix: {
+    type: Boolean,
+    default: !0
+  },
+  prependIcon: q,
+  hideDetails: [Boolean, String],
+  hideSpinButtons: Boolean,
+  hint: String,
+  persistentHint: Boolean,
+  messages: {
+    type: [Array, String],
+    default: () => []
+  },
+  direction: {
+    type: String,
+    default: "horizontal",
+    validator: (e) => ["horizontal", "vertical"].includes(e)
+  },
+  "onClick:prepend": j(),
+  "onClick:append": j(),
+  ...z(),
+  ...Mt(),
+  ...sa()
+}, "VInput"), De = B()({
+  name: "VInput",
+  props: {
+    ...Ze()
+  },
+  emits: {
+    "update:modelValue": (e) => !0
+  },
+  setup(e, n) {
+    let {
+      attrs: s,
+      slots: r,
+      emit: t
+    } = n;
+    const {
+      densityClasses: i
+    } = At(e), {
+      rtlClasses: l
+    } = $e(), {
+      InputIcon: d
+    } = He(e), c = me(), u = v(() => e.id || `input-${c}`), f = v(() => `${u.value}-messages`), {
+      errorMessages: V,
+      isDirty: m,
+      isDisabled: k,
+      isReadonly: y,
+      isPristine: o,
+      isValid: g,
+      isValidating: b,
+      reset: w,
+      resetValidation: P,
+      validate: x,
+      validationClasses: _
+    } = oa(e, "v-input", u), C = v(() => ({
+      id: u,
+      messagesId: f,
+      isDirty: m,
+      isDisabled: k,
+      isReadonly: y,
+      isPristine: o,
+      isValid: g,
+      isValidating: b,
+      reset: w,
+      resetValidation: P,
+      validate: x
+    })), S = v(() => e.errorMessages?.length || !o.value && V.value.length ? V.value : e.hint && (e.persistentHint || e.focused) ? e.hint : e.messages);
+    return Y(() => {
+      const p = !!(r.prepend || e.prependIcon), h = !!(r.append || e.appendIcon), M = S.value.length > 0, A = !e.hideDetails || e.hideDetails === "auto" && (M || !!r.details);
+      return a("div", {
+        class: ["v-input", `v-input--${e.direction}`, {
+          "v-input--center-affix": e.centerAffix,
+          "v-input--hide-spin-buttons": e.hideSpinButtons
+        }, i.value, l.value, _.value, e.class],
+        style: e.style
+      }, [p && a("div", {
+        key: "prepend",
+        class: "v-input__prepend"
+      }, [r.prepend?.(C.value), e.prependIcon && a(d, {
+        key: "prepend-icon",
+        name: "prepend"
+      }, null)]), r.default && a("div", {
+        class: "v-input__control"
+      }, [r.default?.(C.value)]), h && a("div", {
+        key: "append",
+        class: "v-input__append"
+      }, [e.appendIcon && a(d, {
+        key: "append-icon",
+        name: "append"
+      }, null), r.append?.(C.value)]), A && a("div", {
+        class: "v-input__details"
+      }, [a(na, {
+        id: f.value,
+        active: M,
+        messages: S.value
+      }, {
+        message: r.message
+      }), r.details?.(C.value)])]);
+    }), {
+      reset: w,
+      resetValidation: P,
+      validate: x,
+      isValid: g,
+      errorMessages: V
+    };
+  }
+}), ra = ["color", "file", "time", "date", "datetime-local", "week", "month"], ua = I({
+  autofocus: Boolean,
+  counter: [Boolean, Number, String],
+  counterValue: [Number, Function],
+  prefix: String,
+  placeholder: String,
+  persistentPlaceholder: Boolean,
+  persistentCounter: Boolean,
+  suffix: String,
+  role: String,
+  type: {
+    type: String,
+    default: "text"
+  },
+  modelModifiers: Object,
+  ...Ze(),
+  ...Xe()
+}, "VTextField"), da = B()({
+  name: "VTextField",
+  directives: {
+    Intersect: Ct
+  },
+  inheritAttrs: !1,
+  props: ua(),
+  emits: {
+    "click:control": (e) => !0,
+    "mousedown:control": (e) => !0,
+    "update:focused": (e) => !0,
+    "update:modelValue": (e) => !0
+  },
+  setup(e, n) {
+    let {
+      attrs: s,
+      emit: r,
+      slots: t
+    } = n;
+    const i = R(e, "modelValue"), {
+      isFocused: l,
+      focus: d,
+      blur: c
+    } = Je(e), u = v(() => typeof e.counterValue == "function" ? e.counterValue(i.value) : typeof e.counterValue == "number" ? e.counterValue : (i.value ?? "").toString().length), f = v(() => {
+      if (s.maxlength)
+        return s.maxlength;
+      if (!(!e.counter || typeof e.counter != "number" && typeof e.counter != "string"))
+        return e.counter;
+    }), V = v(() => ["plain", "underlined"].includes(e.variant));
+    function m(C, S) {
+      !e.autofocus || !C || S[0].target?.focus?.();
+    }
+    const k = O(), y = O(), o = O(), g = v(() => ra.includes(e.type) || e.persistentPlaceholder || l.value || e.active);
+    function b() {
+      o.value !== document.activeElement && o.value?.focus(), l.value || d();
+    }
+    function w(C) {
+      r("mousedown:control", C), C.target !== o.value && (b(), C.preventDefault());
+    }
+    function P(C) {
+      b(), r("click:control", C);
+    }
+    function x(C) {
+      C.stopPropagation(), b(), ie(() => {
+        i.value = null, kt(e["onClick:clear"], C);
+      });
+    }
+    function _(C) {
+      const S = C.target;
+      if (i.value = S.value, e.modelModifiers?.trim && ["text", "search", "password", "tel", "url"].includes(e.type)) {
+        const p = [S.selectionStart, S.selectionEnd];
+        ie(() => {
+          S.selectionStart = p[0], S.selectionEnd = p[1];
+        });
+      }
+    }
+    return Y(() => {
+      const C = !!(t.counter || e.counter !== !1 && e.counter != null), S = !!(C || t.details), [p, h] = mt(s), {
+        modelValue: M,
+        ...A
+      } = De.filterProps(e), H = ta(e);
+      return a(De, N({
+        ref: k,
+        modelValue: i.value,
+        "onUpdate:modelValue": (E) => i.value = E,
+        class: ["v-text-field", {
+          "v-text-field--prefixed": e.prefix,
+          "v-text-field--suffixed": e.suffix,
+          "v-input--plain-underlined": V.value
+        }, e.class],
+        style: e.style
+      }, p, A, {
+        centerAffix: !V.value,
+        focused: l.value
+      }), {
+        ...t,
+        default: (E) => {
+          let {
+            id: $,
+            isDisabled: F,
+            isDirty: D,
+            isReadonly: L,
+            isValid: T
+          } = E;
+          return a(qe, N({
+            ref: y,
+            onMousedown: w,
+            onClick: P,
+            "onClick:clear": x,
+            "onClick:prependInner": e["onClick:prependInner"],
+            "onClick:appendInner": e["onClick:appendInner"],
+            role: e.role
+          }, H, {
+            id: $.value,
+            active: g.value || D.value,
+            dirty: D.value || e.dirty,
+            disabled: F.value,
+            focused: l.value,
+            error: T.value === !1
+          }), {
+            ...t,
+            default: (K) => {
+              let {
+                props: {
+                  class: ee,
+                  ...te
+                }
+              } = K;
+              const ae = fe(a("input", N({
+                ref: o,
+                value: i.value,
+                onInput: _,
+                autofocus: e.autofocus,
+                readonly: L.value,
+                disabled: F.value,
+                name: e.name,
+                placeholder: e.placeholder,
+                size: 1,
+                type: e.type,
+                onFocus: b,
+                onBlur: c
+              }, te, h), null), [[yt("intersect"), {
+                handler: m
+              }, null, {
+                once: !0
+              }]]);
+              return a(X, null, [e.prefix && a("span", {
+                class: "v-text-field__prefix"
+              }, [a("span", {
+                class: "v-text-field__prefix__text"
+              }, [e.prefix])]), t.default ? a("div", {
+                class: ee,
+                "data-no-activator": ""
+              }, [t.default(), ae]) : ht(ae, {
+                class: ee
+              }), e.suffix && a("span", {
+                class: "v-text-field__suffix"
+              }, [a("span", {
+                class: "v-text-field__suffix__text"
+              }, [e.suffix])])]);
+            }
+          });
+        },
+        details: S ? (E) => a(X, null, [t.details?.(E), C && a(X, null, [a("span", null, null), a(qt, {
+          active: e.persistentCounter || l.value,
+          value: u.value,
+          max: f.value
+        }, t.counter)])]) : void 0
+      });
+    }), Lt({}, k, y, o);
+  }
+}), ca = { class: "fill-height fill-width align-center justify-center" }, va = {
+  key: 0,
+  class: "fill-height fill-width"
+}, Va = {
+  __name: "EodashDatePicker",
+  props: {
+    inline: {
+      type: Boolean
+    }
+  },
+  setup(e) {
+    const n = e, s = v({
+      get() {
+        return n.inline ? ne.value.split("T")[0] : new Date(ne.value) ?? /* @__PURE__ */ new Date();
+      },
+      /** @param {Date | string} updatedDate */
+      set(l) {
+        n.inline && (l = new Date(l)), l instanceof Date && !isNaN(l) ? ne.value = new Date(l.getTime() - l.getTimezoneOffset() * 6e4).toISOString() : ne.value = (/* @__PURE__ */ new Date()).toISOString();
+      }
+    }), r = O(null), t = O(), i = O();
+    return de(() => {
+      const l = r.value?.$el.parentElement?.parentElement;
+      t.value = l?.clientWidth ? l.clientWidth + "px" : void 0, i.value = l?.clientHeight ? l.clientHeight + "px" : void 0;
+    }), (l, d) => (re(), ge("span", ca, [
+      e.inline ? (re(), ge("div", va, [
+        a(da, {
+          ref: "inlineDatePicker",
+          "base-color": "primary",
+          class: "fill-height fill-width pa-2 align-center",
+          type: "date",
+          "bg-color": "surface",
+          color: "primary",
+          density: "comfortable",
+          label: "Select Date",
+          modelValue: s.value,
+          "onUpdate:modelValue": d[0] || (d[0] = (c) => s.value = c),
+          variant: "plain",
+          "hide-details": ""
+        }, null, 8, ["modelValue"])
+      ])) : (re(), gt(Jt, {
+        key: 1,
+        ref_key: "datePicker",
+        ref: r,
+        width: t.value,
+        height: i.value,
+        "hide-header": "",
+        modelValue: s.value,
+        "onUpdate:modelValue": d[1] || (d[1] = (c) => s.value = c),
+        color: "primary",
+        "bg-color": "surface",
+        location: "center",
+        class: "overflow-auto fill-height fill-width",
+        position: "relative",
+        "show-adjacent-months": ""
+      }, null, 8, ["width", "height", "modelValue"]))
+    ]));
+  }
+};
+export {
+  Va as default
+};