hisonvue 1.0.0

package/dist/HCalendar-w18iIB90.mjs

@@ -0,0 +1,3387 @@
+import { resolveComponent as ae, createElementBlock as m, openBlock as v, normalizeClass as V, createVNode as We, createCommentVNode as D, createSlots as Le, withCtx as T, renderSlot as k, createTextVNode as x, toDisplayString as E, createElementVNode as H, Transition as Ye, createBlock as G, normalizeProps as ze, mergeProps as Re, normalizeStyle as z, Fragment as L, renderList as N, resolveDynamicComponent as at, TransitionGroup as ft, withKeys as nt, withModifiers as oe, defineComponent as wt, ref as b, useSlots as Dt, computed as Ie, onMounted as gt, onBeforeUnmount as pt, watch as p, nextTick as Je, guardReactiveProps as bt } from "vue";
+import { H as Ze, k as kt, g as Ct, u as _t, l as P, n as ue, m as de, e as Tt, t as Mt, a as St, b as Qe, h as C, o as Ve, p as $e, q as R, s as Ae, v as je, r as Et, c as Ht, d as Ot } from "./index-DUh7pai4.mjs";
+import { _ as Wt } from "./_plugin-vue_export-helper-CHgC5LLL.mjs";
+var Vt = Object.defineProperty, At = (t, e, s) => e in t ? Vt(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s, Z = (t, e, s) => At(t, typeof e != "symbol" ? e + "" : e, s);
+const jt = (t, e, s) => {
+  const l = t[e];
+  return l ? typeof l == "function" ? l() : Promise.resolve(l) : new Promise((r, i) => {
+    (typeof queueMicrotask == "function" ? queueMicrotask : setTimeout)(
+      i.bind(
+        null,
+        new Error(
+          "Unknown variable dynamic import: " + e + (e.split("/").length !== s ? ". Note that variables only represent file names one level deep." : "")
+        )
+      )
+    );
+  });
+};
+let Ee, et, tt, U, He = {}, ce = {};
+class Ft {
+  constructor(e, s = !1) {
+    Z(this, "texts", {}), Z(this, "dateToMinutes", (l) => l.getHours() * 60 + l.getMinutes()), U = this, this._texts = e, !s && Date && !Date.prototype.addDays && this._initDatePrototypes();
+  }
+  _initDatePrototypes() {
+    Date.prototype.addDays = function(e) {
+      return U.addDays(this, e);
+    }, Date.prototype.subtractDays = function(e) {
+      return U.subtractDays(this, e);
+    }, Date.prototype.addHours = function(e) {
+      return U.addHours(this, e);
+    }, Date.prototype.subtractHours = function(e) {
+      return U.subtractHours(this, e);
+    }, Date.prototype.addMinutes = function(e) {
+      return U.addMinutes(this, e);
+    }, Date.prototype.subtractMinutes = function(e) {
+      return U.subtractMinutes(this, e);
+    }, Date.prototype.getWeek = function() {
+      return U.getWeek(this);
+    }, Date.prototype.isToday = function() {
+      return U.isToday(this);
+    }, Date.prototype.isLeapYear = function() {
+      return U.isLeapYear(this);
+    }, Date.prototype.format = function(e = "YYYY-MM-DD") {
+      return U.formatDate(this, e);
+    }, Date.prototype.formatTime = function(e = "HH:mm") {
+      return U.formatTime(this, e);
+    };
+  }
+  removePrototypes() {
+    delete Date.prototype.addDays, delete Date.prototype.subtractDays, delete Date.prototype.addHours, delete Date.prototype.subtractHours, delete Date.prototype.addMinutes, delete Date.prototype.subtractMinutes, delete Date.prototype.getWeek, delete Date.prototype.isToday, delete Date.prototype.isLeapYear, delete Date.prototype.format, delete Date.prototype.formatTime;
+  }
+  updateTexts(e) {
+    this._texts = e;
+  }
+  // Cache Today's date (to a maximum) for better isToday() performances. Formatted without leading 0.
+  // We still need to update Today's date when Today changes without page refresh.
+  _todayFormatted() {
+    return et !== (/* @__PURE__ */ new Date()).getDate() && (Ee = /* @__PURE__ */ new Date(), et = Ee.getDate(), tt = `${Ee.getFullYear()}-${Ee.getMonth()}-${Ee.getDate()}`), tt;
+  }
+  // UTILITIES.
+  // ====================================================================
+  addDays(e, s) {
+    const l = new Date(e.valueOf());
+    return l.setDate(l.getDate() + s), l;
+  }
+  subtractDays(e, s) {
+    const l = new Date(e.valueOf());
+    return l.setDate(l.getDate() - s), l;
+  }
+  addHours(e, s) {
+    const l = new Date(e.valueOf());
+    return l.setHours(l.getHours() + s), l;
+  }
+  subtractHours(e, s) {
+    const l = new Date(e.valueOf());
+    return l.setHours(l.getHours() - s), l;
+  }
+  addMinutes(e, s) {
+    const l = new Date(e.valueOf());
+    return l.setMinutes(l.getMinutes() + s), l;
+  }
+  subtractMinutes(e, s) {
+    const l = new Date(e.valueOf());
+    return l.setMinutes(l.getMinutes() - s), l;
+  }
+  getWeek(e) {
+    const s = new Date(Date.UTC(e.getFullYear(), e.getMonth(), e.getDate())), l = s.getUTCDay() || 7;
+    s.setUTCDate(s.getUTCDate() + 4 - l);
+    const r = new Date(Date.UTC(s.getUTCFullYear(), 0, 1));
+    return Math.ceil(((s - r) / 864e5 + 1) / 7);
+  }
+  isToday(e) {
+    return `${e.getFullYear()}-${e.getMonth()}-${e.getDate()}` === this._todayFormatted();
+  }
+  isLeapYear(e) {
+    const s = e.getFullYear();
+    return !(s % 400) || s % 100 && !(s % 4);
+  }
+  // Returns today if it's FirstDayOfWeek (Monday or Sunday) or previous FirstDayOfWeek otherwise.
+  getPreviousFirstDayOfWeek(e = null, s) {
+    const l = e && new Date(e.valueOf()) || /* @__PURE__ */ new Date(), r = s ? 7 : 6;
+    return l.setDate(l.getDate() - (l.getDay() + r) % 7), l;
+  }
+  /**
+   * Converts a string to a Javascript Date object. If a Date object is passed, return it as is.
+   *
+   * @param {String | Date} date the string to convert to Date.
+   * @return {Date} the equivalent Javascript Date object.
+   */
+  stringToDate(e) {
+    return e instanceof Date ? e : (e.length === 10 && (e += " 00:00"), new Date(e.replace(/-/g, "/")));
+  }
+  /**
+   * Count the number of days this date range spans onto.
+   * E.g. countDays(2019-11-02 18:00, 2019-11-03 02:00) = 2
+   *
+   * @param {String | Date} start the start date
+   * @param {String | Date} end the end date
+   * @return {Integer} The number of days this date range involves
+   */
+  countDays(e, s) {
+    typeof e == "string" && (e = e.replace(/-/g, "/")), typeof s == "string" && (s = s.replace(/-/g, "/")), e = new Date(e).setHours(0, 0, 0, 0), s = new Date(s).setHours(0, 0, 1, 0);
+    const l = (new Date(s).getTimezoneOffset() - new Date(e).getTimezoneOffset()) * 60 * 1e3;
+    return Math.ceil((s - e - l) / (24 * 3600 * 1e3));
+  }
+  /**
+   * Take 2 dates and check if within the same time step (useful in overlapping events).
+   *
+   * @return {Boolean} `true` if their time is included in the same time step,
+   *                   this means these 2 dates are very close.
+   */
+  datesInSameTimeStep(e, s, l) {
+    return Math.abs(e.getTime() - s.getTime()) <= l * 60 * 1e3;
+  }
+  // ====================================================================
+  // FORMATTERS.
+  // ====================================================================
+  /**
+   * Formats a date/time to the given format and returns the formatted string.
+   *
+   * @param {Date} date a JavaScript Date object to format.
+   * @param {String} format the wanted format.
+   * @param {Object} texts Optional: the localized texts object to override the vue-cal one in this._texts.
+   *                       This becomes useful when showing multiple instances with different languages,
+   *                       like in the documentation page.
+   * @return {String} the formatted date.
+   */
+  formatDate(e, s = "YYYY-MM-DD", l = null) {
+    if (l || (l = this._texts), s || (s = "YYYY-MM-DD"), s === "YYYY-MM-DD") return this.formatDateLite(e);
+    He = {}, ce = {};
+    const r = {
+      YYYY: () => this._hydrateDateObject(e, l).YYYY,
+      YY: () => this._hydrateDateObject(e, l).YY(),
+      M: () => this._hydrateDateObject(e, l).M,
+      MM: () => this._hydrateDateObject(e, l).MM(),
+      MMM: () => this._hydrateDateObject(e, l).MMM(),
+      MMMM: () => this._hydrateDateObject(e, l).MMMM(),
+      MMMMG: () => this._hydrateDateObject(e, l).MMMMG(),
+      D: () => this._hydrateDateObject(e, l).D,
+      DD: () => this._hydrateDateObject(e, l).DD(),
+      S: () => this._hydrateDateObject(e, l).S(),
+      d: () => this._hydrateDateObject(e, l).d,
+      dd: () => this._hydrateDateObject(e, l).dd(),
+      ddd: () => this._hydrateDateObject(e, l).ddd(),
+      dddd: () => this._hydrateDateObject(e, l).dddd(),
+      HH: () => this._hydrateTimeObject(e, l).HH,
+      H: () => this._hydrateTimeObject(e, l).H,
+      hh: () => this._hydrateTimeObject(e, l).hh,
+      h: () => this._hydrateTimeObject(e, l).h,
+      am: () => this._hydrateTimeObject(e, l).am,
+      AM: () => this._hydrateTimeObject(e, l).AM,
+      mm: () => this._hydrateTimeObject(e, l).mm,
+      m: () => this._hydrateTimeObject(e, l).m
+    };
+    return s.replace(/(\{[a-zA-Z]+\}|[a-zA-Z]+)/g, (i, o) => {
+      const n = r[o.replace(/\{|\}/g, "")];
+      return n !== void 0 ? n() : o;
+    });
+  }
+  // More performant function to convert a Date to `YYYY-MM-DD` formatted string only.
+  formatDateLite(e) {
+    const s = e.getMonth() + 1, l = e.getDate();
+    return `${e.getFullYear()}-${s < 10 ? "0" : ""}${s}-${l < 10 ? "0" : ""}${l}`;
+  }
+  /**
+   * Formats a time (from Date or number of mins) to the given format and returns the formatted string.
+   *
+   * @param {Date | Number} date a JavaScript Date object or a time in minutes.
+   * @param {String} format the wanted format.
+   * @param {Object} texts Optional: the localized texts object to override the vue-cal one in this._texts.
+   *                       This becomes useful when showing multiple instances with different languages,
+   *                       like in the documentation page.
+   * @param {Boolean} round if time is 23:59:59, rounds up to 24:00 for formatting only.
+   * @return {String} the formatted time.
+   */
+  formatTime(e, s = "HH:mm", l = null, r = !1) {
+    let i = !1;
+    if (r) {
+      const [h, d, c] = [e.getHours(), e.getMinutes(), e.getSeconds()];
+      h + d + c === 141 && (i = !0);
+    }
+    if (e instanceof Date && s === "HH:mm") return i ? "24:00" : this.formatTimeLite(e);
+    ce = {}, l || (l = this._texts);
+    const o = this._hydrateTimeObject(e, l), n = s.replace(/(\{[a-zA-Z]+\}|[a-zA-Z]+)/g, (h, d) => {
+      const c = o[d.replace(/\{|\}/g, "")];
+      return c !== void 0 ? c : d;
+    });
+    return i ? n.replace("23:59", "24:00") : n;
+  }
+  /**
+   * Formats a time to 'HH:mm' from a Date and returns the formatted string.
+   *
+   * @param {Date} date a JavaScript Date object to format.
+   * @return {String} the formatted time.
+   */
+  formatTimeLite(e) {
+    const s = e.getHours(), l = e.getMinutes();
+    return `${(s < 10 ? "0" : "") + s}:${(l < 10 ? "0" : "") + l}`;
+  }
+  _nth(e) {
+    if (e > 3 && e < 21) return "th";
+    switch (e % 10) {
+      case 1:
+        return "st";
+      case 2:
+        return "nd";
+      case 3:
+        return "rd";
+      default:
+        return "th";
+    }
+  }
+  _hydrateDateObject(e, s) {
+    if (He.D) return He;
+    const l = e.getFullYear(), r = e.getMonth() + 1, i = e.getDate(), n = (e.getDay() - 1 + 7) % 7;
+    return He = {
+      // Year.
+      YYYY: l,
+      // 2019.
+      YY: () => l.toString().substring(2),
+      // 19.
+      // Month.
+      M: r,
+      // 1 to 12.
+      MM: () => (r < 10 ? "0" : "") + r,
+      // 01 to 12.
+      MMM: () => s.months[r - 1].substring(0, 3),
+      // Jan to Dec.
+      MMMM: () => s.months[r - 1],
+      // January to December.
+      MMMMG: () => (s.monthsGenitive || s.months)[r - 1],
+      // January to December in genitive form (Greek...)
+      // Day.
+      D: i,
+      // 1 to 31.
+      DD: () => (i < 10 ? "0" : "") + i,
+      // 01 to 31.
+      S: () => this._nth(i),
+      // st, nd, rd, th.
+      // Day of the week.
+      d: n + 1,
+      // 1 to 7 with 7 = Sunday.
+      dd: () => s.weekDays[n][0],
+      // M to S.
+      ddd: () => s.weekDays[n].substr(0, 3),
+      // Mon to Sun.
+      dddd: () => s.weekDays[n]
+      // Monday to Sunday.
+    }, He;
+  }
+  _hydrateTimeObject(e, s) {
+    if (ce.am) return ce;
+    let l, r;
+    e instanceof Date ? (l = e.getHours(), r = e.getMinutes()) : (l = Math.floor(e / 60), r = Math.floor(e % 60));
+    const i = l % 12 ? l % 12 : 12, o = (s || { am: "am", pm: "pm" })[l === 24 || l < 12 ? "am" : "pm"];
+    return ce = {
+      H: l,
+      h: i,
+      HH: (l < 10 ? "0" : "") + l,
+      hh: (i < 10 ? "0" : "") + i,
+      am: o,
+      AM: o.toUpperCase(),
+      m: r,
+      mm: (r < 10 ? "0" : "") + r
+    }, ce;
+  }
+  // ====================================================================
+}
+const Lt = 24 * 60;
+class Yt {
+  constructor(e) {
+    Z(this, "_vuecal", null), Z(this, "selectCell", (s = !1, l, r) => {
+      this._vuecal.$emit("cell-click", r ? { date: l, split: r } : l), this._vuecal.clickToNavigate || s ? this._vuecal.switchToNarrowerView() : this._vuecal.dblclickToNavigate && "ontouchstart" in window && (this._vuecal.domEvents.dblTapACell.taps++, setTimeout(() => this._vuecal.domEvents.dblTapACell.taps = 0, this._vuecal.domEvents.dblTapACell.timeout), this._vuecal.domEvents.dblTapACell.taps >= 2 && (this._vuecal.domEvents.dblTapACell.taps = 0, this._vuecal.switchToNarrowerView(), this._vuecal.$emit("cell-dblclick", r ? { date: l, split: r } : l)));
+    }), Z(this, "keyPressEnterCell", (s, l) => {
+      this._vuecal.$emit("cell-keypress-enter", l ? { date: s, split: l } : s), this._vuecal.switchToNarrowerView();
+    }), Z(this, "getPosition", (s) => {
+      const { left: l, top: r } = this._vuecal.cellsEl.getBoundingClientRect(), { clientX: i, clientY: o } = "ontouchstart" in window && s.touches ? s.touches[0] : s;
+      return { x: i - l, y: o - r };
+    }), Z(this, "minutesAtCursor", (s) => {
+      let l = 0, r = { x: 0, y: 0 };
+      const { timeStep: i, timeCellHeight: o, timeFrom: n } = this._vuecal.$props;
+      return typeof s == "number" ? l = s : typeof s == "object" && (r = this.getPosition(s), l = Math.round(r.y * i / parseInt(o) + n)), { minutes: Math.max(Math.min(l, Lt), 0), cursorCoords: r };
+    }), this._vuecal = e;
+  }
+}
+const Nt = 2, Pe = 24 * 60;
+let M, S, xe;
+class Bt {
+  constructor(e, s) {
+    Z(this, "_vuecal", null), Z(this, "eventDefaults", {
+      _eid: null,
+      start: "",
+      // Externally given formatted date & time or Date object.
+      startTimeMinutes: 0,
+      end: "",
+      // Externally given formatted date & time or Date object.
+      endTimeMinutes: 0,
+      title: "",
+      content: "",
+      background: !1,
+      allDay: !1,
+      segments: null,
+      repeat: null,
+      daysCount: 1,
+      deletable: !0,
+      deleting: !1,
+      titleEditable: !0,
+      resizable: !0,
+      resizing: !1,
+      draggable: !0,
+      dragging: !1,
+      draggingStatic: !1,
+      // Controls the CSS class of the static clone while dragging.
+      focused: !1,
+      class: ""
+    }), this._vuecal = e, M = s;
+  }
+  /**
+   * Create an event at the given date and time, and allow overriding
+   * event attributes through the eventOptions object.
+   *
+   * @param {Date | String} dateTime The date and time of the new event start.
+   * @param {Number} duration the event duration in minutes.
+   * @param {Object} eventOptions some options to override the `eventDefaults` - optional.
+   */
+  createAnEvent(e, s, l) {
+    if (typeof e == "string" && (e = M.stringToDate(e)), !(e instanceof Date)) return !1;
+    const r = M.dateToMinutes(e);
+    s = s * 1 || Nt * 60;
+    const i = r + s, o = M.addMinutes(new Date(e), s);
+    l.end && (typeof l.end == "string" && (l.end = M.stringToDate(l.end)), l.endTimeMinutes = M.dateToMinutes(l.end));
+    const n = {
+      ...this.eventDefaults,
+      _eid: `${this._vuecal._.uid}_${this._vuecal.eventIdIncrement++}`,
+      start: e,
+      startTimeMinutes: r,
+      end: o,
+      endTimeMinutes: i,
+      segments: null,
+      ...l
+    };
+    if (!(typeof this._vuecal.onEventCreate == "function" && !this._vuecal.onEventCreate(n, () => this.deleteAnEvent(n))))
+      return n.startDateF !== n.endDateF && (n.daysCount = M.countDays(n.start, n.end)), this._vuecal.mutableEvents.push(n), this._vuecal.addEventsToView([n]), this._vuecal.emitWithEvent("event-create", n), this._vuecal.$emit("event-change", { event: this._vuecal.cleanupEvent(n), originalEvent: null }), n;
+  }
+  /**
+   * Add an event segment (= day) to a multiple-day event.
+   *
+   * @param {Object} e the multiple-day event to add segment in.
+   */
+  addEventSegment(e) {
+    e.segments || (e.segments = {}, e.segments[M.formatDateLite(e.start)] = {
+      start: e.start,
+      startTimeMinutes: e.startTimeMinutes,
+      endTimeMinutes: Pe,
+      isFirstDay: !0,
+      isLastDay: !1
+    });
+    const s = e.segments[M.formatDateLite(e.end)];
+    s && (s.isLastDay = !1, s.endTimeMinutes = Pe);
+    const l = M.addDays(e.end, 1), r = M.formatDateLite(l);
+    return l.setHours(0, 0, 0, 0), e.segments[r] = {
+      start: l,
+      startTimeMinutes: 0,
+      endTimeMinutes: e.endTimeMinutes,
+      isFirstDay: !1,
+      isLastDay: !0
+    }, e.end = M.addMinutes(l, e.endTimeMinutes), e.daysCount = Object.keys(e.segments).length, r;
+  }
+  /**
+   * Remove an event segment (= day) from a multiple-day event.
+   *
+   * @param {Object} e the multiple-day event to remove segments from.
+   */
+  removeEventSegment(e) {
+    let s = Object.keys(e.segments).length;
+    if (s <= 1) return M.formatDateLite(e.end);
+    delete e.segments[M.formatDateLite(e.end)], s--;
+    const l = M.subtractDays(e.end, 1), r = M.formatDateLite(l), i = e.segments[r];
+    return s ? i && (i.isLastDay = !0, i.endTimeMinutes = e.endTimeMinutes) : e.segments = null, e.daysCount = s || 1, e.end = l, r;
+  }
+  /**
+   * Create 1 segment per day of the given event, but only within the current view.
+   * (It won't create segments for all the days in view that are not in the event!)
+   *
+   * An event segment is a piece of event per day that contains more day-specific data.
+   *
+   * @param {Object} e the multiple-day event to create segments for.
+   * @param {Date} viewStartDate the starting date of the view.
+   * @param {Date} viewEndDate the ending date of the view.
+   */
+  createEventSegments(e, s, l) {
+    const r = s.getTime(), i = l.getTime();
+    let o = e.start.getTime(), n = e.end.getTime(), h = !1, d, c, y;
+    for (!e.end.getHours() && !e.end.getMinutes() && (n -= 1e3), e.segments = {}, e.repeat ? (d = r, c = Math.min(
+      i,
+      e.repeat.until ? M.stringToDate(e.repeat.until).getTime() : i
+    )) : (d = Math.max(r, o), c = Math.min(i, n)); d <= c; ) {
+      let w = !1;
+      const A = M.addDays(new Date(d), 1).setHours(0, 0, 0, 0);
+      let g, Y, j, _;
+      if (e.repeat) {
+        const B = new Date(d), O = M.formatDateLite(B);
+        (h || e.occurrences && e.occurrences[O]) && (h || (o = e.occurrences[O].start, y = new Date(o).setHours(0, 0, 0, 0), n = e.occurrences[O].end), h = !0, w = !0), g = d === y, Y = O === M.formatDateLite(new Date(n)), j = new Date(g ? o : d), _ = M.formatDateLite(j), Y && (h = !1);
+      } else
+        w = !0, g = d === o, Y = c === n && A > c, j = g ? e.start : new Date(d), _ = M.formatDateLite(g ? e.start : j);
+      w && (e.segments[_] = {
+        start: j,
+        startTimeMinutes: g ? e.startTimeMinutes : 0,
+        endTimeMinutes: Y ? e.endTimeMinutes : Pe,
+        isFirstDay: g,
+        isLastDay: Y
+      }), d = A;
+    }
+    return e;
+  }
+  /**
+   * Delete an event.
+   *
+   * @param {Object} event the calendar event to delete.
+   */
+  deleteAnEvent(e) {
+    this._vuecal.emitWithEvent("event-delete", e), this._vuecal.mutableEvents = this._vuecal.mutableEvents.filter((s) => s._eid !== e._eid), this._vuecal.view.events = this._vuecal.view.events.filter((s) => s._eid !== e._eid);
+  }
+  // EVENT OVERLAPS.
+  // ===================================================================
+  // Will recalculate all the overlaps of the current cell OR split.
+  // cellEvents will contain only the current split events if in a split.
+  checkCellOverlappingEvents(e, s) {
+    xe = e.slice(0), S = {}, e.forEach((r) => {
+      xe.shift(), S[r._eid] || (S[r._eid] = { overlaps: [], start: r.start, position: 0 }), S[r._eid].position = 0, xe.forEach((i) => {
+        S[i._eid] || (S[i._eid] = { overlaps: [], start: i.start, position: 0 });
+        const o = this.eventInRange(i, r.start, r.end), n = s.overlapsPerTimeStep ? M.datesInSameTimeStep(r.start, i.start, s.timeStep) : 1;
+        if (!r.background && !r.allDay && !i.background && !i.allDay && o && n)
+          S[r._eid].overlaps.push(i._eid), S[r._eid].overlaps = [...new Set(S[r._eid].overlaps)], S[i._eid].overlaps.push(r._eid), S[i._eid].overlaps = [...new Set(S[i._eid].overlaps)], S[i._eid].position++;
+        else {
+          let h, d;
+          (h = (S[r._eid] || { overlaps: [] }).overlaps.indexOf(i._eid)) > -1 && S[r._eid].overlaps.splice(h, 1), (d = (S[i._eid] || { overlaps: [] }).overlaps.indexOf(r._eid)) > -1 && S[i._eid].overlaps.splice(d, 1), S[i._eid].position--;
+        }
+      });
+    });
+    let l = 0;
+    for (const r in S) {
+      const i = S[r], o = i.overlaps.map((n) => ({ id: n, start: S[n].start }));
+      o.push({ id: r, start: i.start }), o.sort((n, h) => n.start < h.start ? -1 : n.start > h.start ? 1 : n.id > h.id ? -1 : 1), i.position = o.findIndex((n) => n.id === r), l = Math.max(this.getOverlapsStreak(i, S), l);
+    }
+    return [S, l];
+  }
+  /**
+   * Overlaps streak is the longest horizontal set of simultaneous events.
+   * This is determining the width of each events in this streak.
+   * E.g. 3 overlapping events [1, 2, 3]; 1 overlaps 2 & 3; 2 & 3 don't overlap;
+   *      => streak = 2; each width = 50% not 33%.
+   *
+   * @param {Object} event The current event we are checking among all the events of the current cell.
+   * @param {Object} cellOverlaps An indexed array of all the events overlaps for the current cell.
+   * @return {Number} The number of simultaneous event for this event.
+   */
+  getOverlapsStreak(e, s = {}) {
+    let l = e.overlaps.length + 1, r = [];
+    return e.overlaps.forEach((i) => {
+      r.includes(i) || e.overlaps.filter((n) => n !== i).forEach((n) => {
+        s[n].overlaps.includes(i) || r.push(n);
+      });
+    }), r = [...new Set(r)], l -= r.length, l;
+  }
+  /**
+   * Tells whether an event is in a given date range, even partially.
+   *
+   * @param {Object} event The event to test.
+   * @param {Date} start The start of range date object.
+   * @param {Date} end The end of range date object.
+   * @return {Boolean} true if in range, even partially.
+   */
+  eventInRange(e, s, l) {
+    if (e.allDay || !this._vuecal.time) {
+      const o = new Date(e.start).setHours(0, 0, 0, 0);
+      return new Date(e.end).setHours(23, 59, 0, 0) >= new Date(s).setHours(0, 0, 0, 0) && o <= new Date(l).setHours(0, 0, 0, 0);
+    }
+    const r = e.start.getTime(), i = e.end.getTime();
+    return r < l.getTime() && i > s.getTime();
+  }
+}
+const It = { class: "vuecal__flex vuecal__weekdays-headings" }, Pt = ["onClick"], xt = {
+  class: "vuecal__flex weekday-label",
+  grow: ""
+}, zt = { class: "full" }, Rt = { class: "small" }, Ut = { class: "xsmall" }, qt = { key: 0 }, Kt = {
+  key: 0,
+  class: "vuecal__flex vuecal__split-days-headers",
+  grow: ""
+};
+function Xt(t, e, s, l, r, i) {
+  return v(), m("div", It, [
+    (v(!0), m(L, null, N(i.headings, (o, n) => (v(), m(L, { key: n }, [
+      o.hide ? D("", !0) : (v(), m("div", {
+        key: 0,
+        class: V(["vuecal__flex vuecal__heading", { today: o.today, clickable: i.cellHeadingsClickable }]),
+        style: z(i.weekdayCellStyles),
+        onClick: (h) => i.view.id === "week" && i.selectCell(o.date, h),
+        onDblclick: e[0] || (e[0] = (h) => i.view.id === "week" && i.vuecal.dblclickToNavigate && s.switchToNarrowerView())
+      }, [
+        We(Ye, {
+          name: `slide-fade--${s.transitionDirection}`,
+          appear: i.vuecal.transitions
+        }, {
+          default: T(() => [
+            (v(), m("div", {
+              class: "vuecal__flex",
+              column: "",
+              key: i.vuecal.transitions ? `${n}-${o.dayOfMonth}` : !1
+            }, [
+              H("div", xt, [
+                k(t.$slots, "weekday-heading", {
+                  heading: i.cleanupHeading(o),
+                  view: i.view
+                }, () => [
+                  H("span", zt, E(o.full), 1),
+                  H("span", Rt, E(o.small), 1),
+                  H("span", Ut, E(o.xsmall), 1),
+                  o.dayOfMonth ? (v(), m("span", qt, " " + E(o.dayOfMonth), 1)) : D("", !0)
+                ])
+              ]),
+              i.vuecal.hasSplits && i.vuecal.stickySplitLabels ? (v(), m("div", Kt, [
+                (v(!0), m(L, null, N(i.vuecal.daySplits, (h, d) => (v(), m("div", {
+                  class: V(["day-split-header", h.class || !1]),
+                  key: d
+                }, [
+                  k(t.$slots, "split-label", {
+                    split: h,
+                    view: i.view
+                  }, () => [
+                    x(E(h.label), 1)
+                  ])
+                ], 2))), 128))
+              ])) : D("", !0)
+            ]))
+          ]),
+          _: 2
+        }, 1032, ["name", "appear"])
+      ], 46, Pt))
+    ], 64))), 128))
+  ]);
+}
+const he = (t, e) => {
+  const s = t.__vccOpts || t;
+  for (const [l, r] of e)
+    s[l] = r;
+  return s;
+}, Gt = {
+  inject: ["vuecal", "utils", "view"],
+  props: {
+    transitionDirection: { type: String, default: "right" },
+    weekDays: { type: Array, default: () => [] },
+    switchToNarrowerView: { type: Function, default: () => {
+    } }
+  },
+  methods: {
+    selectCell(t, e) {
+      t.getTime() !== this.view.selectedDate.getTime() && (this.view.selectedDate = t), this.utils.cell.selectCell(!1, t, e);
+    },
+    cleanupHeading: (t) => ({
+      label: t.full,
+      date: t.date,
+      ...t.today ? { today: t.today } : {}
+    })
+  },
+  computed: {
+    headings() {
+      if (!["month", "week"].includes(this.view.id)) return [];
+      let t = !1;
+      return this.weekDays.map((s, l) => {
+        const r = this.utils.date.addDays(this.view.startDate, this.vuecal.startWeekOnSunday && this.vuecal.hideWeekends ? l - 1 : l);
+        return {
+          hide: s.hide,
+          full: s.label,
+          // If defined in i18n file, weekDaysShort overrides default truncation of
+          // week days when does not fit on screen or with small/xsmall options.
+          small: s.short || s.label.substr(0, 3),
+          xsmall: s.short || s.label.substr(0, 1),
+          // Only for week view.
+          ...this.view.id === "week" ? {
+            dayOfMonth: r.getDate(),
+            date: r,
+            today: !t && this.utils.date.isToday(r) && !t++
+          } : {}
+        };
+      });
+    },
+    cellWidth() {
+      return 100 / (7 - this.weekDays.reduce((t, e) => t + e.hide, 0));
+    },
+    weekdayCellStyles() {
+      return {
+        ...this.vuecal.hideWeekdays.length ? { width: `${this.cellWidth}%` } : {}
+      };
+    },
+    cellHeadingsClickable() {
+      return this.view.id === "week" && (this.vuecal.clickToNavigate || this.vuecal.dblclickToNavigate);
+    }
+  }
+}, rt = /* @__PURE__ */ he(Gt, [["render", Xt]]), Jt = { class: "vuecal__header" }, Zt = {
+  key: 0,
+  class: "vuecal__flex vuecal__menu",
+  role: "tablist",
+  "aria-label": "Calendar views navigation"
+}, Qt = ["onDragenter", "onDragleave", "onClick", "aria-label"], $t = {
+  key: 1,
+  class: "vuecal__title-bar"
+}, ei = ["aria-label"], ti = {
+  class: "vuecal__flex vuecal__title",
+  grow: ""
+}, ii = ["aria-label"], si = {
+  key: 0,
+  class: "vuecal__flex vuecal__split-days-headers"
+};
+function li(t, e, s, l, r, i) {
+  const o = ae("weekdays-headings");
+  return v(), m("div", Jt, [
+    s.options.hideViewSelector ? D("", !0) : (v(), m("div", Zt, [
+      (v(!0), m(L, null, N(s.viewProps.views, (n, h) => (v(), m(L, { key: h }, [
+        n.enabled ? (v(), m("button", {
+          key: 0,
+          class: V(["vuecal__view-btn", { "vuecal__view-btn--active": i.view.id === h, "vuecal__view-btn--highlighted": t.highlightedControl === h }]),
+          type: "button",
+          onDragenter: (d) => s.editEvents.drag && i.dnd && i.dnd.viewSelectorDragEnter(d, h, t.$data),
+          onDragleave: (d) => s.editEvents.drag && i.dnd && i.dnd.viewSelectorDragLeave(d, h, t.$data),
+          onClick: (d) => i.switchView(h, null, !0),
+          "aria-label": `${n.label} view`
+        }, E(n.label), 43, Qt)) : D("", !0)
+      ], 64))), 128))
+    ])),
+    s.options.hideTitleBar ? D("", !0) : (v(), m("div", $t, [
+      H("button", {
+        class: V(["vuecal__arrow vuecal__arrow--prev", { "vuecal__arrow--highlighted": t.highlightedControl === "previous" }]),
+        type: "button",
+        onClick: e[0] || (e[0] = (...n) => i.previous && i.previous(...n)),
+        onDragenter: e[1] || (e[1] = (n) => s.editEvents.drag && i.dnd && i.dnd.viewSelectorDragEnter(n, "previous", t.$data)),
+        onDragleave: e[2] || (e[2] = (n) => s.editEvents.drag && i.dnd && i.dnd.viewSelectorDragLeave(n, "previous", t.$data)),
+        "aria-label": `Previous ${i.view.id}`
+      }, [
+        k(t.$slots, "arrow-prev")
+      ], 42, ei),
+      H("div", ti, [
+        We(Ye, {
+          name: s.options.transitions ? `slide-fade--${i.transitionDirection}` : ""
+        }, {
+          default: T(() => [
+            (v(), G(at(i.broaderView ? "button" : "span"), {
+              type: !!i.broaderView && "button",
+              key: `${i.view.id}${i.view.startDate.toString()}`,
+              onClick: e[3] || (e[3] = (n) => !!i.broaderView && i.switchToBroaderView()),
+              "aria-label": !!i.broaderView && `Go to ${i.broaderView} view`
+            }, {
+              default: T(() => [
+                k(t.$slots, "title")
+              ]),
+              _: 3
+            }, 8, ["type", "aria-label"]))
+          ]),
+          _: 3
+        }, 8, ["name"])
+      ]),
+      s.options.todayButton ? (v(), m("button", {
+        key: 0,
+        class: V(["vuecal__today-btn", { "vuecal__today-btn--highlighted": t.highlightedControl === "today" }]),
+        type: "button",
+        onClick: e[4] || (e[4] = (...n) => i.goToToday && i.goToToday(...n)),
+        onDragenter: e[5] || (e[5] = (n) => s.editEvents.drag && i.dnd && i.dnd.viewSelectorDragEnter(n, "today", t.$data)),
+        onDragleave: e[6] || (e[6] = (n) => s.editEvents.drag && i.dnd && i.dnd.viewSelectorDragLeave(n, "today", t.$data)),
+        "aria-label": "Today"
+      }, [
+        k(t.$slots, "today-button")
+      ], 34)) : D("", !0),
+      H("button", {
+        class: V(["vuecal__arrow vuecal__arrow--next", { "vuecal__arrow--highlighted": t.highlightedControl === "next" }]),
+        type: "button",
+        onClick: e[7] || (e[7] = (...n) => i.next && i.next(...n)),
+        onDragenter: e[8] || (e[8] = (n) => s.editEvents.drag && i.dnd && i.dnd.viewSelectorDragEnter(n, "next", t.$data)),
+        onDragleave: e[9] || (e[9] = (n) => s.editEvents.drag && i.dnd && i.dnd.viewSelectorDragLeave(n, "next", t.$data)),
+        "aria-label": `Next ${i.view.id}`
+      }, [
+        k(t.$slots, "arrow-next")
+      ], 42, ii)
+    ])),
+    s.viewProps.weekDaysInHeader ? (v(), G(o, {
+      key: 2,
+      "week-days": s.weekDays,
+      "transition-direction": i.transitionDirection,
+      "switch-to-narrower-view": s.switchToNarrowerView
+    }, Le({ _: 2 }, [
+      t.$slots["weekday-heading"] ? {
+        name: "weekday-heading",
+        fn: T(({ heading: n, view: h }) => [
+          k(t.$slots, "weekday-heading", {
+            heading: n,
+            view: h
+          })
+        ]),
+        key: "0"
+      } : void 0,
+      t.$slots["split-label"] ? {
+        name: "split-label",
+        fn: T(({ split: n }) => [
+          k(t.$slots, "split-label", {
+            split: n,
+            view: i.view
+          })
+        ]),
+        key: "1"
+      } : void 0
+    ]), 1032, ["week-days", "transition-direction", "switch-to-narrower-view"])) : D("", !0),
+    We(Ye, {
+      name: `slide-fade--${i.transitionDirection}`
+    }, {
+      default: T(() => [
+        i.showDaySplits ? (v(), m("div", si, [
+          (v(!0), m(L, null, N(s.daySplits, (n, h) => (v(), m("div", {
+            class: V(["day-split-header", n.class || !1]),
+            key: h
+          }, [
+            k(t.$slots, "split-label", {
+              split: n,
+              view: i.view.id
+            }, () => [
+              x(E(n.label), 1)
+            ])
+          ], 2))), 128))
+        ])) : D("", !0)
+      ]),
+      _: 3
+    }, 8, ["name"])
+  ]);
+}
+const ai = {
+  inject: ["vuecal", "previous", "next", "switchView", "updateSelectedDate", "modules", "view"],
+  components: { WeekdaysHeadings: rt },
+  props: {
+    // Vuecal main component options (props).
+    options: { type: Object, default: () => ({}) },
+    editEvents: { type: Object, required: !0 },
+    hasSplits: { type: [Boolean, Number], default: !1 },
+    daySplits: { type: Array, default: () => [] },
+    viewProps: { type: Object, default: () => ({}) },
+    weekDays: { type: Array, default: () => [] },
+    switchToNarrowerView: { type: Function, default: () => {
+    } }
+  },
+  data: () => ({
+    highlightedControl: null
+  }),
+  methods: {
+    goToToday() {
+      this.updateSelectedDate(new Date((/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0)));
+    },
+    switchToBroaderView() {
+      this.transitionDirection = "left", this.broaderView && this.switchView(this.broaderView);
+    }
+  },
+  computed: {
+    transitionDirection: {
+      get() {
+        return this.vuecal.transitionDirection;
+      },
+      set(t) {
+        this.vuecal.transitionDirection = t;
+      }
+    },
+    broaderView() {
+      const { enabledViews: t } = this.vuecal;
+      return t[t.indexOf(this.view.id) - 1];
+    },
+    showDaySplits() {
+      return this.view.id === "day" && this.hasSplits && this.options.stickySplitLabels && !this.options.minSplitWidth;
+    },
+    // Drag & drop module.
+    dnd() {
+      return this.modules.dnd;
+    }
+  }
+}, ni = /* @__PURE__ */ he(ai, [["render", li]]), ri = ["draggable"];
+function oi(t, e, s, l, r, i) {
+  return v(), m("div", {
+    class: V(["vuecal__event", i.eventClasses]),
+    style: z(i.eventStyles),
+    tabindex: "0",
+    onFocus: e[4] || (e[4] = (...o) => i.focusEvent && i.focusEvent(...o)),
+    onKeypress: e[5] || (e[5] = nt(oe((...o) => i.onEnterKeypress && i.onEnterKeypress(...o), ["stop"]), ["enter"])),
+    onMouseenter: e[6] || (e[6] = (...o) => i.onMouseEnter && i.onMouseEnter(...o)),
+    onMouseleave: e[7] || (e[7] = (...o) => i.onMouseLeave && i.onMouseLeave(...o)),
+    onTouchstart: e[8] || (e[8] = oe((...o) => i.onTouchStart && i.onTouchStart(...o), ["stop"])),
+    onMousedown: e[9] || (e[9] = (o) => i.onMouseDown(o)),
+    onMouseup: e[10] || (e[10] = (...o) => i.onMouseUp && i.onMouseUp(...o)),
+    onTouchend: e[11] || (e[11] = (...o) => i.onMouseUp && i.onMouseUp(...o)),
+    onTouchmove: e[12] || (e[12] = (...o) => i.onTouchMove && i.onTouchMove(...o)),
+    onDblclick: e[13] || (e[13] = (...o) => i.onDblClick && i.onDblClick(...o)),
+    draggable: i.draggable,
+    onDragstart: e[14] || (e[14] = (o) => i.draggable && i.onDragStart(o)),
+    onDragend: e[15] || (e[15] = (o) => i.draggable && i.onDragEnd())
+  }, [
+    i.vuecal.editEvents.delete && s.event.deletable ? (v(), m("div", {
+      key: 0,
+      class: "vuecal__event-delete",
+      onClick: e[0] || (e[0] = oe((...o) => i.deleteEvent && i.deleteEvent(...o), ["stop"])),
+      onTouchstart: e[1] || (e[1] = oe((...o) => i.touchDeleteEvent && i.touchDeleteEvent(...o), ["stop"]))
+    }, E(i.vuecal.texts.deleteEvent), 33)) : D("", !0),
+    k(t.$slots, "event", {
+      event: s.event,
+      view: i.view.id
+    }),
+    i.resizable ? (v(), m("div", {
+      key: 1,
+      class: "vuecal__event-resize-handle",
+      contenteditable: "false",
+      onMousedown: e[2] || (e[2] = oe((...o) => i.onResizeHandleMouseDown && i.onResizeHandleMouseDown(...o), ["stop", "prevent"])),
+      onTouchstart: e[3] || (e[3] = oe((...o) => i.onResizeHandleMouseDown && i.onResizeHandleMouseDown(...o), ["stop", "prevent"]))
+    }, null, 32)) : D("", !0)
+  ], 46, ri);
+}
+const ui = {
+  inject: ["vuecal", "utils", "modules", "view", "domEvents", "editEvents"],
+  props: {
+    cellFormattedDate: { type: String, default: "" },
+    event: { type: Object, default: () => ({}) },
+    cellEvents: { type: Array, default: () => [] },
+    overlaps: { type: Array, default: () => [] },
+    // If multiple simultaneous events, the events are placed from left to right from the
+    // one starting first to the last. (See utils/event.js > checkCellOverlappingEvents)
+    eventPosition: { type: Number, default: 0 },
+    overlapsStreak: { type: Number, default: 0 },
+    allDay: { type: Boolean, default: !1 }
+    // Is the event displayed in the all-day bar.
+  },
+  data: () => ({
+    // Event touch detection with 30px threshold.
+    touch: {
+      dragThreshold: 30,
+      // px.
+      startX: 0,
+      startY: 0,
+      // Detect if the event touch start + touch end was a drag or a tap.
+      // If it was a drag, don't call the event-click handler.
+      dragged: !1
+    }
+  }),
+  methods: {
+    /**
+     * On event mousedown.
+     * Do not prevent propagation to trigger cell mousedown which highlights the cell if not highlighted.
+     */
+    onMouseDown(t, e = !1) {
+      if ("ontouchstart" in window && !e) return !1;
+      const { clickHoldAnEvent: s, focusAnEvent: l, resizeAnEvent: r, dragAnEvent: i } = this.domEvents;
+      if (l._eid === this.event._eid && s._eid === this.event._eid)
+        return !0;
+      this.focusEvent(), s._eid = null, this.vuecal.editEvents.delete && this.event.deletable && (s.timeoutId = setTimeout(() => {
+        !r._eid && !i._eid && (s._eid = this.event._eid, this.event.deleting = !0);
+      }, s.timeout));
+    },
+    /**
+     * The mouseup handler is global (whole document) and initialized in index.vue on mounted.
+     * It handles the mouseup on cell, events, and everything.
+     * All mouseup on event, should be put there to avoid conflicts with other cases.
+     * This function is also called on touchend on the event.
+     */
+    onMouseUp(t) {
+      this.domEvents.focusAnEvent._eid === this.event._eid && !this.touch.dragged && (this.domEvents.focusAnEvent.mousedUp = !0), this.touch.dragged = !1;
+    },
+    onMouseEnter(t) {
+      t.preventDefault(), this.vuecal.emitWithEvent("event-mouse-enter", this.event);
+    },
+    onMouseLeave(t) {
+      t.preventDefault(), this.vuecal.emitWithEvent("event-mouse-leave", this.event);
+    },
+    // Detect if user taps on an event or drags it. If dragging, don't fire the event-click handler (if any).
+    onTouchMove(t) {
+      if (typeof this.vuecal.onEventClick != "function") return;
+      const { clientX: e, clientY: s } = t.touches[0], { startX: l, startY: r, dragThreshold: i } = this.touch;
+      (Math.abs(e - l) > i || Math.abs(s - r) > i) && (this.touch.dragged = !0);
+    },
+    onTouchStart(t) {
+      this.touch.startX = t.touches[0].clientX, this.touch.startY = t.touches[0].clientY, this.onMouseDown(t, !0);
+    },
+    onEnterKeypress(t) {
+      if (typeof this.vuecal.onEventClick == "function") return this.vuecal.onEventClick(this.event, t);
+    },
+    onDblClick(t) {
+      if (typeof this.vuecal.onEventDblclick == "function") return this.vuecal.onEventDblclick(this.event, t);
+    },
+    onDragStart(t) {
+      this.dnd && this.dnd.eventDragStart(t, this.event);
+    },
+    onDragEnd() {
+      this.dnd && this.dnd.eventDragEnd(this.event);
+    },
+    onResizeHandleMouseDown() {
+      this.focusEvent(), this.domEvents.dragAnEvent._eid = null, this.domEvents.resizeAnEvent = Object.assign(this.domEvents.resizeAnEvent, {
+        _eid: this.event._eid,
+        start: (this.segment || this.event).start,
+        split: this.event.split || null,
+        segment: !!this.segment && this.utils.date.formatDateLite(this.segment.start),
+        originalEnd: new Date((this.segment || this.event).end),
+        originalEndTimeMinutes: this.event.endTimeMinutes
+      }), this.event.resizing = !0;
+    },
+    deleteEvent(t = !1) {
+      if ("ontouchstart" in window && !t) return !1;
+      this.utils.event.deleteAnEvent(this.event);
+    },
+    touchDeleteEvent(t) {
+      this.deleteEvent(!0);
+    },
+    cancelDeleteEvent() {
+      this.event.deleting = !1;
+    },
+    focusEvent() {
+      const { focusAnEvent: t } = this.domEvents, e = t._eid;
+      if (e !== this.event._eid) {
+        if (e) {
+          const s = this.view.events.find((l) => l._eid === e);
+          s && (s.focused = !1);
+        }
+        this.vuecal.cancelDelete(), this.vuecal.emitWithEvent("event-focus", this.event), t._eid = this.event._eid, this.event.focused = !0;
+      }
+    }
+  },
+  computed: {
+    eventDimensions() {
+      const { startTimeMinutes: t, endTimeMinutes: e } = this.segment || this.event;
+      let s = t - this.vuecal.timeFrom;
+      const l = Math.max(Math.round(s * this.vuecal.timeCellHeight / this.vuecal.timeStep), 0);
+      s = Math.min(e, this.vuecal.timeTo) - this.vuecal.timeFrom;
+      const r = Math.round(s * this.vuecal.timeCellHeight / this.vuecal.timeStep), i = Math.max(r - l, 5);
+      return { top: l, height: i };
+    },
+    eventStyles() {
+      if (this.event.allDay || !this.vuecal.time || !this.event.endTimeMinutes || this.view.id === "month" || this.allDay) return {};
+      let t = 100 / Math.min(this.overlaps.length + 1, this.overlapsStreak), e = 100 / (this.overlaps.length + 1) * this.eventPosition;
+      this.vuecal.minEventWidth && t < this.vuecal.minEventWidth && (t = this.vuecal.minEventWidth, e = (100 - this.vuecal.minEventWidth) / this.overlaps.length * this.eventPosition);
+      const { top: s, height: l } = this.eventDimensions;
+      return {
+        top: `${s}px`,
+        height: `${l}px`,
+        width: `${t}%`,
+        left: this.event.left && `${this.event.left}px` || `${e}%`
+      };
+    },
+    // Don't rely on global variables otherwise whenever it would change all the events would be redrawn.
+    eventClasses() {
+      const { isFirstDay: t, isLastDay: e } = this.segment || {};
+      return {
+        [this.event.class]: !!this.event.class,
+        "vuecal__event--focus": this.event.focused,
+        "vuecal__event--resizing": this.event.resizing,
+        "vuecal__event--background": this.event.background,
+        "vuecal__event--deletable": this.event.deleting,
+        "vuecal__event--all-day": this.event.allDay,
+        // Only apply the dragging class on the event copy that is being dragged.
+        "vuecal__event--dragging": !this.event.draggingStatic && this.event.dragging,
+        // Only apply the static class on the event original that remains static while a copy is being dragged.
+        // Sometimes when dragging fast the static class would get stuck and events stays invisible,
+        // So if dragging is false disable the static class as well.
+        "vuecal__event--static": this.event.dragging && this.event.draggingStatic,
+        // Multiple days events.
+        "vuecal__event--multiple-days": !!this.segment,
+        "event-start": this.segment && t && !e,
+        "event-middle": this.segment && !t && !e,
+        "event-end": this.segment && e && !t
+      };
+    },
+    // When multiple-day events, a segment is a portion of event spanning on 1 day.
+    segment() {
+      return this.event.segments && this.event.segments[this.cellFormattedDate] || null;
+    },
+    draggable() {
+      const { draggable: t, background: e, daysCount: s } = this.event;
+      return this.vuecal.editEvents.drag && t && !e && s === 1;
+    },
+    resizable() {
+      const { editEvents: t, time: e } = this.vuecal;
+      return t.resize && this.event.resizable && e && !this.allDay && (!this.segment || this.segment && this.segment.isLastDay) && this.view.id !== "month";
+    },
+    // Drag & drop module.
+    dnd() {
+      return this.modules.dnd;
+    }
+  }
+}, di = /* @__PURE__ */ he(ui, [["render", oi]]), ci = ["data-split", "aria-label", "onTouchstart", "onMousedown", "onDragover", "onDrop"], hi = {
+  key: 0,
+  class: "cell-time-labels"
+}, vi = ["innerHTML"], mi = {
+  key: 2,
+  class: "vuecal__cell-events"
+}, yi = ["title"];
+function fi(t, e, s, l, r, i) {
+  const o = ae("event");
+  return v(), G(ft, {
+    class: V(["vuecal__cell", i.cellClasses]),
+    name: `slide-fade--${i.transitionDirection}`,
+    tag: "div",
+    appear: s.options.transitions,
+    style: z(i.cellStyles)
+  }, {
+    default: T(() => [
+      (v(!0), m(L, null, N(i.splitsCount ? i.splits : 1, (n, h) => (v(), m("div", {
+        class: V(["vuecal__flex vuecal__cell-content", i.splitsCount && i.splitClasses(n)]),
+        key: s.options.transitions ? `${i.view.id}-${s.data.content}-${h}` : h,
+        "data-split": i.splitsCount ? n.id : !1,
+        column: "",
+        tabindex: "0",
+        "aria-label": s.data.content,
+        onFocus: e[0] || (e[0] = (d) => i.onCellFocus(d)),
+        onKeypress: e[1] || (e[1] = nt((d) => i.onCellkeyPressEnter(d), ["enter"])),
+        onTouchstart: (d) => !i.isDisabled && i.onCellTouchStart(d, i.splitsCount ? n.id : null),
+        onMousedown: (d) => !i.isDisabled && i.onCellMouseDown(d, i.splitsCount ? n.id : null),
+        onClick: e[2] || (e[2] = (d) => !i.isDisabled && i.onCellClick(d)),
+        onDblclick: e[3] || (e[3] = (d) => !i.isDisabled && i.onCellDblClick(d)),
+        onContextmenu: e[4] || (e[4] = (d) => !i.isDisabled && s.options.cellContextmenu && i.onCellContextMenu(d)),
+        onDragenter: e[5] || (e[5] = (d) => !i.isDisabled && s.editEvents.drag && i.dnd && i.dnd.cellDragEnter(d, t.$data, s.data.startDate)),
+        onDragover: (d) => !i.isDisabled && s.editEvents.drag && i.dnd && i.dnd.cellDragOver(d, t.$data, s.data.startDate, i.splitsCount ? n.id : null),
+        onDragleave: e[6] || (e[6] = (d) => !i.isDisabled && s.editEvents.drag && i.dnd && i.dnd.cellDragLeave(d, t.$data, s.data.startDate)),
+        onDrop: (d) => !i.isDisabled && s.editEvents.drag && i.dnd && i.dnd.cellDragDrop(d, t.$data, s.data.startDate, i.splitsCount ? n.id : null)
+      }, [
+        s.options.showTimeInCells && s.options.time && i.isWeekOrDayView && !s.allDay ? (v(), m("div", hi, [
+          (v(!0), m(L, null, N(i.vuecal.timeCells, (d, c) => (v(), m("span", {
+            class: "cell-time-label",
+            key: c
+          }, E(d.label), 1))), 128))
+        ])) : D("", !0),
+        i.isWeekOrDayView && !s.allDay && i.specialHours.length ? (v(!0), m(L, { key: 1 }, N(i.specialHours, (d, c) => (v(), m("div", {
+          class: V(["vuecal__special-hours", `vuecal__special-hours--day${d.day} ${d.class}`]),
+          style: z(`height: ${d.height}px;top: ${d.top}px`)
+        }, [
+          d.label ? (v(), m("div", {
+            key: 0,
+            class: "special-hours-label",
+            innerHTML: d.label
+          }, null, 8, vi)) : D("", !0)
+        ], 6))), 256)) : D("", !0),
+        k(t.$slots, "cell-content", {
+          events: i.events,
+          selectCell: (d) => i.selectCell(d, !0),
+          split: i.splitsCount ? n : !1
+        }),
+        i.eventsCount && (i.isWeekOrDayView || i.view.id === "month" && s.options.eventsOnMonthView) ? (v(), m("div", mi, [
+          (v(!0), m(L, null, N(i.splitsCount ? n.events : i.events, (d, c) => (v(), G(o, {
+            key: c,
+            "cell-formatted-date": s.data.formattedDate,
+            event: d,
+            "all-day": s.allDay,
+            "cell-events": i.splitsCount ? n.events : i.events,
+            overlaps: ((i.splitsCount ? n.overlaps[d._eid] : t.cellOverlaps[d._eid]) || []).overlaps,
+            "event-position": ((i.splitsCount ? n.overlaps[d._eid] : t.cellOverlaps[d._eid]) || []).position,
+            "overlaps-streak": i.splitsCount ? n.overlapsStreak : t.cellOverlapsStreak
+          }, {
+            event: T(({ event: y, view: w }) => [
+              k(t.$slots, "event", {
+                view: w,
+                event: y
+              })
+            ]),
+            _: 2
+          }, 1032, ["cell-formatted-date", "event", "all-day", "cell-events", "overlaps", "event-position", "overlaps-streak"]))), 128))
+        ])) : D("", !0)
+      ], 42, ci))), 128)),
+      i.timelineVisible ? (v(), m("div", {
+        class: "vuecal__now-line",
+        style: z(`top: ${i.todaysTimePosition}px`),
+        key: s.options.transitions ? `${i.view.id}-now-line` : "now-line",
+        title: i.utils.date.formatTime(i.vuecal.now)
+      }, null, 12, yi)) : D("", !0)
+    ]),
+    _: 3
+  }, 8, ["class", "name", "appear", "style"]);
+}
+const wi = {
+  inject: ["vuecal", "utils", "modules", "view", "domEvents"],
+  components: { Event: di },
+  props: {
+    // Vue-cal main component options (props).
+    options: { type: Object, default: () => ({}) },
+    editEvents: { type: Object, required: !0 },
+    data: { type: Object, required: !0 },
+    cellSplits: { type: Array, default: () => [] },
+    minTimestamp: { type: [Number, null], default: null },
+    maxTimestamp: { type: [Number, null], default: null },
+    cellWidth: { type: [Number, Boolean], default: !1 },
+    allDay: { type: Boolean, default: !1 }
+  },
+  data: () => ({
+    cellOverlaps: {},
+    cellOverlapsStreak: 1,
+    // Largest amount of simultaneous events in cell.
+    // On mouse down, save the time at cursor so it can be reused on cell focus event
+    // where there is no cursor coords.
+    timeAtCursor: null,
+    highlighted: !1,
+    // On event drag over.
+    highlightedSplit: null
+  }),
+  methods: {
+    getSplitAtCursor({ target: t }) {
+      let s = t.classList.contains("vuecal__cell-split") ? t : this.vuecal.findAncestor(t, "vuecal__cell-split");
+      return s && (s = s.attributes["data-split"].value, parseInt(s).toString() === s.toString() && (s = parseInt(s))), s || null;
+    },
+    splitClasses(t) {
+      return {
+        "vuecal__cell-split": !0,
+        "vuecal__cell-split--highlighted": this.highlightedSplit === t.id,
+        [t.class]: !!t.class
+      };
+    },
+    checkCellOverlappingEvents() {
+      this.options.time && this.eventsCount && !this.splitsCount && (this.eventsCount === 1 ? (this.cellOverlaps = [], this.cellOverlapsStreak = 1) : [this.cellOverlaps, this.cellOverlapsStreak] = this.utils.event.checkCellOverlappingEvents(this.events, this.options));
+    },
+    isDOMElementAnEvent(t) {
+      return this.vuecal.isDOMElementAnEvent(t);
+    },
+    /**
+     * Select a cell and go to narrower view on double click or single click according to vuecalProps option.
+     */
+    selectCell(t, e = !1) {
+      const s = this.splitsCount ? this.getSplitAtCursor(t) : null;
+      this.utils.cell.selectCell(e, this.timeAtCursor, s), this.timeAtCursor = null;
+    },
+    onCellkeyPressEnter(t) {
+      this.isSelected || this.onCellFocus(t);
+      const e = this.splitsCount ? this.getSplitAtCursor(t) : null;
+      this.utils.cell.keyPressEnterCell(this.timeAtCursor, e), this.timeAtCursor = null;
+    },
+    /**
+     * On cell focus, from tab key or from mousedown, highlight the cell and emit
+     * the cell-focus event with the date of the cell start when focusing from tab or
+     * the date & time at cursor if click/touch.
+     */
+    onCellFocus(t) {
+      if (!this.isSelected && !this.isDisabled) {
+        this.isSelected = this.data.startDate;
+        const e = this.splitsCount ? this.getSplitAtCursor(t) : null, s = this.timeAtCursor || this.data.startDate;
+        this.vuecal.$emit("cell-focus", e ? { date: s, split: e } : s);
+      }
+    },
+    onCellMouseDown(t, e = null, s = !1) {
+      if ("ontouchstart" in window && !s) return !1;
+      this.isSelected || this.onCellFocus(t);
+      const { clickHoldACell: l, focusAnEvent: r } = this.domEvents;
+      this.domEvents.cancelClickEventCreation = !1, l.eventCreated = !1, this.timeAtCursor = new Date(this.data.startDate);
+      const { minutes: i, cursorCoords: { y: o } } = this.vuecal.minutesAtCursor(t);
+      this.timeAtCursor.setMinutes(i);
+      const n = this.isDOMElementAnEvent(t.target);
+      !n && r._eid && ((this.view.events.find((h) => h._eid === r._eid) || {}).focused = !1), this.editEvents.create && !n && this.setUpEventCreation(t, o);
+    },
+    setUpEventCreation(t, e) {
+      if (this.options.dragToCreateEvent && ["week", "day"].includes(this.view.id)) {
+        const { dragCreateAnEvent: s } = this.domEvents;
+        if (s.startCursorY = e, s.split = this.splitsCount ? this.getSplitAtCursor(t) : null, s.start = this.timeAtCursor, this.options.snapToTime) {
+          let l = this.timeAtCursor.getHours() * 60 + this.timeAtCursor.getMinutes();
+          const r = l + this.options.snapToTime / 2;
+          l = r - r % this.options.snapToTime, s.start.setHours(0, l, 0, 0);
+        }
+      } else this.options.cellClickHold && ["month", "week", "day"].includes(this.view.id) && this.setUpCellHoldTimer(t);
+    },
+    // When click & holding a cell, and if allowed, set a timeout to create an event (can be cancelled).
+    setUpCellHoldTimer(t) {
+      const { clickHoldACell: e } = this.domEvents;
+      e.cellId = `${this.vuecal._.uid}_${this.data.formattedDate}`, e.split = this.splitsCount ? this.getSplitAtCursor(t) : null, e.timeoutId = setTimeout(() => {
+        if (e.cellId && !this.domEvents.cancelClickEventCreation) {
+          const { _eid: s } = this.utils.event.createAnEvent(
+            this.timeAtCursor,
+            null,
+            e.split ? { split: e.split } : {}
+          );
+          e.eventCreated = s;
+        }
+      }, e.timeout);
+    },
+    onCellTouchStart(t, e = null) {
+      this.onCellMouseDown(t, e, !0);
+    },
+    onCellClick(t) {
+      this.isDOMElementAnEvent(t.target) || this.selectCell(t);
+    },
+    onCellDblClick(t) {
+      const e = new Date(this.data.startDate);
+      e.setMinutes(this.vuecal.minutesAtCursor(t).minutes);
+      const s = this.splitsCount ? this.getSplitAtCursor(t) : null;
+      this.vuecal.$emit("cell-dblclick", s ? { date: e, split: s } : e), this.options.dblclickToNavigate && this.vuecal.switchToNarrowerView();
+    },
+    onCellContextMenu(t) {
+      t.stopPropagation(), t.preventDefault();
+      const e = new Date(this.data.startDate), { cursorCoords: s, minutes: l } = this.vuecal.minutesAtCursor(t);
+      e.setMinutes(l);
+      const r = this.splitsCount ? this.getSplitAtCursor(t) : null;
+      this.vuecal.$emit("cell-contextmenu", { date: e, ...s, ...r || {}, e: t });
+    }
+  },
+  computed: {
+    // Drag & drop module.
+    dnd() {
+      return this.modules.dnd;
+    },
+    nowInMinutes() {
+      return this.utils.date.dateToMinutes(this.vuecal.now);
+    },
+    isBeforeMinDate() {
+      return this.minTimestamp !== null && this.minTimestamp > this.data.endDate.getTime();
+    },
+    isAfterMaxDate() {
+      return this.maxTimestamp && this.maxTimestamp < this.data.startDate.getTime();
+    },
+    // Is the current cell disabled or not.
+    isDisabled() {
+      const { disableDays: t } = this.options, { isYearsOrYearView: e } = this.vuecal;
+      return t.length && t.includes(this.data.formattedDate) && !e ? !0 : this.isBeforeMinDate || this.isAfterMaxDate;
+    },
+    // Is the current cell selected or not.
+    isSelected: {
+      get() {
+        let t = !1;
+        const { selectedDate: e } = this.view;
+        return this.view.id === "years" ? t = e.getFullYear() === this.data.startDate.getFullYear() : this.view.id === "year" ? t = e.getFullYear() === this.data.startDate.getFullYear() && e.getMonth() === this.data.startDate.getMonth() : t = e.getTime() === this.data.startDate.getTime(), t;
+      },
+      set(t) {
+        this.view.selectedDate = t, this.vuecal.$emit("update:selected-date", this.view.selectedDate);
+      }
+    },
+    // Cache result for performance.
+    isWeekOrDayView() {
+      return ["week", "day"].includes(this.view.id);
+    },
+    transitionDirection() {
+      return this.vuecal.transitionDirection;
+    },
+    specialHours() {
+      return this.data.specialHours.map((t) => {
+        let { from: e, to: s } = t;
+        return e = Math.max(e, this.options.timeFrom), s = Math.min(s, this.options.timeTo), {
+          ...t,
+          height: (s - e) * this.timeScale,
+          top: (e - this.options.timeFrom) * this.timeScale
+        };
+      });
+    },
+    events() {
+      const { startDate: t, endDate: e } = this.data;
+      let s = [];
+      if (!(["years", "year"].includes(this.view.id) && !this.options.eventsCountOnYearView)) {
+        if (s = this.view.events.slice(0), this.view.id === "month" && s.push(...this.view.outOfScopeEvents), s = s.filter((l) => this.utils.event.eventInRange(l, t, e)), this.options.showAllDayEvents && this.view.id !== "month" && (s = s.filter((l) => !!l.allDay === this.allDay)), this.options.time && this.isWeekOrDayView && !this.allDay) {
+          const { timeFrom: l, timeTo: r } = this.options;
+          s = s.filter((i) => {
+            const o = i.daysCount > 1 && i.segments[this.data.formattedDate] || {}, n = i.daysCount === 1 && i.startTimeMinutes < r && i.endTimeMinutes > l, h = i.daysCount > 1 && o.startTimeMinutes < r && o.endTimeMinutes > l;
+            return i.allDay || n || h || !1;
+          });
+        }
+        this.options.time && this.isWeekOrDayView && !(this.options.showAllDayEvents && this.allDay) && s.sort((l, r) => l.start < r.start ? -1 : 1), this.cellSplits.length || this.$nextTick(this.checkCellOverlappingEvents);
+      }
+      return s;
+    },
+    eventsCount() {
+      return this.events.length;
+    },
+    splits() {
+      return this.cellSplits.map((t, e) => {
+        const s = this.events.filter((i) => i.split === t.id), [l, r] = this.utils.event.checkCellOverlappingEvents(s.filter((i) => !i.background && !i.allDay), this.options);
+        return {
+          ...t,
+          overlaps: l,
+          overlapsStreak: r,
+          events: s
+        };
+      });
+    },
+    splitsCount() {
+      return this.splits.length;
+    },
+    cellClasses() {
+      return {
+        [this.data.class]: !!this.data.class,
+        "vuecal__cell--current": this.data.current,
+        // E.g. Current year in years view.
+        "vuecal__cell--today": this.data.today,
+        "vuecal__cell--out-of-scope": this.data.outOfScope,
+        "vuecal__cell--before-min": this.isDisabled && this.isBeforeMinDate,
+        "vuecal__cell--after-max": this.isDisabled && this.isAfterMaxDate,
+        "vuecal__cell--disabled": this.isDisabled,
+        "vuecal__cell--selected": this.isSelected,
+        "vuecal__cell--highlighted": this.highlighted,
+        "vuecal__cell--has-splits": this.splitsCount,
+        "vuecal__cell--has-events": this.eventsCount
+      };
+    },
+    cellStyles() {
+      return {
+        // cellWidth is only applied when hiding weekdays on month and week views.
+        ...this.cellWidth ? { width: `${this.cellWidth}%` } : {}
+      };
+    },
+    timelineVisible() {
+      const { time: t, timeTo: e } = this.options;
+      return this.data.today && this.isWeekOrDayView && t && !this.allDay && this.nowInMinutes <= e;
+    },
+    todaysTimePosition() {
+      if (!this.data.today || !this.options.time) return;
+      const t = this.nowInMinutes - this.options.timeFrom;
+      return Math.round(t * this.timeScale);
+    },
+    timeScale() {
+      return this.options.timeCellHeight / this.options.timeStep;
+    }
+  }
+}, ot = /* @__PURE__ */ he(wi, [["render", fi]]), Di = {
+  key: 0,
+  class: "vuecal__all-day-text",
+  style: { width: "3em" }
+};
+function gi(t, e, s, l, r, i) {
+  const o = ae("vuecal-cell");
+  return v(), m("div", {
+    class: "vuecal__flex vuecal__all-day",
+    style: z(s.cellOrSplitMinWidth && { height: s.height })
+  }, [
+    s.cellOrSplitMinWidth ? D("", !0) : (v(), m("div", Di, [
+      H("span", null, E(s.label), 1)
+    ])),
+    H("div", {
+      class: V(["vuecal__flex vuecal__cells", `${i.view.id}-view`]),
+      grow: "",
+      style: z(s.cellOrSplitMinWidth ? `min-width: ${s.cellOrSplitMinWidth}px` : "")
+    }, [
+      (v(!0), m(L, null, N(s.cells, (n, h) => (v(), G(o, {
+        key: h,
+        options: s.options,
+        "edit-events": i.editEvents,
+        data: n,
+        "all-day": !0,
+        "cell-width": s.options.hideWeekdays.length && (i.vuecal.isWeekView || i.vuecal.isMonthView) && i.vuecal.cellWidth,
+        "min-timestamp": s.options.minTimestamp,
+        "max-timestamp": s.options.maxTimestamp,
+        "cell-splits": s.daySplits
+      }, {
+        event: T(({ event: d, view: c }) => [
+          k(t.$slots, "event", {
+            view: c,
+            event: d
+          })
+        ]),
+        _: 2
+      }, 1032, ["options", "edit-events", "data", "cell-width", "min-timestamp", "max-timestamp", "cell-splits"]))), 128))
+    ], 6)
+  ], 4);
+}
+const pi = {
+  inject: ["vuecal", "view", "editEvents"],
+  components: { "vuecal-cell": ot },
+  props: {
+    // Vue-cal main component options (props).
+    options: { type: Object, required: !0 },
+    cells: { type: Array, required: !0 },
+    label: { type: String, required: !0 },
+    daySplits: { type: Array, default: () => [] },
+    shortEvents: { type: Boolean, default: !0 },
+    height: { type: String, default: "" },
+    cellOrSplitMinWidth: { type: Number, default: null }
+  },
+  computed: {
+    hasCellOrSplitWidth() {
+      return !!(this.options.minCellWidth || this.daySplits.length && this.options.minSplitWidth);
+    }
+  }
+}, bi = /* @__PURE__ */ he(pi, [["render", gi]]), ki = ["lang"], Ci = { class: "default" }, _i = {
+  key: 0,
+  class: "vuecal__flex vuecal__body",
+  grow: ""
+}, Ti = ["onBlur", "innerHTML"], Mi = ["innerHTML"], Si = ["innerHTML"], Ei = {
+  class: "vuecal__flex",
+  row: "",
+  grow: ""
+}, Hi = {
+  key: 0,
+  class: "vuecal__time-column"
+}, Oi = { class: "vuecal__time-cell-label" }, Wi = {
+  key: 1,
+  class: "vuecal__flex vuecal__week-numbers",
+  column: ""
+}, Vi = ["wrap", "column"], Ai = ["onBlur", "innerHTML"], ji = ["innerHTML"], Fi = ["innerHTML"], Li = ["wrap"], Yi = ["innerHTML"], Ni = ["innerHTML"], Bi = {
+  key: 2,
+  class: "vuecal__cell-events-count"
+}, Ii = {
+  key: 3,
+  class: "vuecal__no-event"
+}, Pi = ["onBlur", "innerHTML"], xi = ["innerHTML"], zi = {
+  key: 2,
+  class: "vuecal__event-time"
+}, Ri = { key: 0 }, Ui = {
+  key: 1,
+  class: "days-to-end"
+}, qi = ["innerHTML"], Ki = {
+  key: 0,
+  class: "vuecal__scrollbar-check"
+};
+function Xi(t, e, s, l, r, i) {
+  const o = ae("vuecal-header"), n = ae("all-day-bar"), h = ae("weekdays-headings"), d = ae("vuecal-cell");
+  return v(), m("div", {
+    class: V(["vuecal__flex vuecal", i.cssClasses]),
+    column: "",
+    ref: "vuecal",
+    lang: s.locale
+  }, [
+    We(o, {
+      options: t.$props,
+      "edit-events": i.editEvents,
+      "view-props": { views: i.views, weekDaysInHeader: i.weekDaysInHeader },
+      "week-days": i.weekDays,
+      "has-splits": i.hasSplits,
+      "day-splits": i.daySplits,
+      "switch-to-narrower-view": i.switchToNarrowerView
+    }, Le({
+      "arrow-prev": T(() => [
+        k(t.$slots, "arrow-prev", {}, () => [
+          e[0] || (e[0] = x(" ")),
+          e[1] || (e[1] = H("i", { class: "angle" }, null, -1)),
+          e[2] || (e[2] = x(" "))
+        ])
+      ]),
+      "arrow-next": T(() => [
+        k(t.$slots, "arrow-next", {}, () => [
+          e[3] || (e[3] = x(" ")),
+          e[4] || (e[4] = H("i", { class: "angle" }, null, -1)),
+          e[5] || (e[5] = x(" "))
+        ])
+      ]),
+      "today-button": T(() => [
+        k(t.$slots, "today-button", {}, () => [
+          H("span", Ci, E(r.texts.today), 1)
+        ])
+      ]),
+      title: T(() => [
+        k(t.$slots, "title", {
+          title: i.viewTitle,
+          view: r.view
+        }, () => [
+          x(E(i.viewTitle), 1)
+        ])
+      ]),
+      _: 2
+    }, [
+      t.$slots["weekday-heading"] ? {
+        name: "weekday-heading",
+        fn: T(({ heading: c, view: y }) => [
+          k(t.$slots, "weekday-heading", {
+            heading: c,
+            view: y
+          })
+        ]),
+        key: "0"
+      } : void 0,
+      t.$slots["split-label"] ? {
+        name: "split-label",
+        fn: T(({ split: c }) => [
+          k(t.$slots, "split-label", {
+            split: c,
+            view: r.view.id
+          })
+        ]),
+        key: "1"
+      } : void 0
+    ]), 1032, ["options", "edit-events", "view-props", "week-days", "has-splits", "day-splits", "switch-to-narrower-view"]),
+    s.hideBody ? D("", !0) : (v(), m("div", _i, [
+      We(Ye, {
+        name: `slide-fade--${r.transitionDirection}`,
+        appear: s.transitions
+      }, {
+        default: T(() => [
+          (v(), m("div", {
+            class: "vuecal__flex",
+            style: { "min-width": "100%" },
+            key: s.transitions ? r.view.id : !1,
+            column: ""
+          }, [
+            s.showAllDayEvents && i.hasTimeColumn && (!i.cellOrSplitMinWidth || i.isDayView && !s.minSplitWidth) ? (v(), G(n, ze(Re({ key: 0 }, i.allDayBar)), {
+              event: T(({ event: c, view: y }) => [
+                k(t.$slots, "event", {
+                  view: y,
+                  event: c
+                }, () => [
+                  i.editEvents.title && c.titleEditable ? (v(), m("div", {
+                    key: 0,
+                    class: "vuecal__event-title vuecal__event-title--edit",
+                    contenteditable: "",
+                    onBlur: (w) => i.onEventTitleBlur(w, c),
+                    innerHTML: c.title
+                  }, null, 40, Ti)) : c.title ? (v(), m("div", {
+                    key: 1,
+                    class: "vuecal__event-title",
+                    innerHTML: c.title
+                  }, null, 8, Mi)) : D("", !0),
+                  c.content && !i.hasShortEvents && !i.isShortMonthView ? (v(), m("div", {
+                    key: 2,
+                    class: "vuecal__event-content",
+                    innerHTML: c.content
+                  }, null, 8, Si)) : D("", !0)
+                ])
+              ]),
+              _: 3
+            }, 16)) : D("", !0),
+            H("div", {
+              class: V(["vuecal__bg", { vuecal__flex: !i.hasTimeColumn }]),
+              column: ""
+            }, [
+              H("div", Ei, [
+                i.hasTimeColumn ? (v(), m("div", Hi, [
+                  s.showAllDayEvents && i.cellOrSplitMinWidth && !(i.isDayView && !s.minSplitWidth) ? (v(), m("div", {
+                    key: 0,
+                    class: "vuecal__all-day-text",
+                    style: z({ height: i.allDayBar.height })
+                  }, [
+                    H("span", null, E(r.texts.allDay), 1)
+                  ], 4)) : D("", !0),
+                  (v(!0), m(L, null, N(i.timeCells, (c, y) => (v(), m("div", {
+                    class: "vuecal__time-cell",
+                    key: y,
+                    style: z(`height: ${s.timeCellHeight}px`)
+                  }, [
+                    k(t.$slots, "time-cell", {
+                      hours: c.hours,
+                      minutes: c.minutes
+                    }, () => [
+                      e[6] || (e[6] = H("span", { class: "vuecal__time-cell-line" }, null, -1)),
+                      H("span", Oi, E(c.label), 1)
+                    ])
+                  ], 4))), 128))
+                ])) : D("", !0),
+                s.showWeekNumbers && i.isMonthView ? (v(), m("div", Wi, [
+                  (v(), m(L, null, N(6, (c) => H("div", {
+                    class: "vuecal__flex vuecal__week-number-cell",
+                    key: c,
+                    grow: ""
+                  }, [
+                    k(t.$slots, "week-number-cell", {
+                      week: i.getWeekNumber(c - 1)
+                    }, () => [
+                      x(E(i.getWeekNumber(c - 1)), 1)
+                    ])
+                  ])), 64))
+                ])) : D("", !0),
+                H("div", {
+                  class: V(["vuecal__flex vuecal__cells", `${r.view.id}-view`]),
+                  grow: "",
+                  wrap: !i.cellOrSplitMinWidth || !i.isWeekView,
+                  column: !!i.cellOrSplitMinWidth
+                }, [
+                  i.cellOrSplitMinWidth && i.isWeekView ? (v(), G(h, {
+                    key: 0,
+                    "transition-direction": r.transitionDirection,
+                    "week-days": i.weekDays,
+                    "switch-to-narrower-view": i.switchToNarrowerView,
+                    style: z(i.cellOrSplitMinWidth ? `min-width: ${i.cellOrSplitMinWidth}px` : "")
+                  }, Le({ _: 2 }, [
+                    t.$slots["weekday-heading"] ? {
+                      name: "weekday-heading",
+                      fn: T(({ heading: c, view: y }) => [
+                        k(t.$slots, "weekday-heading", {
+                          heading: c,
+                          view: y
+                        })
+                      ]),
+                      key: "0"
+                    } : void 0,
+                    t.$slots["split-label"] ? {
+                      name: "split-label",
+                      fn: T(({ split: c }) => [
+                        k(t.$slots, "split-label", {
+                          split: c,
+                          view: r.view.id
+                        })
+                      ]),
+                      key: "1"
+                    } : void 0
+                  ]), 1032, ["transition-direction", "week-days", "switch-to-narrower-view", "style"])) : i.hasSplits && s.stickySplitLabels && s.minSplitWidth ? (v(), m("div", {
+                    key: 1,
+                    class: "vuecal__flex vuecal__split-days-headers",
+                    style: z(i.cellOrSplitMinWidth ? `min-width: ${i.cellOrSplitMinWidth}px` : "")
+                  }, [
+                    (v(!0), m(L, null, N(i.daySplits, (c, y) => (v(), m("div", {
+                      class: V(["day-split-header", c.class || !1]),
+                      key: y
+                    }, [
+                      k(t.$slots, "split-label", {
+                        split: c,
+                        view: r.view.id
+                      }, () => [
+                        x(E(c.label), 1)
+                      ])
+                    ], 2))), 128))
+                  ], 4)) : D("", !0),
+                  s.showAllDayEvents && i.hasTimeColumn && (i.isWeekView && i.cellOrSplitMinWidth || i.isDayView && i.hasSplits && s.minSplitWidth) ? (v(), G(n, ze(Re({ key: 2 }, i.allDayBar)), {
+                    event: T(({ event: c, view: y }) => [
+                      k(t.$slots, "event", {
+                        view: y,
+                        event: c
+                      }, () => [
+                        i.editEvents.title && c.titleEditable ? (v(), m("div", {
+                          key: 0,
+                          class: "vuecal__event-title vuecal__event-title--edit",
+                          contenteditable: "",
+                          onBlur: (w) => i.onEventTitleBlur(w, c),
+                          innerHTML: c.title
+                        }, null, 40, Ai)) : c.title ? (v(), m("div", {
+                          key: 1,
+                          class: "vuecal__event-title",
+                          innerHTML: c.title
+                        }, null, 8, ji)) : D("", !0),
+                        c.content && !i.hasShortEvents && !i.isShortMonthView ? (v(), m("div", {
+                          key: 2,
+                          class: "vuecal__event-content",
+                          innerHTML: c.content
+                        }, null, 8, Fi)) : D("", !0)
+                      ])
+                    ]),
+                    _: 3
+                  }, 16)) : D("", !0),
+                  H("div", {
+                    class: "vuecal__flex",
+                    ref: (c) => r.cellsEl = c,
+                    grow: "",
+                    wrap: !i.cellOrSplitMinWidth || !i.isWeekView,
+                    style: z(i.cellOrSplitMinWidth ? `min-width: ${i.cellOrSplitMinWidth}px` : "")
+                  }, [
+                    (v(!0), m(L, null, N(i.viewCells, (c, y) => (v(), G(d, {
+                      key: y,
+                      options: t.$props,
+                      "edit-events": i.editEvents,
+                      data: c,
+                      "cell-width": s.hideWeekdays.length && (i.isWeekView || i.isMonthView) && i.cellWidth,
+                      "min-timestamp": i.minTimestamp,
+                      "max-timestamp": i.maxTimestamp,
+                      "cell-splits": i.hasSplits && i.daySplits || []
+                    }, {
+                      "cell-content": T(({ events: w, split: A, selectCell: g }) => [
+                        k(t.$slots, "cell-content", {
+                          cell: c,
+                          view: r.view,
+                          goNarrower: g,
+                          events: w
+                        }, () => [
+                          A && !s.stickySplitLabels ? (v(), m("div", {
+                            key: 0,
+                            class: "split-label",
+                            innerHTML: A.label
+                          }, null, 8, Yi)) : D("", !0),
+                          c.content ? (v(), m("div", {
+                            key: 1,
+                            class: "vuecal__cell-date",
+                            innerHTML: c.content
+                          }, null, 8, Ni)) : D("", !0),
+                          (i.isMonthView && !s.eventsOnMonthView || i.isYearsOrYearView && s.eventsCountOnYearView) && w.length ? (v(), m("div", Bi, [
+                            k(t.$slots, "events-count", {
+                              view: r.view,
+                              events: w
+                            }, () => [
+                              x(E(w.length), 1)
+                            ])
+                          ])) : D("", !0),
+                          !i.cellOrSplitHasEvents(w, A) && i.isWeekOrDayView ? (v(), m("div", Ii, [
+                            k(t.$slots, "no-event", {}, () => [
+                              x(E(r.texts.noEvent), 1)
+                            ])
+                          ])) : D("", !0)
+                        ])
+                      ]),
+                      event: T(({ event: w, view: A }) => [
+                        k(t.$slots, "event", {
+                          view: A,
+                          event: w
+                        }, () => [
+                          i.editEvents.title && w.titleEditable ? (v(), m("div", {
+                            key: 0,
+                            class: "vuecal__event-title vuecal__event-title--edit",
+                            contenteditable: "",
+                            onBlur: (g) => i.onEventTitleBlur(g, w),
+                            innerHTML: w.title
+                          }, null, 40, Pi)) : w.title ? (v(), m("div", {
+                            key: 1,
+                            class: "vuecal__event-title",
+                            innerHTML: w.title
+                          }, null, 8, xi)) : D("", !0),
+                          s.time && !w.allDay && !(i.isMonthView && (w.allDay || s.showAllDayEvents === "short")) && !i.isShortMonthView ? (v(), m("div", zi, [
+                            x(E(r.utils.date.formatTime(w.start, i.TimeFormat)), 1),
+                            w.endTimeMinutes ? (v(), m("span", Ri, " - " + E(r.utils.date.formatTime(w.end, i.TimeFormat, null, !0)), 1)) : D("", !0),
+                            w.daysCount > 1 && (w.segments[c.formattedDate] || {}).isFirstDay ? (v(), m("small", Ui, " +" + E(w.daysCount - 1) + E((r.texts.day[0] || "").toLowerCase()), 1)) : D("", !0)
+                          ])) : D("", !0),
+                          w.content && !(i.isMonthView && w.allDay && s.showAllDayEvents === "short") && !i.isShortMonthView ? (v(), m("div", {
+                            key: 3,
+                            class: "vuecal__event-content",
+                            innerHTML: w.content
+                          }, null, 8, qi)) : D("", !0)
+                        ])
+                      ]),
+                      "no-event": T(() => [
+                        k(t.$slots, "no-event", {}, () => [
+                          x(E(r.texts.noEvent), 1)
+                        ])
+                      ]),
+                      _: 2
+                    }, 1032, ["options", "edit-events", "data", "cell-width", "min-timestamp", "max-timestamp", "cell-splits"]))), 128))
+                  ], 12, Li)
+                ], 10, Vi)
+              ])
+            ], 2)
+          ]))
+        ]),
+        _: 3
+      }, 8, ["name", "appear"]),
+      r.ready ? D("", !0) : (v(), m("div", Ki, e[7] || (e[7] = [
+        H("div", null, null, -1)
+      ])))
+    ]))
+  ], 10, ki);
+}
+const Oe = 24 * 60, Fe = {
+  weekDays: Array(7).fill(""),
+  weekDaysShort: [],
+  months: Array(12).fill(""),
+  years: "",
+  year: "",
+  month: "",
+  week: "",
+  day: "",
+  today: "",
+  noEvent: "",
+  allDay: "",
+  deleteEvent: "",
+  createEvent: "",
+  dateFormat: "dddd MMMM D, YYYY",
+  am: "am",
+  pm: "pm"
+}, it = ["years", "year", "month", "week", "day"], st = new Ft(Fe), Gi = {
+  name: "vue-cal",
+  components: { "vuecal-cell": ot, "vuecal-header": ni, WeekdaysHeadings: rt, AllDayBar: bi },
+  // By Vue design, passing props loses the reactivity unless it's a method or reactive OBJECT.
+  provide() {
+    return {
+      vuecal: this,
+      utils: this.utils,
+      modules: this.modules,
+      // Methods.
+      previous: this.previous,
+      next: this.next,
+      switchView: this.switchView,
+      updateSelectedDate: this.updateSelectedDate,
+      editEvents: this.editEvents,
+      // Objects.
+      view: this.view,
+      domEvents: this.domEvents
+    };
+  },
+  props: {
+    activeView: { type: String, default: "week" },
+    // Only used if there are daySplits with minSplitWidth, to add the same height top spacer on time column.
+    allDayBarHeight: { type: [String, Number], default: "25px" },
+    cellClickHold: { type: Boolean, default: !0 },
+    cellContextmenu: { type: Boolean, default: !1 },
+    clickToNavigate: { type: Boolean, default: !1 },
+    dblclickToNavigate: { type: Boolean, default: !0 },
+    disableDatePrototypes: { type: Boolean, default: !1 },
+    disableDays: { type: Array, default: () => [] },
+    disableViews: { type: Array, default: () => [] },
+    dragToCreateEvent: { type: Boolean, default: !0 },
+    // Start a drag creation after dragging a certain amount of pixels.
+    // This prevents drag creation by mistake when you want to navigate.
+    dragToCreateThreshold: { type: Number, default: 15 },
+    editableEvents: { type: [Boolean, Object], default: !1 },
+    events: { type: Array, default: () => [] },
+    eventsCountOnYearView: { type: Boolean, default: !1 },
+    eventsOnMonthView: { type: [Boolean, String], default: !1 },
+    hideBody: { type: Boolean, default: !1 },
+    hideTitleBar: { type: Boolean, default: !1 },
+    hideViewSelector: { type: Boolean, default: !1 },
+    hideWeekdays: { type: Array, default: () => [] },
+    hideWeekends: { type: Boolean, default: !1 },
+    locale: { type: [String, Object], default: "en" },
+    maxDate: { type: [String, Date], default: "" },
+    minCellWidth: { type: Number, default: 0 },
+    minDate: { type: [String, Date], default: "" },
+    minEventWidth: { type: Number, default: 0 },
+    minSplitWidth: { type: Number, default: 0 },
+    onEventClick: { type: [Function, null], default: null },
+    onEventCreate: { type: [Function, null], default: null },
+    onEventDblclick: { type: [Function, null], default: null },
+    overlapsPerTimeStep: { type: Boolean, default: !1 },
+    resizeX: { type: Boolean, default: !1 },
+    selectedDate: { type: [String, Date], default: "" },
+    showAllDayEvents: { type: [Boolean, String], default: !1 },
+    showTimeInCells: { type: Boolean, default: !1 },
+    showWeekNumbers: { type: [Boolean, String], default: !1 },
+    snapToTime: { type: Number, default: 0 },
+    small: { type: Boolean, default: !1 },
+    specialHours: { type: Object, default: () => ({}) },
+    splitDays: { type: Array, default: () => [] },
+    startWeekOnSunday: { type: Boolean, default: !1 },
+    stickySplitLabels: { type: Boolean, default: !1 },
+    time: { type: Boolean, default: !0 },
+    timeCellHeight: { type: Number, default: 40 },
+    // In pixels.
+    timeFormat: { type: String, default: "" },
+    timeFrom: { type: Number, default: 0 },
+    // In minutes.
+    timeStep: { type: Number, default: 60 },
+    // In minutes.
+    timeTo: { type: Number, default: Oe },
+    // In minutes.
+    todayButton: { type: Boolean, default: !1 },
+    transitions: { type: Boolean, default: !0 },
+    twelveHour: { type: Boolean, default: !1 },
+    watchRealTime: { type: Boolean, default: !1 },
+    // Expensive, so only trigger on demand.
+    xsmall: { type: Boolean, default: !1 }
+  },
+  data() {
+    return {
+      ready: !1,
+      // Is vue-cal ready.
+      // Make texts reactive before a locale is loaded.
+      texts: { ...Fe },
+      utils: {
+        // Remove prototypes ASAP if the user wants so.
+        date: (this.disableDatePrototypes ? st.removePrototypes() : !1) || st,
+        cell: null,
+        // Note: Destructuring class method loses the `this` context and Vue Cal becomes inaccessible
+        // from the event utils function. Don't do:
+        // const { eventInRange, createEventSegments } = this.utils.event
+        event: null
+      },
+      modules: { dnd: null },
+      cellsEl: null,
+      // At any time this object will be filled with current view, visible events and selected date.
+      view: {
+        id: "",
+        title: "",
+        startDate: null,
+        endDate: null,
+        firstCellDate: null,
+        lastCellDate: null,
+        selectedDate: null,
+        // All the events are stored in the mutableEvents array, but subset of visible ones are passed
+        // Into the current view for fast lookup and manipulation.
+        events: []
+      },
+      eventIdIncrement: 1,
+      // Internal unique id.
+      // Preset at now date on load, but updated every minute if watchRealTime,
+      // or updated at least on each cells rerender, in order to keep Today's date accurate.
+      now: /* @__PURE__ */ new Date(),
+      // Useful when watchRealTime = true, 2 timeouts: 1 to snap to round minutes, then 1 every minute.
+      timeTickerIds: [null, null],
+      // All the possible events/cells interractions:
+      // e.g. focus, click, click & hold, resize, drag & drop (coming).
+      domEvents: {
+        resizeAnEvent: {
+          _eid: null,
+          // Only one at a time.
+          start: null,
+          split: null,
+          segment: null,
+          originalEndTimeMinutes: 0,
+          originalEnd: null,
+          end: null,
+          startCell: null,
+          endCell: null
+        },
+        dragAnEvent: {
+          // Only one at a time, only needed for vuecal dragging-event class.
+          _eid: null
+        },
+        dragCreateAnEvent: {
+          startCursorY: null,
+          start: null,
+          // The cell date where we start the drag.
+          split: null,
+          event: null
+        },
+        focusAnEvent: {
+          _eid: null,
+          // Only one at a time.
+          // Useful to detect a full click (mousedown + mouseup on same event).
+          // E.g. Only call onEventClick function (if any) on full click.
+          mousedUp: !1
+        },
+        clickHoldAnEvent: {
+          _eid: null,
+          // Only one at a time.
+          timeout: 1200,
+          // Hold for 1.2s to delete an event.
+          timeoutId: null
+        },
+        dblTapACell: {
+          taps: 0,
+          timeout: 500
+          // Allowed latency between first and second click.
+        },
+        clickHoldACell: {
+          cellId: null,
+          split: null,
+          timeout: 1200,
+          // Hold for 1.2s to create an event.
+          timeoutId: null,
+          eventCreated: !1
+        },
+        // A single click can trigger event creation if the user decides so.
+        // But prevent this to happen on click & hold, on event click and on resize event.
+        cancelClickEventCreation: !1
+      },
+      // The events source of truth.
+      // An array of mutable events updated each time given external events array changes.
+      mutableEvents: [],
+      // Transition when switching view. left when going toward the past, right when going toward future.
+      transitionDirection: "right"
+    };
+  },
+  methods: {
+    /**
+     * Only import locale on demand to keep a small library weight.
+     *
+     * @param {String|Object} locale the language user whishes to have on vue-cal.
+     */
+    async loadLocale(t) {
+      if (typeof this.locale == "object") {
+        this.texts = Object.assign({}, Fe, t), this.utils.date.updateTexts(this.texts);
+        return;
+      }
+      const e = await jt(/* @__PURE__ */ Object.assign({ "./i18n/ar.json": () => import("./ar.es-XxSuE68c.mjs"), "./i18n/bg.json": () => import("./bg.es-BJ7fu6yy.mjs"), "./i18n/bn.json": () => import("./bn.es-CYlBkxc5.mjs"), "./i18n/bs.json": () => import("./bs.es-yMnaKmdi.mjs"), "./i18n/ca.json": () => import("./ca.es-DIhlxmQc.mjs"), "./i18n/cs.json": () => import("./cs.es-BN8oxRXQ.mjs"), "./i18n/da.json": () => import("./da.es-DJB5lAli.mjs"), "./i18n/de.json": () => import("./de.es-glb8GeJh.mjs"), "./i18n/el.json": () => import("./el.es-_bBZf22h.mjs"), "./i18n/en.json": () => import("./en.es-CV9nmQGr.mjs"), "./i18n/es.json": () => import("./es.es-CZjcWK54.mjs"), "./i18n/et.json": () => import("./et.es-CjvQAzNF.mjs"), "./i18n/fa.json": () => import("./fa.es-DykeFwDA.mjs"), "./i18n/fi.json": () => import("./fi.es-Bl7Pp7AO.mjs"), "./i18n/fr.json": () => import("./fr.es-CNKVhFfO.mjs"), "./i18n/he.json": () => import("./he.es-nF4GFhjH.mjs"), "./i18n/hr.json": () => import("./hr.es-QFfz660j.mjs"), "./i18n/hu.json": () => import("./hu.es-Ck2rE01V.mjs"), "./i18n/id.json": () => import("./id.es-Je7FEUJ5.mjs"), "./i18n/is.json": () => import("./is.es-bzprHvXI.mjs"), "./i18n/it.json": () => import("./it.es-CJtfqmNS.mjs"), "./i18n/ja.json": () => import("./ja.es-BaiGjqZ6.mjs"), "./i18n/ka.json": () => import("./ka.es-x9QJo_dl.mjs"), "./i18n/ko.json": () => import("./ko.es-6c447eTS.mjs"), "./i18n/lt.json": () => import("./lt.es-2twYdvmJ.mjs"), "./i18n/mn.json": () => import("./mn.es-BLQRG1uu.mjs"), "./i18n/nl.json": () => import("./nl.es-bB1qWR_S.mjs"), "./i18n/no.json": () => import("./no.es-CWDVXpTf.mjs"), "./i18n/pl.json": () => import("./pl.es-Dzct23w9.mjs"), "./i18n/pt-br.json": () => import("./pt-br.es-BeBuiitI.mjs"), "./i18n/pt-pt.json": () => import("./pt-pt.es-BeBuiitI.mjs"), "./i18n/ro.json": () => import("./ro.es-DfMVJ30M.mjs"), "./i18n/ru.json": () => import("./ru.es-Bv9UvrBe.mjs"), "./i18n/sk.json": () => import("./sk.es-CUOTpLuL.mjs"), "./i18n/sl.json": () => import("./sl.es-DeIGgZbR.mjs"), "./i18n/sq.json": () => import("./sq.es-CQJJrZHv.mjs"), "./i18n/sr.json": () => import("./sr.es-CKS0AkiW.mjs"), "./i18n/sv.json": () => import("./sv.es-ChHQRrAe.mjs"), "./i18n/tr.json": () => import("./tr.es-B3v90gVv.mjs"), "./i18n/uk.json": () => import("./uk.es-CiR4NnbN.mjs"), "./i18n/vi.json": () => import("./vi.es-DFDi5l7p.mjs"), "./i18n/zh-cn.json": () => import("./zh-cn.es-9cbEAuAi.mjs"), "./i18n/zh-hk.json": () => import("./zh-hk.es-z0tio4jE.mjs") }), `./i18n/${t}.json`, 3);
+      this.texts = Object.assign({}, Fe, e), this.utils.date.updateTexts(this.texts);
+    },
+    /**
+     * Only import drag and drop module on demand to keep a small library weight.
+     */
+    loadDragAndDrop() {
+      import("./drag-and-drop.es-Ckzp6XEn.mjs").then((t) => {
+        const { DragAndDrop: e } = t;
+        this.modules.dnd = new e(this);
+      }).catch(() => console.warn("Vue Cal: Missing drag & drop module."));
+    },
+    /**
+     * Checks that the given view is in the array of valid views or use 'week' otherwise.
+     * Then check the view is enabled or use the first enabled view instead.
+     * Raises error and warning if needed.
+     *
+     * @param {String} view The view to validate.
+     * @return {String} a valid view.
+     */
+    validateView(t) {
+      return it.includes(t) || (console.error(`Vue Cal: invalid active-view parameter provided: "${t}".
+A valid view must be one of: ${it.join(", ")}.`), t = "week"), this.enabledViews.includes(t) || (console.warn(`Vue Cal: the provided active-view "${t}" is disabled. Using the "${this.enabledViews[0]}" view instead.`), t = this.enabledViews[0]), t;
+    },
+    /**
+     * On click/dblclick of a cell go to a narrower view if available.
+     * E.g. Click on month cell takes you to week view if not hidden, otherwise on day view if not hidden.
+     *
+     * @param {String | Date} date A starting date for the view, if none, fallbacks to the selected date,
+     *                             If also empty fallbacks to the current view start date.
+     */
+    switchToNarrowerView(t = null) {
+      this.transitionDirection = "right";
+      const e = this.enabledViews[this.enabledViews.indexOf(this.view.id) + 1];
+      e && this.switchView(e, t);
+    },
+    /**
+     * Switches to the specified view on view selector click, or programmatically form external call (via $refs).
+     * If a date is given, it will be selected and if the view does not contain it, it will go to that date.
+     *
+     * @param {String} view the view to go to. Among `years`, `year`, `month`, `week`, `day`.
+     * @param {String | Date} date A starting date for the view, if none, fallbacks to the selected date,
+     *                             If also empty fallbacks to the current view start date.
+     * @param {Boolean} fromViewSelector to know if the caller is the built-in view selector.
+     */
+    switchView(t, e = null, s = !1) {
+      t = this.validateView(t);
+      const l = this.utils.date, r = this.view.startDate && this.view.startDate.getTime();
+      if (this.transitions && s) {
+        if (this.view.id === t) return;
+        const n = this.enabledViews;
+        this.transitionDirection = n.indexOf(this.view.id) > n.indexOf(t) ? "left" : "right";
+      }
+      const i = this.view.id;
+      switch (this.view.events = [], this.view.id = t, this.view.firstCellDate = null, this.view.lastCellDate = null, e || (e = this.view.selectedDate || this.view.startDate), t) {
+        case "years": {
+          this.view.startDate = new Date(Math.floor(e.getFullYear() / 25) * 25 || 2e3, 0, 1), this.view.endDate = new Date(this.view.startDate.getFullYear() + 25, 0, 1), this.view.endDate.setSeconds(-1);
+          break;
+        }
+        case "year": {
+          this.view.startDate = new Date(e.getFullYear(), 0, 1), this.view.endDate = new Date(e.getFullYear() + 1, 0, 1), this.view.endDate.setSeconds(-1);
+          break;
+        }
+        case "month": {
+          this.view.startDate = new Date(e.getFullYear(), e.getMonth(), 1), this.view.endDate = new Date(e.getFullYear(), e.getMonth() + 1, 1), this.view.endDate.setSeconds(-1);
+          let n = new Date(this.view.startDate);
+          if (n.getDay() !== (this.startWeekOnSunday ? 0 : 1) && (n = l.getPreviousFirstDayOfWeek(n, this.startWeekOnSunday)), this.view.firstCellDate = n, this.view.lastCellDate = l.addDays(n, 41), this.view.lastCellDate.setHours(23, 59, 59, 0), this.hideWeekends) {
+            if ([0, 6].includes(this.view.firstCellDate.getDay())) {
+              const h = this.view.firstCellDate.getDay() === 6 && !this.startWeekOnSunday ? 2 : 1;
+              this.view.firstCellDate = l.addDays(this.view.firstCellDate, h);
+            }
+            if ([0, 6].includes(this.view.startDate.getDay())) {
+              const h = this.view.startDate.getDay() === 6 ? 2 : 1;
+              this.view.startDate = l.addDays(this.view.startDate, h);
+            }
+            if ([0, 6].includes(this.view.lastCellDate.getDay())) {
+              const h = this.view.lastCellDate.getDay() === 0 && !this.startWeekOnSunday ? 2 : 1;
+              this.view.lastCellDate = l.subtractDays(this.view.lastCellDate, h);
+            }
+            if ([0, 6].includes(this.view.endDate.getDay())) {
+              const h = this.view.endDate.getDay() === 0 ? 2 : 1;
+              this.view.endDate = l.subtractDays(this.view.endDate, h);
+            }
+          }
+          break;
+        }
+        case "week": {
+          e = l.getPreviousFirstDayOfWeek(e, this.startWeekOnSunday);
+          const n = this.hideWeekends ? 5 : 7;
+          this.view.startDate = this.hideWeekends && this.startWeekOnSunday ? l.addDays(e, 1) : e, this.view.startDate.setHours(0, 0, 0, 0), this.view.endDate = l.addDays(e, n), this.view.endDate.setSeconds(-1);
+          break;
+        }
+        case "day": {
+          this.view.startDate = e, this.view.startDate.setHours(0, 0, 0, 0), this.view.endDate = new Date(e), this.view.endDate.setHours(23, 59, 59, 0);
+          break;
+        }
+      }
+      this.addEventsToView();
+      const o = this.view.startDate && this.view.startDate.getTime();
+      if (!(i === t && o === r) && (this.$emit("update:activeView", t), this.ready)) {
+        const n = this.view.startDate, h = {
+          view: t,
+          startDate: n,
+          endDate: this.view.endDate,
+          ...this.isMonthView ? {
+            firstCellDate: this.view.firstCellDate,
+            lastCellDate: this.view.lastCellDate,
+            outOfScopeEvents: this.view.outOfScopeEvents.map(this.cleanupEvent)
+          } : {},
+          events: this.view.events.map(this.cleanupEvent),
+          ...this.isWeekView ? { week: l.getWeek(this.startWeekOnSunday ? l.addDays(n, 1) : n) } : {}
+        };
+        this.$emit("view-change", h);
+      }
+    },
+    /**
+     * Shorthand function for external call (via $refs).
+     */
+    previous() {
+      this.previousNext(!1);
+    },
+    /**
+     * Shorthand function for external call (via $refs).
+     */
+    next() {
+      this.previousNext();
+    },
+    /**
+     * On click on previous or next arrow, update the calendar visible date range.
+     *
+     * @param {Boolean} next
+     */
+    previousNext(t = !0) {
+      const e = this.utils.date;
+      this.transitionDirection = t ? "right" : "left";
+      const s = t ? 1 : -1;
+      let l = null;
+      const { startDate: r, id: i } = this.view;
+      switch (i) {
+        case "years":
+          l = new Date(r.getFullYear() + 25 * s, 0, 1);
+          break;
+        case "year":
+          l = new Date(r.getFullYear() + 1 * s, 1, 1);
+          break;
+        case "month":
+          l = new Date(r.getFullYear(), r.getMonth() + 1 * s, 1);
+          break;
+        case "week":
+          l = e[t ? "addDays" : "subtractDays"](e.getPreviousFirstDayOfWeek(r, this.startWeekOnSunday), 7);
+          break;
+        case "day":
+          l = e[t ? "addDays" : "subtractDays"](r, 1);
+          const o = l.getDay(), n = this.startWeekOnSunday ? o : (o || 7) - 1;
+          if (this.weekDays[n].hide) {
+            const d = this.weekDays.map((y, w) => ({ ...y, i: w }));
+            let c = 0;
+            t ? ([...d.slice(n), ...d].find((y) => (c++, !y.hide)).i, c--) : [...d, ...d.slice(0, n)].reverse().find((y) => (c++, !y.hide)).i, l = e[t ? "addDays" : "subtractDays"](l, c);
+          }
+          break;
+      }
+      l && this.switchView(i, l);
+    },
+    /**
+     * Add events (subset from mutableEvents) to the current view (in `this.view.events`).
+     * This is done for performance, so that all the cells have a quick lookup of only what's needed.
+     *
+     * @param {Array} events
+     */
+    addEventsToView(t = []) {
+      const e = this.utils.event, { startDate: s, endDate: l, firstCellDate: r, lastCellDate: i } = this.view;
+      if (t.length || (this.view.events = []), t = t.length ? t : [...this.mutableEvents], !t || this.isYearsOrYearView && !this.eventsCountOnYearView) return;
+      let o = t.filter((n) => e.eventInRange(n, s, l));
+      !this.isYearsOrYearView && !(this.isMonthView && !this.eventsOnMonthView) && (o = o.map((n) => n.daysCount > 1 ? e.createEventSegments(n, r || s, i || l) : n)), this.view.events.push(...o), this.isMonthView && (this.view.outOfScopeEvents = [], t.forEach((n) => {
+        (e.eventInRange(n, r, s) || e.eventInRange(n, l, i)) && (this.view.events.some((h) => h._eid === n._eid) || this.view.outOfScopeEvents.push(n));
+      }));
+    },
+    /**
+     * find a DOM ancestor of a given DOM node `el` matching given class name.
+     *
+     * @param {Object} el a DOM node to find ancestor from.
+     * @param {String} Class the CSS class name of the ancestor.
+     * @return {Object} The matched DOM node or null if no match.
+     */
+    findAncestor(t, e) {
+      for (; (t = t.parentElement) && !t.classList.contains(e); )
+        ;
+      return t;
+    },
+    /**
+     * Tells whether a clicked DOM node is or is within a calendar event.
+     *
+     * @param {Object} el a DOM node to check if event.
+     * @return {Boolean} true if the given DOM node is - or is in - an event.
+     */
+    isDOMElementAnEvent(t) {
+      return t.classList.contains("vuecal__event") || this.findAncestor(t, "vuecal__event");
+    },
+    /**
+     * Capture mousemove anywhere in the page.
+     * If resizing an event was started earlier, this will update event end.
+     * If resizing was not started, this method is calculation is avoided with a premature return.
+     * Notes: Event resizing is started in cell component (onMouseDown) but place onMouseMove & onMouseUp
+     *        handlers in the single-instance parent for performance.
+     *
+     * @param {Object} e the native DOM event object.
+     */
+    onMouseMove(t) {
+      const { resizeAnEvent: e, dragAnEvent: s, dragCreateAnEvent: l } = this.domEvents;
+      e._eid === null && s._eid === null && !l.start || (t.preventDefault(), e._eid ? this.eventResizing(t) : this.dragToCreateEvent && l.start && this.eventDragCreation(t));
+    },
+    /**
+     * Capture mouseup anywhere in the page, not only on a cell or event.
+     * Then end up any resize, drag & drop, click & hold or event or cell.
+     * Notes: Mouseup can never cancel a click with preventDefault or stopPropagation,
+     *        But it always happens before the click event.
+     *
+     * @param {Object} e the native DOM event object.
+     */
+    onMouseUp(t) {
+      const {
+        focusAnEvent: e,
+        resizeAnEvent: s,
+        clickHoldAnEvent: l,
+        clickHoldACell: r,
+        dragCreateAnEvent: i
+      } = this.domEvents, { _eid: o } = l, { _eid: n } = s;
+      let h = !1;
+      const { event: d, start: c } = i, y = this.isDOMElementAnEvent(t.target), w = e.mousedUp;
+      if (e.mousedUp = !1, y && (this.domEvents.cancelClickEventCreation = !0), r.eventCreated) return;
+      if (n) {
+        const { originalEnd: g, originalEndTimeMinutes: Y, endTimeMinutes: j } = s, _ = this.view.events.find((B) => B._eid === s._eid);
+        if (h = j && j !== Y, _ && _.end.getTime() !== g.getTime()) {
+          const B = this.mutableEvents.find((Q) => Q._eid === s._eid);
+          B.endTimeMinutes = _.endTimeMinutes, B.end = _.end;
+          const O = this.cleanupEvent(_), q = {
+            ...this.cleanupEvent(_),
+            end: g,
+            endTimeMinutes: _.originalEndTimeMinutes
+          };
+          this.$emit("event-duration-change", { event: O, oldDate: s.originalEnd, originalEvent: q }), this.$emit("event-change", { event: O, originalEvent: q });
+        }
+        _ && (_.resizing = !1), s._eid = null, s.start = null, s.split = null, s.segment = null, s.originalEndTimeMinutes = null, s.originalEnd = null, s.endTimeMinutes = null, s.startCell = null, s.endCell = null;
+      } else c && (d && (this.emitWithEvent("event-drag-create", d), i.event.resizing = !1), i.start = null, i.split = null, i.event = null);
+      !y && !n && this.unfocusEvent(), l.timeoutId && !o && (clearTimeout(l.timeoutId), l.timeoutId = null), r.timeoutId && (clearTimeout(r.timeoutId), r.timeoutId = null);
+      const A = typeof this.onEventClick == "function";
+      if (w && !h && !o && !d && A) {
+        let g = this.view.events.find((Y) => Y._eid === e._eid);
+        return !g && this.isMonthView && (g = this.view.outOfScopeEvents.find((Y) => Y._eid === e._eid)), g && this.onEventClick(g, t);
+      }
+    },
+    /**
+     * Capture `escape` keypress when delete button is visible, and cancel deletion.
+     *
+     * @param {Object} e the native DOM event object.
+     */
+    onKeyUp(t) {
+      t.keyCode === 27 && this.cancelDelete();
+    },
+    /**
+     * On mousemove while resising an event.
+     *
+     * @param {Object} e the native DOM event object.
+     */
+    eventResizing(t) {
+      const { resizeAnEvent: e } = this.domEvents, s = this.view.events.find((d) => d._eid === e._eid) || { segments: {} }, { minutes: l, cursorCoords: r } = this.minutesAtCursor(t), i = s.segments && s.segments[e.segment], { date: o, event: n } = this.utils, h = Math.max(l, this.timeFrom + 1, (i || s).startTimeMinutes + 1);
+      if (s.endTimeMinutes = e.endTimeMinutes = h, this.snapToTime) {
+        const d = s.endTimeMinutes + this.snapToTime / 2;
+        s.endTimeMinutes = d - d % this.snapToTime;
+      }
+      if (i && (i.endTimeMinutes = s.endTimeMinutes), s.end.setHours(0, s.endTimeMinutes, s.endTimeMinutes === Oe ? -1 : 0, 0), this.resizeX && this.isWeekView) {
+        s.daysCount = o.countDays(s.start, s.end);
+        const d = this.cellsEl, c = d.offsetWidth / d.childElementCount, y = Math.floor(r.x / c);
+        if (e.startCell === null && (e.startCell = y - (s.daysCount - 1)), e.endCell !== y) {
+          e.endCell = y;
+          const w = o.addDays(s.start, y - e.startCell), A = Math.max(o.countDays(s.start, w), 1);
+          if (A !== s.daysCount) {
+            let g = null;
+            A > s.daysCount ? g = n.addEventSegment(s) : g = n.removeEventSegment(s), e.segment = g, s.endTimeMinutes += 1e-3;
+          }
+        }
+      }
+      this.$emit("event-resizing", { _eid: s._eid, end: s.end, endTimeMinutes: s.endTimeMinutes });
+    },
+    /**
+     * On mousemove while dragging to create an event.
+     *
+     * @param {Object} e the native DOM event object.
+     */
+    eventDragCreation(t) {
+      const { dragCreateAnEvent: e } = this.domEvents, { start: s, startCursorY: l, split: r } = e, i = new Date(s), { minutes: o, cursorCoords: { y: n } } = this.minutesAtCursor(t);
+      if (!(!e.event && Math.abs(l - n) < this.dragToCreateThreshold))
+        if (e.event) {
+          if (i.setHours(0, o, o === Oe ? -1 : 0, 0), this.snapToTime) {
+            let c = i.getHours() * 60 + i.getMinutes();
+            const y = c + this.snapToTime / 2;
+            c = y - y % this.snapToTime, i.setHours(0, c, 0, 0);
+          }
+          const h = s < i, { event: d } = e;
+          d.start = h ? s : i, d.end = h ? i : s, d.startTimeMinutes = d.start.getHours() * 60 + d.start.getMinutes(), d.endTimeMinutes = d.end.getHours() * 60 + d.end.getMinutes();
+        } else {
+          if (e.event = this.utils.event.createAnEvent(s, 1, { split: r }), !e.event) {
+            e.start = null, e.split = null, e.event = null;
+            return;
+          }
+          e.event.resizing = !0;
+        }
+    },
+    /**
+     * Unfocus an event (e.g. when clicking outside of focused event).
+     */
+    unfocusEvent() {
+      const { focusAnEvent: t, clickHoldAnEvent: e } = this.domEvents, s = this.view.events.find((l) => l._eid === (t._eid || e._eid));
+      t._eid = null, e._eid = null, s && (s.focused = !1, s.deleting = !1);
+    },
+    /**
+     * Cancel an event deletion (e.g. when clicking outside of visible delete button).
+     */
+    cancelDelete() {
+      const { clickHoldAnEvent: t } = this.domEvents;
+      if (t._eid) {
+        const e = this.view.events.find((s) => s._eid === t._eid);
+        e && (e.deleting = !1), t._eid = null, t.timeoutId = null;
+      }
+    },
+    /**
+     * After editing an event title (if `this.editable`), save the new string into the event object
+     * and emit event to the outside world.
+     *
+     * @param {Object} e the native DOM event object.
+     * @param {Object} event the vue-cal event object.
+     */
+    onEventTitleBlur(t, e) {
+      if (e.title === t.target.innerHTML) return;
+      const s = e.title;
+      e.title = t.target.innerHTML;
+      const l = this.cleanupEvent(e);
+      this.$emit("event-title-change", { event: l, oldTitle: s }), this.$emit("event-change", { event: l, originalEvent: { ...l, title: s } });
+    },
+    /**
+     * The `mutableEvents` array of events is the source of truth.
+     * It is first populated from the `events` prop and every time the `events` prop changes.
+     * When the user updates an event through interractions, the event gets updated here.
+     * Notes: mutableEvents couldn't be a computed variable based on this.events, because we add
+     *        items to the array. (Cannot mutate props)
+     */
+    updateMutableEvents() {
+      const t = this.utils.date;
+      this.mutableEvents = [], this.events.forEach((e) => {
+        const s = typeof e.start == "string" ? t.stringToDate(e.start) : e.start, l = t.formatDateLite(s), r = t.dateToMinutes(s);
+        let i = null;
+        typeof e.end == "string" && e.end.includes("24:00") ? (i = new Date(e.end.replace(" 24:00", "")), i.setHours(23, 59, 59, 0)) : i = typeof e.end == "string" ? t.stringToDate(e.end) : e.end;
+        let o = t.formatDateLite(i), n = t.dateToMinutes(i);
+        (!n || n === Oe) && (!this.time || typeof e.end == "string" && e.end.length === 10 ? i.setHours(23, 59, 59, 0) : i.setSeconds(i.getSeconds() - 1), o = t.formatDateLite(i), n = Oe);
+        const h = l !== o;
+        e = Object.assign({ ...this.utils.event.eventDefaults }, e, {
+          // Keep the event ids scoped to this calendar instance.
+          _eid: `${this._.uid}_${this.eventIdIncrement++}`,
+          segments: h ? {} : null,
+          start: s,
+          startTimeMinutes: r,
+          end: i,
+          endTimeMinutes: n,
+          daysCount: h ? t.countDays(s, i) : 1,
+          class: e.class
+        }), this.mutableEvents.push(e);
+      });
+    },
+    /**
+     * Get the number of minutes from the top to the mouse cursor.
+     *
+     * @param {Object} e the native DOM event object.
+     * @return {Object} containing { minutes: {Number}, cursorCoords: { x: {Number}, y: {Number} } }
+     */
+    minutesAtCursor(t) {
+      return this.utils.cell.minutesAtCursor(t);
+    },
+    /**
+     * Creates a new event in vue-cal memory (in the mutableEvents array) starting at the given date & time.
+     * Proxy method to allow call from cell click & hold or external call (via $refs).
+     * Notes: Event duration is by default 2 hours. You can override the event end through eventOptions.
+     *
+     * @param {String | Date} dateTime date & time at which the event will start.
+     * @param {Number} duration the event duration in minutes.
+     * @param {Object} eventOptions an object of options to override the event creation defaults.
+     *                              (can be any key allowed in an event object)
+     * @return {Object} the created event.
+     */
+    createEvent(t, e, s = {}) {
+      return this.utils.event.createAnEvent(t, e, s);
+    },
+    /**
+     * Remove all the vue-cal private vars from the event (before returning it through $emit()).
+     *
+     * @param {Object} event the event object to cleanup.
+     */
+    cleanupEvent(t) {
+      return t = { ...t }, [
+        "segments",
+        "deletable",
+        "deleting",
+        "titleEditable",
+        "resizable",
+        "resizing",
+        "draggable",
+        "dragging",
+        "draggingStatic",
+        "focused"
+      ].forEach((s) => {
+        s in t && delete t[s];
+      }), t.repeat || delete t.repeat, t;
+    },
+    /**
+     * Emits an event (custom DOM event) to the outside world.
+     * This event has an event name and a clean calendar event as a parameter.
+     *
+     * @param {String} eventName the name of the custom emitted event (e.g. `event-focus`).
+     * @param {Object} event the event to return to the outside world.
+     */
+    emitWithEvent(t, e) {
+      this.$emit(t, this.cleanupEvent(e));
+    },
+    /**
+     * Update the selected date:
+     * - on created, from given selectedDate prop
+     * - on click/dblClick of another cell
+     * - from external call (via $refs)
+     * - when the given selectedDate prop changes.
+     * If date is not in the view, the view will change to show it.
+     *
+     * @param {String | Date} date The date to select.
+     */
+    updateSelectedDate(t) {
+      if (t && typeof t == "string" ? t = this.utils.date.stringToDate(t) : t = new Date(t), t && t instanceof Date) {
+        const { selectedDate: e } = this.view;
+        e && (this.transitionDirection = e.getTime() > t.getTime() ? "left" : "right"), t.setHours(0, 0, 0, 0), (!e || e.getTime() !== t.getTime()) && (this.view.selectedDate = t), this.switchView(this.view.id);
+      }
+      this.$emit("update:selected-date", this.view.selectedDate);
+    },
+    /**
+     * Double checks the week number is correct. Read below to understand!
+     * this is a wrapper around the `getWeek()` function for performance:
+     * As this is called multiple times from the template and cannot be in computed since there is
+     * a parameter, this wrapper function avoids the `getWeek()` function call 5 times out of 6
+     * using the computed `firstCellDateWeekNumber`.
+     *
+     * Reason why:
+     * Getting the week number is not that straightforward as there might be a 53rd week in the year.
+     * Whenever the year starts on a Thursday or any leap year starting on a Wednesday, this week will be 53.
+     *
+     * @param {Number} weekFromFirstCell Number from 0 to 6.
+     */
+    getWeekNumber(t) {
+      const e = this.utils.date, l = this.firstCellDateWeekNumber + t, r = this.startWeekOnSunday ? 1 : 0;
+      return l > 52 ? e.getWeek(e.addDays(this.view.firstCellDate, 7 * t + r)) : l;
+    },
+    /**
+     * Only if watchRealTime is true.
+     * Pull the current time from user machine every minute to keep vue-cal accurate even when idle.
+     * This will redraw the now line every minute and ensure that Today's date is always accurate.
+     */
+    timeTick() {
+      this.now = /* @__PURE__ */ new Date(), this.timeTickerIds[1] = setTimeout(this.timeTick, 60 * 1e3);
+    },
+    /**
+     * Updates the localized texts in use in the Date prototypes. (E.g. new Date().format())
+     * Callable from outside of Vue Cal.
+     */
+    updateDateTexts() {
+      this.utils.date.updateTexts(this.texts);
+    },
+    /**
+     * On Windows devices, the .vuecal__bg's vertical scrollbar takes space and pushes the content.
+     * This function will also push the weekdays-headings and all-day bar to have them properly aligned.
+     * The calculated style will be placed in the document head in a style tag so it's only done once
+     * (the scrollbar width never changes).
+     * Ref. https://github.com/antoniandre/vue-cal-v4/issues/221
+     */
+    alignWithScrollbar() {
+      if (document.getElementById("vuecal-align-with-scrollbar")) return;
+      const t = this.$refs.vuecal.getElementsByClassName("vuecal__scrollbar-check")[0], e = t.offsetWidth - t.children[0].offsetWidth;
+      if (e) {
+        const s = document.createElement("style");
+        s.id = "vuecal-align-with-scrollbar", s.type = "text/css", s.innerHTML = `.vuecal--view-with-time .vuecal__weekdays-headings,.vuecal--view-with-time .vuecal__all-day {padding-right: ${e}px}`, document.head.appendChild(s);
+      }
+    },
+    /**
+     * Tells wether there are events in the given cell or split and returns a Boolean.
+     * This function simplifies the template.
+     *
+     * @param {Array} events The cell events.
+     * @param {Object|Boolean} split The current split object if any or false.
+     * @return {Boolean} true if there are events, false otherwise.
+     */
+    cellOrSplitHasEvents(t, e = null) {
+      return t.length && (!e && t.length || e && t.some((s) => s.split === e.id));
+    }
+  },
+  created() {
+    this.utils.cell = new Yt(this), this.utils.event = new Bt(this, this.utils.date), this.loadLocale(this.locale), this.editEvents.drag && this.loadDragAndDrop(), this.updateMutableEvents(this.events), this.view.id = this.currentView, this.selectedDate ? this.updateSelectedDate(this.selectedDate) : (this.view.selectedDate = /* @__PURE__ */ new Date(), this.switchView(this.currentView)), this.time && this.watchRealTime && (this.timeTickerIds[0] = setTimeout(this.timeTick, (60 - this.now.getSeconds()) * 1e3));
+  },
+  mounted() {
+    const t = this.utils.date, e = "ontouchstart" in window, { resize: s, drag: l, create: r, delete: i, title: o } = this.editEvents, n = this.onEventClick && typeof this.onEventClick == "function";
+    (s || l || r || i || o || n) && window.addEventListener(e ? "touchend" : "mouseup", this.onMouseUp), (s || l || r && this.dragToCreateEvent) && window.addEventListener(e ? "touchmove" : "mousemove", this.onMouseMove, { passive: !1 }), o && window.addEventListener("keyup", this.onKeyUp), e && (this.$refs.vuecal.oncontextmenu = function(c) {
+      c.preventDefault(), c.stopPropagation();
+    }), this.hideBody || this.alignWithScrollbar();
+    const h = this.view.startDate, d = {
+      view: this.view.id,
+      startDate: h,
+      endDate: this.view.endDate,
+      ...this.isMonthView ? { firstCellDate: this.view.firstCellDate, lastCellDate: this.view.lastCellDate } : {},
+      events: this.view.events.map(this.cleanupEvent),
+      ...this.isWeekView ? { week: t.getWeek(this.startWeekOnSunday ? t.addDays(h, 1) : h) } : {}
+    };
+    this.$emit("ready", d), this.ready = !0;
+  },
+  beforeUnmount() {
+    const t = "ontouchstart" in window;
+    window.removeEventListener(t ? "touchmove" : "mousemove", this.onMouseMove, { passive: !1 }), window.removeEventListener(t ? "touchend" : "mouseup", this.onMouseUp), window.removeEventListener("keyup", this.onKeyUp), this.timeTickerIds[0] && clearTimeout(this.timeTickerIds[0]), this.timeTickerIds[1] && clearTimeout(this.timeTickerIds[1]), this.timeTickerIds = [null, null];
+  },
+  computed: {
+    editEvents() {
+      return this.editableEvents && typeof this.editableEvents == "object" ? {
+        title: !!this.editableEvents.title,
+        drag: !!this.editableEvents.drag,
+        resize: !!this.editableEvents.resize,
+        create: !!this.editableEvents.create,
+        delete: !!this.editableEvents.delete
+      } : {
+        title: !!this.editableEvents,
+        drag: !!this.editableEvents,
+        resize: !!this.editableEvents,
+        create: !!this.editableEvents,
+        delete: !!this.editableEvents
+      };
+    },
+    views() {
+      return {
+        years: { label: this.texts.years, enabled: !this.disableViews.includes("years") },
+        year: { label: this.texts.year, enabled: !this.disableViews.includes("year") },
+        month: { label: this.texts.month, enabled: !this.disableViews.includes("month") },
+        week: { label: this.texts.week, enabled: !this.disableViews.includes("week") },
+        day: { label: this.texts.day, enabled: !this.disableViews.includes("day") }
+      };
+    },
+    currentView() {
+      return this.validateView(this.activeView);
+    },
+    enabledViews() {
+      return Object.keys(this.views).filter((t) => this.views[t].enabled);
+    },
+    hasTimeColumn() {
+      return this.time && this.isWeekOrDayView;
+    },
+    isShortMonthView() {
+      return this.isMonthView && this.eventsOnMonthView === "short";
+    },
+    firstCellDateWeekNumber() {
+      const t = this.utils.date, e = this.view.firstCellDate;
+      return t.getWeek(this.startWeekOnSunday ? t.addDays(e, 1) : e);
+    },
+    // For week & day views.
+    timeCells() {
+      const t = [];
+      for (let e = this.timeFrom, s = this.timeTo; e < s; e += this.timeStep)
+        t.push({
+          hours: Math.floor(e / 60),
+          minutes: e % 60,
+          label: this.utils.date.formatTime(e, this.TimeFormat),
+          // The texts (3rd param) are given on Vue Cal init.
+          value: e
+        });
+      return t;
+    },
+    TimeFormat() {
+      return this.timeFormat || (this.twelveHour ? "h:mm{am}" : "HH:mm");
+    },
+    // Filter out the day splits that are hidden.
+    daySplits() {
+      return (this.splitDays.filter((t) => !t.hide) || []).map((t, e) => ({ ...t, id: t.id || e + 1 }));
+    },
+    // Whether the current view has days splits.
+    hasSplits() {
+      return this.daySplits.length && this.isWeekOrDayView;
+    },
+    hasShortEvents() {
+      return this.showAllDayEvents === "short";
+    },
+    // Returns the min cell width or the min split width if any.
+    cellOrSplitMinWidth() {
+      let t = null;
+      return this.hasSplits && this.minSplitWidth ? t = this.visibleDaysCount * this.minSplitWidth * this.daySplits.length : this.minCellWidth && this.isWeekView && (t = this.visibleDaysCount * this.minCellWidth), t;
+    },
+    allDayBar() {
+      let t = this.allDayBarHeight || null;
+      return t && !isNaN(t) && (t += "px"), {
+        cells: this.viewCells,
+        options: this.$props,
+        label: this.texts.allDay,
+        shortEvents: this.hasShortEvents,
+        daySplits: this.hasSplits && this.daySplits || [],
+        cellOrSplitMinWidth: this.cellOrSplitMinWidth,
+        height: t
+      };
+    },
+    minTimestamp() {
+      let t = null;
+      return this.minDate && typeof this.minDate == "string" ? t = this.utils.date.stringToDate(this.minDate) : this.minDate && this.minDate instanceof Date && (t = this.minDate), t ? t.getTime() : null;
+    },
+    maxTimestamp() {
+      let t = null;
+      return this.maxDate && typeof this.maxDate == "string" ? t = this.utils.date.stringToDate(this.maxDate) : this.maxDate && this.maxDate instanceof Date && (t = this.maxDate), t ? t.getTime() : null;
+    },
+    weekDays() {
+      let { weekDays: t, weekDaysShort: e = [] } = this.texts;
+      return t = t.slice(0).map((s, l) => ({
+        label: s,
+        ...e.length ? { short: e[l] } : {},
+        hide: this.hideWeekends && l >= 5 || this.hideWeekdays.length && this.hideWeekdays.includes(l + 1)
+      })), this.startWeekOnSunday && t.unshift(t.pop()), t;
+    },
+    weekDaysInHeader() {
+      return this.isMonthView || // hasSplits check is important here in case the user toggles the splits but keep minSplitWidth.
+      this.isWeekView && !this.minCellWidth && !(this.hasSplits && this.minSplitWidth);
+    },
+    months() {
+      return this.texts.months.map((t) => ({ label: t }));
+    },
+    // Validate and fill up the special hours object once for all at root level and not in cell.
+    specialDayHours() {
+      return !this.specialHours || !Object.keys(this.specialHours).length ? {} : Array(7).fill("").map((t, e) => {
+        let s = this.specialHours[e + 1] || [];
+        return Array.isArray(s) || (s = [s]), t = [], s.forEach(({ from: l, to: r, class: i, label: o }, n) => {
+          t[n] = {
+            day: e + 1,
+            from: [null, void 0].includes(l) ? null : l * 1,
+            to: [null, void 0].includes(r) ? null : r * 1,
+            class: i || "",
+            label: o || ""
+          };
+        }), t;
+      });
+    },
+    viewTitle() {
+      const t = this.utils.date;
+      let e = "";
+      const s = this.view.startDate, l = s.getFullYear(), r = s.getMonth();
+      switch (this.view.id) {
+        case "years": {
+          e = this.texts.years;
+          break;
+        }
+        case "year": {
+          e = l;
+          break;
+        }
+        case "month": {
+          e = `${this.months[r].label} ${l}`;
+          break;
+        }
+        case "week": {
+          const i = this.view.endDate, o = s.getFullYear();
+          let n = this.texts.months[s.getMonth()];
+          this.xsmall && (n = n.substring(0, 3));
+          let h = `${n} ${o}`;
+          if (i.getMonth() !== s.getMonth()) {
+            const d = i.getFullYear();
+            let c = this.texts.months[i.getMonth()];
+            this.xsmall && (c = c.substring(0, 3)), o === d ? h = `${n} - ${c} ${o}` : this.small ? h = `${n.substring(0, 3)} ${o} - ${c.substring(0, 3)} ${d}` : h = `${n} ${o} - ${c} ${d}`;
+          }
+          e = `${this.texts.week} ${t.getWeek(this.startWeekOnSunday ? t.addDays(s, 1) : s)} (${h})`;
+          break;
+        }
+        case "day": {
+          e = this.utils.date.formatDate(s, this.texts.dateFormat, this.texts);
+          break;
+        }
+      }
+      return e;
+    },
+    viewCells() {
+      const t = this.utils.date;
+      let e = [], s = null, l = !1;
+      this.watchRealTime || (this.now = /* @__PURE__ */ new Date());
+      const r = this.now;
+      switch (this.view.id) {
+        case "years": {
+          s = this.view.startDate.getFullYear(), e = Array.apply(null, Array(25)).map((i, o) => {
+            const n = new Date(s + o, 0, 1), h = new Date(s + o + 1, 0, 1);
+            return h.setSeconds(-1), {
+              startDate: n,
+              formattedDate: t.formatDateLite(n),
+              endDate: h,
+              content: s + o,
+              current: s + o === r.getFullYear()
+            };
+          });
+          break;
+        }
+        case "year": {
+          s = this.view.startDate.getFullYear(), e = Array.apply(null, Array(12)).map((i, o) => {
+            const n = new Date(s, o, 1), h = new Date(s, o + 1, 1);
+            return h.setSeconds(-1), {
+              startDate: n,
+              formattedDate: t.formatDateLite(n),
+              endDate: h,
+              content: this.xsmall ? this.months[o].label.substr(0, 3) : this.months[o].label,
+              current: o === r.getMonth() && s === r.getFullYear()
+            };
+          });
+          break;
+        }
+        case "month": {
+          const i = this.view.startDate.getMonth(), o = new Date(this.view.firstCellDate);
+          l = !1, e = Array.apply(null, Array(42)).map((n, h) => {
+            const d = t.addDays(o, h), c = new Date(d);
+            c.setHours(23, 59, 59, 0);
+            const y = !l && t.isToday(d) && !l++;
+            return {
+              startDate: d,
+              formattedDate: t.formatDateLite(d),
+              endDate: c,
+              content: d.getDate(),
+              today: y,
+              outOfScope: d.getMonth() !== i,
+              class: `vuecal__cell--day${d.getDay() || 7}`
+            };
+          }), (this.hideWeekends || this.hideWeekdays.length) && (e = e.filter((n) => {
+            const h = n.startDate.getDay() || 7;
+            return !(this.hideWeekends && h >= 6 || this.hideWeekdays.length && this.hideWeekdays.includes(h));
+          }));
+          break;
+        }
+        case "week": {
+          l = !1;
+          const i = this.view.startDate, o = this.weekDays;
+          e = o.map((n, h) => {
+            const d = t.addDays(i, this.startWeekOnSunday && this.hideWeekends ? h - 1 : h), c = new Date(d);
+            c.setHours(23, 59, 59, 0);
+            const y = (d.getDay() || 7) - 1;
+            return {
+              startDate: d,
+              formattedDate: t.formatDateLite(d),
+              endDate: c,
+              // To increase performance skip checking isToday if today already found.
+              today: !l && t.isToday(d) && !l++,
+              specialHours: this.specialDayHours[y] || []
+            };
+          }).filter((n, h) => !o[h].hide);
+          break;
+        }
+        case "day": {
+          const i = this.view.startDate, o = new Date(this.view.startDate);
+          o.setHours(23, 59, 59, 0);
+          const n = (i.getDay() || 7) - 1;
+          e = [{
+            startDate: i,
+            formattedDate: t.formatDateLite(i),
+            endDate: o,
+            today: t.isToday(i),
+            specialHours: this.specialDayHours[n] || []
+          }];
+          break;
+        }
+      }
+      return e;
+    },
+    // Only when hiding weekdays on month and week views.
+    visibleDaysCount() {
+      return this.isDayView ? 1 : 7 - this.weekDays.reduce((t, e) => t + e.hide, 0);
+    },
+    cellWidth() {
+      return 100 / this.visibleDaysCount;
+    },
+    cssClasses() {
+      const { resizeAnEvent: t, dragAnEvent: e, dragCreateAnEvent: s } = this.domEvents;
+      return {
+        [`vuecal--${this.view.id}-view`]: !0,
+        [`vuecal--${this.locale}`]: this.locale,
+        "vuecal--no-time": !this.time,
+        "vuecal--view-with-time": this.hasTimeColumn,
+        "vuecal--week-numbers": this.showWeekNumbers && this.isMonthView,
+        "vuecal--twelve-hour": this.twelveHour,
+        "vuecal--click-to-navigate": this.clickToNavigate,
+        "vuecal--hide-weekends": this.hideWeekends,
+        "vuecal--split-days": this.hasSplits,
+        "vuecal--sticky-split-labels": this.hasSplits && this.stickySplitLabels,
+        "vuecal--overflow-x": this.minCellWidth && this.isWeekView || this.hasSplits && this.minSplitWidth,
+        "vuecal--small": this.small,
+        "vuecal--xsmall": this.xsmall,
+        "vuecal--resizing-event": t._eid,
+        "vuecal--drag-creating-event": s.event,
+        "vuecal--dragging-event": e._eid,
+        "vuecal--events-on-month-view": this.eventsOnMonthView,
+        "vuecal--short-events": this.isMonthView && this.eventsOnMonthView === "short",
+        "vuecal--has-touch": typeof window < "u" && "ontouchstart" in window
+      };
+    },
+    isYearsOrYearView() {
+      return ["years", "year"].includes(this.view.id);
+    },
+    isYearsView() {
+      return this.view.id === "years";
+    },
+    isYearView() {
+      return this.view.id === "year";
+    },
+    isMonthView() {
+      return this.view.id === "month";
+    },
+    isWeekOrDayView() {
+      return ["week", "day"].includes(this.view.id);
+    },
+    isWeekView() {
+      return this.view.id === "week";
+    },
+    isDayView() {
+      return this.view.id === "day";
+    }
+  },
+  watch: {
+    events: {
+      // To be able to detect an event attribute change, it has to be first initialized with a value.
+      handler(t, e) {
+        this.updateMutableEvents(t), this.addEventsToView();
+      },
+      deep: !0
+    },
+    locale(t) {
+      this.loadLocale(t);
+    },
+    selectedDate(t) {
+      this.updateSelectedDate(t);
+    },
+    activeView(t) {
+      this.switchView(t);
+    }
+  }
+}, lt = /* @__PURE__ */ he(Gi, [["render", Xi]]), Ji = {
+  /**
+   * Unique identifier for the calendar component.
+   * - Use `hison.component.getCalendar(id)` to access methods at runtime.
+   * - ⚠️ Duplicate `id` values will throw an error at mount time.
+   */
+  id: { type: String, required: !1 },
+  /**
+   * Custom class applied to the calendar (string / array / object all supported).
+   * - Works with responsive classes like `hison-col-*`, `hison-size-*`, etc.
+   */
+  class: {
+    type: [String, Array, Object],
+    required: !1
+  },
+  /**
+   * Inline style for the calendar (string, object, or an array of objects).
+   */
+  style: {
+    type: [String, Object, Array],
+    required: !1
+  },
+  /**
+   * Controls visibility of the calendar.
+   * - true: visible / false: display: none
+   */
+  visible: { type: Boolean, default: !0 },
+  /**
+   * Whether the calendar is disabled (selection blocked + dimmed style).
+   */
+  disable: { type: Boolean, default: !1 },
+  /**
+   * Initially selected date.
+   * - String (e.g. '2025-01-01') or Date
+   */
+  selectedDate: {
+    type: [String, Date],
+    default: () => /* @__PURE__ */ new Date()
+  },
+  /**
+   * Array of calendar events to display.
+   */
+  events: {
+    type: Array,
+    default: () => []
+  },
+  /**
+   * Weekend header background color (CSS color).
+   */
+  weekendColor: { type: String, required: !1 },
+  /**
+   * Weekend day indexes (0..6). Example: [0,6] for Sun/Sat.
+   */
+  weekendDays: {
+    type: Array,
+    required: !1,
+    validator: (t) => Array.isArray(t) && t.every((e) => Number.isInteger(e) && e >= 0 && e <= 6)
+  },
+  /**
+   * Whether to highlight today's cell background.
+   */
+  showTodayColor: { type: Boolean, default: !0 },
+  /**
+   * Selected date cell background color (CSS color).
+   */
+  selectedColor: { type: String, required: !1 },
+  /**
+   * Time highlight blocks per day.
+   */
+  specialTime: {
+    type: Object,
+    required: !1
+  },
+  /**
+   * Min height (px) for date cells in 'month' view.
+   */
+  dateCellMinHeight: { type: Number, required: !1 },
+  /**
+   * Max height (px) for date cells in 'month' view (enables scroll).
+   */
+  dateCellMaxHeight: { type: Number, required: !1 },
+  /**
+   * Disabled (non-selectable) date strings. Example: ['2025-06-26']
+   */
+  disableDays: {
+    type: Array,
+    required: !1,
+    default: void 0
+  },
+  /**
+   * Controls how events are shown in the month view.
+   * - false  : show only count
+   * - 'short': show titles only
+   * - true or any other string: show full details
+   */
+  eventsOnMonthView: {
+    type: [String, Boolean],
+    default: !1
+  },
+  /**
+   * Weekday indexes (0..6) to hide.
+   */
+  hideWeekdays: {
+    type: Array,
+    required: !1,
+    validator: (t) => Array.isArray(t) && t.every((e) => Number.isInteger(e) && e >= 0 && e <= 6)
+  },
+  /**
+   * Whether to hide weekends (Sat/Sun).
+   */
+  hideWeekends: { type: Boolean, default: !1 },
+  /**
+   * Calendar locale. Example: 'en', 'ko', 'fr'.
+   */
+  locale: { type: String, default: "en" },
+  /**
+   * Max selectable date (string or Date).
+   */
+  maxDate: { type: [String, Date], required: !1 },
+  /**
+   * Min selectable date (string or Date).
+   */
+  minDate: { type: [String, Date], required: !1 },
+  /**
+   * Week starts on Sunday (true) or Monday (false).
+   */
+  startWeekOnSunday: { type: Boolean, default: !1 },
+  /**
+   * Whether to display time-axis in week/day view.
+   */
+  time: { type: Boolean, default: !0 },
+  /**
+   * Time cell height in week/day view (px).
+   */
+  timeCellHeight: { type: Number, required: !1 },
+  /**
+   * Time label format (overrides twelveHour if provided).
+   * - Accepts enum or literal string (with Volar completion).
+   */
+  timeFormat: {
+    type: String,
+    required: !1,
+    validator: (t) => t == null || kt.includes(t)
+  },
+  /**
+   * Time axis start (minutes from 0..1440).
+   */
+  timeFrom: {
+    type: Number,
+    required: !1,
+    validator: (t) => t == null || Number.isFinite(t) && t >= 0 && t <= 1440
+  },
+  /**
+   * Time axis step (minutes).
+   */
+  timeStep: {
+    type: Number,
+    required: !1,
+    validator: (t) => t == null || Number.isFinite(t) && t > 0 && t <= 1440
+  },
+  /**
+   * Time axis end (minutes from 0..1440).
+   */
+  timeTo: {
+    type: Number,
+    required: !1,
+    validator: (t) => t == null || Number.isFinite(t) && t >= 0 && t <= 1440
+  },
+  /**
+   * Hide title bar (month/year & nav).
+   */
+  hideTitleBar: { type: Boolean, default: !1 },
+  /**
+   * Use 12-hour clock with AM/PM labels.
+   * - Ignored if `timeFormat` is set.
+   */
+  twelveHour: { type: Boolean, default: !1 },
+  /**
+   * Initial view mode of the calendar.
+   * - Accepts enum or literal ('day' | 'week' | 'month' | 'year' | 'years')
+   */
+  activeView: {
+    type: String,
+    required: !1,
+    validator: (t) => t == null || Ze.includes(t)
+  },
+  /**
+   * List of views to disable in navigation.
+   * - All values must be in ('day'|'week'|'month'|'year'|'years')
+   */
+  disableViews: {
+    type: Array,
+    required: !1,
+    validator: (t) => t == null || Array.isArray(t) && t.every((e) => Ze.includes(e))
+  }
+}, Zi = wt({
+  name: "HCalendar",
+  components: { VueCal: lt },
+  props: Ji,
+  emits: [
+    "responsive-change",
+    "cell-click",
+    "view-change",
+    "mounted"
+  ],
+  setup(t, { emit: e, attrs: s }) {
+    const l = t.id || Ct(), r = `hcalendar:${l}`, i = b(null), o = b(null), n = _t(), h = Dt(), d = Ie(() => Object.keys(h)), c = b(t.visible), y = b(t.disable), w = Ie(() => c.value ? "" : "hison-display-none"), A = Ie(() => y.value ? "hison-disable-calendar" : ""), g = b(P.utils.getJSDateObject(t.selectedDate) ?? /* @__PURE__ */ new Date()), Y = g.value, j = b(t.events ?? []), _ = b(t.weekendColor ? ue(t.weekendColor) : void 0), B = b(t.weekendDays), O = b(t.selectedColor ? ue(t.selectedColor) : void 0), q = b(t.showTodayColor), Q = b(t.specialTime ?? {}), ne = b(t.dateCellMinHeight), ee = b(t.dateCellMaxHeight), ve = b(t.disableDays), me = b(t.eventsOnMonthView), ye = b(t.hideWeekdays), fe = b(t.hideWeekends), we = b(t.locale), K = b(
+      y.value ? "100-01-01" : t.maxDate
+    ), te = b(t.minDate), re = b(t.startWeekOnSunday), De = b(t.time), ge = b(t.timeCellHeight), pe = b(t.timeFormat), be = b(t.timeFrom), ke = b(t.timeStep), Ce = b(t.timeTo), _e = b(t.hideTitleBar), Te = b(t.twelveHour), Ne = b(t.activeView), Me = b(t.disableViews), X = b([]), ie = () => {
+      var a;
+      if (X.value = Tt(Mt(t.class) || "", n.value), St(X.value, "col") === -1 && X.value.push("hison-col-12"), Qe(X.value, "size", C.componentStyle.size), Qe(X.value, "color", "primary"), (a = i.value) != null && a.$el) {
+        const u = i.value.$el;
+        let f = Ve(X.value, "color");
+        const W = Ve(X.value, "size");
+        switch ((!f || !$e(f)) && (f = "primary"), u.style.setProperty("--vuecal-filled-back-color", C.componentStyle.componentColor[`${f}`].buttonColor), u.style.setProperty("--vuecal-filled-font-color", C.componentStyle.componentColor[`${f}`].filledTextColor), C.componentStyle.invertColor ? (u.style.setProperty("--vuecal-empty-back-color", C.componentStyle.emptyInvertColor), u.style.setProperty("--vuecal-empty-font-color", C.componentStyle.emptyTextInvertColor), u.style.setProperty("--vuecal-empty-disabled-color", R(C.componentStyle.emptyTextInvertColor, 0.3)), u.style.setProperty("--vuecal-empty-out-of-scope-font-color", R(C.componentStyle.emptyTextInvertColor, 0.5)), u.style.setProperty("--vuecal-selected-back-color", O.value ? Ae(O.value) : R(C.componentStyle.componentColor[`${f}`].buttonColor, 0.5)), u.style.setProperty("--vuecal-weekend-back-color", _.value ? Ae(_.value) : null), u.style.setProperty("--vuecal-today-back-color", q.value ? R(C.componentStyle.componentColor[`${f}`].buttonColor, 0.3) : C.componentStyle.emptyInvertColor)) : (u.style.setProperty("--vuecal-empty-back-color", C.componentStyle.emptyColor), u.style.setProperty("--vuecal-empty-font-color", C.componentStyle.emptyTextColor), u.style.setProperty("--vuecal-empty-disabled-color", R(C.componentStyle.emptyTextColor, 0.3)), u.style.setProperty("--vuecal-empty-out-of-scope-font-color", R(C.componentStyle.emptyTextColor, 0.5)), u.style.setProperty("--vuecal-selected-back-color", O.value ? O.value : R(C.componentStyle.componentColor[`${f}`].buttonColor, 0.5)), u.style.setProperty("--vuecal-weekend-back-color", _.value ? _.value : null), u.style.setProperty("--vuecal-today-back-color", q.value ? R(C.componentStyle.componentColor[`${f}`].buttonColor, 0.3) : C.componentStyle.emptyColor)), W) {
+          case je.xl:
+            u.style.setProperty("--vuecal-header-font-size", "0.9em"), u.style.setProperty("--vuecal-title-button-font-size", "1em"), u.style.setProperty("--vuecal-body-font-size", "0.9em"), u.style.setProperty("--vuecal-no-event-font-size", "0.8em");
+            break;
+          case je.l:
+            u.style.setProperty("--vuecal-header-font-size", "0.75em"), u.style.setProperty("--vuecal-title-button-font-size", "1em"), u.style.setProperty("--vuecal-body-font-size", "0.9em"), u.style.setProperty("--vuecal-no-event-font-size", "0.8em");
+            break;
+          case je.m:
+            u.style.setProperty("--vuecal-header-font-size", "0.7em"), u.style.setProperty("--vuecal-title-button-font-size", "0.6em"), u.style.setProperty("--vuecal-body-font-size", "0.8em"), u.style.setProperty("--vuecal-no-event-font-size", "0.7em");
+            break;
+          case je.s:
+            u.style.setProperty("--vuecal-header-font-size", "0.6em"), u.style.setProperty("--vuecal-title-button-font-size", "0.5em"), u.style.setProperty("--vuecal-body-font-size", "0.8em"), u.style.setProperty("--vuecal-no-event-font-size", "0.7em");
+            break;
+        }
+        u.style.setProperty("--calendar-clickable-cursor", y.value ? "not-allowed" : null);
+      }
+    }, ut = (a) => {
+      const u = /pm/i.test(a), f = /am/i.test(a), W = a.replace(/[^\d:]/g, "").trim();
+      let F = 0, J = 0;
+      if (W.includes(":")) {
+        const [I, le] = W.split(":");
+        F = parseInt(I, 10), J = parseInt(le, 10);
+      } else {
+        const I = parseInt(W, 10);
+        I <= 12 && (f || u) || I <= 23 ? F = I : J = I;
+      }
+      return u && F < 12 && (F += 12), f && F === 12 && (F = 0), F * 60 + J;
+    }, $ = (a) => {
+      if (!i.value) return;
+      const u = i.value.$el, f = a ?? P.utils.getJSDateObject(g.value);
+      if (Q.value && f) {
+        const W = f.getDay(), F = Q.value[W], J = u.querySelectorAll(".vuecal__time-cell");
+        J.length > 0 && F && Array.isArray(F) ? J.forEach((I) => {
+          const le = I.querySelector(".vuecal__time-cell-label");
+          if (le) {
+            const ht = le.textContent, Xe = ut(ht);
+            let Be = "";
+            F.some(({ from: vt, to: mt, className: yt }) => {
+              const Ge = vt <= Xe && Xe <= mt;
+              return Ge && (Be = yt ?? ""), Ge;
+            }) && I.classList.add(Be || "special_time");
+          }
+        }) : J.forEach((I) => {
+          I.classList.forEach((le) => {
+            le !== "vuecal__time-cell" && I.classList.remove(le);
+          });
+        });
+      }
+    }, se = (a) => {
+      if (a === de.month || a === de.week) {
+        const u = i.value.$el, f = B.value ? B.value : re.value ? [0, 6] : [5, 6], W = u.querySelectorAll(".vuecal__heading");
+        W.length > 0 && W.forEach((F, J) => {
+          f.includes(J) ? F.classList.add("weekend") : F.classList.remove("weekend");
+        });
+      }
+    }, Se = (a) => {
+      const u = i.value.$el;
+      u.style.setProperty("--vuecal-cell-content-min_heihgt", a === "month" && ne.value ? ne.value + "px" : null), u.style.setProperty("--vuecal-cell-content-max_heihgt", a === "month" && ee.value ? ee.value + "px" : null), u.style.setProperty("--vuecal-cell-content-overflow", a === "month" && ee.value ? "auto" : null);
+    }, Ue = (a) => {
+      if (!i.value) return;
+      const u = a ?? i.value.view.id;
+      _.value && Je(() => se(u)), Se(u);
+    }, dt = (a) => {
+      Ue(a.view), a.view === de.day ? $(a.startDate) : a.view === de.week && $(), Ne.value = a.view, e("view-change", a);
+    }, ct = (a) => {
+      var f;
+      const u = a instanceof Date ? a : a.date;
+      y.value ? (g.value = Y, (f = i.value) == null || f.updateSelectedDate(Y)) : (g.value = u, e("cell-click", u));
+    }, qe = () => {
+      C.component.calendarList[l] && C.component.calendarList[l].isHisonvueComponent && console.warn(`[Hisonvue] The calendar ID is at risk of being duplicated. ${l}`), Et(r, () => {
+        Ke(), Je(qe);
+      }), i.value && (ie(), $(), Ue(), o.value = {
+        isHisonvueComponent: !0,
+        getId: () => l,
+        getType: () => "calendar",
+        isDisable: () => y.value,
+        setDisable: (a) => {
+          y.value = a, y.value ? K.value = "100-01-01" : K.value = t.maxDate;
+        },
+        isVisible: () => c.value,
+        setVisible: (a) => {
+          c.value = a;
+        },
+        getSelectedDate: (a, u) => a ? g.value : P.utils.getDateWithFormat(g.value, u ?? P.getDatetimeFormat()),
+        setSelectedDate: (a) => {
+          const u = P.utils.getJSDateObject(a);
+          u && (g.value = u);
+        },
+        getEvents: () => j.value,
+        setEvents: (a) => {
+          j.value = a;
+        },
+        getSpecialTime: () => Q.value,
+        setSpecialTime: (a) => {
+          Q.value = a;
+        },
+        getWeekendColor: () => _.value,
+        setWeekendColor: (a) => {
+          if (_.value = ue(a), !i.value) return;
+          const u = i.value.$el;
+          u && (C.componentStyle.invertColor ? u.style.setProperty("--vuecal-weekend-back-color", _.value ? Ae(_.value) : null) : u.style.setProperty("--vuecal-weekend-back-color", _.value ? _.value : null), se(i.value.view.id));
+        },
+        getWeekendDays: () => B.value,
+        setWeekendDays: (a) => {
+          B.value = a, se(i.value.view.id);
+        },
+        isShowTodayColor: () => q.value,
+        setShowTodayColor: (a) => {
+          if (q.value = a, !i.value) return;
+          const u = i.value.$el;
+          if (!u) return;
+          let f = Ve(X.value, "color");
+          (!f || !$e(f)) && (f = "primary"), C.componentStyle.invertColor ? u.style.setProperty("--vuecal-today-back-color", q.value ? R(C.componentStyle.componentColor[`${f}`].buttonColor, 0.3) : C.componentStyle.emptyInvertColor) : u.style.setProperty("--vuecal-today-back-color", q.value ? R(C.componentStyle.componentColor[`${f}`].buttonColor, 0.3) : C.componentStyle.emptyColor);
+        },
+        getSelectedColor: () => O.value,
+        setSelectedColor: (a) => {
+          if (O.value = ue(a), !i.value) return;
+          const u = i.value.$el;
+          if (!u) return;
+          let f = Ve(X.value, "color");
+          C.componentStyle.invertColor ? u.style.setProperty("--vuecal-selected-back-color", O.value ? Ae(O.value) : R(C.componentStyle.componentColor[`${f}`].buttonColor, 0.5)) : u.style.setProperty("--vuecal-selected-back-color", O.value ? O.value : R(C.componentStyle.componentColor[`${f}`].buttonColor, 0.5));
+        },
+        getDateCellMinHeight: () => ne.value,
+        setDateCellMinHeight: (a) => {
+          ne.value = a, Se(i.value.view.id);
+        },
+        getDateCellMaxHeight: () => ee.value,
+        setDateCellMaxHeight: (a) => {
+          ee.value = a, Se(i.value.view.id);
+        },
+        getDisableDays: () => ve.value,
+        setDisableDays: (a) => {
+          ve.value = a;
+        },
+        getEventsOnMonthView: () => me.value,
+        setEventsOnMonthView: (a) => {
+          me.value = a;
+        },
+        getHideWeekdays: () => ye.value,
+        setHideWeekdays: (a) => {
+          ye.value = a;
+        },
+        getHideWeekends: () => fe.value,
+        setHideWeekends: (a) => {
+          fe.value = a;
+        },
+        getLocale: () => we.value,
+        setLocale: (a) => {
+          we.value = a;
+        },
+        getMaxDate: (a) => {
+          if (K.value)
+            return a ? y.value ? new Date(100, 0, 1) : P.utils.getJSDateObject(K.value) : y.value ? "100-01-01" : P.utils.getDateWithFormat(K.value, P.getDateFormat());
+        },
+        setMaxDate: (a) => {
+          K.value = a;
+        },
+        getMinDate: (a) => {
+          if (te.value)
+            return a ? P.utils.getJSDateObject(te.value) : P.utils.getDateWithFormat(te.value, P.getDateFormat());
+        },
+        setMinDate: (a) => {
+          te.value = a;
+        },
+        isStartWeekOnSunday: () => re.value,
+        setStartWeekOnSunday: (a) => {
+          re.value = a, se(i.value.view.id);
+        },
+        isShowTimeCell: () => De.value,
+        setShowTimeCell: (a) => {
+          De.value = a;
+        },
+        getTimeCellHeight: () => ge.value,
+        setTimeCellHeight: (a) => {
+          ge.value = a;
+        },
+        getTimeFormat: () => pe.value,
+        setTimeFormat: (a) => {
+          pe.value = a;
+        },
+        getTimeFrom: () => be.value,
+        setTimeFrom: (a) => {
+          be.value = a;
+        },
+        getTimeStep: () => ke.value,
+        setTimeStep: (a) => {
+          ke.value = a;
+        },
+        getTimeTo: () => Ce.value,
+        setTimeTo: (a) => {
+          Ce.value = a;
+        },
+        isHideTitleBar: () => _e.value,
+        setHideTitleBar: (a) => {
+          _e.value = a;
+        },
+        isTwelveHour: () => Te.value,
+        setTwelveHour: (a) => {
+          Te.value = a;
+        },
+        getActiveView: () => i.value.view.id,
+        setActiveView: (a) => {
+          i.value.switchView(a);
+        },
+        getDisableViews: () => Me.value,
+        setDisableViews: (a) => {
+          if (Me.value = a, a.includes(i.value.view.id)) {
+            const u = ["years", "year", "month", "week", "day"].filter((f) => !a.includes(f));
+            i.value.switchView(u[0]);
+          }
+        },
+        reload: () => Ht(r)
+      }, C.component.calendarList[l] = o.value, e("mounted", o.value));
+    }, Ke = () => {
+      Ot(r), delete C.component.calendarList[l];
+    };
+    return gt(qe), pt(Ke), p(n, (a) => {
+      ie(), e("responsive-change", a);
+    }), p(() => g.value, () => {
+      $();
+    }), p(() => t.selectedDate, (a) => {
+      g.value = P.utils.getJSDateObject(a) ?? /* @__PURE__ */ new Date(), $();
+    }), p(() => t.events, (a) => {
+      j.value = a;
+    }), p(() => t.visible, (a) => {
+      a !== c.value && (c.value = !!a);
+    }), p(() => t.disable, (a) => {
+      const u = !!a;
+      u !== y.value && (y.value = u, K.value = u ? "100-01-01" : t.maxDate, ie());
+    }), p(() => g.value, () => $()), p(() => t.selectedDate, (a) => {
+      const u = P.utils.getJSDateObject(a) ?? /* @__PURE__ */ new Date();
+      +u != +g.value && (g.value = u, $());
+    }), p(() => t.events, (a) => {
+      a !== j.value && (j.value = a ?? []);
+    }), p(() => t.weekendColor, (a) => {
+      var f, W;
+      const u = a ? ue(a) : void 0;
+      u !== _.value && (_.value = u, ie(), (W = (f = i.value) == null ? void 0 : f.view) != null && W.id && se(i.value.view.id));
+    }), p(() => t.weekendDays, (a) => {
+      var u, f;
+      a && a !== B.value && (B.value = a, (f = (u = i.value) == null ? void 0 : u.view) != null && f.id && se(i.value.view.id));
+    }), p(() => t.selectedColor, (a) => {
+      const u = a ? ue(a) : void 0;
+      u !== O.value && (O.value = u, ie());
+    }), p(() => t.showTodayColor, (a) => {
+      const u = !!a;
+      u !== q.value && (q.value = u, ie());
+    }), p(() => t.specialTime, (a) => {
+      a !== Q.value && (Q.value = a ?? {}, $());
+    }), p(() => t.dateCellMinHeight, (a) => {
+      var u, f;
+      a !== ne.value && (ne.value = a, Se(((f = (u = i.value) == null ? void 0 : u.view) == null ? void 0 : f.id) || de.month));
+    }), p(() => t.dateCellMaxHeight, (a) => {
+      var u, f;
+      a !== ee.value && (ee.value = a, Se(((f = (u = i.value) == null ? void 0 : u.view) == null ? void 0 : f.id) || de.month));
+    }), p(() => t.disableDays, (a) => {
+      a !== ve.value && (ve.value = a);
+    }), p(() => t.eventsOnMonthView, (a) => {
+      a !== me.value && (me.value = a);
+    }), p(() => t.hideWeekdays, (a) => {
+      a !== ye.value && (ye.value = a);
+    }), p(() => t.hideWeekends, (a) => {
+      const u = !!a;
+      u !== fe.value && (fe.value = u);
+    }), p(() => t.locale, (a) => {
+      a && a !== we.value && (we.value = a);
+    }), p(() => t.maxDate, (a) => {
+      !y.value && a !== K.value && (K.value = a);
+    }), p(() => t.minDate, (a) => {
+      a !== te.value && (te.value = a);
+    }), p(() => t.startWeekOnSunday, (a) => {
+      var f, W;
+      const u = !!a;
+      u !== re.value && (re.value = u, (W = (f = i.value) == null ? void 0 : f.view) != null && W.id && se(i.value.view.id));
+    }), p(() => t.time, (a) => {
+      const u = !!a;
+      u !== De.value && (De.value = u);
+    }), p(() => t.timeCellHeight, (a) => {
+      a !== ge.value && (ge.value = a);
+    }), p(() => t.timeFormat, (a) => {
+      a && a !== pe.value && (pe.value = a);
+    }), p(() => t.timeFrom, (a) => {
+      const u = Number(a);
+      (a == null || Number.isFinite(u) && u >= 0 && u <= 1440) && a !== be.value && (be.value = a);
+    }), p(() => t.timeStep, (a) => {
+      const u = Number(a);
+      (a == null || Number.isFinite(u) && u > 0 && u <= 1440) && a !== ke.value && (ke.value = a);
+    }), p(() => t.timeTo, (a) => {
+      const u = Number(a);
+      (a == null || Number.isFinite(u) && u >= 0 && u <= 1440) && a !== Ce.value && (Ce.value = a);
+    }), p(() => t.hideTitleBar, (a) => {
+      const u = !!a;
+      u !== _e.value && (_e.value = u);
+    }), p(() => t.twelveHour, (a) => {
+      const u = !!a;
+      u !== Te.value && (Te.value = u);
+    }), p(() => t.activeView, (a) => {
+      var u, f, W;
+      a && a !== ((f = (u = i.value) == null ? void 0 : u.view) == null ? void 0 : f.id) && (Ne.value = a, (W = i.value) == null || W.switchView(a));
+    }), p(() => t.disableViews, (a) => {
+      if (a !== Me.value && (Me.value = a, i.value && Array.isArray(a) && a.includes(i.value.view.id))) {
+        const u = ["years", "year", "month", "week", "day"].find((f) => !a.includes(f));
+        u && i.value.switchView(u);
+      }
+    }), p(() => t.class, () => ie()), {
+      VueCal: lt,
+      attrs: s,
+      props: t,
+      calendarRef: i,
+      visibleClass: w,
+      disableClass: A,
+      responsiveClassList: X,
+      slotNames: d,
+      selectedDate: g,
+      events: j,
+      disableDays: ve,
+      eventsOnMonthView: me,
+      hideWeekdays: ye,
+      hideWeekends: fe,
+      locale: we,
+      maxDate: K,
+      minDate: te,
+      startWeekOnSunday: re,
+      time: De,
+      timeCellHeight: ge,
+      timeFormat: pe,
+      timeFrom: be,
+      timeStep: ke,
+      timeTo: Ce,
+      hideTitleBar: _e,
+      twelveHour: Te,
+      activeView: Ne,
+      disableViews: Me,
+      onViewChange: dt,
+      onCellClick: ct
+    };
+  }
+});
+function Qi(t, e, s, l, r, i) {
+  return v(), m("div", {
+    class: V([
+      "hison-calendar",
+      "hison-wrapper",
+      ...t.responsiveClassList,
+      t.visibleClass,
+      t.disableClass
+    ]),
+    style: z(t.props.style)
+  }, [
+    (v(), G(at(t.VueCal), Re({ ref: "calendarRef" }, t.attrs, {
+      "selected-date": t.selectedDate,
+      events: t.events,
+      "dblclick-to-create": !1,
+      "editable-events": !1,
+      "disable-days": t.disableDays,
+      "events-on-month-view": t.eventsOnMonthView,
+      "hide-weekdays": t.hideWeekdays,
+      "hide-weekends": t.hideWeekends,
+      locale: t.locale,
+      "max-date": t.maxDate,
+      "min-date": t.minDate,
+      "start-week-on-sunday": t.startWeekOnSunday,
+      time: t.time,
+      "time-cell-height": t.timeCellHeight,
+      "time-format": t.timeFormat,
+      "time-from": t.timeFrom,
+      "time-step": t.timeStep,
+      "time-to": t.timeTo,
+      "hide-title-bar": t.hideTitleBar,
+      "twelve-hour": t.twelveHour,
+      "active-view": t.activeView,
+      "disable-views": t.disableViews,
+      onViewChange: t.onViewChange,
+      onCellClick: t.onCellClick
+    }), Le({ _: 2 }, [
+      N(t.slotNames, (o) => ({
+        name: o,
+        fn: T((n) => [
+          k(t.$slots, o, ze(bt(n)), void 0, !0)
+        ])
+      }))
+    ]), 1040, ["selected-date", "events", "disable-days", "events-on-month-view", "hide-weekdays", "hide-weekends", "locale", "max-date", "min-date", "start-week-on-sunday", "time", "time-cell-height", "time-format", "time-from", "time-step", "time-to", "hide-title-bar", "twelve-hour", "active-view", "disable-views", "onViewChange", "onCellClick"]))
+  ], 6);
+}
+const ss = /* @__PURE__ */ Wt(Zi, [["render", Qi], ["__scopeId", "data-v-4c9eb363"]]);
+export {
+  ss as default
+};