@bagelink/vue 0.0.1218 → 0.0.1220

package/dist/index.cjs

@@ -47,7 +47,7 @@ const bagelFormUtils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defi
     return uploadField;
   }
 }, Symbol.toStringTag, { value: "Module" }));
-const _sfc_main$17 = /* @__PURE__ */ vue.defineComponent({
+const _sfc_main$1m = /* @__PURE__ */ vue.defineComponent({
   __name: "Accordion",
   setup(__props) {
     const state2 = vue.reactive({
@@ -61,10 +61,10 @@ const _sfc_main$17 = /* @__PURE__ */ vue.defineComponent({
     };
   }
 });
-const _hoisted_1$W = ["aria-expanded", "aria-controls"];
-const _hoisted_2$D = { class: "accordion-label" };
-const _hoisted_3$u = ["id", "aria-hidden"];
-const _sfc_main$16 = /* @__PURE__ */ vue.defineComponent({
+const _hoisted_1$19 = ["aria-expanded", "aria-controls"];
+const _hoisted_2$Q = { class: "accordion-label" };
+const _hoisted_3$F = ["id", "aria-hidden"];
+const _sfc_main$1l = /* @__PURE__ */ vue.defineComponent({
   __name: "AccordionItem",
   props: {
     label: {},
@@ -130,7 +130,7 @@ const _sfc_main$16 = /* @__PURE__ */ vue.defineComponent({
             vue.createVNode(vue.unref(_sfc_main$q), { icon: computedIcon.value }, null, 8, ["icon"])
           ], 2)) : vue.createCommentVNode("", true),
           vue.renderSlot(_ctx.$slots, "head", {}, () => [
-            vue.createElementVNode("span", _hoisted_2$D, vue.toDisplayString(_ctx.label), 1)
+            vue.createElementVNode("span", _hoisted_2$Q, vue.toDisplayString(_ctx.label), 1)
           ], true),
           iconPosition.value === "end" ? (vue.openBlock(), vue.createElementBlock("span", {
             key: 1,
@@ -138,7 +138,7 @@ const _sfc_main$16 = /* @__PURE__ */ vue.defineComponent({
           }, [
             vue.createVNode(vue.unref(_sfc_main$q), { icon: computedIcon.value }, null, 8, ["icon"])
           ], 2)) : vue.createCommentVNode("", true)
-        ], 8, _hoisted_1$W),
+        ], 8, _hoisted_1$19),
         vue.createVNode(vue.Transition, { name: "expand" }, {
           default: vue.withCtx(() => [
             vue.unref(isOpen) ? (vue.openBlock(), vue.createElementBlock("div", {
@@ -148,7 +148,7 @@ const _sfc_main$16 = /* @__PURE__ */ vue.defineComponent({
               "aria-hidden": vue.unref(isOpen) ? "false" : "true"
             }, [
               vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
-            ], 8, _hoisted_3$u)) : vue.createCommentVNode("", true)
+            ], 8, _hoisted_3$F)) : vue.createCommentVNode("", true)
           ]),
           _: 3
         })
@@ -163,9 +163,9 @@ const _export_sfc = (sfc, props2) => {
   }
   return target;
 };
-const AccordionItem = /* @__PURE__ */ _export_sfc(_sfc_main$16, [["__scopeId", "data-v-3334f637"]]);
-const _hoisted_1$V = { class: "relative" };
-const _sfc_main$15 = /* @__PURE__ */ vue.defineComponent({
+const AccordionItem = /* @__PURE__ */ _export_sfc(_sfc_main$1l, [["__scopeId", "data-v-3334f637"]]);
+const _hoisted_1$18 = { class: "relative" };
+const _sfc_main$1k = /* @__PURE__ */ vue.defineComponent({
   __name: "AddressSearch",
   emits: ["addressSelected"],
   setup(__props, { emit: __emit }) {
@@ -187,7 +187,7 @@ const _sfc_main$15 = /* @__PURE__ */ vue.defineComponent({
       (_a2 = suggestion.value) == null ? void 0 : _a2.show();
     }
     return (_ctx, _cache) => {
-      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$V, [
+      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$18, [
         vue.createVNode(vue.unref(_sfc_main$U), {
           ref_key: "suggestion",
           ref: suggestion,
@@ -223,11 +223,11 @@ const _sfc_main$15 = /* @__PURE__ */ vue.defineComponent({
     };
   }
 });
-const _hoisted_1$U = {
+const _hoisted_1$17 = {
   key: 1,
   class: "bgl_btn-flex"
 };
-const _sfc_main$14 = /* @__PURE__ */ vue.defineComponent({
+const _sfc_main$1j = /* @__PURE__ */ vue.defineComponent({
   __name: "Btn",
   props: {
     disabled: { type: Boolean, default: false },
@@ -293,7 +293,7 @@ const _sfc_main$14 = /* @__PURE__ */ vue.defineComponent({
             key: 0,
             class: "h-100p",
             size: "15"
-          })) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$U, [
+          })) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$17, [
             _ctx.icon ? (vue.openBlock(), vue.createBlock(vue.unref(_sfc_main$q), {
               key: 0,
               icon: _ctx.icon,
@@ -317,10 +317,10 @@ const _sfc_main$14 = /* @__PURE__ */ vue.defineComponent({
     };
   }
 });
-const Btn = /* @__PURE__ */ _export_sfc(_sfc_main$14, [["__scopeId", "data-v-7b18a02c"]]);
-const _hoisted_1$T = ["dismissable"];
-const _hoisted_2$C = { class: "m-0" };
-const _sfc_main$13 = /* @__PURE__ */ vue.defineComponent({
+const Btn = /* @__PURE__ */ _export_sfc(_sfc_main$1j, [["__scopeId", "data-v-7b18a02c"]]);
+const _hoisted_1$16 = ["dismissable"];
+const _hoisted_2$P = { class: "m-0" };
+const _sfc_main$1i = /* @__PURE__ */ vue.defineComponent({
   __name: "Alert",
   props: {
     message: {},
@@ -348,7 +348,7 @@ const _sfc_main$13 = /* @__PURE__ */ vue.defineComponent({
           size: 2,
           color: color2[_ctx.type]
         }, null, 8, ["icon", "color"])) : vue.createCommentVNode("", true),
-        vue.createElementVNode("p", _hoisted_2$C, vue.toDisplayString(_ctx.message), 1),
+        vue.createElementVNode("p", _hoisted_2$P, vue.toDisplayString(_ctx.message), 1),
         vue.createVNode(Btn, {
           flat: "",
           thin: "",
@@ -356,13 +356,13 @@ const _sfc_main$13 = /* @__PURE__ */ vue.defineComponent({
           icon: "close",
           onClick: _cache[0] || (_cache[0] = ($event) => isDismissed.value = true)
         })
-      ], 10, _hoisted_1$T)) : vue.createCommentVNode("", true);
+      ], 10, _hoisted_1$16)) : vue.createCommentVNode("", true);
     };
   }
 });
-const Alert = /* @__PURE__ */ _export_sfc(_sfc_main$13, [["__scopeId", "data-v-064bdd20"]]);
-const _hoisted_1$S = ["src", "alt"];
-const _sfc_main$12 = /* @__PURE__ */ vue.defineComponent({
+const Alert = /* @__PURE__ */ _export_sfc(_sfc_main$1i, [["__scopeId", "data-v-064bdd20"]]);
+const _hoisted_1$15 = ["src", "alt"];
+const _sfc_main$1h = /* @__PURE__ */ vue.defineComponent({
   __name: "Avatar",
   props: {
     fallback: {},
@@ -380,7 +380,7 @@ const _sfc_main$12 = /* @__PURE__ */ vue.defineComponent({
           key: 0,
           src: _ctx.src,
           alt: _ctx.name
-        }, null, 8, _hoisted_1$S)) : (vue.openBlock(), vue.createElementBlock("p", {
+        }, null, 8, _hoisted_1$15)) : (vue.openBlock(), vue.createElementBlock("p", {
           key: 1,
           style: vue.normalizeStyle({ "line-height": `${_ctx.size}px`, "font-size": `calc(1.5rem * ${_ctx.size} / 50)` })
         }, vue.toDisplayString((_ctx.fallback || vue.unref(initials)(_ctx.name || "")).toUpperCase()), 5))
@@ -388,8 +388,8 @@ const _sfc_main$12 = /* @__PURE__ */ vue.defineComponent({
     };
   }
 });
-const Avatar = /* @__PURE__ */ _export_sfc(_sfc_main$12, [["__scopeId", "data-v-46ad8c25"]]);
-const _sfc_main$11 = /* @__PURE__ */ vue.defineComponent({
+const Avatar = /* @__PURE__ */ _export_sfc(_sfc_main$1h, [["__scopeId", "data-v-46ad8c25"]]);
+const _sfc_main$1g = /* @__PURE__ */ vue.defineComponent({
   __name: "Badge",
   props: {
     color: {},
@@ -418,9 +418,9 @@ const _sfc_main$11 = /* @__PURE__ */ vue.defineComponent({
     };
   }
 });
-const Badge = /* @__PURE__ */ _export_sfc(_sfc_main$11, [["__scopeId", "data-v-689f051f"]]);
-const _hoisted_1$R = { key: 1 };
-const _sfc_main$10 = /* @__PURE__ */ vue.defineComponent({
+const Badge = /* @__PURE__ */ _export_sfc(_sfc_main$1g, [["__scopeId", "data-v-689f051f"]]);
+const _hoisted_1$14 = { key: 1 };
+const _sfc_main$1f = /* @__PURE__ */ vue.defineComponent({
   __name: "BglComponent",
   props: {
     field: {},
@@ -566,7 +566,7 @@ const _sfc_main$10 = /* @__PURE__ */ vue.defineComponent({
                   id: [props2.id, child.id].filter(Boolean).join("."),
                   field: child,
                   "parent-path": props2.id
-                }, null, 8, ["id", "field", "parent-path"])) : (vue.openBlock(), vue.createElementBlock("span", _hoisted_1$R, vue.toDisplayString(child), 1))
+                }, null, 8, ["id", "field", "parent-path"])) : (vue.openBlock(), vue.createElementBlock("span", _hoisted_1$14, vue.toDisplayString(child), 1))
               ], 64);
             }), 128))
           ], 64))
@@ -576,10 +576,10 @@ const _sfc_main$10 = /* @__PURE__ */ vue.defineComponent({
     };
   }
 });
-const _hoisted_1$Q = ["src"];
-const _hoisted_2$B = ["autoplay", "muted", "loop", "controls", "playsinline"];
-const _hoisted_3$t = ["src", "type"];
-const _sfc_main$$ = /* @__PURE__ */ vue.defineComponent({
+const _hoisted_1$13 = ["src"];
+const _hoisted_2$O = ["autoplay", "muted", "loop", "controls", "playsinline"];
+const _hoisted_3$E = ["src", "type"];
+const _sfc_main$1e = /* @__PURE__ */ vue.defineComponent({
   __name: "BglVideo",
   props: {
     src: {},
@@ -656,7 +656,7 @@ const _sfc_main$$ = /* @__PURE__ */ vue.defineComponent({
           allowfullscreen: "",
           title: "Video",
           allow: "autoplay"
-        }, null, 12, _hoisted_1$Q)) : _ctx.src ? (vue.openBlock(), vue.createElementBlock("video", {
+        }, null, 12, _hoisted_1$13)) : _ctx.src ? (vue.openBlock(), vue.createElementBlock("video", {
           key: 1,
           ref_key: "video",
           ref: video,
@@ -670,13 +670,3467 @@ const _sfc_main$$ = /* @__PURE__ */ vue.defineComponent({
           vue.createElementVNode("source", {
             src: _ctx.src,
             type: `video/${videoFormat.value}`
-          }, null, 8, _hoisted_3$t)
-        ], 12, _hoisted_2$B)) : vue.createCommentVNode("", true)
+          }, null, 8, _hoisted_3$E)
+        ], 12, _hoisted_2$O)) : vue.createCommentVNode("", true)
       ], 2);
     };
   }
 });
-const BglVideo = /* @__PURE__ */ _export_sfc(_sfc_main$$, [["__scopeId", "data-v-006552f6"]]);
+const BglVideo = /* @__PURE__ */ _export_sfc(_sfc_main$1e, [["__scopeId", "data-v-006552f6"]]);
+const _hoisted_1$12 = { class: "calendar-header" };
+const _hoisted_2$N = {
+  key: 0,
+  class: "calendar-header__period-name"
+};
+const _hoisted_3$D = { class: "flex gap-05" };
+const _hoisted_4$q = { class: "calendar-header__chevron-arrows" };
+const _hoisted_5$o = {
+  key: 0,
+  class: "calendar-header__mode-picker"
+};
+const _sfc_main$1d = /* @__PURE__ */ vue.defineComponent({
+  __name: "Header",
+  props: {
+    config: {
+      type: Object,
+      default: () => ({})
+    },
+    mode: {
+      type: String,
+      default: "week"
+    },
+    time: {
+      type: Object,
+      default: () => ({})
+    },
+    period: {
+      type: Object,
+      required: true
+    },
+    isSmall: {
+      type: Boolean,
+      required: true
+    }
+  },
+  emits: ["changeMode", "updatedPeriod"],
+  setup(__props, { emit: __emit }) {
+    const props2 = __props;
+    const emit2 = __emit;
+    const periodSelect = vue.ref();
+    const currentPeriod = vue.ref(props2.period);
+    const modeOptions = vue.ref(["month", "week", "day", "agenda"]);
+    const icons = {
+      chevronLeft: "chevron_left",
+      chevronRight: "chevron_right"
+    };
+    const periodName = vue.computed(() => {
+      if (props2.mode === "week") {
+        const startMonth = props2.time.getLocalizedNameOfMonth(
+          currentPeriod.value.start,
+          "short"
+        );
+        const endMonth = props2.time.getLocalizedNameOfMonth(
+          currentPeriod.value.end,
+          "short"
+        );
+        return startMonth === endMonth ? startMonth : `${startMonth} - ${endMonth}`;
+      }
+      return `${props2.time.getLocalizedNameOfMonth(
+        currentPeriod.value.selectedDate,
+        "short"
+      )} ${currentPeriod.value.selectedDate.getFullYear()}`;
+    });
+    const modeLocal = vue.ref(props2.mode);
+    const onlyDayModeIsEnabled = vue.computed(() => {
+      var _a2, _b;
+      const weekIsDisabled = (_a2 = props2.config.disableModes) == null ? void 0 : _a2.includes("week");
+      const monthIsDisabled = (_b = props2.config.disableModes) == null ? void 0 : _b.includes("month");
+      return props2.config.disableModes && weekIsDisabled && monthIsDisabled;
+    });
+    vue.watch(() => props2.isSmall, (value) => {
+      if (value) modeOptions.value = ["month", "day"];
+      else modeOptions.value = ["month", "week", "day", "agenda"];
+    }, { immediate: true });
+    function dateToPeriod(selectedDate) {
+      const period = {
+        start: /* @__PURE__ */ new Date(),
+        end: /* @__PURE__ */ new Date(),
+        selectedDate
+      };
+      if (props2.mode === "week") {
+        period.start = props2.time.getCalendarWeekDateObjects(selectedDate)[0];
+        period.end = props2.time.getCalendarWeekDateObjects(selectedDate)[6];
+      } else if (props2.mode === "month") {
+        period.start = new Date(selectedDate.getFullYear(), selectedDate.getMonth(), 1);
+        period.end = new Date(selectedDate.getFullYear(), selectedDate.getMonth() + 1, 0);
+      } else {
+        period.start = selectedDate;
+        period.end = selectedDate;
+      }
+      return period;
+    }
+    function handlePeriodChange() {
+      if (!currentPeriod.value) return;
+      currentPeriod.value = dateToPeriod(currentPeriod.value.selectedDate);
+      emit2("updatedPeriod", currentPeriod.value);
+    }
+    function goToPeriod(direction) {
+      const date2 = currentPeriod.value.selectedDate;
+      if (props2.mode === "month") {
+        date2.setMonth(direction === "previous" ? date2.getMonth() - 1 : date2.getMonth() + 1);
+      } else if (props2.mode === "week") {
+        date2.setDate(direction === "previous" ? date2.getDate() - 7 : date2.getDate() + 7);
+      } else {
+        date2.setDate(direction === "previous" ? date2.getDate() - 1 : date2.getDate() + 1);
+      }
+      currentPeriod.value = dateToPeriod(date2);
+      emit2("updatedPeriod", currentPeriod.value);
+    }
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$12, [
+        periodName.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2$N, vue.toDisplayString(periodName.value), 1)) : vue.createCommentVNode("", true),
+        vue.createElementVNode("div", _hoisted_3$D, [
+          vue.createElementVNode("div", _hoisted_4$q, [
+            vue.createVNode(vue.unref(_sfc_main$q), {
+              class: "calendar-header__chevron-arrow calendar-header__chevron-arrow-left",
+              icon: icons.chevronLeft,
+              onClick: _cache[0] || (_cache[0] = ($event) => goToPeriod("previous"))
+            }, null, 8, ["icon"]),
+            vue.createVNode(vue.unref(_sfc_main$q), {
+              class: "calendar-header__chevron-arrow calendar-header__chevron-arrow-right",
+              icon: icons.chevronRight,
+              onClick: _cache[1] || (_cache[1] = ($event) => goToPeriod("next"))
+            }, null, 8, ["icon"])
+          ]),
+          vue.createVNode(vue.unref(DatePick), {
+            ref_key: "periodSelect",
+            ref: periodSelect,
+            modelValue: currentPeriod.value.selectedDate,
+            "onUpdate:modelValue": [
+              _cache[2] || (_cache[2] = ($event) => currentPeriod.value.selectedDate = $event),
+              handlePeriodChange
+            ],
+            mode: __props.mode
+          }, null, 8, ["modelValue", "mode"]),
+          !onlyDayModeIsEnabled.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_5$o, [
+            vue.createVNode(vue.unref(TabsNav), {
+              modelValue: modeLocal.value,
+              "onUpdate:modelValue": [
+                _cache[3] || (_cache[3] = ($event) => modeLocal.value = $event),
+                _cache[4] || (_cache[4] = ($event) => emit2("changeMode", $event))
+              ],
+              tabs: modeOptions.value,
+              group: "mode"
+            }, null, 8, ["modelValue", "tabs"])
+          ])) : vue.createCommentVNode("", true)
+        ])
+      ]);
+    };
+  }
+});
+const AppHeader = /* @__PURE__ */ _export_sfc(_sfc_main$1d, [["__scopeId", "data-v-34cb97da"]]);
+class EDate extends Date {
+  get fullYear() {
+    return this.getFullYear();
+  }
+  get month() {
+    return this.getMonth();
+  }
+  get date() {
+    return this.getDate();
+  }
+}
+var DAY_TIME_POINT = /* @__PURE__ */ ((DAY_TIME_POINT2) => {
+  DAY_TIME_POINT2[DAY_TIME_POINT2["MIDNIGHT"] = 0] = "MIDNIGHT";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["ONE_AM"] = 100] = "ONE_AM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["TWO_AM"] = 200] = "TWO_AM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["THREE_AM"] = 300] = "THREE_AM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["FOUR_AM"] = 400] = "FOUR_AM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["FIVE_AM"] = 500] = "FIVE_AM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["SIX_AM"] = 600] = "SIX_AM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["SEVEN_AM"] = 700] = "SEVEN_AM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["EIGHT_AM"] = 800] = "EIGHT_AM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["NINE_AM"] = 900] = "NINE_AM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["TEN_AM"] = 1e3] = "TEN_AM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["ELEVEN_AM"] = 1100] = "ELEVEN_AM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["TWELVE_PM"] = 1200] = "TWELVE_PM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["ONE_PM"] = 1300] = "ONE_PM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["TWO_PM"] = 1400] = "TWO_PM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["THREE_PM"] = 1500] = "THREE_PM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["FOUR_PM"] = 1600] = "FOUR_PM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["FIVE_PM"] = 1700] = "FIVE_PM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["SIX_PM"] = 1800] = "SIX_PM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["SEVEN_PM"] = 1900] = "SEVEN_PM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["EIGHT_PM"] = 2e3] = "EIGHT_PM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["NINE_PM"] = 2100] = "NINE_PM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["TEN_PM"] = 2200] = "TEN_PM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["ELEVEN_PM"] = 2300] = "ELEVEN_PM";
+  DAY_TIME_POINT2[DAY_TIME_POINT2["TWELVE_AM"] = 2400] = "TWELVE_AM";
+  return DAY_TIME_POINT2;
+})(DAY_TIME_POINT || {});
+var DAY_MODE = /* @__PURE__ */ ((DAY_MODE2) => {
+  DAY_MODE2["REGULAR"] = "regular";
+  DAY_MODE2["SHORTENED"] = "shortened";
+  DAY_MODE2["FLEXIBLE"] = "flexible";
+  return DAY_MODE2;
+})(DAY_MODE || {});
+const EVENT_COLORS = {
+  yellow: "rgb(244, 180, 0)",
+  blue: "rgb(38, 132, 255)",
+  green: "rgb(51, 182, 121)",
+  red: "rgb(255, 84, 86)",
+  pink: "rgb(239, 139, 239)",
+  purple: "rgb(157, 114, 245)",
+  turquoise: "rgb(64, 190, 190)",
+  brown: "rgb(169, 99, 30)"
+};
+const DATE_TIME_STRING_PATTERN = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/;
+const DATE_TIME_STRING_FULL_DAY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+class Helpers {
+  /**
+   * If navigator.languages is present (correlating to the browser's Accept-Language header), then use it
+   * otherwise just use navigator.language
+   */
+  static getBrowserNavigatorLocale() {
+    if (typeof navigator !== "object") return "en-US";
+    return navigator.languages && navigator.languages.length ? navigator.languages[0] : navigator.language;
+  }
+  /**
+   * Solution from https://github.com/vuejs/core/issues/4733#issuecomment-1024816095
+   */
+  static hasSlotContent(slot) {
+    if (!slot) return false;
+    return slot().some((vnode) => {
+      if (vnode.type === vue.Comment) return false;
+      if (Array.isArray(vnode.children) && !vnode.children.length) return false;
+      return vnode.type !== vue.Text || typeof vnode.children === "string" && vnode.children.trim() !== "";
+    });
+  }
+  static getEventType(event, time) {
+    const isTimedEvent = DATE_TIME_STRING_PATTERN.test(event.time.start) && DATE_TIME_STRING_PATTERN.test(event.time.end);
+    const isFullDayEvent = DATE_TIME_STRING_FULL_DAY_PATTERN.test(event.time.start) && DATE_TIME_STRING_FULL_DAY_PATTERN.test(event.time.end);
+    if (isTimedEvent) return this.getTimedEventType(event, time);
+    if (isFullDayEvent) return this.getFullDayEventType(event, time);
+    throw new Error("Event has invalid type");
+  }
+  static getTimedEventType(event, time) {
+    if (time.dateStringsHaveEqualDates(event.time.start, event.time.end)) {
+      return "SINGLE_DAY_TIMED";
+    }
+    if (time.dayMode === DAY_MODE.FLEXIBLE) {
+      const endBoundaryForSingleHybridDay = time.setHourInDateTimeString(
+        time.addDaysToDateTimeString(
+          1,
+          time.dateStringFrom(event.time.start)
+        ),
+        Time.getHourFromTimePoints(time.DAY_END)
+      );
+      if (event.time.end < endBoundaryForSingleHybridDay) {
+        return "SINGLE_HYBRID_DAY_TIMED";
+      }
+    }
+    return "MULTI_DAY_TIMED";
+  }
+  static getFullDayEventType(event, time) {
+    if (time.dateStringsHaveEqualDates(event.time.start, event.time.end)) {
+      return "SINGLE_DAY_FULL_DAY";
+    }
+    return "MULTI_DAY_FULL_DAY";
+  }
+  static isUIEventTouchEvent(event) {
+    return "touches" in event && typeof event.touches === "object";
+  }
+}
+var WEEK_START_DAY = /* @__PURE__ */ ((WEEK_START_DAY2) => {
+  WEEK_START_DAY2["SUNDAY"] = "sunday";
+  WEEK_START_DAY2["MONDAY"] = "monday";
+  return WEEK_START_DAY2;
+})(WEEK_START_DAY || {});
+class Time {
+  constructor(firstDayOfWeek = "monday", locale2 = null, dayBoundaries = { start: 0, end: 2400 }) {
+    __publicField(this, "FIRST_DAY_OF_WEEK");
+    __publicField(this, "CALENDAR_LOCALE");
+    __publicField(this, "ALL_HOURS", [
+      0,
+      100,
+      200,
+      300,
+      400,
+      500,
+      600,
+      700,
+      800,
+      900,
+      1e3,
+      1100,
+      1200,
+      1300,
+      1400,
+      1500,
+      1600,
+      1700,
+      1800,
+      1900,
+      2e3,
+      2100,
+      2200,
+      2300
+    ]);
+    __publicField(this, "DAY_START");
+    __publicField(this, "DAY_END");
+    __publicField(this, "HOURS_PER_DAY", 24);
+    __publicField(this, "MS_PER_DAY");
+    this.FIRST_DAY_OF_WEEK = firstDayOfWeek;
+    this.CALENDAR_LOCALE = locale2 || Helpers.getBrowserNavigatorLocale();
+    this.DAY_START = dayBoundaries.start;
+    this.DAY_END = dayBoundaries.end;
+    this.HOURS_PER_DAY = (() => {
+      const dayEnd = Time.getHourFromTimePoints(this.DAY_END);
+      const dayStart = Time.getHourFromTimePoints(this.DAY_START);
+      if (dayEnd > dayStart) return dayEnd - dayStart;
+      return this.HOURS_PER_DAY - dayStart + dayEnd;
+    })();
+    this.MS_PER_DAY = 864e5;
+  }
+  get dayMode() {
+    if (this.DAY_START === 0 && this.DAY_END === 2400) return DAY_MODE.REGULAR;
+    if (this.DAY_START >= this.DAY_END) return DAY_MODE.FLEXIBLE;
+    return DAY_MODE.SHORTENED;
+  }
+  getDatesBetweenTwoDates(start, end) {
+    let arr = [];
+    let dt2 = new Date(start);
+    while (dt2 <= end) {
+      arr.push(new Date(dt2.getFullYear(), dt2.getMonth(), dt2.getDate()));
+      dt2.setDate(dt2.getDate() + 1);
+    }
+    return arr;
+  }
+  getCalendarWeekDateObjects(date2) {
+    let subtractedDaysToGetFirstDate;
+    if (this.FIRST_DAY_OF_WEEK === "sunday") {
+      subtractedDaysToGetFirstDate = date2.getDay();
+    } else {
+      subtractedDaysToGetFirstDate = date2.getDay() === 0 ? 6 : date2.getDay() - 1;
+    }
+    const dateOfFirstDayOfWeek = date2.getDate() - subtractedDaysToGetFirstDate;
+    const firstDay = new Date(
+      date2.getFullYear(),
+      date2.getMonth(),
+      dateOfFirstDayOfWeek
+    );
+    return this.getDatesBetweenTwoDates(
+      firstDay,
+      new Date(
+        firstDay.getFullYear(),
+        firstDay.getMonth(),
+        firstDay.getDate() + 6
+      )
+    );
+  }
+  /**
+   * Returns an array of the weeks that comprise a month
+   *
+   * @param {number} yyyy
+   * @param {number} mm - zero indexed (January === 0)
+   */
+  getCalendarMonthSplitInWeeks(yyyy, mm) {
+    const month = [];
+    const selectedDate = new Date(yyyy, mm, 1);
+    const firstDateOfMonth = new Date(
+      selectedDate.getFullYear(),
+      selectedDate.getMonth(),
+      1
+    );
+    const firstWeekOfMonth = this.getCalendarWeekDateObjects(firstDateOfMonth);
+    month.push(firstWeekOfMonth);
+    let isInMonth = true;
+    let mondayOfWeekToPush = firstWeekOfMonth[0];
+    const specifiedMonth = selectedDate.getMonth();
+    while (isInMonth) {
+      const newMonday = new Date(
+        mondayOfWeekToPush.getFullYear(),
+        mondayOfWeekToPush.getMonth(),
+        mondayOfWeekToPush.getDate() + 7
+      );
+      if (newMonday.getMonth() === specifiedMonth) {
+        month.push(this.getCalendarWeekDateObjects(newMonday));
+        mondayOfWeekToPush = newMonday;
+      } else {
+        isInMonth = false;
+      }
+    }
+    return month;
+  }
+  /**
+   * Returns an array with the length of 12 dates,
+   * one date for the first day of each month of the year
+   */
+  getCalendarYearMonths(year) {
+    const yearList = [];
+    let month = 0;
+    while (month <= 11) {
+      yearList.push(new Date(year, month, 1));
+      month++;
+    }
+    return yearList;
+  }
+  getHourAndMinutesFromTimePoints(timePoints) {
+    const time = timePoints.toString();
+    let hour = "0";
+    let minutes = "0";
+    if (time.length === 4) {
+      hour = time[0] + time[1];
+      minutes = time[2] + time[3];
+    } else if (time.length === 3) {
+      hour = time[0];
+      minutes = time[1] + time[2];
+    }
+    return {
+      hour: +hour,
+      minutes: +minutes
+    };
+  }
+  /**
+   * Given timePoints (0, 100, 200 etc.), this function returns
+   * a localized string with the respective hour
+   * (in en-US for example: 0 => 12 AM, 1600 => 4 PM )
+   */
+  getHourLocaleStringFromHourDigits(timePoints) {
+    const { hour, minutes } = this.getHourAndMinutesFromTimePoints(timePoints);
+    const hourLocaleString = new Date(
+      2100,
+      0,
+      1,
+      +hour,
+      +minutes,
+      0
+    ).toLocaleTimeString(this.CALENDAR_LOCALE, {
+      hour: "2-digit"
+    });
+    if (hourLocaleString[0] === "0") return hourLocaleString.substring(1);
+    return hourLocaleString;
+  }
+  getLocalizedNameOfWeekday(date2, weekdayNameLength = "short") {
+    return date2.toLocaleDateString(this.CALENDAR_LOCALE, {
+      weekday: weekdayNameLength
+    });
+  }
+  getLocalizedNameOfMonth(date2, monthNameLength = "short") {
+    return date2.toLocaleDateString(this.CALENDAR_LOCALE, {
+      month: monthNameLength
+    });
+  }
+  getLocalizedDateString(date2) {
+    return date2.toLocaleDateString(this.CALENDAR_LOCALE);
+  }
+  /**
+   * Takes a date object, and creates a time string from it, in the format of
+   * YYYY-MM-DD hh:mm
+   */
+  getDateTimeStringFromDate(date2, timeIsStartOrEndOfDay) {
+    const y2 = date2.getFullYear();
+    const m2 = date2.getMonth() + 1;
+    const d2 = date2.getDate();
+    const fullDate = `${y2}-${m2 >= 10 ? m2 : `0${m2}`}-${d2 >= 10 ? d2 : `0${d2}`}`;
+    if (!timeIsStartOrEndOfDay) {
+      const hour = date2.getHours();
+      const minutes = date2.getMinutes();
+      return `${fullDate} ${hour >= 10 ? hour : `0${hour}`}:${minutes >= 10 ? minutes : `0${minutes}`}`;
+    }
+    const fullTime = timeIsStartOrEndOfDay === "start" ? "00:00" : "23:59";
+    return `${fullDate} ${fullTime}`;
+  }
+  getLocalizedTime(dateTimeString) {
+    const {
+      year,
+      month,
+      date: date2,
+      hour,
+      minutes
+    } = this.getAllVariablesFromDateTimeString(dateTimeString);
+    const d2 = new Date(year, month, date2, hour, minutes);
+    return d2.toLocaleTimeString(this.CALENDAR_LOCALE, {
+      hour: "numeric",
+      minute: "numeric"
+    });
+  }
+  getLocalizedHour(date2) {
+    return date2.toLocaleTimeString(this.CALENDAR_LOCALE, { hour: "2-digit" });
+  }
+  getLocalizedTimeRange(start, end) {
+    return `${this.getLocalizedTime(start)} - ${this.getLocalizedTime(end)}`;
+  }
+  /**
+   * Returns numeric values for year, month, date, hour and minutes, given a dateTimeString
+   * All variables are Date-Object compatible, meaning "month" is zero-indexed
+   */
+  getAllVariablesFromDateTimeString(dateTimeString) {
+    return {
+      year: +dateTimeString.substring(0, 4),
+      month: +dateTimeString.substring(5, 7) - 1,
+      date: +dateTimeString.substring(8, 10),
+      hour: this.hourFrom(dateTimeString),
+      minutes: this.minutesFrom(dateTimeString)
+    };
+  }
+  dateIsToday(date2) {
+    const {
+      fullYear: yearToday,
+      month: monthToday,
+      date: dateToday
+    } = new EDate();
+    const {
+      fullYear: dateYear,
+      month: dateMonth,
+      date: dateDate
+    } = new EDate(date2);
+    return yearToday === dateYear && monthToday === dateMonth && dateToday === dateDate;
+  }
+  dateIsInWeek(dateToCheck, week) {
+    const { date: date2, month, fullYear } = new EDate(dateToCheck);
+    for (const weekDay of week) {
+      const dateIsSame = date2 === weekDay.getDate();
+      const monthIsSame = month === weekDay.getMonth();
+      const yearIsSame = fullYear === weekDay.getFullYear();
+      if (dateIsSame && monthIsSame && yearIsSame) return true;
+    }
+    return false;
+  }
+  getDateStringFromDate(date2) {
+    const yyyy = date2.getFullYear();
+    const mm = date2.getMonth() + 1;
+    const dd = date2.getDate();
+    return `${yyyy}-${mm >= 10 ? mm : `0${mm}`}-${dd >= 10 ? dd : `0${dd}`}`;
+  }
+  addMinutesToDateTimeString(minutes, dateTimeString) {
+    const {
+      year: oldYear,
+      month: oldMonth,
+      date: oldDate,
+      hour: oldHour,
+      minutes: oldMinutes
+    } = this.getAllVariablesFromDateTimeString(dateTimeString);
+    const oldDateObject = new Date(oldYear, oldMonth, oldDate, oldHour, oldMinutes);
+    const newDateObject = new Date(oldDateObject.getTime() + minutes * 6e4);
+    return this.getDateTimeStringFromDate(newDateObject);
+  }
+  addDaysToDateTimeString(days, dateTimeString) {
+    return this.addMinutesToDateTimeString(days * 1440, dateTimeString);
+  }
+  dateStringsHaveEqualDates(dateTimeString1, dateTimeString2) {
+    const { year: year1, month: month1, date: date1 } = this.getAllVariablesFromDateTimeString(dateTimeString1);
+    const { year: year2, month: month2, date: date2 } = this.getAllVariablesFromDateTimeString(dateTimeString2);
+    return year1 === year2 && month1 === month2 && date1 === date2;
+  }
+  setDateToEndOfDay(date2) {
+    return new Date(
+      date2.getFullYear(),
+      date2.getMonth(),
+      date2.getDate(),
+      23,
+      59,
+      59,
+      999
+    );
+  }
+  turnMinutesIntoPercentageOfHour(minutes) {
+    const oneMinutePercentage = 100 / 60;
+    const minutePoints = oneMinutePercentage * minutes;
+    if (minutePoints < 10) return `0${minutePoints}`;
+    return minutePoints.toString();
+  }
+  /**
+   * Every hour between 'dayStart' and 'dayEnd' is 100, in this function referred to as 100 points
+   * If an event starts 30 minutes after 'dayStart', it should have 50 pointsIntoDay
+   * If a day consists of 4 hours (400 points), we then have to count
+   * (50 / 400) * 100 = 12.5 => event starts after 12.5 percent of the day
+   *
+   * Result is supposed to be a number between 0 and 100, and is used for setting the CSS- top- and height-attributes for events
+   */
+  getPercentageOfDayFromDateTimeString(dateTimeString, dayStart, dayEnd) {
+    const hour = this.hourFrom(dateTimeString);
+    const hourPoints = hour * 100;
+    const minutes = +dateTimeString.substring(14, 16);
+    const minutesPoints = +this.turnMinutesIntoPercentageOfHour(+minutes);
+    if (dayEnd > dayStart) {
+      const pointsInDay2 = dayEnd - dayStart;
+      const eventPoints2 = hourPoints + minutesPoints;
+      const eventPointsIntoDay = eventPoints2 - dayStart;
+      return eventPointsIntoDay / pointsInDay2 * 100;
+    }
+    const hourPointsInOriginalDay = DAY_TIME_POINT.TWELVE_AM - dayStart;
+    const pointsInDay = hourPointsInOriginalDay + dayEnd;
+    const eventPoints = hourPoints + minutesPoints;
+    const pointsIntoDay = eventPoints >= dayStart ? eventPoints - dayStart : hourPointsInOriginalDay + eventPoints;
+    return pointsIntoDay / pointsInDay * 100;
+  }
+  getTimeFromClick(clickOffsetY, weekHeight) {
+    if (weekHeight <= 0) throw new Error("weekHeight cannot be a negative number");
+    if (clickOffsetY < 0) throw new Error("clickOffsetY cannot be a negative number");
+    const dayStartHour = this.DAY_START / 100;
+    const hourHeight = weekHeight / this.HOURS_PER_DAY;
+    const minutes = Math.floor(clickOffsetY % hourHeight / (hourHeight / 60));
+    if (this.DAY_END <= this.DAY_START) {
+      const dayEndHour = this.DAY_END / 100;
+      const nightHeight = dayEndHour * hourHeight;
+      const nightOffset = weekHeight - nightHeight;
+      if (clickOffsetY > nightOffset) {
+        const hour2 = Math.floor((clickOffsetY - nightOffset) / hourHeight);
+        return `${this.doubleDigit(hour2)}:${this.doubleDigit(minutes)}`;
+      }
+    }
+    const hour = Math.floor(clickOffsetY / hourHeight) + dayStartHour;
+    return `${this.doubleDigit(hour)}:${this.doubleDigit(minutes)}`;
+  }
+  setSegmentOfDateTimeString(dateTimeString, segments) {
+    if (segments.hour < 0 || segments.hour > 23) throw new Error("Invalid hour");
+    const newHour = this.doubleDigit(segments.hour);
+    dateTimeString = dateTimeString.replace(/\d{2}:/, `${newHour}:`);
+    return dateTimeString;
+  }
+  isTrailingOrLeadingDate(date2, month) {
+    const { month: dateMonth } = new EDate(date2);
+    return month !== dateMonth;
+  }
+  static getTimePointsFromHour(boundary) {
+    if (boundary < 0 || boundary > 24 || boundary % 1 !== 0) {
+      throw new Error("Invalid day boundary");
+    }
+    if (boundary === 0) return boundary;
+    return boundary * 100;
+  }
+  static getHourFromTimePoints(timePoints) {
+    if (timePoints < 0 || timePoints > 2400 || timePoints % 100 !== 0) {
+      throw new Error("Invalid time points");
+    }
+    if (timePoints === 0) return timePoints;
+    return timePoints / 100;
+  }
+  getTimelineHours() {
+    if (this.dayMode !== DAY_MODE.FLEXIBLE) {
+      return this.ALL_HOURS.filter((hour) => {
+        return hour >= this.DAY_START && hour < this.DAY_END;
+      });
+    }
+    return [
+      ...this.ALL_HOURS.filter((hour) => hour >= this.DAY_START),
+      ...this.ALL_HOURS.filter((hour) => hour < this.DAY_END)
+    ];
+  }
+  dateStringFrom(dateTimeString) {
+    return dateTimeString.substring(0, 10);
+  }
+  timeStringFrom(dateTimeString) {
+    return dateTimeString.substring(11, 16);
+  }
+  hourFrom(dateTimeString) {
+    return +dateTimeString.substring(11, 13);
+  }
+  minutesFrom(dateTimeString) {
+    return +dateTimeString.substring(14, 16);
+  }
+  areDaysConsecutive(dayOne, dayTwo) {
+    const dayOnePlusOneDay = this.dateStringFrom(this.addDaysToDateTimeString(1, dayOne));
+    return dayOnePlusOneDay === this.dateStringFrom(dayTwo);
+  }
+  setHourInDateTimeString(dateTimeString, hour) {
+    const hourString = this.doubleDigit(hour);
+    dateTimeString = dateTimeString.replace(/\d{2}:/, `${hourString}:`);
+    return dateTimeString;
+  }
+  setMinutesInDateTimeString(dateTimeString, minutes) {
+    const minutesString = this.doubleDigit(minutes);
+    dateTimeString = dateTimeString.replace(/:\d{2}/, `:${minutesString}`);
+    return dateTimeString;
+  }
+  getDateTimeStringDayBoundariesFrom(dateString) {
+    if (this.DAY_END <= this.DAY_START) {
+      const nextDay = this.addDaysToDateTimeString(1, dateString);
+      const endOfDay2 = this.setHourInDateTimeString(nextDay, this.getHourAndMinutesFromTimePoints(this.DAY_END).hour);
+      const startOfDay22 = this.setHourInDateTimeString(dateString, this.getHourAndMinutesFromTimePoints(this.DAY_START).hour);
+      return { start: startOfDay22, end: endOfDay2 };
+    }
+    const startOfDay2 = this.setHourInDateTimeString(dateString, this.getHourAndMinutesFromTimePoints(this.DAY_START).hour);
+    let endOfDay;
+    if (this.DAY_END === DAY_TIME_POINT.TWELVE_AM) {
+      endOfDay = this.setHourInDateTimeString(dateString, 23);
+      endOfDay = this.setMinutesInDateTimeString(endOfDay, 59);
+    } else {
+      endOfDay = this.setHourInDateTimeString(dateString, this.getHourAndMinutesFromTimePoints(this.DAY_END).hour);
+    }
+    return { start: startOfDay2, end: endOfDay };
+  }
+  doubleDigit(number2) {
+    if (number2 < 0 || number2 > 60) throw new Error("Invalid number. This is not a valid hour or minute");
+    return number2 < 10 ? `0${number2}` : String(number2);
+  }
+}
+class EventPosition extends Time {
+  /**
+   * Yields a full calendar week, with all full-day events positioned in it
+   */
+  positionFullDayEventsInWeek(weekStart, weekEnd, events) {
+    const eventsWithJSDates = events.map((scheduleEvent) => {
+      const { year: startYear, month: startMonth, date: startDate } = this.getAllVariablesFromDateTimeString(scheduleEvent.time.start);
+      const { year: endYear, month: endMonth, date: endDate } = this.getAllVariablesFromDateTimeString(scheduleEvent.time.end);
+      scheduleEvent.timeJS = {
+        start: new Date(startYear, startMonth, startDate),
+        end: new Date(endYear, endMonth, endDate)
+      };
+      return scheduleEvent;
+    }).sort((a2, b2) => {
+      if (a2.time.start < b2.time.start) return -1;
+      if (a2.time.start > b2.time.start) return 1;
+      return 0;
+    });
+    const allDatesOfWeek = this.getDatesBetweenTwoDates(weekStart, weekEnd);
+    const week = allDatesOfWeek.map((d2) => ({ date: d2 }));
+    for (const scheduleEvent of eventsWithJSDates) {
+      for (const [dayIndex, day] of week.entries()) {
+        const thisDayDateString = this.getDateStringFromDate(day.date);
+        if (this.getDateStringFromDate(scheduleEvent.timeJS.start) <= thisDayDateString && this.getDateStringFromDate(scheduleEvent.timeJS.end) >= thisDayDateString) {
+          let levelToStartOn = 1;
+          while (typeof week[dayIndex][`level${levelToStartOn}`] !== "undefined") {
+            levelToStartOn++;
+          }
+          let eventNDays = Math.ceil((scheduleEvent.timeJS.end.getTime() - day.date.getTime()) / this.MS_PER_DAY) + 1;
+          const remainingDaysOfWeek = week.length - dayIndex;
+          if (eventNDays > remainingDaysOfWeek) eventNDays = remainingDaysOfWeek;
+          week[dayIndex][`level${levelToStartOn}`] = {
+            ...scheduleEvent,
+            nDays: eventNDays
+            // Denotes the number of days to display in the week, not the actual number of days
+          };
+          for (let i2 = 1; i2 < eventNDays; i2++) {
+            week[dayIndex + i2][`level${levelToStartOn}`] = "blocked";
+          }
+          break;
+        }
+      }
+    }
+    const weekWithSortedLevelsInDays = [];
+    for (const day of week) {
+      weekWithSortedLevelsInDays.push(Object.keys(day).sort().reduce(
+        (obj, key) => {
+          obj[key] = day[key];
+          return obj;
+        },
+        {}
+      ));
+    }
+    return weekWithSortedLevelsInDays;
+  }
+  positionFullDayEventsInMonth(calendarMonth, fullDayEvents) {
+    const newMonth = [];
+    const flatMonth = calendarMonth.flat();
+    const monthMap = /* @__PURE__ */ new Map();
+    flatMonth.forEach((day) => monthMap.set(this.dateStringFrom(day.dateTimeString), day));
+    fullDayEvents = fullDayEvents.sort((a2, b2) => {
+      if (a2.time.start < b2.time.start) return 1;
+      if (a2.time.start > b2.time.start) return -1;
+      return 0;
+    });
+    for (const fullDayEvent of fullDayEvents) {
+      const { year: startYear, month: startMonth, date: startDate } = this.getAllVariablesFromDateTimeString(fullDayEvent.time.start);
+      const { year: endYear, month: endMonth, date: endDate } = this.getAllVariablesFromDateTimeString(fullDayEvent.time.end);
+      const allDatesOfEvent = this.getDatesBetweenTwoDates(
+        new Date(startYear, startMonth, startDate),
+        new Date(endYear, endMonth, endDate)
+      );
+      for (const date2 of allDatesOfEvent) {
+        const dateString = this.getDateStringFromDate(date2);
+        const dateInMap = monthMap.get(dateString);
+        if (dateInMap) {
+          monthMap.set(dateString, {
+            ...dateInMap,
+            // Since we're iterating over the fullDayEvents sorted backwards, the earliest events will end up first (which is the wanted behavior)
+            events: [fullDayEvent, ...dateInMap.events]
+          });
+        }
+      }
+    }
+    let weekIterator = 0;
+    monthMap.forEach((day) => {
+      if (!newMonth.length) {
+        newMonth.push([day]);
+      } else if (newMonth[weekIterator] && newMonth[weekIterator].length < 7) {
+        newMonth[weekIterator].push(day);
+      } else if (newMonth[weekIterator] && newMonth[weekIterator].length === 7) {
+        newMonth.push([day]);
+        weekIterator++;
+      }
+    });
+    return newMonth;
+  }
+}
+const calendarDomRectForVitest = {
+  x: 8,
+  y: 26,
+  width: 903,
+  height: 702,
+  top: 26,
+  right: 911,
+  bottom: 728,
+  left: 8
+};
+const EVENT_FLYOUT_WIDTH = 400;
+class EventFlyoutPosition {
+  calculateFlyoutPosition(eventElementDOMRect, flyoutDimensions, calendarDomRectParam = null) {
+    const calendarDomRect = calendarDomRectParam || calendarDomRectForVitest;
+    const spaceTop = eventElementDOMRect.top - calendarDomRect.top;
+    const spaceRight = calendarDomRect.right - eventElementDOMRect.right;
+    const spaceBottom = calendarDomRect.bottom - eventElementDOMRect.bottom;
+    const spaceLeft = eventElementDOMRect.left - calendarDomRect.left;
+    const flyoutNeededWidth = flyoutDimensions.width + 10;
+    const topWhenSpaceToBottomIsNegative = spaceBottom < 0 ? calendarDomRect.bottom - flyoutDimensions.height - 10 : null;
+    const topWhenSpaceTopIsNegative = spaceTop < 0 ? calendarDomRect.top + 10 : null;
+    if (spaceBottom > flyoutDimensions.height && spaceRight > flyoutNeededWidth) {
+      return {
+        top: topWhenSpaceTopIsNegative || Math.round(eventElementDOMRect.top),
+        left: Math.round(eventElementDOMRect.right) + 10
+      };
+    }
+    if (spaceTop > flyoutDimensions.height && spaceRight > flyoutNeededWidth) {
+      return {
+        top: topWhenSpaceToBottomIsNegative || Math.round(eventElementDOMRect.bottom) - flyoutDimensions.height,
+        left: Math.round(eventElementDOMRect.right) + 10
+      };
+    }
+    if (spaceLeft > flyoutNeededWidth && spaceBottom > flyoutDimensions.height) {
+      return {
+        top: topWhenSpaceTopIsNegative || eventElementDOMRect.top,
+        left: Math.round(
+          eventElementDOMRect.left - (flyoutDimensions.width + 10)
+        )
+      };
+    }
+    if (spaceLeft > flyoutNeededWidth && spaceTop > flyoutDimensions.height) {
+      return {
+        top: topWhenSpaceToBottomIsNegative || Math.round(eventElementDOMRect.bottom - flyoutDimensions.height),
+        left: Math.round(
+          eventElementDOMRect.left - (flyoutDimensions.width + 10)
+        )
+      };
+    }
+    if (spaceBottom < flyoutDimensions.height) {
+      return { top: calendarDomRect.bottom - flyoutDimensions.height, left: null };
+    }
+    return { top: eventElementDOMRect.top, left: null };
+  }
+}
+const _hoisted_1$11 = {
+  key: 0,
+  class: "event-flyout__relative-wrapper"
+};
+const _hoisted_2$M = { class: "event-flyout__menu" };
+const _hoisted_3$C = {
+  key: 0,
+  class: "event-flyout__menu-editable"
+};
+const _hoisted_4$p = { class: "event-flyout__menu-close" };
+const _hoisted_5$n = {
+  key: 0,
+  class: "event-flyout__info-wrapper"
+};
+const _hoisted_6$g = {
+  key: 0,
+  class: "event-flyout__row is-title"
+};
+const _hoisted_7$c = {
+  key: 1,
+  class: "event-flyout__row is-time"
+};
+const _hoisted_8$7 = {
+  key: 2,
+  class: "event-flyout__row is-location"
+};
+const _hoisted_9$5 = {
+  key: 3,
+  class: "event-flyout__row is-with"
+};
+const _hoisted_10$5 = {
+  key: 4,
+  class: "event-flyout__row is-topic"
+};
+const _hoisted_11$4 = {
+  key: 5,
+  class: "event-flyout__row is-description"
+};
+const _hoisted_12$4 = ["innerHTML"];
+const _sfc_main$1c = /* @__PURE__ */ vue.defineComponent({
+  __name: "EventFlyout",
+  props: {
+    calendarEventProp: {
+      type: Object,
+      default: () => ({})
+    },
+    eventElement: {
+      type: Object,
+      default: null
+    },
+    time: {
+      type: Object,
+      required: true
+    },
+    config: {
+      type: Object,
+      required: true
+    }
+  },
+  emits: ["hide", "editEvent", "deleteEvent"],
+  setup(__props, { emit: __emit }) {
+    vue.useCssVars((_ctx) => ({
+      "2bf9b46b": flyoutWidth
+    }));
+    const props2 = __props;
+    const emit2 = __emit;
+    const eventFlyoutPositionHelper = new EventFlyoutPosition();
+    const isVisible = vue.ref(false);
+    const top2 = vue.ref(0);
+    const left2 = vue.ref(0);
+    const calendarEvent = vue.ref(props2.calendarEventProp);
+    const flyoutWidth = `${EVENT_FLYOUT_WIDTH}px`;
+    const colors = EVENT_COLORS;
+    const icons = {
+      clock: "clock",
+      user: "user",
+      description: "comment",
+      trash: "delete",
+      edit: "edit",
+      times: "close",
+      topic: "help",
+      location: "location_on"
+    };
+    const getEventTime = vue.computed(() => {
+      if (!calendarEvent.value || !calendarEvent.value.time) return null;
+      const eventType = Helpers.getEventType(calendarEvent.value, props2.time);
+      if (["MULTI_DAY_TIMED"].includes(eventType)) {
+        const startLocalizedString = `${getDateFromDateString(
+          calendarEvent.value.time.start
+        )} ${props2.time.getLocalizedTime(calendarEvent.value.time.start)}`;
+        const endLocalizedString = `${getDateFromDateString(
+          calendarEvent.value.time.end
+        )} ${props2.time.getLocalizedTime(calendarEvent.value.time.end)}`;
+        return `${startLocalizedString} - ${endLocalizedString}`;
+      }
+      if (["SINGLE_DAY_FULL_DAY", "MULTI_DAY_FULL_DAY"].includes(eventType)) {
+        const startDate = getDateFromDateString(calendarEvent.value.time.start);
+        const endDate = getDateFromDateString(calendarEvent.value.time.end);
+        if (startDate === endDate) return startDate;
+        return `${startDate} - ${endDate}`;
+      }
+      const dateString = getDateFromDateString(calendarEvent.value.time.start);
+      const timeString = props2.time.getLocalizedTimeRange(
+        calendarEvent.value.time.start,
+        calendarEvent.value.time.end
+      );
+      return `${dateString} ⋅ ${timeString}`;
+    });
+    const eventFlyoutInlineStyles = vue.computed(() => {
+      if (typeof top2.value === "number" && !left2.value) {
+        return {
+          top: `${top2.value}px`,
+          left: "50%",
+          position: "fixed",
+          transform: "translateX(-50%)"
+        };
+      }
+      return {
+        top: `${top2.value}px`,
+        left: `${left2.value}px`,
+        position: "fixed"
+      };
+    });
+    const isEditable = vue.computed(() => {
+      var _a2;
+      return ((_a2 = props2.calendarEventProp) == null ? void 0 : _a2.isEditable) || false;
+    });
+    const eventBackgroundColor = vue.computed(() => {
+      var _a2, _b, _c;
+      if (((_a2 = calendarEvent.value) == null ? void 0 : _a2.colorScheme) && ((_b = props2.config.style) == null ? void 0 : _b.colorSchemes) && props2.config.style.colorSchemes[calendarEvent.value.colorScheme]) {
+        return props2.config.style.colorSchemes[calendarEvent.value.colorScheme].backgroundColor;
+      }
+      return colors[((_c = calendarEvent.value) == null ? void 0 : _c.color) || "blue"];
+    });
+    function setFlyoutPosition() {
+      var _a2, _b;
+      const calendar = (_a2 = props2.eventElement) == null ? void 0 : _a2.closest(".calendar-root");
+      const flyout = document.querySelector(".event-flyout");
+      if (!props2.eventElement) return;
+      const flyoutPosition = eventFlyoutPositionHelper.calculateFlyoutPosition(
+        (_b = props2.eventElement) == null ? void 0 : _b.getBoundingClientRect(),
+        {
+          height: (flyout == null ? void 0 : flyout.clientHeight) || 300,
+          width: (flyout == null ? void 0 : flyout.clientWidth) || 0
+        },
+        calendar ? calendar.getBoundingClientRect() : null
+      );
+      top2.value = typeof (flyoutPosition == null ? void 0 : flyoutPosition.top) === "number" ? flyoutPosition.top : null;
+      left2.value = typeof (flyoutPosition == null ? void 0 : flyoutPosition.left) === "number" ? flyoutPosition.left : null;
+    }
+    function editEvent() {
+      var _a2;
+      emit2("editEvent", (_a2 = calendarEvent.value) == null ? void 0 : _a2.id);
+      closeFlyout();
+    }
+    function deleteEvent() {
+      var _a2;
+      emit2("deleteEvent", (_a2 = calendarEvent.value) == null ? void 0 : _a2.id);
+      closeFlyout();
+    }
+    function closeFlyout() {
+      isVisible.value = false;
+      setTimeout(() => {
+        emit2("hide");
+      }, 100);
+    }
+    function getDateFromDateString(dateString) {
+      const { year, month, date: date2 } = props2.time.getAllVariablesFromDateTimeString(dateString);
+      return new Date(year, month, date2).toLocaleDateString(
+        props2.time.CALENDAR_LOCALE,
+        {
+          year: "numeric",
+          month: "long",
+          day: "numeric"
+        }
+      );
+    }
+    function closeFlyoutOnClickOutside(e) {
+      var _a2;
+      const flyout = document.querySelector(".event-flyout");
+      if (!flyout || !isVisible.value) return;
+      const isClickOutside = !flyout.contains(e.target);
+      const isClickOnEvent = !!e.target.closest(".is-event");
+      const closeOnClickOutside = ((_a2 = props2.config.eventDialog) == null ? void 0 : _a2.closeOnClickOutside) ?? true;
+      if (isVisible.value && isClickOutside && !isClickOnEvent && closeOnClickOutside) {
+        closeFlyout();
+      }
+    }
+    vue.watch(
+      () => props2.calendarEventProp,
+      (value) => {
+        setTimeout(() => {
+          calendarEvent.value = value;
+          isVisible.value = !!value;
+          vue.nextTick(() => {
+            setFlyoutPosition();
+          });
+        }, 10);
+      },
+      { deep: true }
+    );
+    vue.onMounted(() => {
+      document.addEventListener("click", closeFlyoutOnClickOutside);
+    });
+    vue.onBeforeUnmount(() => {
+      document.removeEventListener("click", closeFlyoutOnClickOutside);
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(["event-flyout p-05 bg-white", { "is-visible": isVisible.value, "is-not-editable": !isEditable.value }]),
+        style: vue.normalizeStyle(eventFlyoutInlineStyles.value)
+      }, [
+        !__props.config.eventDialog || !__props.config.eventDialog.isCustom ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$11, [
+          vue.createElementVNode("div", _hoisted_2$M, [
+            isEditable.value ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_3$C, [
+              vue.createVNode(vue.unref(_sfc_main$q), {
+                class: "event-flyout__menu-item is-edit-icon",
+                icon: icons.edit,
+                onClick: editEvent
+              }, null, 8, ["icon"]),
+              vue.createVNode(vue.unref(_sfc_main$q), {
+                class: "event-flyout__menu-item is-trash-icon",
+                icon: icons.trash,
+                onClick: deleteEvent
+              }, null, 8, ["icon"])
+            ])) : vue.createCommentVNode("", true),
+            vue.createElementVNode("span", _hoisted_4$p, [
+              vue.createVNode(vue.unref(_sfc_main$q), {
+                class: "event-flyout__menu-item is-times-icon",
+                icon: icons.times,
+                onClick: closeFlyout
+              }, null, 8, ["icon"])
+            ])
+          ]),
+          calendarEvent.value ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_5$n, [
+            calendarEvent.value.title ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_6$g, [
+              vue.createElementVNode("div", {
+                class: "event-flyout__color-icon",
+                style: vue.normalizeStyle({ backgroundColor: eventBackgroundColor.value })
+              }, null, 4),
+              vue.createTextVNode(" " + vue.toDisplayString(calendarEvent.value.title), 1)
+            ])) : vue.createCommentVNode("", true),
+            calendarEvent.value.time ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_7$c, vue.toDisplayString(getEventTime.value), 1)) : vue.createCommentVNode("", true),
+            calendarEvent.value.location ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_8$7, [
+              vue.createVNode(vue.unref(_sfc_main$q), {
+                icon: icons.location
+              }, null, 8, ["icon"]),
+              vue.createTextVNode(" " + vue.toDisplayString(calendarEvent.value.location), 1)
+            ])) : vue.createCommentVNode("", true),
+            calendarEvent.value.with ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_9$5, [
+              vue.createVNode(vue.unref(_sfc_main$q), {
+                icon: icons.user
+              }, null, 8, ["icon"]),
+              vue.createTextVNode(" " + vue.toDisplayString(calendarEvent.value.with), 1)
+            ])) : vue.createCommentVNode("", true),
+            calendarEvent.value.topic ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_10$5, [
+              vue.createVNode(vue.unref(_sfc_main$q), {
+                icon: icons.topic
+              }, null, 8, ["icon"]),
+              vue.createTextVNode(" " + vue.toDisplayString(calendarEvent.value.topic), 1)
+            ])) : vue.createCommentVNode("", true),
+            calendarEvent.value.description ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_11$4, [
+              vue.createVNode(vue.unref(_sfc_main$q), {
+                icon: icons.description
+              }, null, 8, ["icon"]),
+              vue.createElementVNode("p", {
+                innerHTML: calendarEvent.value.description
+              }, null, 8, _hoisted_12$4)
+            ])) : vue.createCommentVNode("", true)
+          ])) : vue.createCommentVNode("", true)
+        ])) : vue.renderSlot(_ctx.$slots, "default", {
+          key: 1,
+          eventDialogData: calendarEvent.value,
+          closeEventDialog: closeFlyout
+        })
+      ], 6);
+    };
+  }
+});
+const languageKeys = {
+  /** The following three keys, describe the calendar modes */
+  week: {
+    "it-IT": "Settimana",
+    "en-US": "Week",
+    "de-DE": "Woche",
+    "sv-SE": "Vecka",
+    "zh-CN": "周",
+    "pt-BR": "Semana",
+    "fr-FR": "Semaine",
+    "th-TH": "สัปดาห์",
+    "nl-NL": "Week",
+    "ru-RU": "Неделя",
+    "ar-YE": "إسبوع",
+    "es-ES": "Semana",
+    "ja-JP": "週",
+    "pl-PL": "Tydzień",
+    "hu-HU": "Hét"
+  },
+  month: {
+    "it-IT": "Mese",
+    "en-US": "Month",
+    "de-DE": "Monat",
+    "sv-SE": "Månad",
+    "zh-CN": "月",
+    "pt-BR": "Mês",
+    "fr-FR": "Mois",
+    "th-TH": "เดือน",
+    "nl-NL": "Maand",
+    "ru-RU": "Месяц",
+    "ar-YE": "شهر",
+    "es-ES": "Mes",
+    "ja-JP": "月",
+    "pl-PL": "Miesiąc",
+    "hu-HU": "Hónap"
+  },
+  day: {
+    "it-IT": "Giorno",
+    "en-US": "Day",
+    "de-DE": "Tag",
+    "sv-SE": "Dag",
+    "zh-CN": "日",
+    "pt-BR": "Dia",
+    "fr-FR": "Jour",
+    "th-TH": "วัน",
+    "nl-NL": "Dag",
+    "ru-RU": "День",
+    "ar-YE": "يوم",
+    "es-ES": "Día",
+    "ja-JP": "日",
+    "pl-PL": "Dzień",
+    "hu-HU": "Nap"
+  },
+  /** Other keys */
+  moreEvents: {
+    "it-IT": "+ altri eventi",
+    "en-US": "+ more events",
+    "de-DE": "+ weitere Ereignisse",
+    "sv-SE": "+ fler event",
+    "zh-CN": "列出其他结果",
+    "pt-BR": "+ mais eventos",
+    "fr-FR": "+ d'autres événements",
+    "th-TH": "+ เหตุการณ์เพิ่มเติม",
+    "nl-NL": "meer evenementen",
+    "ru-RU": "+ ещё события",
+    "ar-YE": "+ المزيد من الأحداث",
+    "es-ES": "más eventos",
+    "ja-JP": "その他イベント",
+    "pl-PL": "+ więcej wydarzeń",
+    "hu-HU": "További események"
+  },
+  noEvent: {
+    "it-IT": "Nessun evento",
+    "en-US": "No events",
+    "de-DE": "Keine Ereignisse",
+    "sv-SE": "Inga event",
+    "zh-CN": "沒有活動",
+    "pt-BR": "Sem eventos",
+    "fr-FR": "Aucun Evènement",
+    "th-TH": "ไม่มีกิจกรรม",
+    "nl-NL": "Geen evenementen",
+    "ru-RU": "Нет событий",
+    "ar-YE": "لا أحداث",
+    "es-ES": "No hay eventos",
+    "ja-JP": "イベントなし",
+    "pl-PL": "Brak wydarzeń",
+    "hu-HU": "Nincs esemény"
+  }
+};
+const localeMap = /* @__PURE__ */ new Map([
+  ["de", "de-DE"],
+  ["en", "en-US"],
+  ["it", "it-IT"],
+  ["sv", "sv-SE"],
+  ["zh", "zh-CN"],
+  ["pt", "pt-BR"],
+  ["fr", "fr-FR"],
+  ["th", "th-TH"],
+  ["nl", "nl-NL"],
+  ["ru", "ru-RU"],
+  ["ar", "ar-YE"],
+  ["es", "es-ES"],
+  ["ja", "ja-JP"],
+  ["pl", "pl-PL"],
+  ["hu", "hu-HU"]
+]);
+function overrideShortLocaleWithLongLocale(locale2) {
+  if (localeMap.has(locale2)) {
+    locale2 = localeMap.get(locale2);
+  }
+  return locale2;
+}
+function getLanguage(languageKeys2, locale2) {
+  locale2 = overrideShortLocaleWithLongLocale(locale2);
+  return languageKeys2[locale2] ? languageKeys2[locale2] : languageKeys2["en-US"];
+}
+const _hoisted_1$10 = ["id"];
+const _hoisted_2$L = {
+  key: 0,
+  class: "agenda__event-time"
+};
+const _hoisted_3$B = { class: "agenda__event-title" };
+const _hoisted_4$o = {
+  key: 1,
+  class: "agenda__event-with"
+};
+const _hoisted_5$m = {
+  key: 2,
+  class: "agenda__event-location"
+};
+const eventIdPrefix$1 = "agenda__event-";
+const _sfc_main$1b = /* @__PURE__ */ vue.defineComponent({
+  __name: "AgendaEventTile",
+  props: {
+    time: {
+      type: Object,
+      required: true
+    },
+    calendarEvent: {
+      type: Object,
+      required: true
+    },
+    config: {
+      type: Object,
+      required: true
+    }
+  },
+  emits: ["eventWasClicked"],
+  setup(__props, { emit: __emit }) {
+    vue.useCssVars((_ctx) => ({
+      "6b656230": eventBackgroundColor.value,
+      "2507007e": eventColor.value
+    }));
+    const props2 = __props;
+    const emit2 = __emit;
+    const icons = {
+      clock: "clock",
+      user: "user",
+      description: "comment",
+      trash: "delete",
+      edit: "pen-to-square",
+      times: "close",
+      topic: "question-circle",
+      location: "location_on"
+    };
+    const colors = EVENT_COLORS;
+    const eventBackgroundColor = vue.ref("");
+    const eventColor = vue.ref("#fff");
+    const eventTime = vue.computed(() => {
+      return DATE_TIME_STRING_PATTERN.test(props2.calendarEvent.time.start) ? props2.time.getLocalizedTimeRange(
+        props2.calendarEvent.time.start,
+        props2.calendarEvent.time.end
+      ) : null;
+    });
+    const elementId = vue.computed(() => {
+      return eventIdPrefix$1 + props2.calendarEvent.id;
+    });
+    function setColors() {
+      var _a2;
+      if (props2.calendarEvent.colorScheme && ((_a2 = props2.config.style) == null ? void 0 : _a2.colorSchemes) && props2.config.style.colorSchemes[props2.calendarEvent.colorScheme]) {
+        eventColor.value = props2.config.style.colorSchemes[props2.calendarEvent.colorScheme].color;
+        eventBackgroundColor.value = props2.config.style.colorSchemes[props2.calendarEvent.colorScheme].backgroundColor;
+        return;
+      }
+      if (props2.calendarEvent.color) {
+        eventBackgroundColor.value = colors[props2.calendarEvent.color];
+        return;
+      }
+      eventBackgroundColor.value = colors.blue;
+    }
+    function handleClickOnEvent() {
+      const eventElement = document.getElementById(elementId.value);
+      emit2("eventWasClicked", {
+        clickedEvent: props2.calendarEvent,
+        eventElement
+      });
+    }
+    vue.onMounted(() => {
+      setColors();
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        id: elementId.value,
+        class: "agenda__event is-event",
+        onClick: vue.withModifiers(handleClickOnEvent, ["prevent"])
+      }, [
+        eventTime.value && !__props.calendarEvent.originalEvent ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_2$L, [
+          vue.createVNode(vue.unref(_sfc_main$q), {
+            icon: icons.clock
+          }, null, 8, ["icon"]),
+          vue.createTextVNode(" " + vue.toDisplayString(eventTime.value), 1)
+        ])) : vue.createCommentVNode("", true),
+        vue.createElementVNode("span", _hoisted_3$B, vue.toDisplayString(__props.calendarEvent.title), 1),
+        __props.calendarEvent.with ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_4$o, [
+          vue.createVNode(vue.unref(_sfc_main$q), {
+            icon: icons.user
+          }, null, 8, ["icon"]),
+          vue.createTextVNode(" " + vue.toDisplayString(__props.calendarEvent.with), 1)
+        ])) : vue.createCommentVNode("", true),
+        __props.calendarEvent.location ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_5$m, [
+          vue.createVNode(vue.unref(_sfc_main$q), {
+            icon: icons.location
+          }, null, 8, ["icon"]),
+          vue.createTextVNode(" " + vue.toDisplayString(__props.calendarEvent.location), 1)
+        ])) : vue.createCommentVNode("", true)
+      ], 8, _hoisted_1$10);
+    };
+  }
+});
+const AgendaEventTile = /* @__PURE__ */ _export_sfc(_sfc_main$1b, [["__scopeId", "data-v-eb2ab566"]]);
+const _hoisted_1$$ = { class: "agenda__wrapper" };
+const _hoisted_2$K = { class: "agenda__header" };
+const _hoisted_3$A = { class: "agenda__header-day-name" };
+const _hoisted_4$n = { class: "agenda__header-date" };
+const _hoisted_5$l = { class: "agenda__content" };
+const _hoisted_6$f = {
+  key: 0,
+  class: "is-empty"
+};
+const _hoisted_7$b = {
+  key: 1,
+  class: "agenda__content-events-list"
+};
+const _sfc_main$1a = /* @__PURE__ */ vue.defineComponent({
+  __name: "AgendaEvents",
+  props: {
+    config: {
+      type: Object,
+      required: true
+    },
+    time: {
+      type: Object,
+      required: true
+    },
+    day: {
+      type: Object,
+      required: true
+    }
+  },
+  emits: ["eventWasClicked"],
+  setup(__props, { emit: __emit }) {
+    const emit2 = __emit;
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$$, [
+        vue.createElementVNode("header", _hoisted_2$K, [
+          vue.createElementVNode("div", _hoisted_3$A, vue.toDisplayString(__props.day.dayName), 1),
+          vue.createElementVNode("div", _hoisted_4$n, vue.toDisplayString(__props.day.dateTimeString.substring(8, 10)), 1)
+        ]),
+        vue.createElementVNode("div", _hoisted_5$l, [
+          __props.day.events.length === 0 ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_6$f, vue.toDisplayString(vue.unref(getLanguage)(vue.unref(languageKeys).noEvent, __props.time.CALENDAR_LOCALE)), 1)) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_7$b, [
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(__props.day.events, (dayEvent) => {
+              return vue.openBlock(), vue.createBlock(AgendaEventTile, {
+                key: `agenda_event_${dayEvent.id}`,
+                day: __props.day,
+                config: __props.config,
+                "calendar-event": dayEvent,
+                time: __props.time,
+                onEventWasClicked: _cache[0] || (_cache[0] = ($event) => emit2("eventWasClicked", $event))
+              }, null, 8, ["day", "config", "calendar-event", "time"]);
+            }), 128))
+          ]))
+        ])
+      ]);
+    };
+  }
+});
+const AgendaEvents = /* @__PURE__ */ _export_sfc(_sfc_main$1a, [["__scopeId", "data-v-25f23df1"]]);
+const _hoisted_1$_ = {
+  key: 0,
+  class: "calendar-month__event"
+};
+const _hoisted_2$J = ["id", "draggable"];
+const _hoisted_3$z = ["id", "draggable"];
+const _hoisted_4$m = {
+  key: 0,
+  class: "calendar-month__event-time"
+};
+const _hoisted_5$k = { class: "calendar-month__event-title" };
+const eventIdPrefix = "calendar-month__event-";
+const _sfc_main$19 = /* @__PURE__ */ vue.defineComponent({
+  __name: "Event",
+  props: {
+    time: {
+      type: Object,
+      required: true
+    },
+    calendarEvent: {
+      type: Object,
+      required: true
+    },
+    config: {
+      type: Object,
+      required: true
+    },
+    day: {
+      type: Object,
+      required: true
+    }
+  },
+  emits: ["eventWasClicked"],
+  setup(__props, { emit: __emit }) {
+    vue.useCssVars((_ctx) => ({
+      "2920aa71": eventBackgroundColor.value
+    }));
+    const props2 = __props;
+    const emit2 = __emit;
+    const colors = vue.ref(EVENT_COLORS);
+    const eventBackgroundColor = vue.ref("");
+    const isCustomEvent = vue.computed(() => {
+      if (Array.isArray(props2.calendarEvent.isCustom)) {
+        return props2.calendarEvent.isCustom.includes("month");
+      }
+      return props2.calendarEvent.isCustom || false;
+    });
+    const eventTimeStart = vue.computed(() => {
+      return DATE_TIME_STRING_PATTERN.test(props2.calendarEvent.time.start) ? props2.time.getLocalizedTime(props2.calendarEvent.time.start) : null;
+    });
+    const elementId = vue.computed(() => eventIdPrefix + props2.calendarEvent.id + props2.time.dateStringFrom(props2.day.dateTimeString));
+    const elementDraggableAttribute = vue.computed(() => {
+      const {
+        year: startYear,
+        month: startMonth,
+        date: startDate
+      } = props2.time.getAllVariablesFromDateTimeString(props2.calendarEvent.time.start);
+      const {
+        year: endYear,
+        month: endMonth,
+        date: endDate
+      } = props2.time.getAllVariablesFromDateTimeString(props2.calendarEvent.time.end);
+      const eventIsSingleDay = startYear === endYear && startMonth === endMonth && startDate === endDate;
+      const dragAndDropIsDisabled = props2.calendarEvent.disableDnD && props2.calendarEvent.disableDnD.includes("month");
+      return props2.calendarEvent.isEditable && eventIsSingleDay && !dragAndDropIsDisabled ? true : void 0;
+    });
+    function setColors() {
+      var _a2;
+      if (props2.calendarEvent.colorScheme && ((_a2 = props2.config.style) == null ? void 0 : _a2.colorSchemes) && props2.config.style.colorSchemes[props2.calendarEvent.colorScheme]) {
+        return eventBackgroundColor.value = props2.config.style.colorSchemes[props2.calendarEvent.colorScheme].backgroundColor;
+      }
+      if (props2.calendarEvent.color) {
+        return eventBackgroundColor.value = colors.value[props2.calendarEvent.color];
+      }
+      return eventBackgroundColor.value = colors.value.blue;
+    }
+    function handleClickOnEvent() {
+      const eventElement = document.getElementById(elementId.value);
+      emit2("eventWasClicked", {
+        clickedEvent: props2.calendarEvent,
+        eventElement
+      });
+    }
+    function handleDragStart(dragEvent) {
+      if (!dragEvent || !dragEvent.dataTransfer) return;
+      dragEvent.dataTransfer.effectAllowed = "move";
+      dragEvent.dataTransfer.setData("json", JSON.stringify(props2.calendarEvent));
+    }
+    vue.onMounted(() => {
+      setColors();
+    });
+    return (_ctx, _cache) => {
+      return __props.config.isSmall ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$_)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+        isCustomEvent.value ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 0,
+          id: elementId.value,
+          class: vue.normalizeClass(["is-event", { "is-draggable": elementDraggableAttribute.value }]),
+          "data-ref": "custom-event",
+          draggable: elementDraggableAttribute.value,
+          onDragstart: handleDragStart,
+          onClick: handleClickOnEvent
+        }, [
+          vue.renderSlot(_ctx.$slots, "monthEvent", { eventData: __props.calendarEvent })
+        ], 42, _hoisted_2$J)) : (vue.openBlock(), vue.createElementBlock("div", {
+          key: 1,
+          id: elementId.value,
+          "data-ref": "default-event",
+          class: vue.normalizeClass(["calendar-month__event is-event", { "is-draggable": elementDraggableAttribute.value }]),
+          draggable: elementDraggableAttribute.value,
+          onDragstart: handleDragStart,
+          onClick: handleClickOnEvent
+        }, [
+          _cache[0] || (_cache[0] = vue.createElementVNode("span", { class: "calendar-month__event-color" }, null, -1)),
+          eventTimeStart.value && !__props.calendarEvent.originalEvent ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_4$m, vue.toDisplayString(eventTimeStart.value), 1)) : vue.createCommentVNode("", true),
+          vue.createElementVNode("span", _hoisted_5$k, vue.toDisplayString(__props.calendarEvent.title), 1)
+        ], 42, _hoisted_3$z))
+      ], 64));
+    };
+  }
+});
+const _hoisted_1$Z = ["id"];
+const _hoisted_2$I = { class: "calendar-month_events" };
+const _hoisted_3$y = {
+  key: 1,
+  class: "space-reserver"
+};
+const _sfc_main$18 = /* @__PURE__ */ vue.defineComponent({
+  __name: "Day",
+  props: {
+    config: {
+      type: Object,
+      required: true
+    },
+    time: {
+      type: Object,
+      required: true
+    },
+    day: {
+      type: Object,
+      required: true
+    },
+    isSelected: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: ["eventWasClicked", "eventWasDragged", "updatedPeriod", "dateWasClicked", "dayWasSelected"],
+  setup(__props, { emit: __emit }) {
+    const props2 = __props;
+    const emit2 = __emit;
+    const isActiveDroppable = vue.ref(false);
+    const canBeDropped = vue.computed(() => isActiveDroppable.value);
+    const hideLeadingAndTrailingDate = vue.computed(
+      () => {
+        var _a2;
+        return props2.day.isTrailingOrLeadingDate === true && ((_a2 = props2.config.month) == null ? void 0 : _a2.showTrailingAndLeadingDates) === false;
+      }
+    );
+    const isToday = vue.computed(() => {
+      const { year, month, date: date2 } = props2.time.getAllVariablesFromDateTimeString(props2.day.dateTimeString);
+      return props2.time.dateIsToday(new Date(year, month, date2));
+    });
+    function getMoreEvents() {
+      const { date: date2, month, year } = props2.time.getAllVariablesFromDateTimeString(props2.day.dateTimeString);
+      const selectedDate = new Date(year, month, date2);
+      const week = props2.time.getCalendarWeekDateObjects(selectedDate);
+      const start = week[0];
+      const end = week[6];
+      emit2("updatedPeriod", { start, end, selectedDate });
+    }
+    function handleDragLeave() {
+      isActiveDroppable.value = false;
+    }
+    function handleDragEnd(mouseEvent) {
+      isActiveDroppable.value = false;
+      mouseEvent.stopPropagation();
+    }
+    function handleDrop(dropEvent) {
+      isActiveDroppable.value = false;
+      dropEvent.stopPropagation();
+      if (!dropEvent || !dropEvent.dataTransfer) return;
+      const calendarEvent = JSON.parse(dropEvent.dataTransfer.getData("json"));
+      const eventDroppedOnSameDay = props2.time.dateStringsHaveEqualDates(
+        calendarEvent.time.start,
+        props2.time.dateStringFrom(props2.day.dateTimeString)
+      );
+      if (eventDroppedOnSameDay) return;
+      calendarEvent.time.start = calendarEvent.time.start.replace(
+        /^\d{4}-\d{2}-\d{2}/,
+        props2.time.dateStringFrom(props2.day.dateTimeString)
+      );
+      calendarEvent.time.end = calendarEvent.time.end.replace(
+        /^\d{4}-\d{2}-\d{2}/,
+        props2.time.dateStringFrom(props2.day.dateTimeString)
+      );
+      emit2("eventWasDragged", calendarEvent);
+    }
+    function handleDragOver(e) {
+      isActiveDroppable.value = true;
+      e.preventDefault();
+      return false;
+    }
+    function emitDayWasClicked() {
+      emit2("dateWasClicked", props2.time.dateStringFrom(props2.day.dateTimeString));
+      if (props2.config.isSmall) emit2("dayWasSelected", props2.day);
+    }
+    return (_ctx, _cache) => {
+      return !hideLeadingAndTrailingDate.value ? (vue.openBlock(), vue.createElementBlock("div", {
+        key: 0,
+        id: `day-${__props.time.dateStringFrom(__props.day.dateTimeString)}`,
+        class: vue.normalizeClass(["calendar-month__weekday", {
+          "is-droppable": canBeDropped.value,
+          "trailing-or-leading": __props.day.isTrailingOrLeadingDate,
+          "is-selected": __props.isSelected,
+          "is-today": isToday.value
+        }]),
+        onClick: vue.withModifiers(emitDayWasClicked, ["self"]),
+        onDragleave: handleDragLeave,
+        onDragover: handleDragOver,
+        onDrop: handleDrop,
+        onDragend: handleDragEnd
+      }, [
+        vue.renderSlot(_ctx.$slots, "dayCell", { dayData: __props.day }, () => [
+          vue.createElementVNode("span", {
+            class: "calendar-month__day-date",
+            onClick: emitDayWasClicked
+          }, vue.toDisplayString(__props.day.dateTimeString.substring(8, 10).startsWith("0") ? __props.day.dateTimeString.substring(9, 10) : __props.day.dateTimeString.substring(8, 10)), 1),
+          vue.createElementVNode("div", _hoisted_2$I, [
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(__props.day.events, (calendarEvent, index2) => {
+              return vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: index2 }, [
+                index2 < 3 ? (vue.openBlock(), vue.createBlock(_sfc_main$19, {
+                  key: calendarEvent.id,
+                  "calendar-event": calendarEvent,
+                  config: __props.config,
+                  time: __props.time,
+                  day: __props.day,
+                  onEventWasClicked: _cache[0] || (_cache[0] = ($event) => emit2("eventWasClicked", $event.clickedEvent))
+                }, {
+                  monthEvent: vue.withCtx((p2) => [
+                    vue.renderSlot(_ctx.$slots, "monthEvent", {
+                      eventData: p2.eventData
+                    }, void 0, true)
+                  ]),
+                  _: 2
+                }, 1032, ["calendar-event", "config", "time", "day"])) : vue.createCommentVNode("", true)
+              ], 64);
+            }), 128)),
+            __props.day.events.length >= 4 ? (vue.openBlock(), vue.createElementBlock("div", {
+              key: 0,
+              class: "calendar-month__weekday-more",
+              onClick: getMoreEvents
+            }, vue.toDisplayString(vue.unref(getLanguage)(vue.unref(languageKeys).moreEvents, __props.time.CALENDAR_LOCALE)), 1)) : vue.createCommentVNode("", true)
+          ])
+        ], true)
+      ], 42, _hoisted_1$Z)) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_3$y));
+    };
+  }
+});
+const Day$1 = /* @__PURE__ */ _export_sfc(_sfc_main$18, [["__scopeId", "data-v-057882e2"]]);
+const _hoisted_1$Y = { class: "calendar-month__day-name" };
+const _sfc_main$17 = /* @__PURE__ */ vue.defineComponent({
+  __name: "WeekDay",
+  props: {
+    day: {}
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("span", _hoisted_1$Y, vue.toDisplayString(_ctx.day.dayName), 1);
+    };
+  }
+});
+const WeekDay = /* @__PURE__ */ _export_sfc(_sfc_main$17, [["__scopeId", "data-v-d96cc47c"]]);
+const _hoisted_1$X = { class: "calendar-month" };
+const _hoisted_2$H = { class: "calendar-month__week-day-names" };
+const _hoisted_3$x = { class: "calendar-month__weeks" };
+const _hoisted_4$l = {
+  key: 0,
+  class: "calendar-month__day_events"
+};
+const _sfc_main$16 = /* @__PURE__ */ vue.defineComponent({
+  __name: "Month",
+  props: {
+    config: {
+      type: Object,
+      required: true
+    },
+    time: {
+      type: Object,
+      required: true
+    },
+    period: {
+      type: Object,
+      required: true
+    },
+    eventsProp: {
+      type: Array,
+      default: () => []
+    }
+  },
+  emits: ["editEvent", "deleteEvent", "updatedPeriod", "eventWasClicked", "eventWasDragged", "dateWasClicked"],
+  setup(__props, { emit: __emit }) {
+    const props2 = __props;
+    const emit2 = __emit;
+    const EventPositionHelper = new EventPosition();
+    const month = vue.ref([]);
+    const selectedEvent = vue.ref(null);
+    const selectedEventElement = vue.ref(null);
+    const events = vue.ref(props2.eventsProp);
+    const fullDayEvents = vue.ref([]);
+    const selectedDay = vue.ref(null);
+    function initMonth() {
+      month.value = [];
+      sortOutFullDayEvents();
+      setMonth2();
+      if (props2.config.isSmall) setInitialSelectedDay();
+    }
+    function setMonth2() {
+      const { month: currentMonth, fullYear } = new EDate(props2.period.selectedDate);
+      const calendarMonth = props2.time.getCalendarMonthSplitInWeeks(
+        fullYear,
+        currentMonth
+      );
+      const monthWithEvents = calendarMonth.map((week) => {
+        return week.map((day) => {
+          const dateTimeString = props2.time.getDateTimeStringFromDate(day);
+          const dayEvents = events.value.filter((event) => {
+            return props2.time.dateStringsHaveEqualDates(event.time.start, dateTimeString);
+          });
+          return {
+            isTrailingOrLeadingDate: props2.time.isTrailingOrLeadingDate(day, currentMonth),
+            dayName: props2.time.getLocalizedNameOfWeekday(day),
+            dateTimeString: props2.time.getDateTimeStringFromDate(day),
+            events: dayEvents
+          };
+        });
+      });
+      month.value = EventPositionHelper.positionFullDayEventsInMonth(
+        monthWithEvents,
+        fullDayEvents.value
+      );
+    }
+    function sortOutFullDayEvents() {
+      const timedEvents = [];
+      const fullDayEventsArray = [];
+      for (const calendarEvent of events.value) {
+        if (Helpers.getEventType(calendarEvent, props2.time) === "SINGLE_DAY_TIMED") {
+          timedEvents.push(calendarEvent);
+        } else {
+          fullDayEventsArray.push(calendarEvent);
+        }
+      }
+      events.value = timedEvents;
+      fullDayEvents.value = fullDayEventsArray;
+    }
+    function handleClickOnEvent(event) {
+      emit2("eventWasClicked", event);
+      selectedEventElement.value = event.eventElement;
+      selectedEvent.value = event.clickedEvent;
+    }
+    function handleEventWasDragged(calendarEvent) {
+      emit2("eventWasDragged", calendarEvent);
+      const newEvents = [...events.value, ...fullDayEvents.value].filter(
+        (e) => e.id !== calendarEvent.id
+      );
+      newEvents.push(calendarEvent);
+      events.value = [];
+      fullDayEvents.value = [];
+      events.value = newEvents;
+      initMonth();
+    }
+    function setInitialSelectedDay() {
+      const selectedDayDateString = props2.time.getDateStringFromDate(props2.period.selectedDate);
+      selectedDay.value = month.value.flat().find((day) => {
+        return props2.time.dateStringFrom(day.dateTimeString) === selectedDayDateString;
+      }) || null;
+    }
+    vue.onMounted(() => {
+      initMonth();
+    });
+    return (_ctx, _cache) => {
+      var _a2;
+      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$X, [
+        vue.createElementVNode("div", _hoisted_2$H, [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(month.value[0], (day, dayIndex) => {
+            return vue.openBlock(), vue.createBlock(WeekDay, {
+              key: dayIndex,
+              class: "calendar-month__week-day-name",
+              config: __props.config,
+              day,
+              time: __props.time
+            }, null, 8, ["config", "day", "time"]);
+          }), 128))
+        ]),
+        vue.createElementVNode("div", _hoisted_3$x, [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(month.value, (week, weekIndex) => {
+            return vue.openBlock(), vue.createElementBlock("div", {
+              key: weekIndex,
+              class: "calendar-month__week"
+            }, [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(week, (day, dayIndex) => {
+                var _a3;
+                return vue.openBlock(), vue.createBlock(Day$1, {
+                  key: dayIndex,
+                  config: __props.config,
+                  day,
+                  time: __props.time,
+                  "is-selected": ((_a3 = selectedDay.value) == null ? void 0 : _a3.dateTimeString) === day.dateTimeString,
+                  onEventWasClicked: handleClickOnEvent,
+                  onEventWasDragged: handleEventWasDragged,
+                  onDateWasClicked: _cache[0] || (_cache[0] = ($event) => emit2("dateWasClicked", $event)),
+                  onDayWasSelected: _cache[1] || (_cache[1] = ($event) => selectedDay.value = $event),
+                  onUpdatedPeriod: _cache[2] || (_cache[2] = ($event) => emit2("updatedPeriod", $event))
+                }, {
+                  monthEvent: vue.withCtx(({ eventData }) => [
+                    vue.renderSlot(_ctx.$slots, "monthEvent", { eventData })
+                  ]),
+                  dayCell: vue.withCtx(({ dayData }) => [
+                    vue.renderSlot(_ctx.$slots, "dayCell", { dayData })
+                  ]),
+                  _: 2
+                }, 1032, ["config", "day", "time", "is-selected"]);
+              }), 128))
+            ]);
+          }), 128))
+        ]),
+        !(((_a2 = __props.config.month) == null ? void 0 : _a2.showEventsOnMobileView) === false) ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_4$l, [
+          selectedDay.value ? (vue.openBlock(), vue.createBlock(AgendaEvents, {
+            key: 0,
+            config: __props.config,
+            time: __props.time,
+            day: selectedDay.value,
+            onEventWasClicked: handleClickOnEvent
+          }, null, 8, ["config", "time", "day"])) : vue.createCommentVNode("", true)
+        ])) : vue.createCommentVNode("", true),
+        !__props.config.eventDialog || !__props.config.eventDialog.isDisabled ? (vue.openBlock(), vue.createBlock(_sfc_main$1c, {
+          key: 1,
+          "calendar-event-prop": selectedEvent.value,
+          "event-element": selectedEventElement.value,
+          time: __props.time,
+          config: __props.config,
+          onHide: _cache[3] || (_cache[3] = ($event) => selectedEvent.value = null),
+          onEditEvent: _cache[4] || (_cache[4] = ($event) => emit2("editEvent", $event)),
+          onDeleteEvent: _cache[5] || (_cache[5] = ($event) => emit2("deleteEvent", $event))
+        }, {
+          default: vue.withCtx((p2) => [
+            vue.renderSlot(_ctx.$slots, "eventDialog", {
+              eventDialogData: p2.eventDialogData,
+              closeEventDialog: p2.closeEventDialog
+            })
+          ]),
+          _: 3
+        }, 8, ["calendar-event-prop", "event-element", "time", "config"])) : vue.createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+class EventsFilter {
+  constructor(events) {
+    this.events = events;
+  }
+  getEventsForDay(timeInstance, startDateTimeString) {
+    return this.events.filter((event) => this.isEventInDayBoundaries(event, timeInstance, startDateTimeString));
+  }
+  isEventInDayBoundaries(event, timeInstance, startDateTimeString) {
+    const eventIsInDay = timeInstance.dateStringFrom(event.time.start) === timeInstance.dateStringFrom(startDateTimeString);
+    if (timeInstance.dayMode === DAY_MODE.REGULAR) {
+      return eventIsInDay;
+    }
+    if (eventIsInDay && timeInstance.dayMode === DAY_MODE.SHORTENED) {
+      return this.handlePartialDayWithinOneDayBoundary(timeInstance, event);
+    }
+    if (timeInstance.dayMode === DAY_MODE.FLEXIBLE) {
+      return this.handleDayStretchingTwoDates(timeInstance, event, startDateTimeString, eventIsInDay);
+    }
+    return false;
+  }
+  handleDayStretchingTwoDates(timeInstance, event, startDateTimeString, eventIsInDay) {
+    const { hour: dayStartHour } = timeInstance.getHourAndMinutesFromTimePoints(timeInstance.DAY_START);
+    const { hour: dayEndHour } = timeInstance.getHourAndMinutesFromTimePoints(timeInstance.DAY_END);
+    const { hour: eventStartHour } = timeInstance.getAllVariablesFromDateTimeString(event.time.start);
+    const nextDay = timeInstance.addDaysToDateTimeString(1, startDateTimeString);
+    const eventStartsInNextDay = event.time.start.substring(0, 11) === nextDay.substring(0, 11);
+    return eventIsInDay && eventStartHour >= dayStartHour || eventStartsInNextDay && eventStartHour < dayEndHour;
+  }
+  handlePartialDayWithinOneDayBoundary(timeInstance, event) {
+    const { hour: dayStartHour } = timeInstance.getHourAndMinutesFromTimePoints(timeInstance.DAY_START);
+    const { hour: dayEndHour } = timeInstance.getHourAndMinutesFromTimePoints(timeInstance.DAY_END);
+    const { hour: eventStartHour } = timeInstance.getAllVariablesFromDateTimeString(event.time.start);
+    return eventStartHour >= dayStartHour && eventStartHour < dayEndHour;
+  }
+}
+class WeekHelper {
+  static getNHoursIntoDayFromHour(hour, timeInstance) {
+    const dayStartHour = Time.getHourFromTimePoints(timeInstance.DAY_START);
+    if (timeInstance.dayMode === DAY_MODE.REGULAR) return hour;
+    if (timeInstance.dayMode === DAY_MODE.SHORTENED || timeInstance.dayMode === DAY_MODE.FLEXIBLE && hour >= dayStartHour) {
+      return hour - dayStartHour;
+    }
+    return 24 - dayStartHour + hour;
+  }
+  static eventSeparator(events, time) {
+    const singleDayTimedEvents = [];
+    const fullDayAndMultipleDayEvents = [];
+    for (const scheduleEvent of events) {
+      const eventType = Helpers.getEventType(scheduleEvent, time);
+      if (["SINGLE_DAY_TIMED", "SINGLE_HYBRID_DAY_TIMED"].includes(eventType)) {
+        singleDayTimedEvents.push(scheduleEvent);
+      } else {
+        fullDayAndMultipleDayEvents.push(scheduleEvent);
+      }
+    }
+    return { fullDayAndMultipleDayEvents, singleDayTimedEvents };
+  }
+}
+class DayIntervals extends Time {
+  constructor(intervalMinutes, dayStartDateTimeString, hoursPerDay = 24) {
+    super();
+    __publicField(this, "INTERVAL_MINUTES");
+    __publicField(this, "DAY_START_DATE_TIME_STRING");
+    __publicField(this, "HOURS_PER_DAY", 24);
+    this.INTERVAL_MINUTES = intervalMinutes;
+    this.DAY_START_DATE_TIME_STRING = dayStartDateTimeString;
+    this.HOURS_PER_DAY = hoursPerDay;
+  }
+  getIntervals() {
+    const intervals = [];
+    const numberOfIntervalsInDay = this.HOURS_PER_DAY * (60 / this.INTERVAL_MINUTES);
+    let iteratorDateTimeString = this.DAY_START_DATE_TIME_STRING;
+    while (intervals.length < numberOfIntervalsInDay) {
+      const intervalEnd = this.addMinutesToDateTimeString(this.INTERVAL_MINUTES, iteratorDateTimeString);
+      intervals.push({
+        intervalStart: iteratorDateTimeString,
+        intervalEnd,
+        // Only show a border at the bottom of an interval, when the upcoming interval is not the start of a new hour.
+        // This prevents double borders
+        hasBorder: intervalEnd.substring(14, 16) !== "00"
+      });
+      iteratorDateTimeString = intervalEnd;
+    }
+    return intervals;
+  }
+}
+class EventConcurrency {
+  sortEventsAccordingToStartOfTime(events) {
+    function compare2(a2, b2) {
+      if (a2.time.start < b2.time.start) {
+        return -1;
+      }
+      if (a2.time.start > b2.time.start) {
+        return 1;
+      }
+      return 0;
+    }
+    return events.sort(compare2);
+  }
+  /**
+   * Sets the "zIndex" and "nOfPreviousConcurrentEvents" properties on an event
+   *
+   * zIndex - lets the event know with which z-index it should be displayed
+   * nOfPreviousConcurrentEvents - lets the event know, how many other, previous events, are competing for the same width
+   */
+  calculateConcurrencyForEvents(events) {
+    const updatedEvents = this.sortEventsAccordingToStartOfTime(events);
+    if (!updatedEvents.length) return [];
+    for (const [index2, calendarEvent] of updatedEvents.entries()) {
+      if (index2 === 0) continue;
+      updatedEvents[index2 - 1];
+      let iterator = 0;
+      let nOfConcurrentEvents = 0;
+      while (iterator < index2) {
+        if (updatedEvents[iterator].time.end > calendarEvent.time.start)
+          nOfConcurrentEvents++;
+        iterator++;
+      }
+      if (nOfConcurrentEvents)
+        updatedEvents[index2].nOfPreviousConcurrentEvents = nOfConcurrentEvents;
+    }
+    for (let index2 = updatedEvents.length - 1; index2 >= 0; index2--) {
+      let nOfUpcomingConcurrentEvents = 0;
+      let iterator = updatedEvents.length - 1;
+      while (iterator > index2) {
+        if (updatedEvents[iterator].time.start < updatedEvents[index2].time.end) {
+          nOfUpcomingConcurrentEvents++;
+        }
+        iterator--;
+      }
+      const nfOfPreviousEvents = updatedEvents[index2].nOfPreviousConcurrentEvents || 0;
+      updatedEvents[index2].totalConcurrentEvents = nfOfPreviousEvents + nOfUpcomingConcurrentEvents + 1;
+    }
+    return events;
+  }
+}
+var DRAG_N_RESIZE_DIRECTION = /* @__PURE__ */ ((DRAG_N_RESIZE_DIRECTION2) => {
+  DRAG_N_RESIZE_DIRECTION2["BACKWARDS"] = "backwards";
+  DRAG_N_RESIZE_DIRECTION2["FORWARDS"] = "forwards";
+  return DRAG_N_RESIZE_DIRECTION2;
+})(DRAG_N_RESIZE_DIRECTION || {});
+class EventChange {
+  constructor(timeInstance, date2) {
+    __publicField(this, "dayStart", "");
+    __publicField(this, "dayEnd", "");
+    this.timeInstance = timeInstance;
+    this.date = date2;
+    this.setDayBoundariesTimeStrings();
+  }
+  canEventBeMoved(event, direction) {
+    if (this.timeInstance.dayMode !== DAY_MODE.FLEXIBLE) {
+      return this.handleNonFlexibleDays(direction, event);
+    }
+    return this.handleFlexibleDays(direction, event);
+  }
+  handleNonFlexibleDays(direction, event) {
+    if (direction === DRAG_N_RESIZE_DIRECTION.FORWARDS) {
+      return this.handleForwardsMoveForNonFlexibleDays(event);
+    }
+    return this.handleBackwardsMoveForNonFlexibleDays(event);
+  }
+  handleFlexibleDays(direction, event) {
+    if (direction == DRAG_N_RESIZE_DIRECTION.FORWARDS) {
+      return this.handleForwardsMoveForFlexibleDays(event);
+    }
+    return this.handleBackwardsMoveForFlexibleDays(event);
+  }
+  handleForwardsMoveForNonFlexibleDays(event) {
+    const endTimePlus15Minutes = this.timeInstance.addMinutesToDateTimeString(15, event.time.end);
+    const endTimeString = this.timeInstance.timeStringFrom(endTimePlus15Minutes);
+    const newEndDateString = this.timeInstance.dateStringFrom(endTimePlus15Minutes);
+    if (newEndDateString > this.date) return false;
+    return endTimeString <= this.dayEnd;
+  }
+  handleBackwardsMoveForNonFlexibleDays(event) {
+    const startTimeMinus15Minutes = this.timeInstance.addMinutesToDateTimeString(-15, event.time.start);
+    const startTimeString = this.timeInstance.timeStringFrom(startTimeMinus15Minutes);
+    const newStartDateString = this.timeInstance.dateStringFrom(startTimeMinus15Minutes);
+    if (newStartDateString < this.date) return false;
+    return startTimeString >= this.dayStart;
+  }
+  handleForwardsMoveForFlexibleDays(event) {
+    const endTimePlus15Minutes = this.timeInstance.addMinutesToDateTimeString(15, event.time.end);
+    const endTimeString = this.timeInstance.timeStringFrom(endTimePlus15Minutes);
+    const newEndDateString = this.timeInstance.dateStringFrom(endTimePlus15Minutes);
+    if (newEndDateString === this.date) return true;
+    return endTimeString <= this.dayEnd;
+  }
+  handleBackwardsMoveForFlexibleDays(event) {
+    const startTimeMinus15Minutes = this.timeInstance.addMinutesToDateTimeString(-15, event.time.start);
+    const startTimeString = this.timeInstance.timeStringFrom(startTimeMinus15Minutes);
+    const newStartDateString = this.timeInstance.dateStringFrom(startTimeMinus15Minutes);
+    if (newStartDateString > this.date) return true;
+    return startTimeString >= this.dayStart;
+  }
+  setDayBoundariesTimeStrings() {
+    const startHour = this.timeInstance.getHourAndMinutesFromTimePoints(this.timeInstance.DAY_START).hour;
+    const endHour = this.timeInstance.getHourAndMinutesFromTimePoints(this.timeInstance.DAY_END).hour;
+    const startHourString = this.timeInstance.doubleDigit(startHour);
+    this.dayStart = `${startHourString}:00`;
+    const endHourString = this.timeInstance.doubleDigit(endHour);
+    this.dayEnd = `${endHourString}:00`;
+  }
+}
+const _hoisted_1$W = ["data-ref"];
+const _hoisted_2$G = { class: "calendar-week__event-row is-title" };
+const _hoisted_3$w = { class: "calendar-week__event-row is-time" };
+const _hoisted_4$k = {
+  key: 0,
+  class: "calendar-week__event-row is-location"
+};
+const _hoisted_5$j = {
+  key: 1,
+  class: "calendar-week__event-row is-with"
+};
+const _hoisted_6$e = {
+  key: 2,
+  class: "calendar-week__event-row is-topic"
+};
+const _hoisted_7$a = {
+  key: 3,
+  class: "calendar-week__event-row is-description"
+};
+const _hoisted_8$6 = ["innerHTML"];
+const _sfc_main$15 = /* @__PURE__ */ vue.defineComponent({
+  __name: "DayEvent",
+  props: {
+    eventProp: {
+      type: Object,
+      required: true
+    },
+    time: {
+      type: Object,
+      required: true
+    },
+    config: {
+      type: Object,
+      required: true
+    },
+    dayInfo: {
+      type: Object,
+      required: true
+    },
+    mode: {
+      type: String,
+      required: true
+    }
+  },
+  emits: ["eventWasClicked", "eventWasResized", "eventWasDragged", "dragStart", "dragEnd"],
+  setup(__props, { emit: __emit }) {
+    const props2 = __props;
+    const emit2 = __emit;
+    const event = vue.ref(props2.eventProp);
+    const icons = vue.ref({
+      clock: "clock",
+      user: "user",
+      description: "description",
+      location: "location_on",
+      topic: "topic"
+    });
+    const showResizeElements = vue.ref(false);
+    const eventTransformValue = vue.ref("initial");
+    const eventZIndexValue = vue.ref("initial");
+    const dayElement = vue.ref(null);
+    const resizingStartingPoint = vue.ref(void 0);
+    const resizingStartingPointEndOfTime = vue.ref(props2.eventProp.time.end);
+    const resizingStartingPointStartOfTime = vue.ref(props2.eventProp.time.start);
+    const resizingDirection = vue.ref("");
+    const changeInQuarterHoursEventStart = vue.ref(0);
+    const changeInQuarterHoursEventEnd = vue.ref(0);
+    const isEditable = vue.ref(props2.eventProp.isEditable || false);
+    const colors = vue.ref(EVENT_COLORS);
+    const eventColor = vue.ref("#fff");
+    const eventBackgroundColor = vue.ref("");
+    const isResizing = vue.ref(false);
+    const canDrag = vue.ref(false);
+    const clientYDragStart = vue.ref(null);
+    const clientXDragStart = vue.ref(null);
+    const changeInQuartersOnDrag = vue.ref(0);
+    const changeInDaysOnDrag = vue.ref(0);
+    vue.ref(false);
+    const timeStartDragStart = vue.ref(props2.eventProp.time.start);
+    const timeEndDragStart = vue.ref(props2.eventProp.time.end);
+    const dragMoveListenerNameAndCallbacks = [
+      ["mousemove", handleDrag],
+      ["touchmove", handleDrag],
+      ["mouseup", onMouseUpWhenDragging],
+      ["touchend", onMouseUpWhenDragging]
+    ];
+    const eventChangeHelper = vue.computed(() => {
+      const eventCurrentDay = props2.time.addDaysToDateTimeString(changeInDaysOnDrag.value, props2.dayInfo.dateTimeString);
+      return new EventChange(props2.time, props2.time.dateStringFrom(eventCurrentDay));
+    });
+    const isCustomEvent = vue.computed(() => {
+      if (Array.isArray(props2.eventProp.isCustom)) {
+        return props2.eventProp.isCustom.includes(props2.mode);
+      }
+      return props2.eventProp.isCustom || false;
+    });
+    const getEventTime = vue.computed(() => {
+      return `${props2.time.getLocalizedTime(event.value.time.start)} - ${props2.time.getLocalizedTime(event.value.time.end)}`;
+    });
+    const timePointsInDay = vue.computed(() => props2.time.HOURS_PER_DAY * 100);
+    const timePointsInOneMinute = vue.computed(() => 100 / 60);
+    const getLeftRule = vue.computed(() => {
+      if (!event.value.totalConcurrentEvents || !event.value.nOfPreviousConcurrentEvents) {
+        return 0;
+      }
+      return event.value.nOfPreviousConcurrentEvents / event.value.totalConcurrentEvents * 100;
+    });
+    const getWidthRule = vue.computed(() => 100 - getLeftRule.value);
+    const getBorderRule = vue.computed(() => !event.value.nOfPreviousConcurrentEvents ? "none" : "1px solid #fff");
+    const eventIsLongerThan30Minutes = vue.computed(() => {
+      const { hour: startHour, minutes: startMinutes } = props2.time.getAllVariablesFromDateTimeString(event.value.time.start);
+      const { hour: endHour, minutes: endMinutes } = props2.time.getAllVariablesFromDateTimeString(event.value.time.end);
+      const startDateMS = new Date(0, 0, 0, startHour, startMinutes).getTime();
+      const endDateMS = new Date(0, 0, 0, endHour, endMinutes).getTime();
+      return endDateMS - startDateMS >= 18e5;
+    });
+    const hasDisabledDragAndDrop = vue.computed(() => {
+      return !!(props2.eventProp.disableDnD && props2.eventProp.disableDnD.includes(props2.mode));
+    });
+    const hasDisabledResize = vue.computed(() => {
+      return !!(props2.eventProp.disableResize && props2.eventProp.disableResize.includes(props2.mode));
+    });
+    const requiredStyles = vue.computed(() => ({
+      top: getPositionInDay(event.value.time.start),
+      height: getLengthOfEvent(event.value.time.start, event.value.time.end),
+      left: `${getLeftRule.value}%`,
+      width: `${getWidthRule.value}%`,
+      transform: eventTransformValue.value,
+      zIndex: eventZIndexValue.value
+    }));
+    function getPositionInDay(dateTimeString) {
+      return `${props2.time.getPercentageOfDayFromDateTimeString(dateTimeString, props2.time.DAY_START, props2.time.DAY_END).toString()}%`;
+    }
+    function getLengthOfEvent(start, end) {
+      const startOfEvent = props2.time.getPercentageOfDayFromDateTimeString(start, props2.time.DAY_START, props2.time.DAY_END);
+      const endOfEvent = props2.time.getPercentageOfDayFromDateTimeString(end, props2.time.DAY_START, props2.time.DAY_END);
+      const length = Math.abs(endOfEvent - startOfEvent);
+      return `${length}%`;
+    }
+    function handleClickOnEvent(event2) {
+      const eventElement = getEventElementFromChildElement(event2);
+      if (!eventElement) return;
+      emit2("eventWasClicked", {
+        clickedEvent: props2.eventProp,
+        eventElement
+      });
+    }
+    function getEventElementFromChildElement(event2) {
+      const eventTarget = event2.target;
+      if (!eventTarget || typeof eventTarget.className.includes !== "function") return null;
+      if (eventTarget.className.includes(".calendar-week__event")) return event2.target;
+      return eventTarget.closest(".calendar-week__event");
+    }
+    function onMouseMoveResize(event2) {
+      const eventsContainer = document.querySelector(".calendar-week__events");
+      if (!eventsContainer) return;
+      if (typeof resizingStartingPoint.value === "undefined") {
+        resizingStartingPoint.value = event2.clientY;
+      }
+      const cursorPositionY = event2.clientY;
+      const nOfPixelsDistance = cursorPositionY - resizingStartingPoint.value;
+      const eventsContainerHeight = eventsContainer.clientHeight;
+      const percentageOfDayChanged = nOfPixelsDistance / eventsContainerHeight * 100;
+      const changeInTimePoints = timePointsInDay.value / 100 * percentageOfDayChanged;
+      const changeInMinutes = getMinutesFromTimePoints(changeInTimePoints);
+      if (resizingDirection.value === "down") {
+        changeInQuarterHoursEventEnd.value = Math.floor(changeInMinutes / 15);
+      } else {
+        changeInQuarterHoursEventStart.value = Math.floor(changeInMinutes / 15);
+      }
+    }
+    function onMouseUpWhenResizing() {
+      stopResizing();
+    }
+    function resizeEvent(direction) {
+      isResizing.value = true;
+      resizingDirection.value = direction;
+      document.addEventListener("mousemove", onMouseMoveResize);
+      document.addEventListener("mouseup", onMouseUpWhenResizing);
+    }
+    function stopResizing() {
+      document.removeEventListener("mousemove", onMouseMoveResize);
+      document.removeEventListener("mouseup", onMouseUpWhenResizing);
+      resetResizingValues();
+      emit2("eventWasResized", event.value);
+      isResizing.value = false;
+    }
+    function resetResizingValues() {
+      resizingStartingPoint.value = void 0;
+      resizingStartingPointStartOfTime.value = props2.eventProp.time.start;
+      resizingStartingPointEndOfTime.value = props2.eventProp.time.end;
+      changeInQuarterHoursEventEnd.value = 0;
+    }
+    function getMinutesFromTimePoints(timePoints) {
+      return timePoints / timePointsInOneMinute.value;
+    }
+    function setColors() {
+      var _a2;
+      if (event.value.colorScheme && ((_a2 = props2.config.style) == null ? void 0 : _a2.colorSchemes) && props2.config.style.colorSchemes[event.value.colorScheme]) {
+        eventColor.value = props2.config.style.colorSchemes[event.value.colorScheme].color;
+        eventBackgroundColor.value = props2.config.style.colorSchemes[event.value.colorScheme].backgroundColor;
+        return;
+      }
+      if (event.value.color) {
+        eventColor.value = "#fff";
+        eventBackgroundColor.value = colors.value[event.value.color];
+        return;
+      }
+      eventBackgroundColor.value = colors.value.blue;
+    }
+    function initDrag(domEvent) {
+      if (!event.value.isEditable || hasDisabledDragAndDrop.value) return;
+      emit2("dragStart");
+      dragMoveListenerNameAndCallbacks.forEach(([name, callback]) => {
+        document.addEventListener(name, callback);
+      });
+      if (Helpers.isUIEventTouchEvent(domEvent)) {
+        setInitialDragValues(
+          domEvent.touches[0].clientX,
+          domEvent.touches[0].clientY
+        );
+      } else {
+        setInitialDragValues(domEvent.clientX, domEvent.clientY);
+      }
+    }
+    function setInitialDragValues(clientX, clientY) {
+      canDrag.value = true;
+      eventZIndexValue.value = 10;
+      clientYDragStart.value = clientY;
+      clientXDragStart.value = clientX;
+      timeStartDragStart.value = event.value.time.start;
+      timeEndDragStart.value = event.value.time.end;
+    }
+    function onMouseUpWhenDragging() {
+      emit2("dragEnd");
+      handleDragEnd();
+    }
+    function handleDragEnd() {
+      canDrag.value = false;
+      eventZIndexValue.value = "initial";
+      dragMoveListenerNameAndCallbacks.forEach(([name, callback]) => {
+        document.removeEventListener(name, callback);
+      });
+      const dayChanged = changeInDaysOnDrag.value <= -1 || changeInDaysOnDrag.value > 0;
+      const timeChanged = changeInQuartersOnDrag.value <= -1 || changeInQuartersOnDrag.value > 0;
+      if (dayChanged || timeChanged) emit2("eventWasDragged", event.value);
+    }
+    function handleDrag(mouseEvent) {
+      if (isResizing.value || !canDrag.value || !clientYDragStart.value) return;
+      if (Helpers.isUIEventTouchEvent(mouseEvent)) {
+        handleVerticalDrag(mouseEvent.touches[0].clientY);
+        handleHorizontalDrag(mouseEvent.touches[0].clientX);
+      } else {
+        handleVerticalDrag(mouseEvent.clientY);
+        handleHorizontalDrag(mouseEvent.clientX);
+      }
+    }
+    function handleVerticalDrag(clientY) {
+      const eventsContainer = document.querySelector(".calendar-week__events");
+      if (!eventsContainer || !clientYDragStart.value) return;
+      const nOfPixelsDistance = clientY - clientYDragStart.value;
+      const eventsContainerHeight = eventsContainer.clientHeight;
+      const percentageOfDayChanged = nOfPixelsDistance / eventsContainerHeight * 100;
+      const changeInTimePoints = timePointsInDay.value / 100 * percentageOfDayChanged;
+      const changeInMinutes = getMinutesFromTimePoints(changeInTimePoints);
+      changeInQuartersOnDrag.value = changeInMinutes < 0 ? Math.ceil(changeInMinutes / 15) : Math.floor(changeInMinutes / 15);
+    }
+    function handleHorizontalDrag(clientX) {
+      if (!dayElement.value || !clientXDragStart.value) return;
+      const dayWidth = dayElement.value.clientWidth;
+      const changeInPixelsX = clientX - clientXDragStart.value;
+      changeInDaysOnDrag.value = changeInPixelsX < 0 ? Math.ceil(changeInPixelsX / dayWidth) : Math.floor(changeInPixelsX / dayWidth);
+    }
+    function updatePositionOnDrag() {
+      const minutesChangedVertically = changeInQuartersOnDrag.value * 15;
+      const minutesChangedHorizontally = changeInDaysOnDrag.value * 1440;
+      event.value.time.start = props2.time.addMinutesToDateTimeString(
+        minutesChangedVertically + minutesChangedHorizontally,
+        timeStartDragStart.value
+      );
+      event.value.time.end = props2.time.addMinutesToDateTimeString(
+        minutesChangedVertically + minutesChangedHorizontally,
+        timeEndDragStart.value
+      );
+    }
+    vue.watch(changeInQuarterHoursEventStart, (newValue, oldValue) => {
+      const newStartOfTimeDateTimeString = props2.time.addMinutesToDateTimeString(
+        15 * newValue,
+        resizingStartingPointStartOfTime.value
+      );
+      const direction = newValue > oldValue ? DRAG_N_RESIZE_DIRECTION.FORWARDS : DRAG_N_RESIZE_DIRECTION.BACKWARDS;
+      const eventCanBeResizedFurther = eventChangeHelper.value.canEventBeMoved(event.value, direction);
+      if (newStartOfTimeDateTimeString < event.value.time.end && eventCanBeResizedFurther) {
+        event.value.time.start = newStartOfTimeDateTimeString;
+      }
+    });
+    vue.watch(changeInQuarterHoursEventEnd, (newValue, oldValue) => {
+      const newEndOfTimeDateTimeString = props2.time.addMinutesToDateTimeString(
+        15 * newValue,
+        resizingStartingPointEndOfTime.value
+      );
+      const direction = newValue > oldValue ? DRAG_N_RESIZE_DIRECTION.FORWARDS : DRAG_N_RESIZE_DIRECTION.BACKWARDS;
+      const eventCanBeResizedFurther = eventChangeHelper.value.canEventBeMoved(event.value, direction);
+      if (newEndOfTimeDateTimeString > event.value.time.start && eventCanBeResizedFurther) {
+        event.value.time.end = newEndOfTimeDateTimeString;
+      }
+    });
+    vue.watch(changeInQuartersOnDrag, (newValue, oldValue) => {
+      const direction = newValue > oldValue ? DRAG_N_RESIZE_DIRECTION.FORWARDS : DRAG_N_RESIZE_DIRECTION.BACKWARDS;
+      const eventCanBeDraggedFurther = eventChangeHelper.value.canEventBeMoved(event.value, direction);
+      if (!eventCanBeDraggedFurther) return;
+      updatePositionOnDrag();
+    });
+    vue.watch(changeInDaysOnDrag, (newValue) => {
+      if (!dayElement.value) return;
+      const upcomingDaysInWeek = props2.dayInfo.daysTotalN - (props2.dayInfo.thisDayIndex + 1);
+      const previousDaysInWeek = 0 - props2.dayInfo.thisDayIndex;
+      if (newValue > upcomingDaysInWeek || newValue < previousDaysInWeek) return;
+      const pixelsToTransform = newValue * dayElement.value.clientWidth;
+      eventTransformValue.value = `translateX(${pixelsToTransform}px)`;
+      updatePositionOnDrag();
+    });
+    vue.onMounted(() => {
+      dayElement.value = document.querySelector(".calendar-week__day");
+      setColors();
+    });
+    function handleFocus() {
+      if (isEditable.value && !hasDisabledResize.value) {
+        showResizeElements.value = true;
+      }
+    }
+    function handleBlur() {
+      showResizeElements.value = false;
+    }
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(["calendar-week__event is-event", {
+          "is-editable": isEditable.value,
+          "has-disabled-dnd": hasDisabledDragAndDrop.value
+        }]),
+        style: vue.normalizeStyle({
+          ...requiredStyles.value,
+          border: getBorderRule.value
+        }),
+        "data-ref": `event-${event.value.id}`,
+        tabindex: "0",
+        onClick: handleClickOnEvent,
+        onMouseenter: handleFocus,
+        onMouseleave: handleBlur,
+        onFocus: handleFocus,
+        onBlur: handleBlur,
+        onMousedown: initDrag,
+        onTouchstart: initDrag
+      }, [
+        !isCustomEvent.value ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 0,
+          class: "calendar-week__event-info-wrapper p-05",
+          style: vue.normalizeStyle({
+            color: eventColor.value,
+            width: "100%",
+            height: "100%",
+            backgroundColor: eventBackgroundColor.value
+          })
+        }, [
+          vue.createElementVNode("div", _hoisted_2$G, vue.toDisplayString(event.value.title), 1),
+          vue.createElementVNode("div", _hoisted_3$w, [
+            vue.createVNode(vue.unref(_sfc_main$q), {
+              icon: icons.value.clock,
+              class: "calendar-week__event-icon"
+            }, null, 8, ["icon"]),
+            vue.createElementVNode("span", null, vue.toDisplayString(getEventTime.value), 1)
+          ]),
+          event.value.location ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_4$k, [
+            vue.createVNode(vue.unref(_sfc_main$q), {
+              icon: icons.value.location,
+              class: "calendar-week__event-icon"
+            }, null, 8, ["icon"]),
+            vue.createElementVNode("span", null, vue.toDisplayString(event.value.location), 1)
+          ])) : vue.createCommentVNode("", true),
+          event.value.with ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_5$j, [
+            vue.createVNode(vue.unref(_sfc_main$q), {
+              icon: icons.value.user,
+              class: "calendar-week__event-icon"
+            }, null, 8, ["icon"]),
+            vue.createElementVNode("span", null, vue.toDisplayString(event.value.with), 1)
+          ])) : vue.createCommentVNode("", true),
+          event.value.topic ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_6$e, [
+            vue.createVNode(vue.unref(_sfc_main$q), {
+              icon: icons.value.topic,
+              class: "calendar-week__event-icon"
+            }, null, 8, ["icon"]),
+            vue.createElementVNode("span", null, vue.toDisplayString(event.value.topic), 1)
+          ])) : vue.createCommentVNode("", true),
+          event.value.description ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_7$a, [
+            vue.createVNode(vue.unref(_sfc_main$q), {
+              icon: icons.value.description,
+              class: "calendar-week__event-icon"
+            }, null, 8, ["icon"]),
+            vue.createElementVNode("p", {
+              innerHTML: event.value.description
+            }, null, 8, _hoisted_8$6)
+          ])) : vue.createCommentVNode("", true),
+          eventIsLongerThan30Minutes.value ? (vue.openBlock(), vue.createElementBlock("div", {
+            key: 4,
+            class: "calendar-week__event-blend-out",
+            style: vue.normalizeStyle({
+              backgroundImage: `linear-gradient(to bottom, transparent, ${eventBackgroundColor.value})`
+            })
+          }, null, 4)) : vue.createCommentVNode("", true)
+        ], 4)) : vue.renderSlot(_ctx.$slots, "weekDayEvent", {
+          key: 1,
+          eventData: event.value
+        }, void 0, true),
+        showResizeElements.value ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 2,
+          class: "calendar-week__event-resize calendar-week__event-resize-up",
+          onMousedown: _cache[0] || (_cache[0] = ($event) => resizeEvent("up"))
+        }, null, 32)) : vue.createCommentVNode("", true),
+        showResizeElements.value ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 3,
+          class: "calendar-week__event-resize calendar-week__event-resize-down",
+          onMousedown: _cache[1] || (_cache[1] = ($event) => resizeEvent("down"))
+        }, null, 32)) : vue.createCommentVNode("", true)
+      ], 46, _hoisted_1$W);
+    };
+  }
+});
+const DayEvent = /* @__PURE__ */ _export_sfc(_sfc_main$15, [["__scopeId", "data-v-7f22cf49"]]);
+const _hoisted_1$V = ["id", "onClick"];
+const _sfc_main$14 = /* @__PURE__ */ vue.defineComponent({
+  __name: "Day",
+  props: {
+    day: {
+      type: Object,
+      required: true
+    },
+    time: {
+      type: Object,
+      required: true
+    },
+    config: {
+      type: Object,
+      required: true
+    },
+    dayInfo: {
+      type: Object,
+      required: true
+    },
+    mode: {
+      type: String,
+      required: true
+    },
+    dayIntervals: {
+      type: Object,
+      required: true
+    },
+    weekHeight: {
+      type: Number,
+      required: true
+    }
+  },
+  emits: [
+    "eventWasClicked",
+    "eventWasResized",
+    "eventWasDragged",
+    "intervalWasClicked",
+    "dayWasClicked",
+    "datetimeWasClicked",
+    "dragStart",
+    "dragEnd"
+  ],
+  setup(__props, { emit: __emit }) {
+    const props2 = __props;
+    const emit2 = __emit;
+    const eventConcurrencyHelper = new EventConcurrency();
+    const events = vue.ref([]);
+    const intervals = vue.ref([]);
+    const intervalStyles = vue.computed(() => {
+      var _a2;
+      return ((_a2 = props2.config.dayIntervals) == null ? void 0 : _a2.intervalStyles) ? props2.config.dayIntervals.intervalStyles : {};
+    });
+    function calculateEventConcurrency() {
+      events.value = eventConcurrencyHelper.calculateConcurrencyForEvents(
+        props2.day.events
+      );
+    }
+    function handleEventWasResized(event) {
+      emit2("eventWasResized", event);
+      calculateEventConcurrency();
+    }
+    function handleClickOnInterval(payload) {
+      const { intervalStart, intervalEnd } = payload;
+      emit2("intervalWasClicked", { intervalStart, intervalEnd });
+    }
+    function setClickableIntervals() {
+      let dayStartTimeString = props2.day.dateTimeString;
+      if (props2.time.DAY_START !== 0) {
+        const { hour: startHour } = props2.time.getHourAndMinutesFromTimePoints(props2.time.DAY_START);
+        dayStartTimeString = props2.time.setSegmentOfDateTimeString(dayStartTimeString, { hour: startHour });
+      }
+      intervals.value = new DayIntervals(
+        props2.dayIntervals.length || 60,
+        dayStartTimeString,
+        props2.time.HOURS_PER_DAY
+      ).getIntervals();
+    }
+    function getDateStringForFlexibleDayBoundaries(dateString, timeClickedHHMM) {
+      const hourTwoDigits = props2.time.doubleDigit(props2.time.DAY_START / 100);
+      const dayStartTimeHHMM = `${hourTwoDigits}:00`;
+      const isClickOnNextDay = timeClickedHHMM < dayStartTimeHHMM;
+      if (isClickOnNextDay) {
+        dateString = props2.time.dateStringFrom(
+          props2.time.addDaysToDateTimeString(1, dateString)
+        );
+      }
+      return dateString;
+    }
+    function handleClickOnDay(event) {
+      const timeClicked = props2.time.getTimeFromClick(event.offsetY, props2.weekHeight);
+      let dateString = props2.time.dateStringFrom(props2.day.dateTimeString);
+      const isFlexibleDay = props2.time.DAY_END <= props2.time.DAY_START;
+      if (isFlexibleDay) dateString = getDateStringForFlexibleDayBoundaries(dateString, timeClicked);
+      const dateTimeString = `${dateString} ${timeClicked}`;
+      emit2("dayWasClicked", dateString);
+      emit2("datetimeWasClicked", dateTimeString);
+    }
+    vue.onMounted(() => {
+      calculateEventConcurrency();
+      if (props2.dayIntervals.displayClickableInterval) setClickableIntervals();
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: "calendar-week__day",
+        onClick: vue.withModifiers(handleClickOnDay, ["self"])
+      }, [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(events.value, (event, eventIndex) => {
+          return vue.openBlock(), vue.createBlock(DayEvent, {
+            key: eventIndex,
+            "data-test": "day-event",
+            "event-prop": event,
+            day: __props.day,
+            time: __props.time,
+            config: __props.config,
+            "day-info": __props.dayInfo,
+            mode: __props.mode,
+            onEventWasClicked: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("eventWasClicked", $event)),
+            onEventWasDragged: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("eventWasDragged", $event)),
+            onEventWasResized: handleEventWasResized,
+            onDragStart: _cache[2] || (_cache[2] = ($event) => _ctx.$emit("dragStart")),
+            onDragEnd: _cache[3] || (_cache[3] = ($event) => _ctx.$emit("dragEnd"))
+          }, {
+            weekDayEvent: vue.withCtx((p2) => [
+              vue.renderSlot(_ctx.$slots, "weekDayEvent", {
+                eventData: p2.eventData
+              }, void 0, true)
+            ]),
+            _: 2
+          }, 1032, ["event-prop", "day", "time", "config", "day-info", "mode"]);
+        }), 128)),
+        __props.dayIntervals && __props.dayIntervals.displayClickableInterval ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 0 }, vue.renderList(intervals.value, (interval, intervalIndex) => {
+          return vue.openBlock(), vue.createElementBlock("div", {
+            id: `interval-${intervalIndex}`,
+            key: interval.intervalStart,
+            class: vue.normalizeClass(["calendar-week__day-interval", { "has-border": interval.hasBorder }]),
+            style: vue.normalizeStyle(intervalStyles.value),
+            onClick: ($event) => handleClickOnInterval(interval)
+          }, vue.toDisplayString(__props.time.getLocalizedTime(interval.intervalStart)), 15, _hoisted_1$V);
+        }), 128)) : vue.createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+const Day = /* @__PURE__ */ _export_sfc(_sfc_main$14, [["__scopeId", "data-v-12350119"]]);
+const _hoisted_1$U = { class: "day-timeline" };
+const _hoisted_2$F = { class: "day-timeline__hour-text" };
+const _sfc_main$13 = /* @__PURE__ */ vue.defineComponent({
+  __name: "DayTimeline",
+  props: {
+    time: {
+      type: Object,
+      required: true
+    },
+    weekHeight: {
+      type: String,
+      required: true
+    }
+  },
+  setup(__props) {
+    vue.useCssVars((_ctx) => ({
+      "73f3c772": __props.weekHeight
+    }));
+    const props2 = __props;
+    const timelineHours = vue.ref([]);
+    vue.onMounted(() => {
+      timelineHours.value = props2.time.getTimelineHours();
+    });
+    function getLocaleTimeString(time) {
+      const { hour } = props2.time.getHourAndMinutesFromTimePoints(time);
+      return props2.time.getLocalizedHour(new Date(2100, 1, 1, hour));
+    }
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$U, [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(timelineHours.value, (hour) => {
+          return vue.openBlock(), vue.createElementBlock("div", {
+            key: hour,
+            class: "day-timeline__hour"
+          }, [
+            vue.createElementVNode("span", _hoisted_2$F, vue.toDisplayString(getLocaleTimeString(hour)), 1)
+          ]);
+        }), 128))
+      ]);
+    };
+  }
+});
+const DayTimeline = /* @__PURE__ */ _export_sfc(_sfc_main$13, [["__scopeId", "data-v-a4d8d28d"]]);
+const _hoisted_1$T = ["id"];
+const _hoisted_2$E = {
+  key: 1,
+  class: "week-timeline__event"
+};
+const eventElementIdPrefix = "week-timeline__event-id-";
+const _sfc_main$12 = /* @__PURE__ */ vue.defineComponent({
+  __name: "FullDayEvent",
+  props: {
+    scheduleEvent: {
+      type: Object,
+      default: null
+    },
+    config: {
+      type: Object,
+      required: true
+    },
+    mode: {
+      type: String,
+      required: true
+    }
+  },
+  emits: ["eventWasClicked"],
+  setup(__props, { emit: __emit }) {
+    const props2 = __props;
+    const emit2 = __emit;
+    const colors = EVENT_COLORS;
+    const eventColor = vue.ref("#fff");
+    const eventBackgroundColor = vue.ref("");
+    const eventWidth = vue.computed(() => {
+      if (props2.mode !== "day")
+        return `calc(${props2.scheduleEvent.nDays * 100}% - 6px)`;
+      return "calc(100% - 6px)";
+    });
+    function setColors() {
+      var _a2;
+      if (props2.scheduleEvent.colorScheme && ((_a2 = props2.config.style) == null ? void 0 : _a2.colorSchemes) && props2.config.style.colorSchemes[props2.scheduleEvent.colorScheme]) {
+        eventColor.value = props2.config.style.colorSchemes[props2.scheduleEvent.colorScheme].color;
+        eventBackgroundColor.value = props2.config.style.colorSchemes[props2.scheduleEvent.colorScheme].backgroundColor;
+        return;
+      }
+      if (props2.scheduleEvent.color) {
+        eventColor.value = "#fff";
+        eventBackgroundColor.value = colors[props2.scheduleEvent.color];
+        return;
+      }
+      eventBackgroundColor.value = colors.blue;
+    }
+    function handleClickOnEvent() {
+      const eventElement = document.getElementById(
+        eventElementIdPrefix + props2.scheduleEvent.id
+      );
+      emit2("eventWasClicked", {
+        clickedEvent: props2.scheduleEvent,
+        eventElement
+      });
+    }
+    vue.onMounted(() => {
+      setColors();
+    });
+    return (_ctx, _cache) => {
+      return __props.scheduleEvent ? (vue.openBlock(), vue.createElementBlock("div", {
+        key: 0,
+        id: `${eventElementIdPrefix}${__props.scheduleEvent.id}`,
+        class: "week-timeline__event is-event",
+        style: vue.normalizeStyle({
+          width: eventWidth.value,
+          color: eventColor.value,
+          backgroundColor: eventBackgroundColor.value,
+          zIndex: 1
+        }),
+        onClick: handleClickOnEvent
+      }, vue.toDisplayString(__props.scheduleEvent.title), 13, _hoisted_1$T)) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_2$E));
+    };
+  }
+});
+const FullDayEvent = /* @__PURE__ */ _export_sfc(_sfc_main$12, [["__scopeId", "data-v-511747c2"]]);
+const _hoisted_1$S = { class: "week-timeline" };
+const _hoisted_2$D = ["onClick"];
+const _hoisted_3$v = { class: "week-timeline__day-name" };
+const _hoisted_4$j = { class: "week-timeline__date" };
+const _hoisted_5$i = { class: "week-timeline__events" };
+const _sfc_main$11 = /* @__PURE__ */ vue.defineComponent({
+  __name: "WeekTimeline",
+  props: {
+    days: {},
+    time: {},
+    fullDayEvents: {},
+    config: {},
+    mode: {}
+  },
+  emits: ["eventWasClicked", "dayWasClicked"],
+  setup(__props, { emit: __emit }) {
+    const props2 = __props;
+    const emit2 = __emit;
+    const now = vue.ref(/* @__PURE__ */ new Date());
+    function getDaysDate(day) {
+      const { date: date2 } = props2.time.getAllVariablesFromDateTimeString(
+        day.dateTimeString
+      );
+      return date2;
+    }
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$S, [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.days, (day, dayIndex) => {
+          return vue.openBlock(), vue.createElementBlock("div", {
+            key: dayIndex,
+            class: vue.normalizeClass(["week-timeline__day", {
+              "is-today": _ctx.time.getDateTimeStringFromDate(now.value, "start") === day.dateTimeString
+            }]),
+            onClick: ($event) => emit2("dayWasClicked", _ctx.time.dateStringFrom(day.dateTimeString))
+          }, [
+            vue.createElementVNode("div", _hoisted_3$v, vue.toDisplayString(day.dayName.substring(0, 2).toUpperCase()), 1),
+            vue.createElementVNode("div", _hoisted_4$j, vue.toDisplayString(getDaysDate(day)), 1),
+            vue.createElementVNode("div", _hoisted_5$i, [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(day.fullDayEvents, (event, key) => {
+                return vue.openBlock(), vue.createElementBlock(vue.Fragment, { key }, [
+                  key !== "date" ? (vue.openBlock(), vue.createBlock(FullDayEvent, {
+                    key: 0,
+                    "schedule-event": typeof event === "object" ? event : null,
+                    config: _ctx.config,
+                    mode: _ctx.mode,
+                    onEventWasClicked: _cache[0] || (_cache[0] = ($event) => emit2("eventWasClicked", $event))
+                  }, null, 8, ["schedule-event", "config", "mode"])) : vue.createCommentVNode("", true)
+                ], 64);
+              }), 128))
+            ])
+          ], 10, _hoisted_2$D);
+        }), 128))
+      ]);
+    };
+  }
+});
+const WeekTimeline = /* @__PURE__ */ _export_sfc(_sfc_main$11, [["__scopeId", "data-v-0e7c9832"]]);
+const _hoisted_1$R = { class: "calendar-week__wrapper" };
+const _hoisted_2$C = { class: "calendar-week" };
+const _hoisted_3$u = { class: "calendar-week__events" };
+const _sfc_main$10 = /* @__PURE__ */ vue.defineComponent({
+  __name: "Week",
+  props: {
+    config: {
+      type: Object,
+      required: true
+    },
+    eventsProp: {
+      type: Array,
+      default: () => []
+    },
+    period: {
+      type: Object,
+      required: true
+    },
+    modeProp: {
+      type: String,
+      default: "week"
+    },
+    time: {
+      type: Object,
+      required: true
+    }
+  },
+  emits: [
+    "eventWasClicked",
+    "eventWasResized",
+    "eventWasDragged",
+    "editEvent",
+    "deleteEvent",
+    "intervalWasClicked",
+    "dayWasClicked",
+    "datetimeWasClicked"
+  ],
+  setup(__props, { emit: __emit }) {
+    vue.useCssVars((_ctx) => ({
+      "6f3e0f98": weekHeight.value
+    }));
+    const props2 = __props;
+    const emit2 = __emit;
+    const eventPosition = new EventPosition();
+    const days = vue.ref([]);
+    const mode = vue.ref(props2.modeProp);
+    const selectedEvent = vue.ref(null);
+    const selectedEventElement = vue.ref(null);
+    const events = vue.ref(props2.eventsProp);
+    const fullDayEvents = vue.ref([]);
+    const weekVersion = vue.ref(0);
+    const dayIntervals = vue.ref({
+      length: 60,
+      height: 66
+    });
+    const weekHeight = vue.ref("1584px");
+    const currentTimePercentage = vue.ref(0);
+    const showCurrentTime = vue.ref(!!props2.config.showCurrentTime);
+    const hasCustomCurrentTimeSlot = vue.computed(() => {
+      return Helpers.hasSlotContent(vue.useSlots().customCurrentTime);
+    });
+    const nDays = vue.computed(() => {
+      var _a2;
+      return ((_a2 = props2.config.week) == null ? void 0 : _a2.nDays) || 7;
+    });
+    vue.watch(() => props2.period, () => {
+      setInitialEvents(mode.value);
+    }, { deep: true });
+    vue.watch(() => props2.modeProp, (value) => {
+      mode.value = value;
+      setInitialEvents(value);
+    }, { deep: true });
+    vue.onMounted(() => {
+      setDayIntervals();
+      separateFullDayEventsFromOtherEvents();
+      setInitialEvents(props2.modeProp);
+      if (props2.config.showCurrentTime || hasCustomCurrentTimeSlot.value) setCurrentTime();
+    });
+    function separateFullDayEventsFromOtherEvents() {
+      const {
+        singleDayTimedEvents,
+        fullDayAndMultipleDayEvents
+      } = WeekHelper.eventSeparator(events.value, props2.time);
+      events.value = singleDayTimedEvents;
+      positionFullDayEvents(fullDayAndMultipleDayEvents);
+    }
+    function positionFullDayEvents(fullDayAndMultipleDayEvents) {
+      const weekEndDate = nDays.value === 5 ? new Date(
+        props2.period.end.getFullYear(),
+        props2.period.end.getMonth(),
+        props2.period.end.getDate() - 2
+      ) : props2.period.end;
+      fullDayEvents.value = fullDayAndMultipleDayEvents.length ? eventPosition.positionFullDayEventsInWeek(
+        props2.period.start,
+        weekEndDate,
+        fullDayAndMultipleDayEvents
+      ) : [];
+    }
+    function setDays() {
+      const daysArray = props2.time.getCalendarWeekDateObjects(props2.period.start).map((day) => {
+        const dayName = props2.time.getLocalizedNameOfWeekday(day, "long");
+        const dateTimeString = props2.time.getDateTimeStringFromDate(
+          day,
+          "start"
+        );
+        const dayEvents = new EventsFilter(events.value).getEventsForDay(props2.time, dateTimeString);
+        return { dayName, dateTimeString, events: dayEvents };
+      });
+      if (nDays.value === 5 && props2.time.FIRST_DAY_OF_WEEK === WEEK_START_DAY.MONDAY) {
+        daysArray.splice(5, 2);
+        fullDayEvents.value.splice(5, 2);
+      } else if (nDays.value === 5 && props2.time.FIRST_DAY_OF_WEEK === WEEK_START_DAY.SUNDAY) {
+        daysArray.splice(6, 1);
+        fullDayEvents.value.splice(6, 1);
+        daysArray.splice(0, 1);
+        fullDayEvents.value.splice(0, 1);
+      }
+      days.value = daysArray;
+    }
+    function mergeFullDayEventsIntoDays() {
+      for (const [dayIndex] of days.value.entries()) {
+        days.value[dayIndex].fullDayEvents = fullDayEvents.value[dayIndex];
+      }
+    }
+    function setDay2() {
+      const dayDateTimeString = props2.time.getDateTimeStringFromDate(
+        props2.period.selectedDate
+      );
+      days.value = [
+        {
+          dayName: new Date(props2.period.selectedDate).toLocaleDateString(
+            props2.time.CALENDAR_LOCALE,
+            { weekday: "long" }
+          ),
+          dateTimeString: props2.time.getDateTimeStringFromDate(
+            props2.period.selectedDate,
+            "start"
+          ),
+          events: new EventsFilter(events.value).getEventsForDay(props2.time, dayDateTimeString)
+        }
+      ];
+      if (!fullDayEvents.value.length) return;
+      for (const day of fullDayEvents.value) {
+        const dayDateString = props2.time.getDateTimeStringFromDate(day.date);
+        if (dayDateString.substring(0, 11) === dayDateTimeString.substring(0, 11)) {
+          fullDayEvents.value = [day];
+          return;
+        }
+      }
+    }
+    function setInitialEvents(currentMode) {
+      if (currentMode === "day") setDay2();
+      if (currentMode === "week") setDays();
+      mergeFullDayEventsIntoDays();
+    }
+    function handleClickOnEvent(event) {
+      emit2("eventWasClicked", event);
+      selectedEventElement.value = event.eventElement;
+      selectedEvent.value = event.clickedEvent;
+    }
+    function handleEventWasDragged(event) {
+      const cleanedUpEvent = event;
+      delete cleanedUpEvent.totalConcurrentEvents;
+      delete cleanedUpEvent.nOfPreviousConcurrentEvents;
+      const filteredEvents = events.value.filter((e) => e.id !== event.id);
+      events.value = [
+        cleanedUpEvent,
+        ...filteredEvents.map((e) => {
+          delete e.nOfPreviousConcurrentEvents;
+          delete e.totalConcurrentEvents;
+          return e;
+        })
+      ];
+      setInitialEvents(mode.value);
+      weekVersion.value = weekVersion.value + 1;
+      emit2("eventWasDragged", event);
+    }
+    function setDayIntervals() {
+      if (props2.config.dayIntervals) {
+        for (const [key, value] of Object.entries(props2.config.dayIntervals)) {
+          dayIntervals.value[key] = value;
+        }
+      }
+      setWeekHeightBasedOnIntervals();
+    }
+    function setWeekHeightBasedOnIntervals() {
+      if (![15, 30, 60].includes(dayIntervals.value.length)) {
+        dayIntervals.value.length = 60;
+        dayIntervals.value.height = 66;
+        console.warn(
+          "The dayIntervals configuration is faulty. It has been reset to default values."
+        );
+      }
+      let intervalMultiplier = 1;
+      if (dayIntervals.value.length === 15) intervalMultiplier = 4;
+      if (dayIntervals.value.length === 30) intervalMultiplier = 2;
+      weekHeight.value = `${dayIntervals.value.height * intervalMultiplier * props2.time.HOURS_PER_DAY}px`;
+    }
+    function setCurrentTime() {
+      const setTime = () => {
+        const nowString = props2.time.getDateTimeStringFromDate(/* @__PURE__ */ new Date());
+        const currentTimePercentage2 = props2.time.getPercentageOfDayFromDateTimeString(
+          nowString,
+          props2.time.DAY_START,
+          props2.time.DAY_END
+        );
+        if (currentTimePercentage2 < 0 || currentTimePercentage2 > 100) {
+          showCurrentTime.value = false;
+          return;
+        }
+        showCurrentTime.value = true;
+        currentTimePercentage2.value = currentTimePercentage2;
+      };
+      setTime();
+      setInterval(() => {
+        setTime();
+      }, 6e4);
+    }
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
+        vue.createVNode(WeekTimeline, {
+          days: days.value,
+          time: __props.time,
+          "full-day-events": fullDayEvents.value,
+          config: __props.config,
+          mode: mode.value,
+          onEventWasClicked: handleClickOnEvent,
+          onDayWasClicked: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("dayWasClicked", $event))
+        }, null, 8, ["days", "time", "full-day-events", "config", "mode"]),
+        vue.createElementVNode("div", _hoisted_1$R, [
+          !__props.config.eventDialog || !__props.config.eventDialog.isDisabled ? (vue.openBlock(), vue.createBlock(_sfc_main$1c, {
+            key: 0,
+            "calendar-event-prop": selectedEvent.value,
+            "event-element": selectedEventElement.value,
+            time: __props.time,
+            config: __props.config,
+            onHide: _cache[1] || (_cache[1] = ($event) => selectedEvent.value = null),
+            onEditEvent: _cache[2] || (_cache[2] = ($event) => _ctx.$emit("editEvent", $event)),
+            onDeleteEvent: _cache[3] || (_cache[3] = ($event) => _ctx.$emit("deleteEvent", $event))
+          }, {
+            default: vue.withCtx((p2) => [
+              vue.renderSlot(_ctx.$slots, "eventDialog", {
+                eventDialogData: p2.eventDialogData,
+                closeEventDialog: p2.closeEventDialog
+              }, void 0, true)
+            ]),
+            _: 3
+          }, 8, ["calendar-event-prop", "event-element", "time", "config"])) : vue.createCommentVNode("", true),
+          vue.createElementVNode("section", _hoisted_2$C, [
+            hasCustomCurrentTimeSlot.value && showCurrentTime.value ? (vue.openBlock(), vue.createElementBlock("div", {
+              key: 0,
+              class: "custom-current-time",
+              style: vue.normalizeStyle({ top: `${currentTimePercentage.value}%` })
+            }, [
+              vue.renderSlot(_ctx.$slots, "customCurrentTime", {}, void 0, true)
+            ], 4)) : __props.config && __props.config.showCurrentTime && showCurrentTime.value ? (vue.openBlock(), vue.createElementBlock("div", {
+              key: 1,
+              class: "current-time-line",
+              style: vue.normalizeStyle({ top: `${currentTimePercentage.value}%` })
+            }, _cache[8] || (_cache[8] = [
+              vue.createElementVNode("div", { class: "current-time-line__circle" }, null, -1)
+            ]), 4)) : vue.createCommentVNode("", true),
+            (vue.openBlock(), vue.createBlock(DayTimeline, {
+              key: __props.period.start.getTime() + __props.period.end.getTime() + mode.value,
+              time: __props.time,
+              "day-intervals": dayIntervals.value,
+              "week-height": weekHeight.value
+            }, null, 8, ["time", "day-intervals", "week-height"])),
+            vue.createElementVNode("div", _hoisted_3$u, [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(days.value, (day, dayIndex) => {
+                return vue.openBlock(), vue.createBlock(Day, {
+                  key: day.dateTimeString + mode.value + weekVersion.value,
+                  day,
+                  time: __props.time,
+                  config: __props.config,
+                  "day-info": { daysTotalN: days.value.length, thisDayIndex: dayIndex, dateTimeString: day.dateTimeString },
+                  mode: mode.value,
+                  "day-intervals": dayIntervals.value,
+                  "week-height": +weekHeight.value.replace("px", ""),
+                  onEventWasClicked: handleClickOnEvent,
+                  onEventWasResized: _cache[4] || (_cache[4] = ($event) => _ctx.$emit("eventWasResized", $event)),
+                  onEventWasDragged: handleEventWasDragged,
+                  onIntervalWasClicked: _cache[5] || (_cache[5] = ($event) => _ctx.$emit("intervalWasClicked", $event)),
+                  onDayWasClicked: _cache[6] || (_cache[6] = ($event) => _ctx.$emit("dayWasClicked", $event)),
+                  onDatetimeWasClicked: _cache[7] || (_cache[7] = ($event) => _ctx.$emit("datetimeWasClicked", $event))
+                }, {
+                  weekDayEvent: vue.withCtx((p2) => [
+                    vue.renderSlot(_ctx.$slots, "weekDayEvent", {
+                      eventData: p2.eventData
+                    }, void 0, true)
+                  ]),
+                  _: 2
+                }, 1032, ["day", "time", "config", "day-info", "mode", "day-intervals", "week-height"]);
+              }), 128))
+            ])
+          ])
+        ])
+      ], 64);
+    };
+  }
+});
+const Week = /* @__PURE__ */ _export_sfc(_sfc_main$10, [["__scopeId", "data-v-21b8e443"]]);
+const _Errors = class _Errors {
+  static checkEventProperties(event) {
+    var _a2, _b, _c, _d;
+    if (!event.id) console.warn(this.MISSING_ID_WARNING);
+    if (!event.title) console.warn(this.MISSING_TITLE_WARNING);
+    if (!event.time) console.warn(this.MISSING_TIME_WARNING);
+    if (!((_a2 = event.time) == null ? void 0 : _a2.start)) console.warn(this.MISSING_TIME_START_WARNING);
+    if (!((_b = event.time) == null ? void 0 : _b.end)) console.warn(this.MISSING_TIME_END_WARNING);
+    if (((_c = event.time) == null ? void 0 : _c.start) && event.time.end && !DATE_TIME_STRING_PATTERN.test(event.time.start) && !DATE_TIME_STRING_FULL_DAY_PATTERN.test(event.time.start)) {
+      console.warn(
+        `${this.PREFIX} event property 'time.start' expects a string formatted like 'YYYY-MM-DD hh:mm', or 'YYYY-MM-DD', received ${event.time.start} 
+${this.SUFFIX}`
+      );
+    }
+    if (((_d = event.time) == null ? void 0 : _d.start) && event.time.end && !DATE_TIME_STRING_PATTERN.test(event.time.end) && !DATE_TIME_STRING_FULL_DAY_PATTERN.test(event.time.end)) {
+      console.warn(
+        `${this.PREFIX} event property 'time.end' expects a string formatted like 'YYYY-MM-DD hh:mm',  or 'YYYY-MM-DD', received ${event.time.end} 
+${this.SUFFIX}`
+      );
+    }
+  }
+  static checkConfig(config) {
+    if (config.locale && !/^[a-z]{2}-[A-Z]{2}$/.test(config.locale)) {
+      console.warn(
+        `${this.PREFIX} config.locale expects a string of format xx-XX, received: ${config.locale}`
+      );
+    }
+    if (config.defaultMode && !["month", "week", "day"].includes(config.defaultMode)) {
+      console.warn(
+        `${this.PREFIX} config.defaultMode expects either one of the values "day", "week" or "month"`
+      );
+    }
+  }
+};
+__publicField(_Errors, "PREFIX", "[Qalendar warning]");
+// public static SUFFIX = 'This is a development warning, which will never be displayed in production environments'
+__publicField(_Errors, "SUFFIX", "");
+__publicField(_Errors, "MISSING_ID_WARNING", `${_Errors.PREFIX} required event property 'id' is missing 
+${_Errors.SUFFIX}`);
+__publicField(_Errors, "MISSING_TITLE_WARNING", `${_Errors.PREFIX} required event property 'title' is missing 
+${_Errors.SUFFIX}`);
+__publicField(_Errors, "MISSING_TIME_WARNING", `${_Errors.PREFIX} required event property 'time' is missing 
+${_Errors.SUFFIX}`);
+__publicField(_Errors, "MISSING_TIME_START_WARNING", `${_Errors.PREFIX} required event property 'time.start' is missing 
+${_Errors.SUFFIX}`);
+__publicField(_Errors, "MISSING_TIME_END_WARNING", `${_Errors.PREFIX} required event property 'time.end' is missing 
+${_Errors.SUFFIX}`);
+let Errors = _Errors;
+const _hoisted_1$Q = { class: "calendar-root-wrapper" };
+const _hoisted_2$B = ["data-lang"];
+const _hoisted_3$t = {
+  key: 0,
+  class: "top-bar-loader"
+};
+const _sfc_main$$ = /* @__PURE__ */ vue.defineComponent({
+  __name: "Index",
+  props: {
+    config: {
+      type: Object,
+      default: () => ({})
+    },
+    events: {
+      type: Array,
+      default: () => []
+    },
+    selectedDate: {
+      type: Date,
+      default: /* @__PURE__ */ new Date()
+    },
+    isLoading: {
+      type: Boolean,
+      default: false
+    }
+  },
+  emits: [
+    "eventWasClicked",
+    "eventWasResized",
+    "eventWasDragged",
+    "updatedPeriod",
+    "updatedMode",
+    "editEvent",
+    "deleteEvent",
+    "intervalWasClicked",
+    "dayWasClicked",
+    // TODO: remove with v4. day-was-clicked is deprecated
+    "dateWasClicked",
+    "datetimeWasClicked"
+  ],
+  setup(__props, { emit: __emit }) {
+    var _a2, _b, _c;
+    const props2 = __props;
+    const emit2 = __emit;
+    const wasInitialized = vue.ref(0);
+    const period = vue.ref({
+      start: /* @__PURE__ */ new Date(),
+      end: /* @__PURE__ */ new Date(),
+      selectedDate: props2.selectedDate
+    });
+    const mode = vue.ref(props2.config.defaultMode || "week");
+    const time = vue.ref(new Time((_a2 = props2.config.week) == null ? void 0 : _a2.startsOn, props2.config.locale || null, {
+      start: setTimePointsFromDayBoundary(((_b = props2.config.dayBoundaries) == null ? void 0 : _b.start) || 0),
+      end: setTimePointsFromDayBoundary(((_c = props2.config.dayBoundaries) == null ? void 0 : _c.end) || 24)
+    }));
+    vue.computed(() => {
+      var _a3;
+      return ((_a3 = props2.config.style) == null ? void 0 : _a3.fontFamily) || "'Verdana', 'Open Sans', serif";
+    });
+    const eventRenderingKey = vue.ref(0);
+    const eventsDataProperty = vue.ref(props2.events);
+    const isSmall = vue.ref(false);
+    const ErrorsHelper = Errors;
+    const appHeaderRef = vue.ref();
+    const enhancedConfig = vue.computed(() => {
+      return { ...props2.config, isSmall: isSmall.value };
+    });
+    vue.watch(() => props2.events, (newVal, oldVal) => {
+      if (JSON.stringify(newVal) !== JSON.stringify(oldVal)) {
+        eventsDataProperty.value = newVal;
+        eventRenderingKey.value = eventRenderingKey.value + 1;
+      }
+      if (props2.config.isSilent) return;
+      props2.events.forEach((e) => {
+        ErrorsHelper.checkEventProperties(e);
+      });
+    }, { deep: true, immediate: true });
+    vue.watch(() => props2.config, (value) => {
+      ErrorsHelper.checkConfig(value);
+    }, { deep: true, immediate: true });
+    vue.onMounted(() => {
+      setConfigOnMount();
+      onCalendarResize();
+      setPeriodOnMount();
+      window.addEventListener("resize", onCalendarResize);
+    });
+    vue.onBeforeUnmount(() => {
+      window.removeEventListener("resize", onCalendarResize);
+    });
+    function setConfigOnMount() {
+      wasInitialized.value = 1;
+    }
+    function handleUpdatedPeriod(value, leaveMonthMode = false) {
+      emit2("updatedPeriod", { start: value.start, end: value.end });
+      period.value = value;
+      if (leaveMonthMode) mode.value = "day";
+    }
+    function handleChangeMode(payload) {
+      if (payload === "day") {
+        period.value.start = period.value.selectedDate;
+        period.value.end = time.value.setDateToEndOfDay(period.value.selectedDate);
+      }
+      if (payload === "week") {
+        const week = time.value.getCalendarWeekDateObjects(period.value.selectedDate);
+        period.value.start = week[0];
+        period.value.end = time.value.setDateToEndOfDay(week[6]);
+      }
+      if (payload === "month") {
+        const month = time.value.getCalendarMonthSplitInWeeks(
+          period.value.selectedDate.getFullYear(),
+          period.value.selectedDate.getMonth()
+        );
+        period.value.start = month[0][0];
+        const lastWeek = month[month.length - 1];
+        period.value.end = time.value.setDateToEndOfDay(lastWeek[lastWeek.length - 1]);
+      }
+      mode.value = payload;
+      emit2("updatedMode", { mode: payload, period: period.value });
+    }
+    const calendarRoot = vue.ref();
+    function onCalendarResize() {
+      const documentRoot = document.documentElement;
+      const documentFontSize = +window.getComputedStyle(documentRoot).fontSize.split("p")[0];
+      const breakPointFor1RemEquals16px = 700;
+      const multiplier = 16 / documentFontSize;
+      const smallCalendarBreakpoint = breakPointFor1RemEquals16px / multiplier;
+      if (!calendarRoot.value) return;
+      isSmall.value = calendarRoot.value.clientWidth < smallCalendarBreakpoint;
+      if (isSmall.value && !["day", "month"].includes(mode.value)) {
+        mode.value = "day";
+      }
+    }
+    function setPeriodOnMount() {
+      if (mode.value === "week") {
+        const currentWeek = time.value.getCalendarWeekDateObjects(period.value.selectedDate);
+        period.value.start = currentWeek[0];
+        period.value.end = currentWeek[6];
+      } else if (mode.value === "month") {
+        const month = time.value.getCalendarMonthSplitInWeeks(
+          period.value.selectedDate.getFullYear(),
+          period.value.selectedDate.getMonth()
+        );
+        period.value.start = month[0][0];
+        const lastWeek = month[month.length - 1];
+        period.value.end = lastWeek[lastWeek.length - 1];
+      }
+    }
+    function handleEventWasUpdated(calendarEvent, eventType) {
+      const newEvents = eventsDataProperty.value.filter(
+        (e) => e.id !== calendarEvent.id
+      );
+      eventsDataProperty.value = [calendarEvent, ...newEvents];
+      emit2(eventType === "dragged" ? "eventWasDragged" : "eventWasResized", calendarEvent);
+    }
+    function setTimePointsFromDayBoundary(boundary) {
+      return Time.getTimePointsFromHour(boundary);
+    }
+    const day = vue.computed(() => {
+      return {
+        dayName: time.value.getLocalizedNameOfWeekday(period.value.selectedDate, "long"),
+        dateTimeString: period.value.selectedDate.toLocaleDateString("en-US", {
+          day: "2-digit",
+          month: "2-digit",
+          year: "numeric"
+        }),
+        events: eventsDataProperty.value.filter((e) => {
+          const eventDate = new Date(e.time.start);
+          return eventDate >= period.value.start && eventDate <= period.value.end;
+        }),
+        fullDayEvents: {
+          date: period.value.selectedDate,
+          events: eventsDataProperty.value.filter((e) => {
+            const eventDate = new Date(e.time.start);
+            return eventDate >= period.value.start && eventDate <= period.value.end;
+          })
+        }
+      };
+    });
+    function handleDateWasClicked(payload) {
+      emit2("dayWasClicked", payload);
+      emit2("dateWasClicked", payload);
+    }
+    return (_ctx, _cache) => {
+      var _a3, _b2;
+      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1$Q, [
+        vue.createElementVNode("div", {
+          ref_key: "calendarRoot",
+          ref: calendarRoot,
+          class: vue.normalizeClass(["calendar-root", {
+            "mode-is-day": mode.value === "day",
+            "mode-is-week": mode.value === "week",
+            "mode-is-month": mode.value === "month",
+            "qalendar-is-small": isSmall.value
+          }]),
+          "data-lang": ((_b2 = (_a3 = __props.config) == null ? void 0 : _a3.locale) == null ? void 0 : _b2.substring(0, 2)) || "en"
+        }, [
+          vue.createVNode(vue.Transition, { name: "loading" }, {
+            default: vue.withCtx(() => [
+              __props.isLoading ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_3$t)) : vue.createCommentVNode("", true)
+            ]),
+            _: 1
+          }),
+          (vue.openBlock(), vue.createBlock(AppHeader, {
+            ref_key: "appHeaderRef",
+            ref: appHeaderRef,
+            key: wasInitialized.value + mode.value,
+            config: __props.config,
+            mode: mode.value,
+            time: time.value,
+            period: period.value,
+            "is-small": isSmall.value,
+            onChangeMode: handleChangeMode,
+            onUpdatedPeriod: handleUpdatedPeriod
+          }, null, 8, ["config", "mode", "time", "period", "is-small"])),
+          mode.value === "agenda" ? (vue.openBlock(), vue.createBlock(AgendaEvents, {
+            key: 0,
+            "events-prop": eventsDataProperty.value,
+            period: period.value,
+            config: __props.config,
+            time: time.value,
+            day: vue.unref(day)
+          }, null, 8, ["events-prop", "period", "config", "time", "day"])) : vue.createCommentVNode("", true),
+          ["week", "day"].includes(mode.value) ? (vue.openBlock(), vue.createBlock(Week, {
+            key: period.value.start.getTime() + period.value.end.getTime() + eventRenderingKey.value,
+            "events-prop": eventsDataProperty.value,
+            period: period.value,
+            config: __props.config,
+            "mode-prop": mode.value,
+            time: time.value,
+            onEventWasClicked: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("eventWasClicked", $event)),
+            onEventWasResized: _cache[1] || (_cache[1] = ($event) => handleEventWasUpdated($event, "resized")),
+            onEventWasDragged: _cache[2] || (_cache[2] = ($event) => handleEventWasUpdated($event, "dragged")),
+            onEditEvent: _cache[3] || (_cache[3] = ($event) => _ctx.$emit("editEvent", $event)),
+            onDeleteEvent: _cache[4] || (_cache[4] = ($event) => _ctx.$emit("deleteEvent", $event)),
+            onIntervalWasClicked: _cache[5] || (_cache[5] = ($event) => _ctx.$emit("intervalWasClicked", $event)),
+            onDayWasClicked: _cache[6] || (_cache[6] = ($event) => _ctx.$emit("dayWasClicked", $event)),
+            onDatetimeWasClicked: _cache[7] || (_cache[7] = ($event) => _ctx.$emit("datetimeWasClicked", $event))
+          }, {
+            weekDayEvent: vue.withCtx((p2) => [
+              vue.renderSlot(_ctx.$slots, "weekDayEvent", {
+                eventData: p2.eventData
+              })
+            ]),
+            eventDialog: vue.withCtx((p2) => [
+              vue.renderSlot(_ctx.$slots, "eventDialog", {
+                eventDialogData: p2.eventDialogData,
+                closeEventDialog: p2.closeEventDialog
+              })
+            ]),
+            customCurrentTime: vue.withCtx(() => [
+              vue.renderSlot(_ctx.$slots, "customCurrentTime")
+            ]),
+            _: 3
+          }, 8, ["events-prop", "period", "config", "mode-prop", "time"])) : vue.createCommentVNode("", true),
+          mode.value === "month" ? (vue.openBlock(), vue.createBlock(_sfc_main$16, {
+            key: period.value.start.getTime() + period.value.end.getTime() + eventRenderingKey.value,
+            "events-prop": eventsDataProperty.value,
+            time: time.value,
+            config: enhancedConfig.value,
+            period: period.value,
+            onEventWasClicked: _cache[8] || (_cache[8] = ($event) => _ctx.$emit("eventWasClicked", $event)),
+            onDateWasClicked: handleDateWasClicked,
+            onEventWasDragged: _cache[9] || (_cache[9] = ($event) => handleEventWasUpdated($event, "dragged")),
+            onUpdatedPeriod: _cache[10] || (_cache[10] = ($event) => handleUpdatedPeriod($event, true)),
+            onEditEvent: _cache[11] || (_cache[11] = ($event) => _ctx.$emit("editEvent", $event)),
+            onDeleteEvent: _cache[12] || (_cache[12] = ($event) => _ctx.$emit("deleteEvent", $event))
+          }, {
+            eventDialog: vue.withCtx((p2) => [
+              vue.renderSlot(_ctx.$slots, "eventDialog", {
+                eventDialogData: p2.eventDialogData,
+                closeEventDialog: p2.closeEventDialog
+              })
+            ]),
+            monthEvent: vue.withCtx((p2) => [
+              vue.renderSlot(_ctx.$slots, "monthEvent", {
+                eventData: p2.eventData
+              })
+            ]),
+            dayCell: vue.withCtx(({ dayData }) => [
+              vue.renderSlot(_ctx.$slots, "dayCell", { dayData })
+            ]),
+            _: 3
+          }, 8, ["events-prop", "time", "config", "period"])) : vue.createCommentVNode("", true)
+        ], 10, _hoisted_2$B)
+      ]);
+    };
+  }
+});
 const _hoisted_1$P = {
   key: 0,
   class: "card_label"
@@ -8208,7 +11662,7 @@ const _sfc_main$W = /* @__PURE__ */ vue.defineComponent({
   emits: /* @__PURE__ */ vue.mergeModels(["update:selectedItems", "orderBy", "select", "lastItemVisible"], ["update:loading", "update:itemHeight", "update:selectedItems"]),
   setup(__props, { emit: __emit }) {
     vue.useCssVars((_ctx) => ({
-      "0c6a620a": vue.unref(computedItemHeight)
+      "3ee4947a": vue.unref(computedItemHeight)
     }));
     const props2 = __props;
     const emit2 = __emit;
@@ -8387,7 +11841,7 @@ const _sfc_main$W = /* @__PURE__ */ vue.defineComponent({
     };
   }
 });
-const DataTable = /* @__PURE__ */ _export_sfc(_sfc_main$W, [["__scopeId", "data-v-a1cf8002"]]);
+const DataTable = /* @__PURE__ */ _export_sfc(_sfc_main$W, [["__scopeId", "data-v-3668ec69"]]);
 function useDraggable(options = {}) {
   const isDragging = vue.ref(false);
   const dragElement = vue.ref(null);
@@ -20707,9 +24161,9 @@ const _hoisted_3$m = {
   class: "required"
 };
 const _hoisted_4$e = { class: "date-picker-container" };
-const _hoisted_5$e = ["type", "value", "min", "max", "required", "disabled"];
+const _hoisted_5$e = ["value", "min", "max", "required", "disabled"];
 const _hoisted_6$a = { class: "flex gap-075 p-05 m_flex-wrap calendar-container justify-content-center h-100p" };
-const _hoisted_7$7 = { class: "calendar-section border-end m_border-none pe-05 m_p-0" };
+const _hoisted_7$7 = { class: "calendar-section m_border-none pe-05 m_p-0" };
 const _hoisted_8$4 = { class: "flex space-between pb-1" };
 const _hoisted_9$3 = { class: "flex gap-05" };
 const _hoisted_10$3 = { class: "month-year" };
@@ -20730,7 +24184,7 @@ const _hoisted_15$2 = {
 const _hoisted_16$2 = ["disabled", "onClick"];
 const _hoisted_17$2 = {
   key: 0,
-  class: "time-picker flex column gap-1 w-120px"
+  class: "time-picker border-start flex column gap-1 w-120px"
 };
 const _hoisted_18 = { class: "flex gap-025" };
 const _hoisted_19 = { class: "txt-center opacity-6 txt14" };
@@ -20745,7 +24199,10 @@ const _sfc_main$K = /* @__PURE__ */ vue.defineComponent({
     modelValue: {},
     min: {},
     max: {},
-    timezone: { default: "UTC" }
+    timezone: { default: "UTC" },
+    mode: { default: "day" },
+    firstDayOfWeek: { default: WEEK_START_DAY.MONDAY },
+    locale: { default: "" }
   },
   emits: ["update:modelValue"],
   setup(__props, { emit: __emit }) {
@@ -20754,13 +24211,33 @@ const _sfc_main$K = /* @__PURE__ */ vue.defineComponent({
     let isOpen = vue.ref(false);
     let currentMonth = vue.ref(/* @__PURE__ */ new Date());
     let currentView = vue.ref("days");
-    const inputType = vue.computed(() => props2.enableTime ? "datetime-local" : "date");
+    const time = new Time(props2.firstDayOfWeek, props2.locale);
+    function formatDisplayDate(date2) {
+      if (!date2) return "";
+      const dateObj = typeof date2 === "string" ? new Date(date2) : date2;
+      if (props2.enableTime) {
+        return dateObj.toLocaleString(props2.locale || void 0, {
+          year: "numeric",
+          month: "short",
+          day: "numeric",
+          hour: "2-digit",
+          minute: "2-digit",
+          timeZone: props2.timezone
+        });
+      }
+      return dateObj.toLocaleString(props2.locale || void 0, {
+        year: "numeric",
+        month: "short",
+        day: "numeric",
+        timeZone: props2.timezone
+      });
+    }
     function formatDate(date2) {
       if (!date2) return "";
       const dateObj = typeof date2 === "string" ? new Date(date2) : date2;
       return props2.enableTime ? dateObj.toISOString().slice(0, 16) : dateObj.toISOString().split("T")[0];
     }
-    const formattedValue = vue.computed(() => formatDate(props2.modelValue));
+    const formattedDisplayValue = vue.computed(() => formatDisplayDate(props2.modelValue));
     const formattedMin = vue.computed(() => formatDate(props2.min));
     const formattedMax = vue.computed(() => formatDate(props2.max));
     const selectedDate = vue.computed(() => {
@@ -20770,31 +24247,25 @@ const _sfc_main$K = /* @__PURE__ */ vue.defineComponent({
     const currentMonthDays = vue.computed(() => {
       const year = currentMonth.value.getFullYear();
       const month = currentMonth.value.getMonth();
-      const firstDay = new Date(year, month, 1);
-      const lastDay = new Date(year, month + 1, 0);
-      const days = [];
-      for (let i2 = 0; i2 < firstDay.getDay(); i2++) days.push(null);
-      for (let i2 = 1; i2 <= lastDay.getDate(); i2++) days.push(new Date(year, month, i2));
-      return days;
+      return time.getCalendarMonthSplitInWeeks(year, month).flat();
     });
     const currentMonthValue = vue.computed(() => ({
       month: currentMonth.value.getMonth(),
       year: currentMonth.value.getFullYear(),
       formatted: {
-        month: currentMonth.value.toLocaleString("default", { month: "long", timeZone: props2.timezone }),
-        year: currentMonth.value.toLocaleString("default", { year: "numeric", timeZone: props2.timezone })
+        month: time.getLocalizedNameOfMonth(currentMonth.value, "long"),
+        year: time.getLocalizedDateString(currentMonth.value).split("/").pop()
+        // Get just the year part
       }
     }));
-    const months = vue.computed(
-      () => Array.from({ length: 12 }, (_2, i2) => {
-        const date2 = new Date(currentMonthValue.value.year, i2, 1);
-        return {
-          name: date2.toLocaleString("default", { month: "short" }),
-          value: i2,
-          disabled: isDateDisabled(date2)
-        };
-      })
-    );
+    const months = vue.computed(() => Array.from({ length: 12 }, (_2, i2) => {
+      const date2 = new Date(currentMonthValue.value.year, i2, 1);
+      return {
+        name: time.getLocalizedNameOfMonth(date2, "short"),
+        value: i2,
+        disabled: isDateDisabled(date2)
+      };
+    }));
     const years = vue.computed(() => {
       const startYear = currentMonthValue.value.year - 10;
       return Array.from({ length: 21 }, (_2, i2) => ({
@@ -20802,6 +24273,15 @@ const _sfc_main$K = /* @__PURE__ */ vue.defineComponent({
         disabled: isYearDisabled(startYear + i2)
       }));
     });
+    const weekDays = vue.computed(() => {
+      const weekStart = /* @__PURE__ */ new Date();
+      weekStart.setDate(weekStart.getDate() - weekStart.getDay() + (props2.firstDayOfWeek === WEEK_START_DAY.MONDAY ? 1 : 0));
+      return Array.from({ length: 7 }, (_2, i2) => {
+        const day = new Date(weekStart);
+        day.setDate(weekStart.getDate() + i2);
+        return time.getLocalizedNameOfWeekday(day, "short");
+      });
+    });
     function isDateDisabled(date2) {
       if (!date2) return true;
       const minDate = props2.min ? new Date(props2.min) : null;
@@ -20848,20 +24328,10 @@ const _sfc_main$K = /* @__PURE__ */ vue.defineComponent({
         const currentMinutes = ((_b = selectedDate.value) == null ? void 0 : _b.getMinutes()) ?? (/* @__PURE__ */ new Date()).getMinutes();
         newDate.setHours(currentHours);
         newDate.setMinutes(currentMinutes);
-        emit2("update:modelValue", newDate.toISOString());
       } else {
-        emit2("update:modelValue", newDate.toISOString().split("T")[0]);
         isOpen.value = false;
       }
-    }
-    function handleInput(event) {
-      const input = event.target;
-      if (!input.value) {
-        emit2("update:modelValue", "");
-        return;
-      }
-      const date2 = new Date(input.value);
-      emit2("update:modelValue", props2.enableTime ? date2.toISOString() : date2.toISOString().split("T")[0]);
+      emit2("update:modelValue", newDate);
     }
     const hours = vue.computed(() => {
       var _a2;
@@ -20889,7 +24359,7 @@ const _sfc_main$K = /* @__PURE__ */ vue.defineComponent({
     }
     function isToday(date2) {
       if (!date2) return false;
-      return date2.toISOString().split("T")[0] === (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+      return time.dateIsToday(date2);
     }
     const timezoneDisplay = vue.computed(() => {
       if (!props2.enableTime) return "";
@@ -20902,6 +24372,9 @@ const _sfc_main$K = /* @__PURE__ */ vue.defineComponent({
         return "UTC";
       }
     });
+    function isNotInMonth(date2) {
+      return time.isTrailingOrLeadingDate(date2, currentMonth.value.getMonth());
+    }
     return (_ctx, _cache) => {
       return vue.openBlock(), vue.createElementBlock("div", {
         class: vue.normalizeClass(["bagel-input", { small: _ctx.small }]),
@@ -20911,15 +24384,28 @@ const _sfc_main$K = /* @__PURE__ */ vue.defineComponent({
           vue.createTextVNode(vue.toDisplayString(_ctx.label) + " ", 1),
           _ctx.required ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_3$m, "*")) : vue.createCommentVNode("", true)
         ])) : vue.createCommentVNode("", true),
-        vue.createVNode(vue.unref(kt$1), {
+        vue.createVNode(vue.unref(_sfc_main$U), {
           shown: vue.unref(isOpen),
-          triggers: [],
           placement: "bottom-start",
-          distance: 4,
           onApplyShow: _cache[4] || (_cache[4] = ($event) => vue.isRef(isOpen) ? isOpen.value = true : isOpen = true),
           onApplyHide: _cache[5] || (_cache[5] = ($event) => vue.isRef(isOpen) ? isOpen.value = false : isOpen = false)
         }, {
-          popper: vue.withCtx(() => [
+          trigger: vue.withCtx(() => [
+            vue.createElementVNode("div", _hoisted_4$e, [
+              vue.createElementVNode("input", {
+                type: "text",
+                value: formattedDisplayValue.value,
+                min: formattedMin.value,
+                max: formattedMax.value,
+                required: _ctx.required,
+                disabled: !_ctx.editMode,
+                class: "date-input",
+                readonly: "",
+                onClick: _cache[0] || (_cache[0] = ($event) => vue.isRef(isOpen) ? isOpen.value = true : isOpen = true)
+              }, null, 8, _hoisted_5$e)
+            ])
+          ]),
+          default: vue.withCtx(() => [
             vue.createElementVNode("div", _hoisted_6$a, [
               vue.createElementVNode("div", _hoisted_7$7, [
                 vue.createElementVNode("div", _hoisted_8$4, [
@@ -20971,20 +24457,21 @@ const _sfc_main$K = /* @__PURE__ */ vue.defineComponent({
                   ], 64))
                 ]),
                 vue.unref(currentView) === "days" ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_11$3, [
-                  (vue.openBlock(), vue.createElementBlock(vue.Fragment, null, vue.renderList(["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], (day) => {
-                    return vue.createElementVNode("div", {
+                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(weekDays.value, (day) => {
+                    return vue.openBlock(), vue.createElementBlock("div", {
                       key: day,
                       class: "txt-center txt-12 opacity-6"
                     }, vue.toDisplayString(day), 1);
-                  }), 64)),
-                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(currentMonthDays.value, (date2, index2) => {
+                  }), 128)),
+                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(currentMonthDays.value, (date2) => {
                     return vue.openBlock(), vue.createElementBlock("button", {
-                      key: index2,
+                      key: date2 == null ? void 0 : date2.toISOString(),
                       type: "button",
                       class: vue.normalizeClass(["day aspect-ratio-1 flex align-items-center justify-content-center pointer round txt14 p-0", {
-                        selected: isSelected(date2),
-                        today: isToday(date2),
-                        disabled: isDateDisabled(date2)
+                        "selected": isSelected(date2),
+                        "today": isToday(date2),
+                        "disabled": isDateDisabled(date2),
+                        "not-in-month": isNotInMonth(date2)
                       }]),
                       disabled: isDateDisabled(date2),
                       onClick: ($event) => selectDate(date2)
@@ -21054,28 +24541,13 @@ const _sfc_main$K = /* @__PURE__ */ vue.defineComponent({
               ])) : vue.createCommentVNode("", true)
             ])
           ]),
-          default: vue.withCtx(() => [
-            vue.createElementVNode("div", _hoisted_4$e, [
-              vue.createElementVNode("input", {
-                type: inputType.value,
-                value: formattedValue.value,
-                min: formattedMin.value,
-                max: formattedMax.value,
-                required: _ctx.required,
-                disabled: !_ctx.editMode,
-                class: "date-input",
-                onInput: handleInput,
-                onClick: _cache[0] || (_cache[0] = ($event) => vue.isRef(isOpen) ? isOpen.value = true : isOpen = true)
-              }, null, 40, _hoisted_5$e)
-            ])
-          ]),
           _: 1
         }, 8, ["shown"])
       ], 10, _hoisted_1$D);
     };
   }
 });
-const DatePick = /* @__PURE__ */ _export_sfc(_sfc_main$K, [["__scopeId", "data-v-8de3f3c6"]]);
+const DatePick = /* @__PURE__ */ _export_sfc(_sfc_main$K, [["__scopeId", "data-v-ca905332"]]);
 const _hoisted_1$C = { class: "datetime-wrap" };
 const _hoisted_2$q = { class: "date-wrap" };
 const _hoisted_3$l = {
@@ -21740,9 +25212,8 @@ const _sfc_main$G = /* @__PURE__ */ vue.defineComponent({
     let formattedValue = vue.ref("");
     function inputHandler() {
       let numeric = formattedValue.value.replace(/[^\d.-]/g, "");
-      if (numeric === "-." || numeric.endsWith(".")) return;
       const emptyValue = ["", "-", "."].includes(numeric);
-      if (emptyValue) numeric = `${__props.min}`;
+      if (numeric === "-." || numeric.endsWith(".") || emptyValue) return;
       numberValue.value = Number.parseFloat(numeric);
       formattedValue.value = emptyValue ? "" : formatNumber2(numberValue.value);
       emit2("update:modelValue", numberValue.value);
@@ -21856,7 +25327,7 @@ const _sfc_main$G = /* @__PURE__ */ vue.defineComponent({
     };
   }
 });
-const NumberInput = /* @__PURE__ */ _export_sfc(_sfc_main$G, [["__scopeId", "data-v-d8856711"]]);
+const NumberInput = /* @__PURE__ */ _export_sfc(_sfc_main$G, [["__scopeId", "data-v-ce1f6e76"]]);
 const _hoisted_1$y = ["value", "autofocus", "onKeydown", "onPaste"];
 const _sfc_main$F = /* @__PURE__ */ vue.defineComponent({
   __name: "OTP",
@@ -40849,19 +44320,20 @@ function timeAgo(date2, lang = "en") {
   }
   return selectedLang.justNow;
 }
-exports.Accordion = _sfc_main$17;
+exports.Accordion = _sfc_main$1m;
 exports.AccordionItem = AccordionItem;
-exports.AddressSearch = _sfc_main$15;
+exports.AddressSearch = _sfc_main$1k;
 exports.Alert = Alert;
 exports.Avatar = Avatar;
 exports.Badge = Badge;
 exports.BagelForm = _sfc_main$R;
 exports.BagelVue = BagelVue;
-exports.BglComponent = _sfc_main$10;
+exports.BglComponent = _sfc_main$1f;
 exports.BglForm = _sfc_main$R;
 exports.BglVideo = BglVideo;
 exports.BottomMenu = BottomMenu;
 exports.Btn = Btn;
+exports.Calendar = _sfc_main$$;
 exports.Card = _sfc_main$_;
 exports.Carousel = Carousel;
 exports.CheckInput = CheckInput;