@mantine-vue/schedule 2.1.0

package/cjs/index.cjs

@@ -0,0 +1,4198 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let dayjs = require("dayjs");
+dayjs = __toESM(dayjs);
+let dayjs_plugin_isoWeek_js = require("dayjs/plugin/isoWeek.js");
+dayjs_plugin_isoWeek_js = __toESM(dayjs_plugin_isoWeek_js);
+let rrule = require("rrule");
+rrule = __toESM(rrule);
+let vue = require("vue");
+let _mantine_vue_core = require("@mantine-vue/core");
+//#region src/labels.ts
+var DEFAULT_SCHEDULE_LABELS = {
+	today: "Today",
+	next: "Next",
+	previous: "Previous",
+	more: "More",
+	day: "Day",
+	week: "Week",
+	month: "Month",
+	year: "Year",
+	allDay: "All day",
+	weekday: "Weekday",
+	timeSlot: "Time slot",
+	selectMonth: "Select month",
+	selectYear: "Select year",
+	switchToDayView: "Switch to day view",
+	switchToWeekView: "Switch to week view",
+	switchToMonthView: "Switch to month view",
+	switchToYearView: "Switch to year view",
+	viewSelectLabel: "Calendar view",
+	noEvents: "No events",
+	moreLabel: (hiddenEventsCount) => `+${hiddenEventsCount} more`
+};
+function getLabel(key, override) {
+	if (override) return {
+		...DEFAULT_SCHEDULE_LABELS,
+		...override
+	}[key];
+	return DEFAULT_SCHEDULE_LABELS[key];
+}
+//#endregion
+//#region src/utils/format-date/format-date.ts
+function formatDate({ locale, date, format }) {
+	if (typeof format === "function") return format((0, dayjs.default)(date).format("YYYY-MM-DD HH:mm:ss"));
+	return (0, dayjs.default)(date).locale(locale).format(format);
+}
+//#endregion
+//#region src/utils/get-weekdays-names/get-weekdays-names.ts
+function getWeekdaysNames({ locale, format = "dd", firstDayOfWeek = 1 }) {
+	const baseDate = (0, dayjs.default)().day(firstDayOfWeek);
+	const labels = [];
+	for (let i = 0; i < 7; i += 1) labels.push(formatDate({
+		locale,
+		date: baseDate.add(i, "days"),
+		format
+	}));
+	return labels;
+}
+//#endregion
+//#region src/utils/get-start-of-week/get-start-of-week.ts
+function getStartOfWeek({ date, firstDayOfWeek = 1 }) {
+	let value = (0, dayjs.default)(date);
+	while (value.day() !== firstDayOfWeek) value = value.subtract(1, "day");
+	return value.format("YYYY-MM-DD");
+}
+//#endregion
+//#region src/utils/get-end-of-week/get-end-of-week.ts
+function getEndOfWeek(date, firstDayOfWeek = 1) {
+	let value = (0, dayjs.default)(date);
+	if (!value.isValid()) return value;
+	const lastDayOfWeek = firstDayOfWeek === 0 ? 6 : firstDayOfWeek - 1;
+	while (value.day() !== lastDayOfWeek) value = value.add(1, "day");
+	return value.format("YYYY-MM-DD");
+}
+//#endregion
+//#region src/utils/get-week-number/get-week-number.ts
+dayjs.default.extend(dayjs_plugin_isoWeek_js.default);
+function getWeekNumber(week) {
+	if (Array.isArray(week)) return (0, dayjs.default)(week.find((date) => (0, dayjs.default)(date).day() === 1)).isoWeek();
+	return (0, dayjs.default)(week).isoWeek();
+}
+//#endregion
+//#region src/utils/get-month-days/get-month-days.ts
+function getMonthDays({ month, firstDayOfWeek = 1, consistentWeeks }) {
+	const start = (0, dayjs.default)((0, dayjs.default)(month).subtract((0, dayjs.default)(month).date() - 1, "day").format("YYYY-MM-DD"));
+	const startOfMonth = start.format("YYYY-MM-DD");
+	const endDate = getEndOfWeek(start.add(+start.daysInMonth() - 1, "day").format("YYYY-MM-DD"), firstDayOfWeek);
+	const weeks = [];
+	let date = (0, dayjs.default)(getStartOfWeek({
+		date: startOfMonth,
+		firstDayOfWeek
+	}));
+	while ((0, dayjs.default)(date).isBefore(endDate, "day")) {
+		const days = [];
+		for (let i = 0; i < 7; i += 1) {
+			days.push(date.format("YYYY-MM-DD 00:00:00"));
+			date = date.add(1, "day");
+		}
+		weeks.push(days);
+	}
+	if (consistentWeeks && weeks.length < 6) {
+		const lastWeek = weeks[weeks.length - 1];
+		const lastDay = lastWeek[lastWeek.length - 1];
+		let nextDay = (0, dayjs.default)(lastDay).add(1, "day");
+		while (weeks.length < 6) {
+			const days = [];
+			for (let i = 0; i < 7; i += 1) {
+				days.push(nextDay.format("YYYY-MM-DD 00:00:00"));
+				nextDay = nextDay.add(1, "day");
+			}
+			weeks.push(days);
+		}
+	}
+	return weeks;
+}
+//#endregion
+//#region src/utils/is-after-min-date/is-after-min-date.ts
+function isAfterMinDate(date, minDate) {
+	return minDate ? (0, dayjs.default)(date).isAfter((0, dayjs.default)(minDate).subtract(1, "day"), "day") : true;
+}
+//#endregion
+//#region src/utils/is-before-max-date/is-before-max-date.ts
+function isBeforeMaxDate(date, maxDate) {
+	return maxDate ? (0, dayjs.default)(date).isBefore((0, dayjs.default)(maxDate).add(1, "day"), "day") : true;
+}
+//#endregion
+//#region src/utils/is-same-month/is-same-month.ts
+function isSameMonth(date, comparison) {
+	return (0, dayjs.default)(date).format("YYYY-MM") === (0, dayjs.default)(comparison).format("YYYY-MM");
+}
+//#endregion
+//#region src/utils/get-months-by-quarter/get-months-by-quarter.ts
+function getMonthsByQuarter(year) {
+	const startOfYear = (0, dayjs.default)(year).startOf("year").toDate();
+	const results = [
+		[],
+		[],
+		[],
+		[]
+	];
+	let currentMonthIndex = 0;
+	for (let i = 0; i < 4; i += 1) for (let j = 0; j < 3; j += 1) {
+		results[i].push((0, dayjs.default)(startOfYear).add(currentMonthIndex, "months").format("YYYY-MM-DD"));
+		currentMonthIndex += 1;
+	}
+	return results;
+}
+//#endregion
+//#region src/utils/clamp-interval-minutes/clamp-interval-minutes.ts
+/** Clamp interval minutes to valid values (1-60) and ensure it divides evenly into 60 */
+function clampIntervalMinutes(intervalMinutes) {
+	let clamped = Math.round(Math.max(1, Math.min(60, intervalMinutes)));
+	clamped = 60 % clamped === 0 ? clamped : 60;
+	return clamped;
+}
+//#endregion
+//#region src/utils/parse-time-string/parse-time-string.ts
+function parseTimeString(time) {
+	const [hours, minutes, seconds] = time.split(":").map(Number);
+	return {
+		hours,
+		minutes,
+		seconds: seconds || 0
+	};
+}
+//#endregion
+//#region src/utils/to-time-string/to-time-string.ts
+function toTimeString({ hours, minutes, seconds }) {
+	return `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
+}
+//#endregion
+//#region src/utils/get-day-time-intervals/get-day-time-intervals.ts
+function getDayTimeIntervals({ startTime, endTime, intervalMinutes: _intervalMinutes = 60 }) {
+	const intervalMinutes = clampIntervalMinutes(_intervalMinutes);
+	const start = parseTimeString(startTime);
+	const end = endTime ? parseTimeString(endTime) : {
+		hours: 23,
+		minutes: 59,
+		seconds: 59
+	};
+	const startSeconds = start.hours * 3600 + start.minutes * 60 + start.seconds;
+	const endSeconds = end.hours * 3600 + end.minutes * 60 + end.seconds;
+	const intervalSeconds = intervalMinutes * 60;
+	const intervals = [];
+	let currentSeconds = startSeconds;
+	while (currentSeconds < endSeconds) {
+		const intervalStartSeconds = currentSeconds;
+		let intervalEndSeconds = currentSeconds + intervalSeconds;
+		if (intervalEndSeconds > endSeconds) intervalEndSeconds = endSeconds;
+		const startHours = Math.floor(intervalStartSeconds / 3600);
+		const startMinutes = Math.floor(intervalStartSeconds % 3600 / 60);
+		const startSecs = intervalStartSeconds % 60;
+		const endHours = Math.floor(intervalEndSeconds / 3600);
+		const endMinutes = Math.floor(intervalEndSeconds % 3600 / 60);
+		const endSecs = intervalEndSeconds % 60;
+		const durationSeconds = intervalEndSeconds - intervalStartSeconds;
+		const isHourStart = startMinutes === 0 && startSecs === 0;
+		intervals.push({
+			startTime: toTimeString({
+				hours: startHours,
+				minutes: startMinutes,
+				seconds: startSecs
+			}),
+			endTime: toTimeString({
+				hours: endHours,
+				minutes: endMinutes,
+				seconds: endSecs
+			}),
+			duration: durationSeconds,
+			isHourStart
+		});
+		currentSeconds = intervalEndSeconds;
+	}
+	return intervals;
+}
+//#endregion
+//#region src/utils/to-date-string/to-date-string.ts
+function toDateString(date) {
+	return (0, dayjs.default)(date).format("YYYY-MM-DD 00:00:00");
+}
+//#endregion
+//#region src/utils/get-week-days/get-week-days.ts
+/** Returns a list of days in a given week */
+function getWeekDays({ week, weekendDays, withWeekendDays = true, firstDayOfWeek = 1 }) {
+	const days = [];
+	let current = (0, dayjs.default)(getStartOfWeek({
+		date: week,
+		firstDayOfWeek
+	}));
+	for (let i = 0; i < 7; i += 1) {
+		const dayOfWeek = current.day();
+		if (!(weekendDays && weekendDays.includes(dayOfWeek)) || withWeekendDays) days.push(toDateString(current));
+		current = current.add(1, "day");
+	}
+	return days;
+}
+//#endregion
+//#region src/utils/get-months-list/get-months-list.ts
+function getMonthsList({ locale, format }) {
+	const months = [];
+	const date = (0, dayjs.default)().locale(locale).startOf("year");
+	for (let i = 0; i < 12; i++) months.push({
+		month: i,
+		name: formatDate({
+			date: date.add(i, "month"),
+			format,
+			locale
+		})
+	});
+	return months;
+}
+//#endregion
+//#region src/utils/get-years-list/get-years-list.ts
+function getYearsList({ startYear, endYear }) {
+	const years = [];
+	for (let year = startYear; year <= endYear; year++) years.push(year);
+	return years;
+}
+//#endregion
+//#region src/utils/next-week/next-week.ts
+function nextWeek(date, firstDayOfWeek) {
+	const start = getStartOfWeek({
+		date,
+		firstDayOfWeek
+	});
+	return toDateString((0, dayjs.default)(start).set("date", (0, dayjs.default)(start).date() + 7));
+}
+//#endregion
+//#region src/utils/previous-week/previous-week.ts
+function previousWeek(date, firstDayOfWeek) {
+	const start = getStartOfWeek({
+		date,
+		firstDayOfWeek
+	});
+	return toDateString((0, dayjs.default)(start).set("date", (0, dayjs.default)(start).date() - 7));
+}
+//#endregion
+//#region src/utils/get-current-time-position/get-current-time-position.ts
+function getCurrentTimePosition(input) {
+	const now = (0, dayjs.default)(input?.now);
+	if (!input?.startTime || !input?.endTime) {
+		const startOf = now.startOf("date");
+		return now.diff(startOf, "minute") / 1440 * 100;
+	}
+	const [startHour, startMinute, startSecond = 0] = input.startTime.split(":").map(Number);
+	const [endHour, endMinute, endSecond = 0] = input.endTime.split(":").map(Number);
+	const startOfDay = now.startOf("date");
+	const startDateTime = startOfDay.hour(startHour).minute(startMinute).second(startSecond);
+	const literalSeconds = startOfDay.hour(endHour).minute(endMinute).second(endSecond).diff(startDateTime, "second");
+	const intervalSeconds = input.intervalMinutes !== void 0 ? clampIntervalMinutes(input.intervalMinutes) * 60 : void 0;
+	const totalSeconds = intervalSeconds ? Math.ceil(literalSeconds / intervalSeconds) * intervalSeconds : literalSeconds;
+	return now.diff(startDateTime, "second") / totalSeconds * 100;
+}
+//#endregion
+//#region src/utils/is-in-time-range/is-in-time-range.ts
+/** Returns true if the given date's time is within the specified time range */
+function isInTimeRange({ date, startTime = "00:00:00", endTime = "23:59:59" }) {
+	const targetDate = (0, dayjs.default)(date);
+	const parsedStartTime = parseTimeString(startTime);
+	const parsedEndTime = parseTimeString(endTime);
+	const startDateTime = targetDate.hour(parsedStartTime.hours).minute(parsedStartTime.minutes).second(parsedStartTime.seconds);
+	const endDateTime = targetDate.hour(parsedEndTime.hours).minute(parsedEndTime.minutes).second(parsedEndTime.seconds);
+	return targetDate.isAfter(startDateTime) && targetDate.isBefore(endDateTime);
+}
+//#endregion
+//#region src/utils/is-all-day-event/is-all-day-event.ts
+function isAllDayEvent({ event, date }) {
+	const dayStart = (0, dayjs.default)(date).startOf("day");
+	const nextDayStart = dayStart.add(1, "day");
+	const sameDayEnd = nextDayStart.subtract(1, "second");
+	const startTime = (0, dayjs.default)(event.start);
+	const endTime = (0, dayjs.default)(event.end);
+	return startTime.isSame(dayStart) && (endTime.isSame(nextDayStart) || endTime.isSame(sameDayEnd));
+}
+//#endregion
+//#region src/utils/validate-event/validate-event.ts
+function validateEvent(eventData) {
+	if (!(0, dayjs.default)(eventData.start).isValid()) throw new Error(`[@mantine/schedule] Invalid start date for event id: ${eventData.id}`);
+	if (!(0, dayjs.default)(eventData.end).isValid()) throw new Error(`[@mantine/schedule] Invalid end date for event id: ${eventData.id}`);
+	if ((0, dayjs.default)(eventData.end).isBefore((0, dayjs.default)(eventData.start))) throw new Error(`[@mantine/schedule] Event end date is before start date for event id: ${eventData.id}`);
+	return eventData;
+}
+//#endregion
+//#region src/utils/sort-events/sort-events.ts
+/** Sorts events by start time, then by duration (longer first) */
+function sortEvents(events) {
+	return [...events].sort((a, b) => {
+		const startDiff = (0, dayjs.default)(a.start).diff((0, dayjs.default)(b.start));
+		if (startDiff !== 0) return startDiff;
+		return (0, dayjs.default)(b.end).diff((0, dayjs.default)(b.start)) - (0, dayjs.default)(a.end).diff((0, dayjs.default)(a.start));
+	});
+}
+//#endregion
+//#region src/utils/is-events-overlap/is-events-overlap.ts
+/** Returns true if two events overlap in time */
+function isEventsOverlap(event1, event2) {
+	const start1 = (0, dayjs.default)(event1.start).valueOf();
+	const end1 = (0, dayjs.default)(event1.end).valueOf();
+	const start2 = (0, dayjs.default)(event2.start).valueOf();
+	return start1 < (0, dayjs.default)(event2.end).valueOf() && start2 < end1;
+}
+//#endregion
+//#region src/utils/get-visible-events/get-visible-events.ts
+function getVisibleEvents({ maxEvents, totalEvents }) {
+	if (totalEvents <= maxEvents) return {
+		visibleEventsCount: totalEvents,
+		hiddenEventsCount: 0
+	};
+	return {
+		visibleEventsCount: maxEvents - 1,
+		hiddenEventsCount: totalEvents - (maxEvents - 1)
+	};
+}
+//#endregion
+//#region src/utils/is-multiday-event/is-multiday-event.ts
+function isMultidayEvent(event) {
+	const startDate = (0, dayjs.default)(event.start).startOf("day");
+	const rawEnd = (0, dayjs.default)(event.end);
+	return (rawEnd.hour() === 0 && rawEnd.minute() === 0 && rawEnd.second() === 0 ? rawEnd.startOf("day").subtract(1, "day") : rawEnd.startOf("day")).isAfter(startDate);
+}
+//#endregion
+//#region src/utils/is-event-in-time-range/is-event-in-time-range.ts
+function spansFullDay(event) {
+	const start = (0, dayjs.default)(event.start);
+	const end = (0, dayjs.default)(event.end);
+	if (!start.isSame(start.startOf("day"))) return false;
+	const nextDayStart = start.startOf("day").add(1, "day");
+	return end.isSame(nextDayStart) || end.isSame(nextDayStart.subtract(1, "second"));
+}
+function isEventInTimeRange({ event, startTime, endTime }) {
+	if (isMultidayEvent(event) || spansFullDay(event)) return true;
+	if (!startTime || !endTime) return true;
+	const [startHour, startMinute] = startTime.split(":").map(Number);
+	const [endHour, endMinute] = endTime.split(":").map(Number);
+	const timeWindowStartMinutes = startHour * 60 + startMinute;
+	const timeWindowEndMinutes = endHour * 60 + endMinute;
+	const eventStart = (0, dayjs.default)(event.start);
+	const eventEnd = (0, dayjs.default)(event.end);
+	const eventStartMinutes = eventStart.hour() * 60 + eventStart.minute();
+	return !(eventEnd.hour() * 60 + eventEnd.minute() <= timeWindowStartMinutes || eventStartMinutes >= timeWindowEndMinutes);
+}
+//#endregion
+//#region src/utils/is-within-week/is-within-week.ts
+function isWithinWeek({ event, targetWeek, firstDayOfWeek }) {
+	const startOfWeek = (0, dayjs.default)(getStartOfWeek({
+		date: targetWeek,
+		firstDayOfWeek
+	}));
+	const endOfWeek = startOfWeek.add(7, "day");
+	return (0, dayjs.default)(event.start).isBefore(endOfWeek) && (0, dayjs.default)(event.end).isAfter(startOfWeek);
+}
+//#endregion
+//#region src/utils/get-month-range/get-month-range.ts
+/** Returns start and end dates as displayed in MonthView */
+function getMonthRange({ month, withOutsideDays, consistentWeeks, firstDayOfWeek }) {
+	if (!withOutsideDays) return {
+		start: toDateString((0, dayjs.default)(month).startOf("month")),
+		end: toDateString((0, dayjs.default)(month).endOf("month"))
+	};
+	const days = getMonthDays({
+		month,
+		firstDayOfWeek,
+		consistentWeeks
+	});
+	return {
+		start: days[0][0],
+		end: days[days.length - 1][6]
+	};
+}
+//#endregion
+//#region src/utils/get-day-position/get-day-position.ts
+/** Calculates day position within given start and end time boundaries. Returns top and height in percentages. */
+function getDayPosition({ event, startTime = "00:00:00", endTime = "23:59:59", intervalMinutes = 60 }) {
+	const eventStart = (0, dayjs.default)(event.start);
+	const eventEnd = (0, dayjs.default)(event.end);
+	const parsedStartTime = parseTimeString(startTime);
+	const parsedEndTime = parseTimeString(endTime);
+	const startOfDay = eventStart.startOf("date");
+	const boundaryStart = startOfDay.hour(parsedStartTime.hours).minute(parsedStartTime.minutes).second(parsedStartTime.seconds);
+	const literalEnd = startOfDay.hour(parsedEndTime.hours).minute(parsedEndTime.minutes).second(parsedEndTime.seconds);
+	const intervalSeconds = clampIntervalMinutes(intervalMinutes) * 60;
+	const literalRangeSeconds = literalEnd.diff(boundaryStart, "second");
+	const totalSeconds = Math.ceil(literalRangeSeconds / intervalSeconds) * intervalSeconds;
+	const eventStartSeconds = (eventStart.isBefore(boundaryStart) ? boundaryStart : eventStart).diff(boundaryStart, "second");
+	const eventEndSeconds = (eventEnd.isAfter(literalEnd) ? literalEnd : eventEnd).diff(boundaryStart, "second");
+	const startPercent = eventStartSeconds / totalSeconds * 100;
+	return {
+		top: startPercent,
+		height: eventEndSeconds / totalSeconds * 100 - startPercent
+	};
+}
+//#endregion
+//#region src/utils/calculate-drop-time/calculate-drop-time.ts
+function calculateDropTime({ draggedEvent, targetDate, targetSlotTime, mouseYOffset = 0, slotHeight = 64, intervalMinutes = 15 }) {
+	const eventDuration = (0, dayjs.default)(draggedEvent.end).diff((0, dayjs.default)(draggedEvent.start), "millisecond");
+	const parsedTime = parseTimeString(targetSlotTime);
+	const baseTargetTime = (0, dayjs.default)(targetDate).startOf("day").hour(parsedTime.hours).minute(parsedTime.minutes).second(0);
+	let finalTargetTime = baseTargetTime;
+	if (mouseYOffset > 0 && slotHeight > 0) {
+		const offsetRatio = mouseYOffset / slotHeight;
+		const offsetMinutes = Math.round(offsetRatio * intervalMinutes);
+		finalTargetTime = baseTargetTime.add(offsetMinutes, "minute");
+	}
+	return {
+		start: finalTargetTime.toDate(),
+		end: finalTargetTime.add(eventDuration, "millisecond").toDate()
+	};
+}
+//#endregion
+//#region src/utils/calculate-month-drop-date/calculate-month-drop-date.ts
+function calculateMonthDropDate({ draggedEvent, targetDay }) {
+	const eventDuration = (0, dayjs.default)(draggedEvent.end).diff((0, dayjs.default)(draggedEvent.start), "millisecond");
+	const originalStartTime = (0, dayjs.default)(draggedEvent.start);
+	const newStart = (0, dayjs.default)(targetDay).startOf("day").hour(originalStartTime.hour()).minute(originalStartTime.minute()).second(originalStartTime.second()).millisecond(originalStartTime.millisecond());
+	const newEnd = newStart.add(eventDuration, "millisecond");
+	return {
+		start: newStart.toDate(),
+		end: newEnd.toDate()
+	};
+}
+//#endregion
+//#region src/utils/get-business-hours-mod/get-business-hours-mod.ts
+function isBusinessHoursRange(value) {
+	return Array.isArray(value) && value.length === 2 && typeof value[0] === "string" && typeof value[1] === "string";
+}
+/**
+* Determines if a given time is within business hours and returns modifier object
+* @param time - Time string in HH:mm:ss format
+* @param businessHours - Tuple of [start, end] times in HH:mm:ss format, or per-day record keyed by day of the week
+* @param highlightBusinessHours - Whether to highlight business hours
+* @param dayOfWeek - Day of the week (0 – Sunday, 6 – Saturday), used to resolve per-day business hours
+* @returns Modifier object for styling business/non-business hours
+*/
+function getBusinessHoursMod({ time, businessHours, highlightBusinessHours, dayOfWeek }) {
+	if (!highlightBusinessHours || !businessHours) return {
+		"business-hours": false,
+		"non-business-hours": false
+	};
+	let range;
+	if (isBusinessHoursRange(businessHours)) range = businessHours;
+	else {
+		if (dayOfWeek === void 0) return {
+			"business-hours": false,
+			"non-business-hours": false
+		};
+		range = businessHours[dayOfWeek] ?? null;
+	}
+	if (!range) return {
+		"business-hours": false,
+		"non-business-hours": true
+	};
+	const [start, end] = range;
+	const isInBusinessHours = time >= start && time < end;
+	return {
+		"business-hours": isInBusinessHours,
+		"non-business-hours": !isInBusinessHours
+	};
+}
+//#endregion
+//#region src/utils/expand-recurring-events/expand-recurring-events.ts
+function resolveRRule(ns) {
+	return (ns.default ?? ns).RRule;
+}
+var RRule = resolveRRule(rrule);
+function getRecurrenceKey(recurringEventId, recurrenceId) {
+	return `${recurringEventId}::${recurrenceId}`;
+}
+function overlapsRange(eventStart, eventEnd, rangeStart, rangeEnd) {
+	return (eventEnd.isAfter(rangeStart) || eventEnd.isSame(rangeStart)) && (eventStart.isBefore(rangeEnd) || eventStart.isSame(rangeEnd));
+}
+function getExdateSet(recurrence) {
+	if (!recurrence?.exdate) return /* @__PURE__ */ new Set();
+	const values = recurrence.exdate.map((value) => (0, dayjs.default)(value)).filter((value) => value.isValid()).map((value) => value.format("YYYY-MM-DD HH:mm:ss"));
+	return new Set(values);
+}
+function getRRuleString(rule) {
+	const normalized = rule.trim();
+	if (!normalized.includes("\n")) return normalized.startsWith("RRULE:") ? normalized.replace(/^RRULE:/, "") : normalized;
+	const rruleLine = normalized.split("\n").map((line) => line.trim()).find((line) => line.startsWith("RRULE:"));
+	return rruleLine ? rruleLine.replace(/^RRULE:/, "") : normalized;
+}
+function getOccurrenceStartsInRange(event, rangeStart, rangeEnd, expansionLimit, durationMs) {
+	const dtstart = (0, dayjs.default)(event.recurrence?.dtstart || event.start);
+	if (!dtstart.isValid() || !event.recurrence) return [];
+	try {
+		const options = RRule.parseString(getRRuleString(event.recurrence.rrule));
+		options.dtstart = dtstart.toDate();
+		const rule = new RRule(options);
+		const searchStart = rangeStart.subtract(Math.max(0, durationMs), "millisecond").toDate();
+		return rule.between(searchStart, rangeEnd.toDate(), true).slice(0, expansionLimit).map((value) => (0, dayjs.default)(value));
+	} catch {
+		return [];
+	}
+}
+function isEventInRange(event, rangeStart, rangeEnd) {
+	const start = (0, dayjs.default)(event.start);
+	const end = (0, dayjs.default)(event.end);
+	if (!start.isValid() || !end.isValid()) return false;
+	return overlapsRange(start, end, rangeStart, rangeEnd);
+}
+function createGeneratedInstance(event, occurrenceStart, durationMs) {
+	const occurrenceEnd = occurrenceStart.add(durationMs, "millisecond");
+	const recurrenceId = occurrenceStart.format("YYYY-MM-DD HH:mm:ss");
+	const { recurrence: _recurrence, ...eventWithoutRecurrence } = event;
+	return {
+		...eventWithoutRecurrence,
+		id: `${event.id}::${recurrenceId}`,
+		start: occurrenceStart.format("YYYY-MM-DD HH:mm:ss"),
+		end: occurrenceEnd.format("YYYY-MM-DD HH:mm:ss"),
+		recurringEventId: event.id,
+		recurrenceId,
+		recurringInstance: {
+			isRecurringInstance: true,
+			recurringEventId: event.id,
+			recurrenceId,
+			originalStart: occurrenceStart.format("YYYY-MM-DD HH:mm:ss"),
+			originalEnd: occurrenceEnd.format("YYYY-MM-DD HH:mm:ss")
+		}
+	};
+}
+var DEFAULT_EXPANSION_LIMIT = 2e3;
+function expandRecurringEvents({ events, rangeStart, rangeEnd, expansionLimit = DEFAULT_EXPANSION_LIMIT }) {
+	if (!events || events.length === 0) return [];
+	const start = (0, dayjs.default)(rangeStart);
+	const end = (0, dayjs.default)(rangeEnd);
+	if (!start.isValid() || !end.isValid()) return [];
+	const regularEvents = [];
+	const recurringEvents = [];
+	const overrides = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		if (event.recurringEventId && event.recurrenceId) {
+			overrides.set(getRecurrenceKey(event.recurringEventId, event.recurrenceId), event);
+			continue;
+		}
+		if (event.recurrence?.rrule) {
+			recurringEvents.push(event);
+			continue;
+		}
+		regularEvents.push(event);
+	}
+	const output = [];
+	const consumedOverrideIds = /* @__PURE__ */ new Set();
+	for (const event of regularEvents) if (isEventInRange(event, start, end)) output.push(validateEvent(event));
+	for (const event of recurringEvents) {
+		const eventStart = (0, dayjs.default)(event.recurrence?.dtstart || event.start);
+		const eventEnd = (0, dayjs.default)(event.end);
+		if (!eventStart.isValid() || !eventEnd.isValid()) continue;
+		const durationMs = eventEnd.diff((0, dayjs.default)(event.start), "millisecond");
+		if (durationMs < 0) continue;
+		const exdate = getExdateSet(event.recurrence);
+		const starts = getOccurrenceStartsInRange(event, start, end, expansionLimit, durationMs);
+		for (const occurrenceStart of starts) {
+			const recurrenceId = occurrenceStart.format("YYYY-MM-DD HH:mm:ss");
+			if (exdate.has(recurrenceId)) continue;
+			const overrideKey = getRecurrenceKey(event.id, recurrenceId);
+			const override = overrides.get(overrideKey);
+			if (override) {
+				if (isEventInRange(override, start, end)) {
+					output.push(validateEvent(override));
+					consumedOverrideIds.add(override.id);
+				}
+				continue;
+			}
+			const generated = createGeneratedInstance(event, occurrenceStart, durationMs);
+			if (overlapsRange((0, dayjs.default)(generated.start), (0, dayjs.default)(generated.end), start, end)) output.push(validateEvent(generated));
+		}
+	}
+	for (const override of overrides.values()) {
+		if (consumedOverrideIds.has(override.id)) continue;
+		if (isEventInRange(override, start, end)) output.push(validateEvent(override));
+	}
+	return output;
+}
+//#endregion
+//#region src/hooks/use-event-resize.ts
+function useEventResize(input) {
+	const resizeState = (0, vue.ref)(null);
+	let justResized = false;
+	let savedUserSelect = null;
+	const clampAndSnap = (minutes, state) => {
+		const snapped = Math.round(minutes / state.intervalMinutes) * state.intervalMinutes;
+		return Math.max(0, Math.min(state.literalRange, snapped));
+	};
+	const snapPercent = (percent, state) => {
+		return clampAndSnap(percent / 100 * state.totalMinutes, state) / state.totalMinutes * 100;
+	};
+	const percentToDateTime = (percent, eventDate, state) => {
+		const minutes = percent / 100 * state.totalMinutes;
+		const totalMinutes = state.startMinutes + clampAndSnap(minutes, state);
+		const hours = Math.floor(totalMinutes / 60);
+		const mins = totalMinutes % 60;
+		return `${eventDate} ${String(hours).padStart(2, "0")}:${String(mins).padStart(2, "0")}:00`;
+	};
+	const handlePointerMove = (event) => {
+		const state = resizeState.value;
+		if (!state) return;
+		const containerRect = state.container.getBoundingClientRect();
+		if (containerRect.height === 0) return;
+		const relativeY = event.clientY - containerRect.top;
+		const snappedPercent = snapPercent(Math.max(0, Math.min(100, relativeY / containerRect.height * 100)), state);
+		let currentTop = state.originalTop;
+		let currentHeight = state.originalHeight;
+		if (state.edge === "bottom") currentHeight = Math.max(state.minHeightPercent, snappedPercent - state.originalTop);
+		else {
+			const originalBottom = state.originalTop + state.originalHeight;
+			currentTop = Math.min(snappedPercent, originalBottom - state.minHeightPercent);
+			currentHeight = originalBottom - currentTop;
+		}
+		resizeState.value = {
+			...state,
+			currentTop,
+			currentHeight
+		};
+	};
+	const removeDocumentListeners = () => {
+		document.removeEventListener("pointermove", handlePointerMove);
+		document.removeEventListener("pointerup", handlePointerUp);
+		if (savedUserSelect !== null) {
+			document.body.style.userSelect = savedUserSelect;
+			savedUserSelect = null;
+		}
+	};
+	const handlePointerUp = () => {
+		const state = resizeState.value;
+		if (state && (state.currentTop !== state.originalTop || state.currentHeight !== state.originalHeight)) {
+			const newStart = state.edge === "top" ? percentToDateTime(state.currentTop, state.eventDate, state) : state.originalStart;
+			const newEnd = state.edge === "bottom" ? percentToDateTime(state.currentTop + state.currentHeight, state.eventDate, state) : state.originalEnd;
+			input.onEventResize()?.({
+				eventId: state.eventId,
+				newStart,
+				newEnd,
+				event: state.event
+			});
+		}
+		resizeState.value = null;
+		removeDocumentListeners();
+		justResized = true;
+		requestAnimationFrame(() => {
+			justResized = false;
+		});
+	};
+	const handleResizeStart = ({ event, edge, container, originalTop, originalHeight, eventDate, pointerEvent }) => {
+		if (!input.enabled() || input.mode() === "static") return;
+		pointerEvent.preventDefault();
+		pointerEvent.stopPropagation();
+		const parsedStartTime = parseTimeString(input.startTime());
+		const parsedEndTime = parseTimeString(input.endTime());
+		const startMinutes = parsedStartTime.hours * 60 + parsedStartTime.minutes;
+		const endMinutes = parsedEndTime.hours * 60 + parsedEndTime.minutes;
+		const intervalMinutes = clampIntervalMinutes(input.intervalMinutes());
+		const literalRange = endMinutes - startMinutes;
+		const totalMinutes = Math.ceil(literalRange / intervalMinutes) * intervalMinutes;
+		resizeState.value = {
+			eventId: event.id,
+			event,
+			edge,
+			container,
+			originalTop,
+			originalHeight,
+			currentTop: originalTop,
+			currentHeight: originalHeight,
+			eventDate,
+			originalStart: (0, dayjs.default)(event.start).format("YYYY-MM-DD HH:mm:ss"),
+			originalEnd: (0, dayjs.default)(event.end).format("YYYY-MM-DD HH:mm:ss"),
+			startMinutes,
+			literalRange,
+			totalMinutes,
+			intervalMinutes,
+			minHeightPercent: intervalMinutes / totalMinutes * 100
+		};
+		savedUserSelect = document.body.style.userSelect;
+		document.body.style.userSelect = "none";
+		document.addEventListener("pointermove", handlePointerMove);
+		document.addEventListener("pointerup", handlePointerUp);
+	};
+	const getResizePosition = (eventId) => {
+		const state = resizeState.value;
+		return state?.eventId === eventId ? {
+			top: state.currentTop,
+			height: state.currentHeight
+		} : null;
+	};
+	const isResizableEvent = (event) => input.enabled() && input.mode() !== "static" && event.display !== "background" && (input.canResizeEvent()?.(event) ?? true);
+	(0, vue.onBeforeUnmount)(removeDocumentListeners);
+	return {
+		handleResizeStart,
+		getResizePosition,
+		isResizableEvent,
+		wasResizing: () => justResized
+	};
+}
+var CurrentTimeIndicator_module_default = {
+	currentTimeIndicator: "_currentTimeIndicator_v2g54_1",
+	currentTimeIndicatorLine: "_currentTimeIndicatorLine_v2g54_23",
+	currentTimeIndicatorThumb: "_currentTimeIndicatorThumb_v2g54_32",
+	currentTimeIndicatorTimeBubble: "_currentTimeIndicatorTimeBubble_v2g54_43"
+};
+//#endregion
+//#region src/components/CurrentTimeIndicator/CurrentTimeIndicator.ts
+var CurrentTimeIndicator = (0, vue.defineComponent)({
+	name: "CurrentTimeIndicator",
+	inheritAttrs: false,
+	props: {
+		color: {
+			type: String,
+			default: "red"
+		},
+		startOffset: {
+			type: String,
+			default: "0px"
+		},
+		endOffset: {
+			type: String,
+			default: "0px"
+		},
+		topOffset: {
+			type: String,
+			default: "0px"
+		},
+		timeBubbleStartOffset: {
+			type: String,
+			default: "0px"
+		},
+		withTimeBubble: {
+			type: Boolean,
+			default: true
+		},
+		withThumb: {
+			type: Boolean,
+			default: true
+		},
+		currentTimeFormat: {
+			type: [String, Function],
+			default: "HH:mm"
+		},
+		locale: String,
+		startTime: {
+			type: String,
+			default: "00:00:00"
+		},
+		endTime: {
+			type: String,
+			default: "23:59:59"
+		},
+		intervalMinutes: {
+			type: Number,
+			default: 60
+		},
+		getCurrentTime: Function
+	},
+	setup(props, { attrs }) {
+		const theme = (0, _mantine_vue_core.useSafeMantineTheme)();
+		const tick = (0, vue.ref)(0);
+		let timer;
+		(0, vue.onMounted)(() => {
+			timer = setInterval(() => tick.value++, 3e4);
+		});
+		(0, vue.onBeforeUnmount)(() => clearInterval(timer));
+		return () => {
+			tick.value;
+			const now = props.getCurrentTime?.() || (0, dayjs.default)();
+			if (!isInTimeRange({
+				date: now,
+				startTime: props.startTime,
+				endTime: props.endTime
+			})) return null;
+			const top = getCurrentTimePosition({
+				now,
+				startTime: props.startTime,
+				endTime: props.endTime,
+				intervalMinutes: props.intervalMinutes
+			});
+			const color = (0, _mantine_vue_core.getThemeColor)(props.color, theme.value);
+			const formattedTime = props.withTimeBubble ? formatDate({
+				date: now,
+				locale: props.locale || "en",
+				format: props.currentTimeFormat
+			}) : "";
+			return (0, vue.h)(_mantine_vue_core.Box, {
+				...attrs,
+				class: [CurrentTimeIndicator_module_default.currentTimeIndicator, attrs.class],
+				style: [{
+					"--indicator-color": color,
+					"--start-offset": props.startOffset,
+					"--end-offset": props.endOffset,
+					"--top-offset": `calc(${top}% + ${props.topOffset})`,
+					"--time-bubble-start-offset": props.timeBubbleStartOffset,
+					"--time-bubble-width": formattedTime.toString().toLowerCase().includes("m") ? "64px" : "46px"
+				}, attrs.style]
+			}, () => [
+				props.withTimeBubble ? (0, vue.h)("div", { class: CurrentTimeIndicator_module_default.currentTimeIndicatorTimeBubble }, formattedTime) : null,
+				props.withThumb ? (0, vue.h)("div", { class: CurrentTimeIndicator_module_default.currentTimeIndicatorThumb }) : null,
+				(0, vue.h)("div", { class: CurrentTimeIndicator_module_default.currentTimeIndicatorLine })
+			]);
+		};
+	}
+});
+var ScheduleEvent_module_default = {
+	event: "_event_bnqc2_1",
+	eventInner: "_eventInner_bnqc2_14",
+	eventResizeHandle: "_eventResizeHandle_bnqc2_177"
+};
+//#endregion
+//#region src/components/ScheduleEvent/ScheduleEvent.ts
+function resolveRadius$1(radius) {
+	if (radius == null) return void 0;
+	if (typeof radius === "number") return `${radius}px`;
+	return [
+		"xs",
+		"sm",
+		"md",
+		"lg",
+		"xl"
+	].includes(radius) ? `var(--mantine-radius-${radius})` : radius;
+}
+var ScheduleEvent = (0, vue.defineComponent)({
+	name: "ScheduleEvent",
+	inheritAttrs: false,
+	slots: Object,
+	props: {
+		event: {
+			type: Object,
+			required: true
+		},
+		radius: {
+			type: [String, Number],
+			default: "sm"
+		},
+		nowrap: Boolean,
+		autoSize: Boolean,
+		size: {
+			type: String,
+			default: "sm"
+		},
+		renderEventBody: Function,
+		renderEvent: Function,
+		hanging: String,
+		draggable: Boolean,
+		onEventDragStart: Function,
+		onEventDragEnd: Function,
+		isDragging: Boolean,
+		mode: {
+			type: String,
+			default: "default"
+		},
+		withResize: Boolean,
+		onResizeStart: Function,
+		isResizing: Boolean
+	},
+	setup(props, { attrs, slots }) {
+		const theme = (0, _mantine_vue_core.useSafeMantineTheme)();
+		const isNativeDragging = (0, vue.ref)(false);
+		return () => {
+			const colors = theme.value.variantColorResolver({
+				color: props.event.color || theme.value.primaryColor,
+				theme: theme.value,
+				variant: props.event.variant || "light",
+				autoContrast: true
+			});
+			const body = props.renderEventBody?.(props.event) || slots.eventBody?.({ event: props.event }) || slots.default?.() || props.event.title;
+			const showResizeHandles = props.withResize && props.mode !== "static";
+			const rootProps = {
+				...attrs,
+				class: [ScheduleEvent_module_default.event, attrs.class],
+				style: [{
+					"--event-color": colors.color,
+					"--event-bg": colors.background,
+					"--event-hover": colors.hover,
+					"--event-radius": resolveRadius$1(props.radius)
+				}, attrs.style],
+				"data-event-id": props.event.id,
+				title: props.event.title,
+				size: props.size,
+				mod: {
+					autoSize: props.autoSize,
+					hanging: props.hanging,
+					draggable: props.draggable,
+					dragging: props.isDragging || isNativeDragging.value,
+					static: props.mode === "static",
+					resizing: props.isResizing,
+					resizable: showResizeHandles
+				},
+				draggable: props.draggable && props.mode !== "static",
+				tabindex: props.mode === "static" ? -1 : 0,
+				onDragstart: (event) => {
+					if (!props.draggable || props.mode === "static") {
+						event.preventDefault();
+						return;
+					}
+					if (event.dataTransfer) {
+						event.dataTransfer.effectAllowed = "move";
+						event.dataTransfer.setData("application/json", JSON.stringify({ eventId: props.event.id }));
+					}
+					isNativeDragging.value = true;
+					props.onEventDragStart?.(props.event);
+				},
+				onDragend: props.mode === "static" ? void 0 : () => {
+					isNativeDragging.value = false;
+					props.onEventDragEnd?.();
+				},
+				onClick: props.mode === "static" ? void 0 : attrs.onClick
+			};
+			const children = [
+				showResizeHandles ? (0, vue.h)(_mantine_vue_core.Box, {
+					class: ScheduleEvent_module_default.eventResizeHandle,
+					mod: { edge: "top" },
+					onPointerdown: (event) => props.onResizeStart?.("top", event)
+				}) : null,
+				(0, vue.h)(_mantine_vue_core.Box, {
+					class: ScheduleEvent_module_default.eventInner,
+					mod: {
+						nowrap: props.nowrap,
+						size: props.size,
+						autoSize: props.autoSize,
+						hanging: props.hanging
+					}
+				}, () => body),
+				showResizeHandles ? (0, vue.h)(_mantine_vue_core.Box, {
+					class: ScheduleEvent_module_default.eventResizeHandle,
+					mod: { edge: "bottom" },
+					onPointerdown: (event) => props.onResizeStart?.("bottom", event)
+				}) : null
+			];
+			const renderProps = {
+				...rootProps,
+				children
+			};
+			return props.renderEvent?.(props.event, renderProps) || slots.event?.({
+				...renderProps,
+				event: props.event
+			}) || (0, vue.h)(_mantine_vue_core.UnstyledButton, rootProps, () => children);
+		};
+	}
+});
+//#endregion
+//#region src/components/shared.ts
+var baseViewProps = {
+	date: {
+		type: [String, Date],
+		required: true
+	},
+	onDateChange: Function,
+	events: Array,
+	locale: String,
+	radius: [String, Number],
+	labels: Object,
+	mode: {
+		type: String,
+		default: "default"
+	},
+	withHeader: {
+		type: Boolean,
+		default: true
+	},
+	onViewChange: Function,
+	previousControlProps: Object,
+	nextControlProps: Object,
+	todayControlProps: Object,
+	viewSelectProps: Object,
+	renderEventBody: Function,
+	renderEvent: Function,
+	onEventClick: Function,
+	recurrenceExpansionLimit: {
+		type: Number,
+		default: 2e3
+	}
+};
+var timeViewProps = {
+	...baseViewProps,
+	startTime: {
+		type: String,
+		default: "00:00:00"
+	},
+	endTime: {
+		type: String,
+		default: "23:59:59"
+	},
+	intervalMinutes: {
+		type: Number,
+		default: 60
+	},
+	slotLabelFormat: {
+		type: [String, Function],
+		default: "HH:mm"
+	},
+	withCurrentTimeIndicator: {
+		type: Boolean,
+		default: void 0
+	},
+	withCurrentTimeBubble: {
+		type: Boolean,
+		default: true
+	},
+	getCurrentTime: Function,
+	slotHeight: {
+		type: [String, Number],
+		default: 64
+	},
+	highlightBusinessHours: Boolean,
+	businessHours: [Array, Object],
+	withEventsDragAndDrop: Boolean,
+	onEventDrop: Function,
+	canDragEvent: Function,
+	onEventDragStart: Function,
+	onEventDragEnd: Function,
+	onTimeSlotClick: Function,
+	onAllDaySlotClick: Function,
+	withDragSlotSelect: Boolean,
+	onSlotDragEnd: Function,
+	startScrollTime: String,
+	onExternalEventDrop: Function,
+	withEventResize: Boolean,
+	onEventResize: Function,
+	canResizeEvent: Function
+};
+function resolveScheduleRadius(radius) {
+	if (radius === void 0) return void 0;
+	if (typeof radius === "number") return `${radius}px`;
+	return [
+		"xs",
+		"sm",
+		"md",
+		"lg",
+		"xl"
+	].includes(radius) ? `var(--mantine-radius-${radius})` : radius;
+}
+function getExpandedEvents(events, rangeStart, rangeEnd, expansionLimit) {
+	return expandRecurringEvents({
+		events,
+		rangeStart,
+		rangeEnd,
+		expansionLimit
+	});
+}
+/**
+* Build the slots object forwarded to a child component, omitting undefined entries.
+* Returns a `Record<string, unknown>` (possibly empty) so it satisfies Vue's `RawSlots`
+* type when passed as the third argument to `h()`.
+*/
+function forwardEventSlots(slots) {
+	const forwarded = {};
+	if (slots?.eventBody) forwarded.eventBody = slots.eventBody;
+	if (slots?.event) forwarded.event = slots.event;
+	return forwarded;
+}
+function eventNode(event, props, extra = {}, slots) {
+	const draggable = props.mode !== "static" && props.withEventsDragAndDrop === true && (props.canDragEvent?.(event) ?? true);
+	return (0, vue.h)(ScheduleEvent, {
+		event,
+		mode: props.mode ?? "default",
+		renderEvent: props.renderEvent,
+		renderEventBody: props.renderEventBody,
+		draggable,
+		onEventDragStart: props.onEventDragStart,
+		onEventDragEnd: props.onEventDragEnd,
+		onClick: (nativeEvent) => props.onEventClick?.(event, nativeEvent),
+		...extra
+	}, forwardEventSlots(slots));
+}
+function getDropEvent(events, transfer) {
+	const raw = transfer?.getData("application/json");
+	if (!raw) return void 0;
+	try {
+		const data = JSON.parse(raw);
+		if (typeof data !== "object" || data === null || !("eventId" in data)) return void 0;
+		const eventId = data.eventId;
+		if (typeof eventId !== "string" && typeof eventId !== "number") return void 0;
+		return events?.find((event) => String(event.id) === String(eventId));
+	} catch {
+		return;
+	}
+}
+function getTimeSlotDropTarget({ nativeEvent, container, intervals, date }) {
+	const targetSlot = (nativeEvent.target instanceof Element ? nativeEvent.target : null)?.closest("[data-time-slot-index]");
+	let slotIndex = targetSlot && container.contains(targetSlot) ? Number(targetSlot.dataset.timeSlotIndex) : NaN;
+	if (!Number.isInteger(slotIndex)) {
+		const slots = container.querySelectorAll("[data-time-slot-index]");
+		slotIndex = Array.from(slots).findIndex((slot) => {
+			const rect = slot.getBoundingClientRect();
+			return nativeEvent.clientY >= rect.top && nativeEvent.clientY <= rect.bottom;
+		});
+	}
+	const interval = intervals[slotIndex];
+	return interval ? {
+		slotIndex,
+		target: `${date} ${interval.startTime}`
+	} : void 0;
+}
+function moveEventTo(event, newStart) {
+	const start = (0, dayjs.default)(event.start);
+	const duration = (0, dayjs.default)(event.end).diff(start, "second");
+	const nextStart = (0, dayjs.default)(newStart);
+	return {
+		eventId: event.id,
+		newStart: nextStart.format("YYYY-MM-DD HH:mm:ss"),
+		newEnd: nextStart.add(duration, "second").format("YYYY-MM-DD HH:mm:ss"),
+		event
+	};
+}
+function moveEventToAllDay(event, date) {
+	const dayStart = (0, dayjs.default)(date).startOf("day");
+	const spanDays = Math.max(1, (0, dayjs.default)(event.end).startOf("day").diff((0, dayjs.default)(event.start).startOf("day"), "day"));
+	return {
+		eventId: event.id,
+		newStart: dayStart.format("YYYY-MM-DD HH:mm:ss"),
+		newEnd: dayStart.add(spanDays, "day").format("YYYY-MM-DD HH:mm:ss"),
+		event
+	};
+}
+var MoreEvents_module_default = {
+	moreEventsButton: "_moreEventsButton_1irmu_1",
+	moreEventsDropdown: "_moreEventsDropdown_1irmu_22",
+	moreEventsList: "_moreEventsList_1irmu_26"
+};
+//#endregion
+//#region src/components/MoreEvents/MoreEvents.ts
+var MoreEvents = (0, vue.defineComponent)({
+	name: "MoreEvents",
+	inheritAttrs: false,
+	slots: Object,
+	props: {
+		events: {
+			type: Array,
+			required: true
+		},
+		moreEventsCount: {
+			type: Number,
+			required: true
+		},
+		radius: [String, Number],
+		modalTitle: String,
+		dropdownType: {
+			type: String,
+			default: "popover"
+		},
+		popoverProps: Object,
+		modalProps: Object,
+		onDropdownClose: Function,
+		renderEventBody: Function,
+		renderEvent: Function,
+		labels: Object,
+		mode: {
+			type: String,
+			default: "default"
+		},
+		onEventClick: Function
+	},
+	setup(props, { attrs, slots }) {
+		const opened = (0, vue.ref)(false);
+		const close = () => {
+			opened.value = false;
+			props.onDropdownClose?.();
+		};
+		return () => {
+			const eventsList = (0, vue.h)(_mantine_vue_core.Box, { class: MoreEvents_module_default.moreEventsList }, () => props.events.map((event) => (0, vue.h)(ScheduleEvent, {
+				key: event.id,
+				event,
+				radius: props.radius ?? "sm",
+				size: "md",
+				mode: props.mode,
+				renderEvent: props.renderEvent,
+				renderEventBody: props.renderEventBody,
+				onClick: (nativeEvent) => props.onEventClick?.(event, nativeEvent)
+			}, forwardEventSlots(slots))));
+			return [props.dropdownType === "modal" ? (0, vue.h)(_mantine_vue_core.Modal, {
+				...props.modalProps,
+				opened: opened.value,
+				onClose: close,
+				radius: props.radius,
+				title: props.modalTitle
+			}, () => eventsList) : null, (0, vue.h)(_mantine_vue_core.Popover, {
+				position: "bottom-start",
+				width: 260,
+				opened: opened.value,
+				trapFocus: true,
+				returnFocus: false,
+				disabled: props.dropdownType === "modal",
+				radius: props.radius,
+				transitionProps: {
+					transition: "pop",
+					duration: 120
+				},
+				offset: -46,
+				...props.popoverProps,
+				onChange: (value) => {
+					if (!value) close();
+				}
+			}, () => [(0, vue.h)(_mantine_vue_core.Popover.Target, null, () => (0, vue.h)(_mantine_vue_core.UnstyledButton, {
+				...attrs,
+				class: [MoreEvents_module_default.moreEventsButton, attrs.class],
+				mod: { static: props.mode === "static" },
+				"aria-expanded": opened.value,
+				onClick: () => {
+					opened.value = !opened.value;
+				}
+			}, () => getLabel("moreLabel", props.labels)(props.moreEventsCount))), (0, vue.h)(_mantine_vue_core.Popover.Dropdown, { class: MoreEvents_module_default.moreEventsDropdown }, () => eventsList)])];
+		};
+	}
+});
+//#endregion
+//#region src/components/use-slot-drag-select.ts
+/**
+* Composable that provides unified slot drag-selection for Day, Week and Month views.
+* tracks a selected range as the pointer
+* moves across elements carrying `data-drag-slot-index` / `data-drag-slot-group`.
+*/
+function useSlotDragSelect(input) {
+	const selectedRange = (0, vue.ref)(null);
+	let drag = null;
+	let savedUserSelect = "";
+	const handlePointerMove = (event) => {
+		if (!drag) return;
+		const elements = document.elementsFromPoint(event.clientX, event.clientY);
+		for (const el of elements) {
+			const element = el;
+			const indexAttr = element.getAttribute?.("data-drag-slot-index");
+			const groupAttr = element.getAttribute?.("data-drag-slot-group");
+			if (indexAttr != null && groupAttr != null) {
+				if (groupAttr === drag.group) {
+					const newIndex = Number(indexAttr);
+					if (!Number.isNaN(newIndex) && newIndex !== drag.currentIndex) {
+						drag.currentIndex = newIndex;
+						selectedRange.value = {
+							group: groupAttr,
+							start: Math.min(drag.startIndex, newIndex),
+							end: Math.max(drag.startIndex, newIndex)
+						};
+					}
+				}
+				break;
+			}
+		}
+	};
+	const handlePointerUp = () => {
+		if (drag) {
+			const { startIndex, currentIndex, group } = drag;
+			if (startIndex !== currentIndex) input.onDragEnd?.()?.(Math.min(startIndex, currentIndex), Math.max(startIndex, currentIndex), group);
+		}
+		drag = null;
+		selectedRange.value = null;
+	};
+	const removeListeners = () => {
+		document.body.style.userSelect = savedUserSelect;
+		document.removeEventListener("pointermove", handlePointerMove);
+		document.removeEventListener("pointerup", handlePointerUp);
+	};
+	(0, vue.watch)(() => selectedRange.value !== null, (isDragging) => {
+		if (isDragging) {
+			savedUserSelect = document.body.style.userSelect;
+			document.body.style.userSelect = "none";
+			document.addEventListener("pointermove", handlePointerMove);
+			document.addEventListener("pointerup", handlePointerUp);
+		} else removeListeners();
+	});
+	(0, vue.onBeforeUnmount)(() => {
+		if (selectedRange.value !== null) removeListeners();
+	});
+	const handleSlotPointerDown = (_event, index, group) => {
+		if (!input.enabled()) return;
+		drag = {
+			group,
+			startIndex: index,
+			currentIndex: index
+		};
+		selectedRange.value = {
+			group,
+			start: index,
+			end: index
+		};
+	};
+	const isSlotSelected = (index, group) => {
+		const range = selectedRange.value;
+		if (!range || range.group !== group) return false;
+		return index >= range.start && index <= range.end;
+	};
+	const isDragging = () => selectedRange.value !== null;
+	return {
+		handleSlotPointerDown,
+		isSlotSelected,
+		isDragging
+	};
+}
+var ScheduleHeader_module_default = {
+	header: "_header_1dfmx_1",
+	navigationGroup: "_navigationGroup_1dfmx_11",
+	todayControl: "_todayControl_1dfmx_25",
+	viewSelect: "_viewSelect_1dfmx_31",
+	compactViewSelect: "_compactViewSelect_1dfmx_37"
+};
+var HeaderControl_module_default = { headerControl: "_headerControl_6ykw9_1" };
+var ViewSelect_module_default = { viewSelect: "_viewSelect_1xfvc_1" };
+var MonthYearSelect_module_default = {
+	monthYearSelectTarget: "_monthYearSelectTarget_2hd16_1",
+	monthYearSelectList: "_monthYearSelectList_2hd16_10",
+	monthYearSelectDropdown: "_monthYearSelectDropdown_2hd16_14",
+	monthYearSelectLabel: "_monthYearSelectLabel_2hd16_24",
+	monthYearSelectControl: "_monthYearSelectControl_2hd16_31"
+};
+//#endregion
+//#region src/components/ScheduleHeader/ScheduleHeader.ts
+var labelsKey = Symbol("schedule-header-labels");
+var commonControlProps = {
+	active: Boolean,
+	square: Boolean,
+	radius: [String, Number],
+	interactive: {
+		type: Boolean,
+		default: true
+	},
+	labels: Object
+};
+function resolveRadius(radius) {
+	if (radius == null) return void 0;
+	if (typeof radius === "number") return `${radius}px`;
+	return [
+		"xs",
+		"sm",
+		"md",
+		"lg",
+		"xl"
+	].includes(radius) ? `var(--mantine-radius-${radius})` : radius;
+}
+var HeaderControl = (0, vue.defineComponent)({
+	name: "HeaderControl",
+	inheritAttrs: false,
+	props: commonControlProps,
+	setup(props, { attrs, slots }) {
+		return () => (0, vue.h)(_mantine_vue_core.UnstyledButton, {
+			...attrs,
+			class: [HeaderControl_module_default.headerControl, attrs.class],
+			style: [props.radius == null ? void 0 : { "--control-radius": resolveRadius(props.radius) }, attrs.style],
+			tabindex: props.interactive ? attrs.tabindex : -1,
+			mod: {
+				active: props.active,
+				square: props.square,
+				interactive: props.interactive
+			}
+		}, () => slots.default?.());
+	}
+});
+function directionalControl(name, type) {
+	return (0, vue.defineComponent)({
+		name,
+		inheritAttrs: false,
+		props: commonControlProps,
+		setup(props, { attrs }) {
+			const inherited = (0, vue.inject)(labelsKey, void 0);
+			const { dir } = (0, _mantine_vue_core.useDirection)();
+			return () => (0, vue.h)(HeaderControl, {
+				...attrs,
+				...props,
+				square: true,
+				"data-type": type,
+				"aria-label": getLabel(type, props.labels || inherited)
+			}, () => (0, vue.h)(_mantine_vue_core.AccordionChevron, { style: { transform: `rotate(${type === "next" ? dir.value === "rtl" ? 90 : -90 : dir.value === "rtl" ? -90 : 90}deg)` } }));
+		}
+	});
+}
+var ScheduleHeaderNext = directionalControl("ScheduleHeaderNext", "next");
+var ScheduleHeaderPrevious = directionalControl("ScheduleHeaderPrevious", "previous");
+var ScheduleHeaderToday = (0, vue.defineComponent)({
+	name: "ScheduleHeaderToday",
+	inheritAttrs: false,
+	props: commonControlProps,
+	setup(props, { attrs }) {
+		const inherited = (0, vue.inject)(labelsKey, void 0);
+		return () => (0, vue.h)(HeaderControl, {
+			...attrs,
+			...props,
+			"data-type": "today",
+			"aria-label": getLabel("today", props.labels || inherited)
+		}, () => getLabel("today", props.labels || inherited));
+	}
+});
+var ViewSelect = (0, vue.defineComponent)({
+	name: "ViewSelect",
+	inheritAttrs: false,
+	props: {
+		views: {
+			type: Array,
+			default: () => [
+				"day",
+				"week",
+				"month",
+				"year"
+			]
+		},
+		value: String,
+		onChange: Function,
+		radius: [String, Number],
+		labels: Object
+	},
+	setup(props, { attrs }) {
+		const inherited = (0, vue.inject)(labelsKey, void 0);
+		const switchLabels = {
+			day: "switchToDayView",
+			week: "switchToWeekView",
+			month: "switchToMonthView",
+			year: "switchToYearView"
+		};
+		const onKeydown = (event, index) => {
+			const controls = event.currentTarget.parentElement?.querySelectorAll("[role=\"tab\"]");
+			if (!controls?.length) return;
+			let next = index;
+			if (event.key === "ArrowRight") next = (index + 1) % controls.length;
+			else if (event.key === "ArrowLeft") next = (index - 1 + controls.length) % controls.length;
+			else if (event.key === "Home") next = 0;
+			else if (event.key === "End") next = controls.length - 1;
+			else return;
+			event.preventDefault();
+			controls[next]?.focus();
+		};
+		return () => {
+			const labels = props.labels || inherited;
+			return (0, vue.h)(_mantine_vue_core.Box, {
+				...attrs,
+				class: [ViewSelect_module_default.viewSelect, attrs.class],
+				role: "tablist",
+				"aria-label": getLabel("viewSelectLabel", labels)
+			}, () => props.views.map((view, index) => (0, vue.h)(HeaderControl, {
+				active: view === props.value,
+				radius: props.radius,
+				role: "tab",
+				"data-type": view,
+				"aria-selected": view === props.value,
+				"aria-label": getLabel(switchLabels[view], labels),
+				tabindex: view === props.value ? 0 : -1,
+				onClick: () => props.onChange?.(view),
+				onKeydown: (event) => onKeydown(event, index)
+			}, () => getLabel(view, labels))));
+		};
+	}
+});
+var MonthYearSelect = (0, vue.defineComponent)({
+	name: "MonthYearSelect",
+	inheritAttrs: false,
+	props: {
+		locale: String,
+		startYear: Number,
+		endYear: Number,
+		yearValue: Number,
+		monthValue: Number,
+		onYearChange: Function,
+		onMonthChange: Function,
+		monthsListFormat: [String, Function],
+		labelFormat: [String, Function],
+		radius: [String, Number],
+		getYearControlProps: Function,
+		getMonthControlProps: Function,
+		withMonths: {
+			type: Boolean,
+			default: true
+		},
+		labels: Object
+	},
+	setup(props, { attrs }) {
+		const inherited = (0, vue.inject)(labelsKey, void 0);
+		const opened = (0, vue.ref)(false);
+		const today = /* @__PURE__ */ new Date();
+		return () => {
+			const labels = props.labels || inherited;
+			const startYear = props.startYear ?? today.getFullYear() - 5;
+			const endYear = props.endYear ?? today.getFullYear() + 5;
+			const selected = new Date(props.yearValue ?? today.getFullYear(), props.monthValue ?? today.getMonth(), 1);
+			const hasActiveYear = props.yearValue !== void 0 && props.yearValue >= startYear && props.yearValue <= endYear;
+			const months = props.withMonths ? getMonthsList({
+				locale: props.locale || "en",
+				format: props.monthsListFormat || "MMMM"
+			}).map((month) => {
+				const extra = props.getMonthControlProps?.(month.month) || {};
+				return (0, vue.h)(_mantine_vue_core.UnstyledButton, {
+					...extra,
+					class: [MonthYearSelect_module_default.monthYearSelectControl, extra.class],
+					mod: {
+						type: "month",
+						active: month.month === props.monthValue
+					},
+					tabindex: month.month === props.monthValue ? 0 : -1,
+					"aria-label": `${getLabel("selectMonth", labels)} ${month.name}`,
+					onKeydown: (0, _mantine_vue_core.createScopedKeydownHandler)({
+						siblingSelector: "[data-type=\"month\"]:not(:disabled)",
+						parentSelector: "[data-list]",
+						activateOnFocus: false,
+						loop: true,
+						orientation: "vertical",
+						onKeydown: extra.onKeydown
+					}),
+					onClick: () => {
+						props.onMonthChange?.(month.month);
+					}
+				}, () => month.name);
+			}) : [];
+			const years = getYearsList({
+				startYear,
+				endYear
+			}).map((year, index) => {
+				const extra = props.getYearControlProps?.(year) || {};
+				return (0, vue.h)(_mantine_vue_core.UnstyledButton, {
+					...extra,
+					class: [MonthYearSelect_module_default.monthYearSelectControl, extra.class],
+					mod: {
+						type: "year",
+						active: year === props.yearValue
+					},
+					tabindex: hasActiveYear ? year === props.yearValue ? 0 : -1 : index === 0 ? 0 : -1,
+					"aria-label": `${getLabel("selectYear", labels)} ${year}`,
+					onKeydown: (0, _mantine_vue_core.createScopedKeydownHandler)({
+						siblingSelector: "[data-type=\"year\"]:not(:disabled)",
+						parentSelector: "[data-list]",
+						activateOnFocus: false,
+						loop: true,
+						orientation: "vertical",
+						onKeydown: extra.onKeydown
+					}),
+					onClick: () => {
+						props.onYearChange?.(year);
+						if (!props.withMonths) opened.value = false;
+					}
+				}, () => String(year));
+			});
+			return (0, vue.h)(_mantine_vue_core.Popover, {
+				position: "bottom-start",
+				trapFocus: true,
+				transitionProps: {
+					transition: "pop",
+					duration: 120
+				},
+				radius: props.radius || "var(--schedule-radius, var(--mantine-radius-default))",
+				shadow: "md",
+				offset: 3,
+				width: props.withMonths ? void 0 : "target",
+				opened: opened.value,
+				onChange: (value) => {
+					opened.value = value;
+				}
+			}, () => [(0, vue.h)(_mantine_vue_core.Popover.Target, null, () => (0, vue.h)(HeaderControl, {
+				...attrs,
+				class: [MonthYearSelect_module_default.monthYearSelectTarget, attrs.class],
+				radius: props.radius,
+				"data-with-months": props.withMonths || void 0,
+				onClick: () => {
+					opened.value = !opened.value;
+				}
+			}, () => formatDate({
+				date: selected,
+				locale: props.locale || "en",
+				format: props.labelFormat || (props.withMonths ? "MMMM YYYY" : "YYYY")
+			}))), (0, vue.h)(_mantine_vue_core.Popover.Dropdown, {
+				class: MonthYearSelect_module_default.monthYearSelectDropdown,
+				"data-with-months": props.withMonths || void 0
+			}, () => [props.withMonths ? (0, vue.h)(_mantine_vue_core.Box, {
+				class: MonthYearSelect_module_default.monthYearSelectList,
+				"data-list": true
+			}, () => [(0, vue.h)(_mantine_vue_core.Box, { class: MonthYearSelect_module_default.monthYearSelectLabel }, () => getLabel("month", labels)), ...months]) : null, (0, vue.h)(_mantine_vue_core.Box, {
+				class: MonthYearSelect_module_default.monthYearSelectList,
+				"data-list": true
+			}, () => [props.withMonths ? (0, vue.h)(_mantine_vue_core.Box, { class: MonthYearSelect_module_default.monthYearSelectLabel }, () => getLabel("year", labels)) : null, ...years])])]);
+		};
+	}
+});
+var ScheduleHeaderBaseComponent = (0, vue.defineComponent)({
+	name: "ScheduleHeader",
+	inheritAttrs: false,
+	props: { labels: Object },
+	setup(props, { attrs, slots }) {
+		(0, vue.provide)(labelsKey, props.labels);
+		return () => (0, vue.h)(_mantine_vue_core.Box, {
+			...attrs,
+			class: [ScheduleHeader_module_default.header, attrs.class]
+		}, () => slots.default?.());
+	}
+});
+var ScheduleHeader = Object.assign(ScheduleHeaderBaseComponent, {
+	Control: HeaderControl,
+	Next: ScheduleHeaderNext,
+	Previous: ScheduleHeaderPrevious,
+	Today: ScheduleHeaderToday,
+	ViewSelect,
+	MonthYearSelect
+});
+//#endregion
+//#region src/components/ScheduleHeader/ScheduleHeaderBase.ts
+var ScheduleHeaderBase = (0, vue.defineComponent)({
+	name: "ScheduleHeaderBase",
+	props: {
+		view: {
+			type: String,
+			required: true
+		},
+		navigationHandlers: {
+			type: Object,
+			required: true
+		},
+		control: {
+			type: Object,
+			required: true
+		},
+		labels: Object,
+		onDateChange: Function,
+		onViewChange: Function,
+		previousControlProps: Object,
+		nextControlProps: Object,
+		todayControlProps: Object,
+		viewSelectProps: Object
+	},
+	setup(props) {
+		return () => {
+			const views = props.viewSelectProps?.views || [
+				"day",
+				"week",
+				"month",
+				"year"
+			];
+			return (0, vue.h)(ScheduleHeader, { labels: props.labels }, () => [
+				(0, vue.h)(_mantine_vue_core.Box, { class: ScheduleHeader_module_default.navigationGroup }, () => [
+					(0, vue.h)(ScheduleHeader.Previous, {
+						...props.previousControlProps,
+						onClick: () => props.onDateChange?.(props.navigationHandlers.previous())
+					}),
+					props.control.monthYearSelect ? (0, vue.h)(ScheduleHeader.MonthYearSelect, {
+						...props.control.monthYearSelect,
+						labels: props.labels
+					}) : (0, vue.h)(ScheduleHeader.Control, { interactive: false }, () => props.control.title),
+					(0, vue.h)(ScheduleHeader.Next, {
+						...props.nextControlProps,
+						onClick: () => props.onDateChange?.(props.navigationHandlers.next())
+					})
+				]),
+				(0, vue.h)(_mantine_vue_core.Box, { class: ScheduleHeader_module_default.todayControl }, () => [(0, vue.h)(ScheduleHeader.Today, {
+					...props.todayControlProps,
+					onClick: () => props.onDateChange?.(props.navigationHandlers.today())
+				})]),
+				(0, vue.h)(_mantine_vue_core.NativeSelect, {
+					class: ScheduleHeader_module_default.compactViewSelect,
+					value: props.view,
+					size: "sm",
+					data: views.map((view) => ({
+						value: view,
+						label: getLabel(view, props.labels)
+					})),
+					"aria-label": getLabel("viewSelectLabel", props.labels),
+					onChange: (event) => props.onViewChange?.(event.currentTarget.value)
+				}),
+				(0, vue.h)(_mantine_vue_core.Box, {
+					class: ScheduleHeader_module_default.viewSelect,
+					style: { marginInlineStart: "auto" }
+				}, () => [(0, vue.h)(ScheduleHeader.ViewSelect, {
+					...props.viewSelectProps,
+					value: props.view,
+					labels: props.labels,
+					onChange: props.onViewChange
+				})])
+			]);
+		};
+	}
+});
+function createHeaderNavigation(date, unit) {
+	return {
+		previous: () => toDateString((0, dayjs.default)(date).subtract(1, unit)),
+		next: () => toDateString((0, dayjs.default)(date).add(1, unit)),
+		today: () => toDateString((0, dayjs.default)())
+	};
+}
+//#endregion
+//#region src/components/DayView/get-day-view-events/get-day-positioned-events.ts
+function columnHasConflict$1({ columns, columnIndex, event, allDay, date }) {
+	if (!columns[columnIndex]) return false;
+	return columns[columnIndex].some((e) => {
+		const eAllDay = isAllDayEvent({
+			event: e,
+			date
+		});
+		const hasTimeConflict = isEventsOverlap(e, event);
+		if (allDay || eAllDay) return false;
+		return hasTimeConflict;
+	});
+}
+function getDayPositionedEvents({ events, startTime, endTime, intervalMinutes, date }) {
+	const columns = [];
+	const positioned = [];
+	const sorted = sortEvents(events);
+	for (const event of sorted) {
+		const allDay = isAllDayEvent({
+			event,
+			date
+		});
+		let column = 0;
+		while (columnHasConflict$1({
+			columns,
+			columnIndex: column,
+			event,
+			allDay,
+			date
+		})) column++;
+		if (!columns[column]) columns[column] = [];
+		columns[column].push(event);
+		const verticalPosition = allDay ? {
+			top: 0,
+			height: 100
+		} : getDayPosition({
+			event,
+			startTime,
+			endTime,
+			intervalMinutes
+		});
+		positioned.push({
+			...event,
+			position: {
+				...verticalPosition,
+				allDay,
+				column,
+				width: 0,
+				offset: 0,
+				overlaps: 0
+			}
+		});
+	}
+	for (const positionedEvent of positioned) {
+		const { allDay, column } = positionedEvent.position;
+		if (allDay) {
+			positionedEvent.position.overlaps = 1;
+			positionedEvent.position.width = 100;
+			positionedEvent.position.offset = 0;
+			continue;
+		}
+		const directlyOverlapping = [];
+		for (const otherEvent of positioned) {
+			if (otherEvent === positionedEvent || otherEvent.position.allDay) continue;
+			if (isEventsOverlap(otherEvent, positionedEvent)) directlyOverlapping.push(otherEvent);
+		}
+		let maxColumn = column;
+		for (const overlappingEvent of directlyOverlapping) {
+			maxColumn = Math.max(maxColumn, overlappingEvent.position.column);
+			for (const otherEvent of positioned) {
+				if (otherEvent === overlappingEvent || otherEvent.position.allDay) continue;
+				if (isEventsOverlap(otherEvent, overlappingEvent)) maxColumn = Math.max(maxColumn, otherEvent.position.column);
+			}
+		}
+		const totalColumns = maxColumn + 1;
+		let nextOccupiedColumn = totalColumns;
+		for (const other of directlyOverlapping) if (other.position.column > column && other.position.column < nextOccupiedColumn) nextOccupiedColumn = other.position.column;
+		const columnsSpanned = nextOccupiedColumn - column;
+		positionedEvent.position.overlaps = totalColumns;
+		positionedEvent.position.width = columnsSpanned / totalColumns * 100;
+		positionedEvent.position.offset = column * 100 / totalColumns;
+	}
+	return positioned;
+}
+//#endregion
+//#region src/components/DayView/get-day-view-events/get-day-view-events.ts
+function getDayViewEvents({ events, date, startTime, endTime, intervalMinutes }) {
+	if (events === void 0) return {
+		allDayEvents: [],
+		regularEvents: [],
+		backgroundTimedEvents: [],
+		backgroundAllDayEvents: []
+	};
+	const ids = /* @__PURE__ */ new Set();
+	const filteredEvents = [];
+	const backgroundFiltered = [];
+	const dayStart = (0, dayjs.default)(date).startOf("day");
+	const dayEnd = (0, dayjs.default)(date).endOf("day");
+	for (const event of events) {
+		const eventStart = (0, dayjs.default)(event.start);
+		const eventEnd = (0, dayjs.default)(event.end);
+		const isOnDay = eventStart.isSame(dayStart, "day");
+		const spansIntoDay = !isOnDay && event.display === "background" && eventStart.isBefore(dayEnd) && eventEnd.isAfter(dayStart);
+		if (isOnDay || spansIntoDay) {
+			if (isOnDay && !isEventInTimeRange({
+				event,
+				startTime,
+				endTime
+			})) continue;
+			const validated = validateEvent(event);
+			if (!ids.has(event.id)) ids.add(event.id);
+			else throw new Error(`[@mantine/schedule] DayView: Duplicated event ids found: ${event.id}`);
+			if (event.display === "background") backgroundFiltered.push(validated);
+			else filteredEvents.push(validated);
+		}
+	}
+	const positionedEvents = getDayPositionedEvents({
+		events: filteredEvents,
+		startTime,
+		endTime,
+		intervalMinutes,
+		date
+	});
+	const allDayEvents = [];
+	const regularEvents = [];
+	for (const event of positionedEvents) if (event.position.allDay) allDayEvents.push(event);
+	else regularEvents.push(event);
+	const backgroundTimedEvents = [];
+	const backgroundAllDayEvents = [];
+	for (const event of backgroundFiltered) {
+		const eventStart = (0, dayjs.default)(event.start);
+		const eventEnd = (0, dayjs.default)(event.end);
+		const clippedStart = eventStart.isBefore(dayStart) ? dayStart : eventStart;
+		const clippedEnd = eventEnd.isAfter(dayEnd) ? dayEnd : eventEnd;
+		const clippedEvent = {
+			...event,
+			start: clippedStart.format("YYYY-MM-DD HH:mm:ss"),
+			end: clippedEnd.format("YYYY-MM-DD HH:mm:ss")
+		};
+		if (isAllDayEvent({
+			event: clippedEvent,
+			date
+		})) backgroundAllDayEvents.push({
+			...event,
+			position: {
+				top: 0,
+				height: 100,
+				allDay: true,
+				width: 100,
+				offset: 0,
+				column: 0,
+				overlaps: 1
+			}
+		});
+		else {
+			const { top, height } = getDayPosition({
+				event: clippedEvent,
+				startTime,
+				endTime,
+				intervalMinutes
+			});
+			if (height <= 0) continue;
+			backgroundTimedEvents.push({
+				...event,
+				position: {
+					top,
+					height,
+					allDay: false,
+					width: 100,
+					offset: 0,
+					column: 0,
+					overlaps: 1
+				}
+			});
+		}
+	}
+	return {
+		allDayEvents,
+		regularEvents,
+		backgroundTimedEvents,
+		backgroundAllDayEvents
+	};
+}
+var DayView_module_default = {
+	dayView: "_dayView_wgb7d_1",
+	dayViewHeader: "_dayViewHeader_wgb7d_22",
+	dayViewScrollArea: "_dayViewScrollArea_wgb7d_32",
+	dayViewInner: "_dayViewInner_wgb7d_42",
+	dayViewTimeSlots: "_dayViewTimeSlots_wgb7d_46",
+	dayViewSlot: "_dayViewSlot_wgb7d_49",
+	dayViewSlotLabels: "_dayViewSlotLabels_wgb7d_54",
+	dayViewSlotLabel: "_dayViewSlotLabel_wgb7d_54",
+	dayViewSlots: "_dayViewSlots_wgb7d_84",
+	dayViewBackgroundEvent: "_dayViewBackgroundEvent_wgb7d_188",
+	dayViewAllDay: "_dayViewAllDay_wgb7d_201",
+	dayViewAllDayEvents: "_dayViewAllDayEvents_wgb7d_206"
+};
+//#endregion
+//#region src/components/DayView/DayView.ts
+var DayView = (0, vue.defineComponent)({
+	name: "DayView",
+	inheritAttrs: false,
+	slots: Object,
+	props: {
+		...timeViewProps,
+		intervalMinutes: {
+			type: Number,
+			default: 15
+		},
+		headerFormat: {
+			type: [String, Function],
+			default: "MMMM D, YYYY"
+		},
+		withAllDaySlot: {
+			type: Boolean,
+			default: true
+		},
+		allDaySlotHeight: {
+			type: [String, Number],
+			default: 44
+		},
+		maxAllDayEvents: {
+			type: Number,
+			default: 3
+		},
+		moreEventsProps: Object
+	},
+	setup(props, { attrs, slots }) {
+		const timeSlotsContainer = (0, vue.ref)(null);
+		const dropTargetSlotIndex = (0, vue.ref)(null);
+		const eventResize = useEventResize({
+			enabled: () => props.withEventResize,
+			mode: () => props.mode,
+			startTime: () => props.startTime,
+			endTime: () => props.endTime,
+			intervalMinutes: () => props.intervalMinutes,
+			onEventResize: () => props.onEventResize,
+			canResizeEvent: () => props.canResizeEvent
+		});
+		const slotTimes = (0, vue.ref)([]);
+		const dayGroupRef = (0, vue.ref)("");
+		const slotDragSelect = useSlotDragSelect({
+			enabled: () => props.withDragSlotSelect && props.mode !== "static",
+			onDragEnd: () => props.onSlotDragEnd ? (startIndex, endIndex) => {
+				const startSlot = slotTimes.value[startIndex];
+				const endSlot = slotTimes.value[endIndex];
+				if (startSlot && endSlot) props.onSlotDragEnd?.(`${dayGroupRef.value} ${startSlot.startTime}`, `${dayGroupRef.value} ${endSlot.endTime}`);
+			} : void 0
+		});
+		return () => {
+			const date = toDateString(props.date);
+			const datePart = (0, dayjs.default)(date).format("YYYY-MM-DD");
+			const now = (0, dayjs.default)(props.getCurrentTime?.() ?? (0, dayjs.default)());
+			const showCurrentTimeIndicator = props.withCurrentTimeIndicator ?? (0, dayjs.default)(date).isSame(now, "day");
+			const expanded = getExpandedEvents(props.events, (0, dayjs.default)(date).startOf("day").format("YYYY-MM-DD HH:mm:ss"), (0, dayjs.default)(date).endOf("day").format("YYYY-MM-DD HH:mm:ss"), props.recurrenceExpansionLimit);
+			const { allDayEvents, regularEvents, backgroundTimedEvents, backgroundAllDayEvents } = getDayViewEvents({
+				events: expanded,
+				date,
+				startTime: props.startTime,
+				endTime: props.endTime,
+				intervalMinutes: props.intervalMinutes
+			});
+			const intervals = getDayTimeIntervals({
+				startTime: props.startTime,
+				endTime: props.endTime,
+				intervalMinutes: props.intervalMinutes
+			});
+			dayGroupRef.value = datePart;
+			slotTimes.value = intervals.map((slot) => ({
+				startTime: slot.startTime,
+				endTime: slot.endTime
+			}));
+			const withSlotSelect = props.withDragSlotSelect && props.mode !== "static";
+			const withDragHandlers = props.mode !== "static" && (props.withEventsDragAndDrop || Boolean(props.onExternalEventDrop));
+			const { visibleEventsCount, hiddenEventsCount } = getVisibleEvents({
+				maxEvents: props.maxAllDayEvents,
+				totalEvents: allDayEvents.length
+			});
+			const emitDrop = (nativeEvent, target) => {
+				nativeEvent.preventDefault();
+				const event = getDropEvent(expanded, nativeEvent.dataTransfer);
+				if (event) props.onEventDrop?.(moveEventTo(event, target));
+				else if (nativeEvent.dataTransfer) props.onExternalEventDrop?.(nativeEvent.dataTransfer, target);
+			};
+			const emitAllDayDrop = (nativeEvent) => {
+				nativeEvent.preventDefault();
+				const event = getDropEvent(expanded, nativeEvent.dataTransfer);
+				if (event) props.onEventDrop?.(moveEventToAllDay(event, datePart));
+				else if (nativeEvent.dataTransfer) props.onExternalEventDrop?.(nativeEvent.dataTransfer, `${datePart} 00:00:00`);
+			};
+			const rootStyle = {
+				"--day-view-radius": resolveScheduleRadius(props.radius),
+				"--day-view-slot-height": typeof props.slotHeight === "number" ? `${props.slotHeight}px` : props.slotHeight,
+				"--day-view-all-day-slot-height": typeof props.allDaySlotHeight === "number" ? `${props.allDaySlotHeight}px` : props.allDaySlotHeight
+			};
+			return (0, vue.h)(_mantine_vue_core.Box, {
+				...attrs,
+				class: [DayView_module_default.dayView, attrs.class],
+				style: [rootStyle, attrs.style],
+				mod: {
+					static: props.mode === "static",
+					"slot-dragging": slotDragSelect.isDragging()
+				}
+			}, () => [props.withHeader ? (0, vue.h)(ScheduleHeaderBase, {
+				view: "day",
+				labels: props.labels,
+				onDateChange: props.onDateChange,
+				onViewChange: props.onViewChange,
+				navigationHandlers: createHeaderNavigation(date, "day"),
+				previousControlProps: props.previousControlProps,
+				nextControlProps: props.nextControlProps,
+				todayControlProps: props.todayControlProps,
+				viewSelectProps: props.viewSelectProps,
+				control: { title: formatDate({
+					date,
+					locale: props.locale || "en",
+					format: props.headerFormat
+				}) }
+			}) : null, (0, vue.h)(_mantine_vue_core.ScrollArea.Autosize, {
+				class: DayView_module_default.dayViewScrollArea,
+				scrollbarSize: 4
+			}, () => [(0, vue.h)(_mantine_vue_core.Box, { class: DayView_module_default.dayViewInner }, () => [(0, vue.h)("div", { class: DayView_module_default.dayViewSlotLabels }, [props.withAllDaySlot ? (0, vue.h)(_mantine_vue_core.Box, {
+				class: DayView_module_default.dayViewSlotLabel,
+				mod: { "all-day": true }
+			}, () => getLabelSafe("allDay", props.labels)) : null, ...intervals.filter((slot) => slot.isHourStart).map((slot) => (0, vue.h)(_mantine_vue_core.Box, { class: DayView_module_default.dayViewSlotLabel }, () => formatDate({
+				date: `${datePart} ${slot.startTime}`,
+				locale: props.locale || "en",
+				format: props.slotLabelFormat
+			})))]), (0, vue.h)("div", { class: DayView_module_default.dayViewSlots }, [props.withAllDaySlot ? (0, vue.h)("div", { class: DayView_module_default.dayViewAllDay }, [
+				...backgroundAllDayEvents.map((event) => (0, vue.h)("div", {
+					class: DayView_module_default.dayViewBackgroundEvent,
+					key: event.id
+				})),
+				(0, vue.h)("div", { class: DayView_module_default.dayViewAllDayEvents }, [...allDayEvents.slice(0, visibleEventsCount).map((event) => eventNode(event, props, {
+					key: event.id,
+					nowrap: true
+				}, slots)), hiddenEventsCount > 0 ? (0, vue.h)(MoreEvents, {
+					events: allDayEvents,
+					moreEventsCount: hiddenEventsCount,
+					labels: props.labels,
+					mode: props.mode,
+					renderEvent: props.renderEvent,
+					renderEventBody: props.renderEventBody,
+					onEventClick: props.onEventClick,
+					...props.moreEventsProps
+				}, forwardEventSlots(slots)) : null]),
+				(0, vue.h)(_mantine_vue_core.UnstyledButton, {
+					class: DayView_module_default.dayViewSlot,
+					mod: {
+						"all-day": true,
+						static: props.mode === "static"
+					},
+					tabindex: props.mode === "static" ? -1 : 0,
+					"aria-label": `${getLabelSafe("timeSlot", props.labels)} ${getLabelSafe("allDay", props.labels)}`,
+					onClick: props.mode === "static" ? void 0 : (event) => props.onAllDaySlotClick?.(date, event),
+					onDragover: (event) => event.preventDefault(),
+					onDrop: (event) => emitAllDayDrop(event)
+				})
+			]) : null, (0, vue.h)("div", {
+				ref: timeSlotsContainer,
+				class: DayView_module_default.dayViewTimeSlots,
+				onDragover: withDragHandlers ? (event) => {
+					event.preventDefault();
+					if (!timeSlotsContainer.value) return;
+					dropTargetSlotIndex.value = getTimeSlotDropTarget({
+						nativeEvent: event,
+						container: timeSlotsContainer.value,
+						intervals,
+						date: datePart
+					})?.slotIndex ?? null;
+					if (event.dataTransfer) event.dataTransfer.dropEffect = event.dataTransfer.types.includes("application/json") ? "move" : "copy";
+				} : void 0,
+				onDragleave: withDragHandlers ? (event) => {
+					if (!(event.relatedTarget instanceof Node) || !timeSlotsContainer.value?.contains(event.relatedTarget)) dropTargetSlotIndex.value = null;
+				} : void 0,
+				onDrop: withDragHandlers ? (event) => {
+					if (!timeSlotsContainer.value) return;
+					const target = getTimeSlotDropTarget({
+						nativeEvent: event,
+						container: timeSlotsContainer.value,
+						intervals,
+						date: datePart
+					});
+					dropTargetSlotIndex.value = null;
+					if (target) emitDrop(event, target.target);
+				} : void 0
+			}, [
+				...backgroundTimedEvents.map((event) => (0, vue.h)("div", {
+					key: event.id,
+					class: DayView_module_default.dayViewBackgroundEvent,
+					style: {
+						top: `${event.position.top}%`,
+						height: `${event.position.height}%`
+					}
+				})),
+				...regularEvents.map((event) => {
+					const resizePosition = eventResize.getResizePosition(event.id);
+					const isResizable = eventResize.isResizableEvent(event);
+					return eventNode(event, props, {
+						key: event.id,
+						autoSize: true,
+						style: {
+							position: "absolute",
+							top: `${resizePosition?.top ?? event.position.top}%`,
+							height: `${resizePosition?.height ?? event.position.height}%`,
+							width: `${event.position.width}%`,
+							insetInlineStart: `${event.position.offset}%`
+						},
+						withResize: isResizable,
+						isResizing: resizePosition !== null,
+						onClick: props.onEventClick ? (nativeEvent) => {
+							if (!eventResize.wasResizing()) props.onEventClick?.(event, nativeEvent);
+						} : void 0,
+						onResizeStart: (edge, pointerEvent) => {
+							if (!timeSlotsContainer.value) return;
+							eventResize.handleResizeStart({
+								event,
+								edge,
+								container: timeSlotsContainer.value,
+								originalTop: event.position.top,
+								originalHeight: event.position.height,
+								eventDate: datePart,
+								pointerEvent
+							});
+						}
+					}, slots);
+				}),
+				showCurrentTimeIndicator ? (0, vue.h)(CurrentTimeIndicator, {
+					startOffset: "calc(var(--day-view-slot-labels-width) * -1)",
+					endOffset: "0rem",
+					topOffset: "0rem",
+					timeBubbleStartOffset: "calc(var(--day-view-slot-labels-width) * -1 + 30px)",
+					currentTimeFormat: props.slotLabelFormat,
+					startTime: props.startTime,
+					endTime: props.endTime,
+					intervalMinutes: props.intervalMinutes,
+					withTimeBubble: props.withCurrentTimeBubble,
+					withThumb: !props.withCurrentTimeBubble,
+					getCurrentTime: props.getCurrentTime,
+					locale: props.locale
+				}) : null,
+				...intervals.map((slot, index) => {
+					const start = (0, dayjs.default)(`${datePart} ${slot.startTime}`);
+					const end = start.add(props.intervalMinutes, "minute");
+					const mod = props.highlightBusinessHours ? getBusinessHoursMod({
+						time: start.format("HH:mm:ss"),
+						businessHours: props.businessHours || ["09:00:00", "17:00:00"],
+						highlightBusinessHours: true,
+						dayOfWeek: start.day()
+					}) : {
+						"business-hours": false,
+						"non-business-hours": false
+					};
+					return (0, vue.h)(_mantine_vue_core.UnstyledButton, {
+						class: DayView_module_default.dayViewSlot,
+						"data-time-slot-index": index,
+						"data-drag-slot-index": withSlotSelect ? index : void 0,
+						"data-drag-slot-group": withSlotSelect ? datePart : void 0,
+						style: { "--slot-size": String(props.intervalMinutes / 60) },
+						mod: {
+							first: index === 0,
+							"hour-start": slot.isHourStart,
+							static: props.mode === "static",
+							"drop-target": dropTargetSlotIndex.value === index,
+							"drag-selected": slotDragSelect.isSlotSelected(index, datePart),
+							"business-hours": mod["business-hours"],
+							"non-business-hours": mod["non-business-hours"]
+						},
+						tabindex: props.mode === "static" ? -1 : index === 0 ? 0 : -1,
+						onKeydown: props.mode === "static" ? void 0 : (event) => {
+							const nextIndex = event.key === "ArrowDown" ? index + 1 : event.key === "ArrowUp" ? index - 1 : -1;
+							if (nextIndex < 0 || nextIndex >= intervals.length) return;
+							event.preventDefault();
+							timeSlotsContainer.value?.querySelector(`[data-time-slot-index="${nextIndex}"]`)?.focus();
+						},
+						"aria-label": `${getLabelSafe("timeSlot", props.labels)} ${slot.startTime} - ${slot.endTime}`,
+						onClick: (nativeEvent) => props.onTimeSlotClick?.({
+							slotStart: start.format("YYYY-MM-DD HH:mm:ss"),
+							slotEnd: end.format("YYYY-MM-DD HH:mm:ss"),
+							nativeEvent
+						}),
+						onPointerdown: withSlotSelect ? (nativeEvent) => slotDragSelect.handleSlotPointerDown(nativeEvent, index, datePart) : void 0,
+						onDragover: (event) => event.preventDefault()
+					});
+				})
+			])])])])]);
+		};
+	}
+});
+function getLabelSafe(key, labels) {
+	return labels?.[key] || {
+		allDay: "All day",
+		timeSlot: "Time slot"
+	}[key];
+}
+//#endregion
+//#region src/components/MobileMonthView/get-mobile-month-view-events.ts
+function groupEventByDate$1(event, groupedEvents) {
+	if (isMultidayEvent(event)) {
+		const startDate = (0, dayjs.default)(event.start).startOf("day");
+		const endDate = (0, dayjs.default)(event.end).startOf("day");
+		for (let date = startDate; date.isBefore(endDate) || date.isSame(endDate); date = date.add(1, "day")) {
+			const dateKey = date.format("YYYY-MM-DD");
+			if (!groupedEvents[dateKey]) groupedEvents[dateKey] = [];
+			groupedEvents[dateKey].push(event);
+		}
+		return;
+	}
+	const eventDate = (0, dayjs.default)(event.start).format("YYYY-MM-DD");
+	if (!groupedEvents[eventDate]) groupedEvents[eventDate] = [];
+	groupedEvents[eventDate].push(event);
+}
+function getMobileMonthViewEvents({ date, events }) {
+	const groupedEvents = {};
+	if (events === void 0) return groupedEvents;
+	const ids = /* @__PURE__ */ new Set();
+	for (const event of events) {
+		if (event.display === "background") continue;
+		if ((0, dayjs.default)(event.start).isSame((0, dayjs.default)(date), "month")) {
+			groupEventByDate$1(validateEvent(event), groupedEvents);
+			if (!ids.has(event.id)) ids.add(event.id);
+			else throw new Error(`[@mantine/schedule] MobileMonthView: Duplicated event ids found: ${event.id}`);
+		}
+	}
+	return groupedEvents;
+}
+var MobileMonthView_module_default = {
+	mobileMonthView: "_mobileMonthView_vgzwg_1",
+	mobileMonthViewHeader: "_mobileMonthViewHeader_vgzwg_24",
+	mobileMonthViewHeaderBackButton: "_mobileMonthViewHeaderBackButton_vgzwg_32",
+	mobileMonthViewHeaderLabel: "_mobileMonthViewHeaderLabel_vgzwg_47",
+	mobileMonthViewCalendar: "_mobileMonthViewCalendar_vgzwg_53",
+	mobileMonthViewWeekdays: "_mobileMonthViewWeekdays_vgzwg_61",
+	mobileMonthViewWeekdaysCorner: "_mobileMonthViewWeekdaysCorner_vgzwg_66",
+	mobileMonthViewWeekday: "_mobileMonthViewWeekday_vgzwg_61",
+	mobileMonthViewWeek: "_mobileMonthViewWeek_vgzwg_61",
+	mobileMonthViewWeekNumber: "_mobileMonthViewWeekNumber_vgzwg_89",
+	mobileMonthViewDay: "_mobileMonthViewDay_vgzwg_119",
+	mobileMonthViewDayIndicators: "_mobileMonthViewDayIndicators_vgzwg_208",
+	mobileMonthViewDayIndicator: "_mobileMonthViewDayIndicator_vgzwg_208",
+	mobileMonthViewEventsList: "_mobileMonthViewEventsList_vgzwg_224",
+	mobileMonthViewEventsHeader: "_mobileMonthViewEventsHeader_vgzwg_232",
+	mobileMonthViewEvent: "_mobileMonthViewEvent_vgzwg_224",
+	mobileMonthViewEventBody: "_mobileMonthViewEventBody_vgzwg_259",
+	mobileMonthViewEventColor: "_mobileMonthViewEventColor_vgzwg_265",
+	mobileMonthViewEventTime: "_mobileMonthViewEventTime_vgzwg_271",
+	mobileMonthViewNoEvents: "_mobileMonthViewNoEvents_vgzwg_277"
+};
+//#endregion
+//#region src/components/MobileMonthView/MobileMonthView.ts
+var MobileMonthView = (0, vue.defineComponent)({
+	name: "MobileMonthView",
+	inheritAttrs: false,
+	slots: Object,
+	props: {
+		...baseViewProps,
+		selectedDate: [
+			String,
+			Date,
+			null
+		],
+		defaultSelectedDate: [
+			String,
+			Date,
+			null
+		],
+		onSelectedDateChange: Function,
+		withWeekNumbers: Boolean,
+		withWeekDays: {
+			type: Boolean,
+			default: true
+		},
+		firstDayOfWeek: {
+			type: Number,
+			default: 1
+		},
+		weekdayFormat: {
+			type: [String, Function],
+			default: "dd"
+		},
+		weekendDays: {
+			type: Array,
+			default: () => [0, 6]
+		},
+		getWeekNumberProps: Function,
+		getDayProps: Function,
+		onDayClick: Function,
+		onWeekNumberClick: Function,
+		consistentWeeks: {
+			type: Boolean,
+			default: true
+		},
+		highlightToday: {
+			type: Boolean,
+			default: true
+		},
+		withOutsideDays: Boolean,
+		eventsHeaderFormat: {
+			type: [String, Function],
+			default: "dddd, MMMM D"
+		},
+		onYearClick: Function,
+		renderHeader: Function
+	},
+	setup(props, { attrs, slots }) {
+		const { dir } = (0, _mantine_vue_core.useDirection)();
+		const theme = (0, _mantine_vue_core.useSafeMantineTheme)();
+		const internalSelected = (0, vue.ref)(props.selectedDate !== void 0 ? props.selectedDate ? (0, dayjs.default)(props.selectedDate).format("YYYY-MM-DD") : null : (0, dayjs.default)(props.defaultSelectedDate ?? (0, dayjs.default)()).format("YYYY-MM-DD"));
+		(0, vue.watch)(() => props.selectedDate, (value) => {
+			if (value !== void 0) internalSelected.value = value ? (0, dayjs.default)(value).format("YYYY-MM-DD") : null;
+		}, { immediate: true });
+		const select = (date) => {
+			internalSelected.value = date;
+			props.onSelectedDateChange?.(date);
+		};
+		return () => {
+			const month = (0, dayjs.default)(props.date).startOf("month");
+			const weeks = getMonthDays({
+				month,
+				firstDayOfWeek: props.firstDayOfWeek,
+				consistentWeeks: props.consistentWeeks
+			});
+			const eventsByDay = getMobileMonthViewEvents({
+				date: month,
+				events: getExpandedEvents(props.events, weeks[0][0], (0, dayjs.default)(weeks.at(-1).at(-1)).endOf("day").format("YYYY-MM-DD HH:mm:ss"), props.recurrenceExpansionLimit)
+			});
+			const weekdays = getWeekdaysNames({
+				locale: props.locale || "en",
+				format: props.weekdayFormat,
+				firstDayOfWeek: props.firstDayOfWeek
+			});
+			const selectedEvents = internalSelected.value ? eventsByDay[internalSelected.value] || [] : [];
+			const headerDefault = [(0, vue.h)(_mantine_vue_core.UnstyledButton, {
+				class: MobileMonthView_module_default.mobileMonthViewHeaderBackButton,
+				mod: { static: props.mode === "static" },
+				tabindex: props.mode === "static" ? -1 : 0,
+				onClick: props.mode === "static" ? void 0 : props.onYearClick
+			}, () => [(0, vue.h)(_mantine_vue_core.AccordionChevron, {
+				size: 20,
+				style: { transform: `rotate(${dir.value === "rtl" ? -90 : 90}deg)` }
+			}), month.format("YYYY")]), (0, vue.h)(_mantine_vue_core.Text, { class: MobileMonthView_module_default.mobileMonthViewHeaderLabel }, () => formatDate({
+				date: month,
+				locale: props.locale || "en",
+				format: "MMMM YYYY"
+			}))];
+			return (0, vue.h)(_mantine_vue_core.Box, {
+				...attrs,
+				class: [MobileMonthView_module_default.mobileMonthView, attrs.class],
+				style: [{ "--mobile-month-view-radius": resolveScheduleRadius(props.radius) }, attrs.style],
+				mod: { "with-week-numbers": props.withWeekNumbers }
+			}, () => [
+				(0, vue.h)("div", { class: MobileMonthView_module_default.mobileMonthViewHeader }, [props.renderHeader?.({
+					mode: props.mode,
+					date: props.date,
+					defaultHeader: headerDefault
+				}) || slots.header?.({
+					mode: props.mode,
+					date: props.date,
+					defaultHeader: headerDefault
+				}) || headerDefault]),
+				(0, vue.h)(_mantine_vue_core.Box, {
+					class: MobileMonthView_module_default.mobileMonthViewCalendar,
+					mod: { "with-weekdays": props.withWeekDays }
+				}, () => [props.withWeekDays ? (0, vue.h)("div", { class: MobileMonthView_module_default.mobileMonthViewWeekdays }, [props.withWeekNumbers ? (0, vue.h)("span", { class: MobileMonthView_module_default.mobileMonthViewWeekdaysCorner }) : null, ...weekdays.map((weekday) => (0, vue.h)("span", { class: MobileMonthView_module_default.mobileMonthViewWeekday }, [weekday]))]) : null, ...weeks.map((week) => (0, vue.h)("div", { class: MobileMonthView_module_default.mobileMonthViewWeek }, [props.withWeekNumbers ? (0, vue.h)(_mantine_vue_core.UnstyledButton, {
+					class: MobileMonthView_module_default.mobileMonthViewWeekNumber,
+					mod: { static: props.mode === "static" },
+					tabindex: props.mode === "static" ? -1 : 0,
+					...props.getWeekNumberProps?.((0, dayjs.default)(week[0]).format("YYYY-MM-DD")),
+					onClick: (event) => props.onWeekNumberClick?.((0, dayjs.default)(week[0]).format("YYYY-MM-DD"), event)
+				}, () => String(getWeekNumber(week))) : null, ...week.map((date) => {
+					const value = (0, dayjs.default)(date).format("YYYY-MM-DD");
+					const outside = !(0, dayjs.default)(date).isSame(month, "month");
+					const events = eventsByDay[value] || [];
+					const extra = props.getDayProps?.(value) || {};
+					const shouldRender = !outside || props.withOutsideDays;
+					return (0, vue.h)(_mantine_vue_core.UnstyledButton, {
+						...extra,
+						class: [MobileMonthView_module_default.mobileMonthViewDay, extra.class],
+						mod: {
+							outside,
+							weekend: props.weekendDays.includes((0, dayjs.default)(date).day()),
+							today: props.highlightToday && (0, dayjs.default)(date).isSame((0, dayjs.default)(), "day"),
+							selected: internalSelected.value === value,
+							static: props.mode === "static",
+							hidden: !shouldRender
+						},
+						tabindex: props.mode === "static" || !shouldRender ? -1 : 0,
+						"aria-label": formatDate({
+							date,
+							locale: props.locale || "en",
+							format: "MMMM D, YYYY"
+						}),
+						"aria-selected": internalSelected.value === value || void 0,
+						onClick: props.mode === "static" || !shouldRender ? void 0 : (event) => {
+							select(value);
+							props.onDayClick?.(value, event);
+						}
+					}, () => [shouldRender ? String((0, dayjs.default)(date).date()) : null, shouldRender && events.length ? (0, vue.h)("span", { class: MobileMonthView_module_default.mobileMonthViewDayIndicators }, events.slice(0, 3).map((event) => (0, vue.h)("span", {
+						class: MobileMonthView_module_default.mobileMonthViewDayIndicator,
+						style: { background: `var(--mantine-color-${event.color}-6, ${event.color})` }
+					}))) : null]);
+				})]))]),
+				(0, vue.h)(_mantine_vue_core.Box, { class: MobileMonthView_module_default.mobileMonthViewEventsList }, () => [(0, vue.h)(_mantine_vue_core.Text, { class: MobileMonthView_module_default.mobileMonthViewEventsHeader }, () => internalSelected.value ? formatDate({
+					date: internalSelected.value,
+					locale: props.locale || "en",
+					format: props.eventsHeaderFormat
+				}) : ""), selectedEvents.length ? selectedEvents.map((event) => {
+					const startTime = (0, dayjs.default)(event.start).format("HH:mm");
+					const endTime = (0, dayjs.default)(event.end).format("HH:mm");
+					const isAllDay = startTime === "00:00" && endTime === "00:00";
+					const eventChildren = (0, vue.h)(_mantine_vue_core.Box, { class: MobileMonthView_module_default.mobileMonthViewEventBody }, () => [(0, vue.h)("div", {
+						class: MobileMonthView_module_default.mobileMonthViewEventColor,
+						style: { backgroundColor: (0, _mantine_vue_core.getThemeColor)(event.color, theme.value) }
+					}), (0, vue.h)("div", [(0, vue.h)(_mantine_vue_core.Text, { class: MobileMonthView_module_default.mobileMonthViewEventTitle }, () => event.title), (0, vue.h)(_mantine_vue_core.Text, { class: MobileMonthView_module_default.mobileMonthViewEventTime }, () => isAllDay ? "All day" : `${startTime} – ${endTime}`)])]);
+					const rootProps = {
+						type: "button",
+						class: MobileMonthView_module_default.mobileMonthViewEvent,
+						tabindex: props.mode === "static" ? -1 : 0,
+						onClick: props.mode === "static" ? void 0 : (nativeEvent) => props.onEventClick?.(event, nativeEvent)
+					};
+					return props.renderEvent?.(event, {
+						...rootProps,
+						children: eventChildren
+					}) || slots.event?.({
+						...rootProps,
+						children: eventChildren,
+						event
+					}) || (0, vue.h)(_mantine_vue_core.UnstyledButton, {
+						...rootProps,
+						key: event.id
+					}, () => eventChildren);
+				}) : (0, vue.h)(_mantine_vue_core.Text, { class: MobileMonthView_module_default.mobileMonthViewNoEvents }, () => props.labels?.noEvents || "No events")])
+			]);
+		};
+	}
+});
+//#endregion
+//#region src/components/keyboard-navigation.ts
+function handleGridKeydown({ event, index, columns, total, getControl }) {
+	const step = event.key === "ArrowRight" ? 1 : event.key === "ArrowLeft" ? -1 : event.key === "ArrowDown" ? columns : event.key === "ArrowUp" ? -columns : 0;
+	if (step === 0) return;
+	event.preventDefault();
+	for (let next = index + step; next >= 0 && next < total; next += step) {
+		const control = getControl(next);
+		if (control && !control.disabled && !control.hasAttribute("data-hidden")) {
+			control.focus();
+			return;
+		}
+	}
+}
+//#endregion
+//#region src/components/MonthView/get-month-view-events/add-event-to-day-groups.ts
+function addEventToDayGroups({ positionedEvent, eventStart, eventEnd, groupedByDay, eventsAddedToDay, weekIdx }) {
+	if (weekIdx === 0 || !eventsAddedToDay.has(positionedEvent.id.toString())) {
+		let dayDate = eventStart;
+		while (dayDate.isBefore(eventEnd) || dayDate.isSame(eventEnd, "day")) {
+			const dayDateStr = dayDate.format("YYYY-MM-DD 00:00:00");
+			if (groupedByDay[dayDateStr]) groupedByDay[dayDateStr].push(positionedEvent);
+			dayDate = dayDate.add(1, "day");
+		}
+		eventsAddedToDay.add(positionedEvent.id.toString());
+	}
+}
+//#endregion
+//#region src/components/MonthView/get-month-view-events/calculate-event-position-in-week.ts
+function calculateEventPositionInWeek({ eventStart, eventEnd, weekStart, weekEnd, isMultiday }) {
+	let displayStart = eventStart;
+	let displayEnd = eventEnd;
+	const hangingStart = eventStart.isBefore(weekStart);
+	const hangingEnd = eventEnd.isAfter(weekEnd);
+	const hanging = hangingStart && hangingEnd ? "both" : hangingStart ? "start" : hangingEnd ? "end" : "none";
+	if (displayStart.isBefore(weekStart)) displayStart = weekStart;
+	if (displayEnd.isAfter(weekEnd)) displayEnd = weekEnd;
+	const startDayIndex = displayStart.diff(weekStart, "day");
+	const endDayIndex = displayEnd.diff(weekStart, "day");
+	const daysSpanned = Math.max(1, endDayIndex - startDayIndex + (isMultiday ? 1 : 0));
+	return {
+		startDayIndex,
+		daysSpanned,
+		startOffset: startDayIndex / 7 * 100,
+		width: daysSpanned / 7 * 100,
+		hanging
+	};
+}
+//#endregion
+//#region src/components/MonthView/get-month-view-events/find-available-row.ts
+function findAvailableRow({ existingEvents, startDayIndex, daysSpanned, weekStart }) {
+	let row = 0;
+	for (const existing of existingEvents) {
+		const existingStart = (0, dayjs.default)(existing.start).startOf("day");
+		const existingDayIndex = (existingStart.isBefore(weekStart) || existingStart.isSame(weekStart, "day") ? weekStart : existingStart).diff(weekStart, "day");
+		if (existingDayIndex + (existing.position?.width || 0) / 100 * 7 > startDayIndex && existingDayIndex < startDayIndex + daysSpanned) row = Math.max(row, (existing.position?.row || 0) + 1);
+	}
+	return row;
+}
+//#endregion
+//#region src/components/MonthView/get-month-view-events/get-weeks-in-range.ts
+function getWeeksInRange({ rangeStart, rangeEnd, firstDayOfWeek }) {
+	const weeks = [];
+	const groupedByDay = {};
+	let currentDate = (0, dayjs.default)(getStartOfWeek({
+		date: rangeStart.format("YYYY-MM-DD"),
+		firstDayOfWeek
+	}));
+	while (currentDate.isBefore(rangeEnd) || currentDate.isSame(rangeEnd, "day")) {
+		const week = [];
+		for (let i = 0; i < 7; i++) {
+			const dateStr = currentDate.format("YYYY-MM-DD 00:00:00");
+			week.push(dateStr);
+			if (!groupedByDay[dateStr]) groupedByDay[dateStr] = [];
+			currentDate = currentDate.add(1, "day");
+		}
+		weeks.push(week);
+	}
+	return {
+		weeks,
+		groupedByDay
+	};
+}
+//#endregion
+//#region src/components/MonthView/get-month-view-events/get-month-positioned-events.ts
+function getMonthPositionedEvents({ date, events, firstDayOfWeek = 1, range }) {
+	const groupedByWeek = {};
+	const backgroundByWeek = {};
+	const eventsAddedToDay = /* @__PURE__ */ new Set();
+	const { weeks, groupedByDay } = getWeeksInRange({
+		rangeStart: range ? (0, dayjs.default)(range.start) : (0, dayjs.default)(date).startOf("month"),
+		rangeEnd: range ? (0, dayjs.default)(range.end) : (0, dayjs.default)(date).startOf("month").endOf("month"),
+		firstDayOfWeek
+	});
+	for (let i = 0; i < weeks.length; i++) {
+		groupedByWeek[i.toString()] = [];
+		backgroundByWeek[i.toString()] = [];
+	}
+	for (const event of events) {
+		const eventStart = (0, dayjs.default)(event.start).startOf("day");
+		const rawEnd = (0, dayjs.default)(event.end);
+		const eventEnd = rawEnd.hour() === 0 && rawEnd.minute() === 0 && rawEnd.second() === 0 ? rawEnd.startOf("day").subtract(1, "day") : rawEnd.startOf("day");
+		const isMultiday = eventEnd.isAfter(eventStart);
+		for (let weekIdx = 0; weekIdx < weeks.length; weekIdx++) {
+			const week = weeks[weekIdx];
+			const weekStart = (0, dayjs.default)(week[0]).startOf("day");
+			const weekEnd = (0, dayjs.default)(week[6]).endOf("day");
+			if ((eventStart.isBefore(weekEnd) || eventStart.isSame(weekEnd, "day")) && (eventEnd.isAfter(weekStart) || eventEnd.isSame(weekStart, "day"))) {
+				const { startDayIndex, daysSpanned, startOffset, width, hanging } = calculateEventPositionInWeek({
+					eventStart,
+					eventEnd,
+					weekStart,
+					weekEnd,
+					isMultiday
+				});
+				if (event.display === "background") {
+					backgroundByWeek[weekIdx.toString()].push({
+						...event,
+						position: {
+							startOffset,
+							width,
+							weekIndex: weekIdx,
+							row: 0,
+							hanging
+						}
+					});
+					continue;
+				}
+				const row = findAvailableRow({
+					existingEvents: groupedByWeek[weekIdx.toString()],
+					startDayIndex,
+					daysSpanned,
+					weekStart
+				});
+				const positionedEvent = {
+					...event,
+					position: {
+						startOffset,
+						width,
+						weekIndex: weekIdx,
+						row,
+						hanging
+					}
+				};
+				groupedByWeek[weekIdx.toString()].push(positionedEvent);
+				addEventToDayGroups({
+					positionedEvent,
+					eventStart,
+					eventEnd,
+					groupedByDay,
+					eventsAddedToDay,
+					weekIdx
+				});
+			}
+		}
+	}
+	return {
+		groupedByWeek,
+		groupedByDay,
+		backgroundByWeek
+	};
+}
+//#endregion
+//#region src/components/MonthView/get-month-view-events/get-month-view-events.ts
+function getMonthViewEvents({ date, events, firstDayOfWeek = 1, withOutsideDays, consistentWeeks }) {
+	if (events === void 0) return {
+		groupedByDay: {},
+		groupedByWeek: {},
+		backgroundByWeek: {}
+	};
+	const ids = /* @__PURE__ */ new Set();
+	const filteredEvents = [];
+	const range = getMonthRange({
+		month: date,
+		withOutsideDays,
+		consistentWeeks,
+		firstDayOfWeek
+	});
+	for (const event of events) if ((0, dayjs.default)(event.end).isAfter(range.start, "day") || (0, dayjs.default)(event.start).isBefore(range.end, "day")) {
+		filteredEvents.push(validateEvent(event));
+		if (!ids.has(event.id)) ids.add(event.id);
+		else throw new Error(`[@mantine/schedule] MonthView: Duplicated event ids found: ${event.id}`);
+	}
+	return getMonthPositionedEvents({
+		date,
+		events: filteredEvents,
+		firstDayOfWeek,
+		range
+	});
+}
+//#endregion
+//#region src/components/MonthView/get-renderable-month-event-segments.ts
+var DAYS_IN_WEEK = 7;
+var DAY_WIDTH = 100 / DAYS_IN_WEEK;
+function getEventDayRange(event) {
+	const startDayIndex = Math.max(0, Math.round(event.position.startOffset / DAY_WIDTH));
+	const daysSpanned = Math.max(1, Math.round(event.position.width / DAY_WIDTH));
+	return {
+		startDayIndex,
+		endDayIndex: Math.min(DAYS_IN_WEEK - 1, startDayIndex + daysSpanned - 1)
+	};
+}
+function getFirstAvailableRow(usedRows, maxEventsPerDay) {
+	for (let row = 0; row < maxEventsPerDay; row += 1) if (!usedRows.has(row)) return row;
+	return null;
+}
+function getSegmentHanging(originalHanging, touchesStart, touchesEnd) {
+	const hangsFromStart = touchesStart && (originalHanging === "start" || originalHanging === "both");
+	const hangsFromEnd = touchesEnd && (originalHanging === "end" || originalHanging === "both");
+	if (hangsFromStart && hangsFromEnd) return "both";
+	if (hangsFromStart) return "start";
+	if (hangsFromEnd) return "end";
+	return "none";
+}
+function getSegmentPosition(event, segment, eventRange) {
+	const touchesStart = segment.startDayIndex === eventRange.startDayIndex;
+	const touchesEnd = segment.endDayIndex === eventRange.endDayIndex;
+	return {
+		...event.position,
+		startOffset: segment.startDayIndex / DAYS_IN_WEEK * 100,
+		width: (segment.endDayIndex - segment.startDayIndex + 1) / DAYS_IN_WEEK * 100,
+		row: segment.row,
+		hanging: getSegmentHanging(event.position.hanging, touchesStart, touchesEnd)
+	};
+}
+function getEventKey(event) {
+	return event.id;
+}
+function getRenderableMonthEventSegments({ events, groupedByDay, maxEventsPerDay, week }) {
+	const eventIndexes = /* @__PURE__ */ new Map();
+	const eventRanges = /* @__PURE__ */ new Map();
+	const renderRows = /* @__PURE__ */ new Map();
+	events.forEach((event, index) => {
+		eventIndexes.set(event, index);
+		eventRanges.set(event, getEventDayRange(event));
+	});
+	const setRenderRow = (event, dayIndex, row) => {
+		if (!renderRows.has(event)) renderRows.set(event, /* @__PURE__ */ new Map());
+		renderRows.get(event).set(dayIndex, row);
+	};
+	for (let dayIndex = 0; dayIndex < week.length; dayIndex += 1) {
+		const dayEvents = groupedByDay[week[dayIndex]] || [];
+		const dayEventIds = new Set(dayEvents.map((event) => getEventKey(event)));
+		const dayWeekEvents = events.filter((event) => {
+			const range = eventRanges.get(event);
+			return dayEventIds.has(getEventKey(event)) && dayIndex >= range.startDayIndex && dayIndex <= range.endDayIndex;
+		});
+		if (dayEvents.length > maxEventsPerDay) {
+			dayWeekEvents.forEach((event) => {
+				if (event.position.row < maxEventsPerDay) setRenderRow(event, dayIndex, event.position.row);
+			});
+			continue;
+		}
+		const usedRows = /* @__PURE__ */ new Set();
+		[...dayWeekEvents].sort((a, b) => {
+			const rowDiff = a.position.row - b.position.row;
+			if (rowDiff !== 0) return rowDiff;
+			return eventIndexes.get(a) - eventIndexes.get(b);
+		}).forEach((event) => {
+			let row = event.position.row;
+			if (row >= maxEventsPerDay || usedRows.has(row)) {
+				const availableRow = getFirstAvailableRow(usedRows, maxEventsPerDay);
+				if (availableRow === null) return;
+				row = availableRow;
+			}
+			usedRows.add(row);
+			setRenderRow(event, dayIndex, row);
+		});
+	}
+	return events.flatMap((event) => {
+		const eventRange = eventRanges.get(event);
+		const eventRenderRows = renderRows.get(event);
+		const segments = [];
+		let currentSegment = null;
+		const addSegment = (segment) => {
+			const position = getSegmentPosition(event, segment, eventRange);
+			segments.push({
+				event,
+				position,
+				clipStart: segment.startDayIndex > eventRange.startDayIndex,
+				clipEnd: segment.endDayIndex < eventRange.endDayIndex,
+				key: `${event.id}-${event.position.weekIndex}-${segment.startDayIndex}-${segment.endDayIndex}-${segment.row}`
+			});
+		};
+		for (let dayIndex = eventRange.startDayIndex; dayIndex <= eventRange.endDayIndex; dayIndex += 1) {
+			const row = eventRenderRows?.get(dayIndex);
+			if (row === void 0) {
+				if (currentSegment) {
+					addSegment(currentSegment);
+					currentSegment = null;
+				}
+				continue;
+			}
+			if (currentSegment && currentSegment.row === row) currentSegment.endDayIndex = dayIndex;
+			else {
+				if (currentSegment) addSegment(currentSegment);
+				currentSegment = {
+					startDayIndex: dayIndex,
+					endDayIndex: dayIndex,
+					row
+				};
+			}
+		}
+		if (currentSegment) addSegment(currentSegment);
+		return segments;
+	});
+}
+var MonthView_module_default = {
+	monthView: "_monthView_2aohq_1",
+	monthViewWeekdays: "_monthViewWeekdays_2aohq_21",
+	monthViewWeek: "_monthViewWeek_2aohq_21",
+	monthViewWeekNumber: "_monthViewWeekNumber_2aohq_31",
+	monthViewWeekday: "_monthViewWeekday_2aohq_21",
+	monthViewWeekdaysCorner: "_monthViewWeekdaysCorner_2aohq_107",
+	monthViewDay: "_monthViewDay_2aohq_114",
+	monthViewDayLabel: "_monthViewDayLabel_2aohq_255",
+	monthViewBackgroundEvent: "_monthViewBackgroundEvent_2aohq_271",
+	monthViewEvents: "_monthViewEvents_2aohq_286"
+};
+//#endregion
+//#region src/components/MonthView/MonthView.ts
+var MonthView = (0, vue.defineComponent)({
+	name: "MonthView",
+	inheritAttrs: false,
+	slots: Object,
+	props: {
+		...baseViewProps,
+		firstDayOfWeek: {
+			type: Number,
+			default: 1
+		},
+		weekdayFormat: {
+			type: [String, Function],
+			default: "ddd"
+		},
+		weekendDays: {
+			type: Array,
+			default: () => [0, 6]
+		},
+		withWeekNumbers: Boolean,
+		withWeekDays: {
+			type: Boolean,
+			default: true
+		},
+		consistentWeeks: {
+			type: Boolean,
+			default: true
+		},
+		highlightToday: {
+			type: Boolean,
+			default: true
+		},
+		withOutsideDays: {
+			type: Boolean,
+			default: true
+		},
+		maxEventsPerDay: {
+			type: Number,
+			default: 2
+		},
+		getDayProps: Function,
+		getWeekNumberProps: Function,
+		onDayClick: Function,
+		onWeekNumberClick: Function,
+		withEventsDragAndDrop: Boolean,
+		onEventDrop: Function,
+		canDragEvent: Function,
+		onEventDragStart: Function,
+		onEventDragEnd: Function,
+		onExternalEventDrop: Function,
+		withDragSlotSelect: Boolean,
+		onSlotDragEnd: Function
+	},
+	setup(props, { attrs, slots }) {
+		const monthGrid = (0, vue.ref)(null);
+		const dropTarget = (0, vue.ref)(null);
+		const monthGroup = "month";
+		const flatDays = (0, vue.ref)([]);
+		const slotDragSelect = useSlotDragSelect({
+			enabled: () => props.withDragSlotSelect && props.mode !== "static",
+			onDragEnd: () => props.onSlotDragEnd ? (startIndex, endIndex) => {
+				const startDay = flatDays.value[startIndex];
+				const endDay = flatDays.value[endIndex];
+				if (startDay && endDay) props.onSlotDragEnd?.((0, dayjs.default)(startDay).startOf("day").format("YYYY-MM-DD HH:mm:ss"), (0, dayjs.default)(endDay).endOf("day").format("YYYY-MM-DD HH:mm:ss"));
+			} : void 0
+		});
+		return () => {
+			const month = (0, dayjs.default)(props.date).startOf("month");
+			const maxEventsPerDay = Math.min(10, Math.max(1, props.maxEventsPerDay));
+			const weeks = getMonthDays({
+				month,
+				firstDayOfWeek: props.firstDayOfWeek,
+				consistentWeeks: props.consistentWeeks
+			});
+			flatDays.value = weeks.flat().map((date) => toDateString(date));
+			const firstFocusableDayIndex = weeks.flat().findIndex((date) => props.withOutsideDays || (0, dayjs.default)(date).isSame(month, "month"));
+			const withSlotSelect = props.withDragSlotSelect && props.mode !== "static";
+			const rangeStart = weeks[0][0];
+			const rangeEnd = weeks.at(-1).at(-1);
+			const expanded = getExpandedEvents(props.events, rangeStart, (0, dayjs.default)(rangeEnd).endOf("day").format("YYYY-MM-DD HH:mm:ss"), props.recurrenceExpansionLimit);
+			const grouped = getMonthViewEvents({
+				date: month,
+				events: expanded,
+				firstDayOfWeek: props.firstDayOfWeek,
+				withOutsideDays: props.withOutsideDays,
+				consistentWeeks: props.consistentWeeks
+			});
+			const weekdays = getWeekdaysNames({
+				locale: props.locale || "en",
+				format: props.weekdayFormat,
+				firstDayOfWeek: props.firstDayOfWeek
+			});
+			const withDragHandlers = props.mode !== "static" && (props.withEventsDragAndDrop || Boolean(props.onExternalEventDrop));
+			const dragOver = (nativeEvent, date) => {
+				nativeEvent.preventDefault();
+				dropTarget.value = toDateString(date);
+				if (nativeEvent.dataTransfer) nativeEvent.dataTransfer.dropEffect = nativeEvent.dataTransfer.types.includes("application/json") ? "move" : "copy";
+			};
+			const dragLeave = (nativeEvent) => {
+				if (!(nativeEvent.relatedTarget instanceof Node) || !monthGrid.value?.contains(nativeEvent.relatedTarget)) dropTarget.value = null;
+			};
+			const drop = (nativeEvent, date) => {
+				nativeEvent.preventDefault();
+				dropTarget.value = null;
+				const event = getDropEvent(expanded, nativeEvent.dataTransfer);
+				if (event) {
+					const { start } = calculateMonthDropDate({
+						draggedEvent: event,
+						targetDay: toDateString(date)
+					});
+					props.onEventDrop?.(moveEventTo(event, start));
+				} else if (nativeEvent.dataTransfer) props.onExternalEventDrop?.(nativeEvent.dataTransfer, toDateString(date));
+			};
+			return (0, vue.h)(_mantine_vue_core.Box, {
+				...attrs,
+				class: [MonthView_module_default.monthView, attrs.class],
+				style: [{
+					"--month-view-radius": resolveScheduleRadius(props.radius),
+					"--month-view-max-events": String(maxEventsPerDay)
+				}, attrs.style],
+				mod: {
+					"with-week-numbers": props.withWeekNumbers,
+					"with-weekdays": props.withWeekDays,
+					static: props.mode === "static",
+					"slot-dragging": slotDragSelect.isDragging()
+				}
+			}, () => [props.withHeader ? (0, vue.h)(ScheduleHeaderBase, {
+				view: "month",
+				labels: props.labels,
+				onDateChange: props.onDateChange,
+				onViewChange: props.onViewChange,
+				navigationHandlers: createHeaderNavigation(props.date, "month"),
+				previousControlProps: props.previousControlProps,
+				nextControlProps: props.nextControlProps,
+				todayControlProps: props.todayControlProps,
+				viewSelectProps: props.viewSelectProps,
+				control: { monthYearSelect: {
+					locale: props.locale,
+					monthValue: month.month(),
+					yearValue: month.year(),
+					onMonthChange: (value) => props.onDateChange?.(toDateString(month.month(value))),
+					onYearChange: (value) => props.onDateChange?.(toDateString(month.year(value)))
+				} }
+			}) : null, (0, vue.h)(_mantine_vue_core.ScrollArea, {
+				class: MonthView_module_default.monthViewScrollArea,
+				scrollbarSize: 4
+			}, () => (0, vue.h)("div", {
+				ref: monthGrid,
+				class: MonthView_module_default.monthViewInner
+			}, [props.withWeekDays ? (0, vue.h)("div", { class: MonthView_module_default.monthViewWeekdays }, [props.withWeekNumbers ? (0, vue.h)("div", { class: MonthView_module_default.monthViewWeekdaysCorner }) : null, ...weekdays.map((weekday) => (0, vue.h)("div", { class: MonthView_module_default.monthViewWeekday }, [weekday]))]) : null, ...weeks.map((week, weekIndex) => {
+				const segments = getRenderableMonthEventSegments({
+					events: grouped.groupedByWeek[String(weekIndex)] || [],
+					groupedByDay: grouped.groupedByDay,
+					maxEventsPerDay,
+					week
+				});
+				return (0, vue.h)("div", { class: MonthView_module_default.monthViewWeek }, [
+					props.withWeekNumbers ? (0, vue.h)(_mantine_vue_core.UnstyledButton, {
+						type: "button",
+						class: MonthView_module_default.monthViewWeekNumber,
+						...props.getWeekNumberProps?.(toDateString(week[0])),
+						onClick: (event) => props.onWeekNumberClick?.(toDateString(week[0]), event)
+					}, () => String(getWeekNumber(week))) : null,
+					...week.map((date, dayIndex) => {
+						const dateKey = (0, dayjs.default)(date).format("YYYY-MM-DD 00:00:00");
+						const dayProps = props.getDayProps?.(toDateString(date)) || {};
+						const events = grouped.groupedByDay[dateKey] || [];
+						const hiddenCount = Math.max(0, events.length - maxEventsPerDay);
+						const outside = !(0, dayjs.default)(date).isSame(month, "month");
+						const gridIndex = weekIndex * 7 + dayIndex;
+						return (0, vue.h)("div", {
+							class: MonthView_module_default.monthViewDay,
+							"data-outside": outside || void 0,
+							"data-weekend": props.weekendDays.includes((0, dayjs.default)(date).day()) || void 0,
+							"data-static": props.mode === "static" || void 0,
+							"data-drop-target": dropTarget.value === toDateString(date) || void 0,
+							"data-drag-selected": slotDragSelect.isSlotSelected(gridIndex, monthGroup) || void 0,
+							"data-drag-slot-index": withSlotSelect ? gridIndex : void 0,
+							"data-drag-slot-group": withSlotSelect ? monthGroup : void 0,
+							onPointerdown: withSlotSelect ? (event) => slotDragSelect.handleSlotPointerDown(event, gridIndex, monthGroup) : void 0,
+							onDragover: withDragHandlers ? (event) => dragOver(event, date) : (event) => event.preventDefault(),
+							onDragleave: withDragHandlers ? dragLeave : void 0,
+							onDrop: (event) => drop(event, date)
+						}, [(0, vue.h)(_mantine_vue_core.UnstyledButton, {
+							type: "button",
+							...dayProps,
+							class: [MonthView_module_default.monthViewDayLabel, dayProps.class],
+							disabled: props.mode === "static",
+							"data-grid-index": gridIndex,
+							"data-outside": outside || void 0,
+							"data-hidden": outside && !props.withOutsideDays || void 0,
+							"aria-label": formatDate({
+								date,
+								locale: props.locale || "en",
+								format: "MMMM D, YYYY"
+							}),
+							"data-today": props.highlightToday && (0, dayjs.default)(date).isSame((0, dayjs.default)(), "day") || void 0,
+							onClick: (event) => props.onDayClick?.(toDateString(date), event),
+							tabindex: props.mode === "static" ? -1 : gridIndex === firstFocusableDayIndex ? 0 : -1,
+							onKeydown: props.mode === "static" ? void 0 : (event) => {
+								handleGridKeydown({
+									event,
+									index: gridIndex,
+									columns: 7,
+									total: weeks.length * 7,
+									getControl: (index) => monthGrid.value?.querySelector(`[data-grid-index="${index}"]:not([data-hidden])`) ?? null
+								});
+								dayProps.onKeydown?.(event);
+							}
+						}, () => outside && !props.withOutsideDays ? "" : String((0, dayjs.default)(date).date())), hiddenCount > 0 ? (0, vue.h)(MoreEvents, {
+							events,
+							moreEventsCount: hiddenCount,
+							labels: props.labels,
+							renderEvent: props.renderEvent,
+							renderEventBody: props.renderEventBody,
+							onEventClick: props.onEventClick,
+							mode: props.mode
+						}, forwardEventSlots(slots)) : null]);
+					}),
+					(0, vue.h)("div", { class: MonthView_module_default.monthViewEvents }, segments.map((segment) => eventNode(segment.event, props, {
+						key: segment.key,
+						nowrap: true,
+						hanging: segment.position.hanging,
+						"data-clip-start": segment.clipStart || void 0,
+						"data-clip-end": segment.clipEnd || void 0,
+						style: {
+							position: "absolute",
+							insetInlineStart: `${segment.position.startOffset}%`,
+							width: `${segment.position.width}%`,
+							top: `${28 + segment.position.row * 22}px`
+						}
+					}, slots)))
+				]);
+			})]))]);
+		};
+	}
+});
+//#endregion
+//#region src/components/WeekView/get-week-label/get-week-label.ts
+function getWeekLabel({ weekdays, locale, weekLabelFormat, renderWeekLabel }) {
+	if (renderWeekLabel) return renderWeekLabel({
+		weekStart: (0, dayjs.default)(weekdays[0]).format("YYYY-MM-DD"),
+		weekEnd: (0, dayjs.default)(weekdays[weekdays.length - 1]).format("YYYY-MM-DD")
+	});
+	return `${formatDate({
+		locale,
+		date: weekdays[0],
+		format: weekLabelFormat
+	})} – ${formatDate({
+		locale,
+		date: weekdays[weekdays.length - 1],
+		format: weekLabelFormat
+	})}, ${formatDate({
+		locale,
+		date: weekdays[0],
+		format: "YYYY"
+	})}`;
+}
+//#endregion
+//#region src/components/WeekView/get-week-view-events/filter-week-view-events.ts
+function filterWeekViewEvents({ date, events, startTime, endTime, firstDayOfWeek = 1 }) {
+	if (events === void 0) return [];
+	const ids = /* @__PURE__ */ new Set();
+	const filteredEvents = [];
+	for (const event of events) if (isWithinWeek({
+		event,
+		targetWeek: date,
+		firstDayOfWeek
+	}) && isEventInTimeRange({
+		event,
+		startTime,
+		endTime
+	})) {
+		filteredEvents.push(validateEvent(event));
+		if (!ids.has(event.id)) ids.add(event.id);
+		else throw new Error(`[@mantine/schedule] WeekView: Duplicated event ids found: ${event.id}`);
+	}
+	return filteredEvents;
+}
+//#endregion
+//#region src/components/WeekView/get-week-view-events/assign-event-rows.ts
+function assignEventRows(events) {
+	const eventRows = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		let row = 0;
+		while (true) {
+			let hasConflict = false;
+			for (const [otherEvent, otherRow] of eventRows.entries()) if (otherRow === row && isEventsOverlap(event, otherEvent)) {
+				hasConflict = true;
+				break;
+			}
+			if (!hasConflict) break;
+			row++;
+		}
+		eventRows.set(event, row);
+	}
+	return eventRows;
+}
+//#endregion
+//#region src/components/WeekView/get-week-view-events/calculate-all-day-event-offset.ts
+function calculateAllDayEventOffset({ eventStartDate, weekStartDate, weekDays, visibleDaysCount, hangingStart }) {
+	let displayStartDate = eventStartDate;
+	if (hangingStart) displayStartDate = weekStartDate;
+	if (!weekDays.some((day) => (0, dayjs.default)(day).isSame(displayStartDate, "day"))) displayStartDate = (0, dayjs.default)(weekDays[0]);
+	return (weekDays.filter((day) => (0, dayjs.default)(day).isBefore(displayStartDate) || (0, dayjs.default)(day).isSame(displayStartDate, "day")).length - 1) / visibleDaysCount * 100;
+}
+//#endregion
+//#region src/components/WeekView/get-week-view-events/calculate-all-day-event-width.ts
+function calculateAllDayEventWidth({ eventStartDate, actualEndDate, weekStartDate, weekEndDate, weekDays, visibleDaysCount }) {
+	let displayStartDate = eventStartDate;
+	if (eventStartDate.isBefore(weekStartDate)) displayStartDate = weekStartDate;
+	let displayEndDate = actualEndDate;
+	if (actualEndDate.isAfter(weekEndDate)) displayEndDate = weekEndDate;
+	return weekDays.filter((day) => ((0, dayjs.default)(day).isAfter(displayStartDate) || (0, dayjs.default)(day).isSame(displayStartDate, "day")) && ((0, dayjs.default)(day).isBefore(displayEndDate) || (0, dayjs.default)(day).isSame(displayEndDate, "day"))).length / visibleDaysCount * 100;
+}
+//#endregion
+//#region src/components/WeekView/get-week-view-events/calculate-event-days.ts
+function calculateEventDays({ event, weekDays, actualEndDate }) {
+	const eventStartDate = (0, dayjs.default)(event.start).startOf("day");
+	return weekDays.filter((day) => {
+		const dayDate = (0, dayjs.default)(day).startOf("day");
+		return (dayDate.isAfter(eventStartDate) || dayDate.isSame(eventStartDate)) && (dayDate.isBefore(actualEndDate) || dayDate.isSame(actualEndDate));
+	});
+}
+//#endregion
+//#region src/components/WeekView/get-week-view-events/calculate-regular-event-overlaps.ts
+function calculateRegularEventOverlaps(events) {
+	for (const event of events) {
+		let maxOverlappingColumn = event.position.column;
+		for (const otherEvent of events) if (isEventsOverlap(event, otherEvent)) maxOverlappingColumn = Math.max(maxOverlappingColumn, otherEvent.position.column);
+		const overlaps = maxOverlappingColumn + 1;
+		event.position.overlaps = overlaps;
+		event.position.width = 100 / overlaps;
+		event.position.offset = event.position.column * 100 / overlaps;
+	}
+}
+//#endregion
+//#region src/components/WeekView/get-week-view-events/find-available-column.ts
+function columnHasConflict({ columns, columnIndex, event, allDay, allWeekDays }) {
+	const columnKey = `col-${columnIndex}`;
+	if (!columns.has(columnKey)) return false;
+	return columns.get(columnKey).some((e) => {
+		const eAllDay = allWeekDays.some((day) => isAllDayEvent({
+			event: e,
+			date: day
+		}));
+		const hasTimeConflict = isEventsOverlap(e, event);
+		if (allDay && eAllDay) return hasTimeConflict;
+		if (allDay || eAllDay) return false;
+		return hasTimeConflict;
+	});
+}
+function findAvailableColumn(input) {
+	let column = 0;
+	while (columnHasConflict({
+		...input,
+		columnIndex: column
+	})) column++;
+	return column;
+}
+//#endregion
+//#region src/components/WeekView/get-week-view-events/get-event-end-date.ts
+function getEventEndDate(event) {
+	const eventEndDate = (0, dayjs.default)(event.end).startOf("day");
+	if ((0, dayjs.default)(event.end).hour() === 0 && (0, dayjs.default)(event.end).minute() === 0) return eventEndDate.subtract(1, "day");
+	return eventEndDate;
+}
+//#endregion
+//#region src/components/WeekView/get-week-view-events/get-hanging-status.ts
+function getHangingStatus({ eventStartDate, actualEndDate, weekDays }) {
+	const weekStartDate = (0, dayjs.default)(weekDays[0]);
+	const weekEndDate = (0, dayjs.default)(weekDays[weekDays.length - 1]);
+	const hangingStart = eventStartDate.isBefore(weekStartDate);
+	const hangingEnd = actualEndDate.isAfter(weekEndDate);
+	if (hangingStart && hangingEnd) return "both";
+	if (hangingStart) return "start";
+	if (hangingEnd) return "end";
+	return "none";
+}
+//#endregion
+//#region src/components/WeekView/get-week-view-events/get-week-positioned-events.ts
+function getWeekPositionedEvents({ date, events, startTime, endTime, intervalMinutes, firstDayOfWeek = 1, weekendDays = [0, 6], withWeekendDays = true }) {
+	const weekDays = getWeekDays({
+		week: date,
+		firstDayOfWeek,
+		withWeekendDays,
+		weekendDays
+	});
+	const visibleDaysCount = weekDays.length;
+	const weekStartDate = (0, dayjs.default)(weekDays[0]);
+	const weekEndDate = (0, dayjs.default)(weekDays[weekDays.length - 1]);
+	const grouped = {
+		allDayEvents: [],
+		regularEvents: Object.fromEntries(weekDays.map((day) => [day, []])),
+		backgroundEvents: Object.fromEntries(weekDays.map((day) => [day, []]))
+	};
+	const columns = /* @__PURE__ */ new Map();
+	const allDayColumns = /* @__PURE__ */ new Map();
+	const sorted = sortEvents(events);
+	for (const event of sorted) {
+		if (event.display === "background") {
+			const eventStartDate = (0, dayjs.default)(event.start).startOf("day");
+			const actualEndDate = getEventEndDate(event);
+			const eventWeekDays = calculateEventDays({
+				event,
+				weekDays,
+				actualEndDate
+			});
+			const hanging = getHangingStatus({
+				eventStartDate,
+				actualEndDate,
+				weekDays
+			});
+			for (const day of eventWeekDays) {
+				const visibleDayIndex = weekDays.indexOf(day);
+				if (visibleDayIndex === -1) continue;
+				const dayStart = (0, dayjs.default)(day);
+				const dayEnd = dayStart.endOf("day");
+				const eventStart = (0, dayjs.default)(event.start);
+				const eventEnd = (0, dayjs.default)(event.end);
+				const clippedStart = eventStart.isBefore(dayStart) ? dayStart : eventStart;
+				const clippedEnd = eventEnd.isAfter(dayEnd) ? dayEnd : eventEnd;
+				const clippedEvent = {
+					...event,
+					start: clippedStart.format("YYYY-MM-DD HH:mm:ss"),
+					end: clippedEnd.format("YYYY-MM-DD HH:mm:ss")
+				};
+				const isAllDay = isAllDayEvent({
+					event: clippedEvent,
+					date: day
+				});
+				const verticalPosition = isAllDay ? {
+					top: 0,
+					height: 100
+				} : getDayPosition({
+					event: clippedEvent,
+					startTime,
+					endTime,
+					intervalMinutes
+				});
+				if (!isAllDay && verticalPosition.height <= 0) continue;
+				const dayWeekOffset = visibleDayIndex / visibleDaysCount * 100;
+				grouped.backgroundEvents[day].push({
+					...event,
+					position: {
+						...verticalPosition,
+						allDay: isAllDay,
+						column: 0,
+						width: 100,
+						offset: 0,
+						overlaps: 1,
+						weekOffset: dayWeekOffset,
+						row: 0,
+						hanging
+					}
+				});
+			}
+			continue;
+		}
+		const eventStartDate = (0, dayjs.default)(event.start).startOf("day");
+		const actualEndDate = getEventEndDate(event);
+		const eventWeekDays = calculateEventDays({
+			event,
+			weekDays,
+			actualEndDate
+		});
+		if (eventWeekDays.length === 0) continue;
+		const isMultiday = actualEndDate.isAfter(eventStartDate);
+		const hanging = getHangingStatus({
+			eventStartDate,
+			actualEndDate,
+			weekDays
+		});
+		const isActuallyAllDay = eventWeekDays.some((day) => isAllDayEvent({
+			event,
+			date: day
+		}));
+		const allDay = isMultiday || isActuallyAllDay;
+		const columnMap = allDay ? allDayColumns : columns;
+		const column = findAvailableColumn({
+			columns: columnMap,
+			event,
+			allDay,
+			allWeekDays: weekDays
+		});
+		const columnKey = `col-${column}`;
+		if (!columnMap.has(columnKey)) columnMap.set(columnKey, []);
+		columnMap.get(columnKey).push(event);
+		const verticalPosition = allDay ? {
+			top: 0,
+			height: 100
+		} : getDayPosition({
+			event,
+			startTime,
+			endTime,
+			intervalMinutes
+		});
+		if (allDay) {
+			const offset = calculateAllDayEventOffset({
+				eventStartDate,
+				weekStartDate,
+				weekDays,
+				visibleDaysCount,
+				hangingStart: hanging === "start" || hanging === "both"
+			});
+			grouped.allDayEvents.push({
+				...event,
+				position: {
+					...verticalPosition,
+					allDay,
+					column,
+					width: 0,
+					offset,
+					overlaps: 0,
+					row: 0,
+					hanging
+				}
+			});
+		} else for (const day of eventWeekDays) {
+			const visibleDayIndex = weekDays.indexOf(day);
+			if (visibleDayIndex === -1) continue;
+			const dayWeekOffset = visibleDayIndex / visibleDaysCount * 100;
+			grouped.regularEvents[day].push({
+				...event,
+				position: {
+					...verticalPosition,
+					allDay,
+					column,
+					width: 0,
+					offset: 0,
+					overlaps: 0,
+					weekOffset: dayWeekOffset,
+					row: 0,
+					hanging
+				}
+			});
+		}
+	}
+	for (const day of weekDays) calculateRegularEventOverlaps(grouped.regularEvents[day]);
+	if (grouped.allDayEvents.length > 0) {
+		const eventRows = assignEventRows(grouped.allDayEvents);
+		const assignedRows = /* @__PURE__ */ new Set();
+		for (const event of grouped.allDayEvents) {
+			const row = eventRows.get(event);
+			event.position.row = row;
+			assignedRows.add(row);
+		}
+		const rowCount = Math.max(...assignedRows) + 1;
+		for (const event of grouped.allDayEvents) {
+			const eventStartDate = (0, dayjs.default)(event.start).startOf("day");
+			const actualEndDate = getEventEndDate(event);
+			event.position.width = calculateAllDayEventWidth({
+				eventStartDate,
+				actualEndDate,
+				weekStartDate,
+				weekEndDate,
+				weekDays,
+				visibleDaysCount
+			});
+			event.position.overlaps = rowCount;
+		}
+	}
+	return grouped;
+}
+//#endregion
+//#region src/components/WeekView/get-week-view-events/get-week-view-events.ts
+function getWeekViewEvents(input) {
+	return getWeekPositionedEvents({
+		...input,
+		events: filterWeekViewEvents(input)
+	});
+}
+var WeekView_module_default = {
+	weekView: "_weekView_16qgh_1",
+	weekViewRoot: "_weekViewRoot_16qgh_22",
+	weekViewInner: "_weekViewInner_16qgh_30",
+	weekViewScrollArea: "_weekViewScrollArea_16qgh_36",
+	weekViewHeader: "_weekViewHeader_16qgh_42",
+	weekViewCorner: "_weekViewCorner_16qgh_57",
+	weekViewSlotLabels: "_weekViewSlotLabels_16qgh_68",
+	weekViewSlotLabel: "_weekViewSlotLabel_16qgh_68",
+	weekViewDay: "_weekViewDay_16qgh_95",
+	weekViewDayLabel: "_weekViewDayLabel_16qgh_100",
+	weekViewDayNumber: "_weekViewDayNumber_16qgh_138",
+	weekViewDayWeekday: "_weekViewDayWeekday_16qgh_154",
+	weekViewBackgroundEvent: "_weekViewBackgroundEvent_16qgh_160",
+	weekViewDaySlots: "_weekViewDaySlots_16qgh_173",
+	weekViewDaySlot: "_weekViewDaySlot_16qgh_173",
+	weekViewWeekLabel: "_weekViewWeekLabel_16qgh_271",
+	weekViewWeekNumber: "_weekViewWeekNumber_16qgh_277",
+	weekViewAllDaySlots: "_weekViewAllDaySlots_16qgh_283",
+	weekViewAllDaySlotsLabel: "_weekViewAllDaySlotsLabel_16qgh_288",
+	weekViewAllDaySlotsEvents: "_weekViewAllDaySlotsEvents_16qgh_295",
+	weekViewAllDaySlotsList: "_weekViewAllDaySlotsList_16qgh_302"
+};
+//#endregion
+//#region src/components/WeekView/WeekView.ts
+var WeekView = (0, vue.defineComponent)({
+	name: "WeekView",
+	inheritAttrs: false,
+	slots: Object,
+	props: {
+		...timeViewProps,
+		withCurrentTimeIndicator: {
+			type: Boolean,
+			default: true
+		},
+		forceCurrentTimeIndicator: Boolean,
+		firstDayOfWeek: {
+			type: Number,
+			default: 1
+		},
+		weekdayFormat: {
+			type: [String, Function],
+			default: "ddd"
+		},
+		dayFormat: {
+			type: [String, Function],
+			default: "D"
+		},
+		withWeekNumber: {
+			type: Boolean,
+			default: true
+		},
+		withAllDaySlots: {
+			type: Boolean,
+			default: true
+		},
+		withWeekNumbers: {
+			type: Boolean,
+			default: void 0
+		},
+		withAllDaySlot: {
+			type: Boolean,
+			default: void 0
+		},
+		allDaySlotsHeight: {
+			type: [String, Number],
+			default: 44
+		},
+		maxAllDayEvents: {
+			type: Number,
+			default: 3
+		},
+		weekendDays: {
+			type: Array,
+			default: () => [0, 6]
+		},
+		withWeekendDays: {
+			type: Boolean,
+			default: true
+		},
+		weekLabelFormat: {
+			type: [String, Function],
+			default: "MMM D"
+		},
+		renderWeekLabel: Function
+	},
+	setup(props, { attrs, slots }) {
+		const daySlotsContainers = /* @__PURE__ */ new Map();
+		const dropTarget = (0, vue.ref)(null);
+		const eventResize = useEventResize({
+			enabled: () => props.withEventResize,
+			mode: () => props.mode,
+			startTime: () => props.startTime,
+			endTime: () => props.endTime,
+			intervalMinutes: () => props.intervalMinutes,
+			onEventResize: () => props.onEventResize,
+			canResizeEvent: () => props.canResizeEvent
+		});
+		const slotTimes = (0, vue.ref)([]);
+		const slotDragSelect = useSlotDragSelect({
+			enabled: () => props.withDragSlotSelect && props.mode !== "static",
+			onDragEnd: () => props.onSlotDragEnd ? (startIndex, endIndex, group) => {
+				const slotDate = (0, dayjs.default)(group).format("YYYY-MM-DD");
+				const startSlot = slotTimes.value[startIndex];
+				const endSlot = slotTimes.value[endIndex];
+				if (startSlot && endSlot) props.onSlotDragEnd?.(`${slotDate} ${startSlot.startTime}`, `${slotDate} ${endSlot.endTime}`);
+			} : void 0
+		});
+		return () => {
+			const withWeekNumber = props.withWeekNumbers ?? props.withWeekNumber;
+			const withAllDaySlots = props.withAllDaySlot ?? props.withAllDaySlots;
+			const days = getWeekDays({
+				week: props.date,
+				firstDayOfWeek: props.firstDayOfWeek,
+				withWeekendDays: props.withWeekendDays,
+				weekendDays: props.weekendDays
+			});
+			const now = (0, dayjs.default)(props.getCurrentTime?.() ?? (0, dayjs.default)());
+			const currentWeekdayIndex = props.withCurrentTimeIndicator ? props.forceCurrentTimeIndicator ? days.findIndex((date) => (0, dayjs.default)(date).day() === now.day()) : days.findIndex((date) => (0, dayjs.default)(date).isSame(now, "day")) : -1;
+			const expanded = getExpandedEvents(props.events, (0, dayjs.default)(days[0]).startOf("day").format("YYYY-MM-DD HH:mm:ss"), (0, dayjs.default)(days.at(-1)).endOf("day").format("YYYY-MM-DD HH:mm:ss"), props.recurrenceExpansionLimit);
+			const grouped = getWeekViewEvents({
+				date: props.date,
+				events: expanded,
+				startTime: props.startTime,
+				endTime: props.endTime,
+				intervalMinutes: props.intervalMinutes,
+				firstDayOfWeek: props.firstDayOfWeek,
+				weekendDays: props.weekendDays,
+				withWeekendDays: props.withWeekendDays
+			});
+			const intervals = getDayTimeIntervals({
+				startTime: props.startTime,
+				endTime: props.endTime,
+				intervalMinutes: props.intervalMinutes
+			});
+			slotTimes.value = intervals.map((slot) => ({
+				startTime: slot.startTime,
+				endTime: slot.endTime
+			}));
+			const withSlotSelect = props.withDragSlotSelect && props.mode !== "static";
+			const getWeekRoot = (event) => event.currentTarget.closest(`.${WeekView_module_default.weekViewRoot}`);
+			const focusWeekControl = (event, selector) => {
+				const control = getWeekRoot(event)?.querySelector(selector);
+				if (!control || control.disabled) return;
+				event.preventDefault();
+				control.focus();
+			};
+			const withDragHandlers = props.mode !== "static" && (props.withEventsDragAndDrop || Boolean(props.onExternalEventDrop));
+			const emitDrop = (nativeEvent, target) => {
+				nativeEvent.preventDefault();
+				const event = getDropEvent(expanded, nativeEvent.dataTransfer);
+				if (event) props.onEventDrop?.(moveEventTo(event, target));
+				else if (nativeEvent.dataTransfer) props.onExternalEventDrop?.(nativeEvent.dataTransfer, target);
+			};
+			const emitAllDayDrop = (nativeEvent, date) => {
+				nativeEvent.preventDefault();
+				const dayKey = (0, dayjs.default)(date).format("YYYY-MM-DD");
+				const event = getDropEvent(expanded, nativeEvent.dataTransfer);
+				if (event) props.onEventDrop?.(moveEventToAllDay(event, dayKey));
+				else if (nativeEvent.dataTransfer) props.onExternalEventDrop?.(nativeEvent.dataTransfer, `${dayKey} 00:00:00`);
+			};
+			const rootStyle = {
+				"--week-view-radius": resolveScheduleRadius(props.radius),
+				"--week-view-slot-height": typeof props.slotHeight === "number" ? `${props.slotHeight}px` : props.slotHeight,
+				"--week-view-all-day-slots-height": typeof props.allDaySlotsHeight === "number" ? `${props.allDaySlotsHeight}px` : props.allDaySlotsHeight
+			};
+			return (0, vue.h)(_mantine_vue_core.Box, {
+				...attrs,
+				class: [WeekView_module_default.weekView, attrs.class],
+				style: [rootStyle, attrs.style],
+				mod: {
+					static: props.mode === "static",
+					"slot-dragging": slotDragSelect.isDragging()
+				}
+			}, () => [props.withHeader ? (0, vue.h)(ScheduleHeaderBase, {
+				view: "week",
+				labels: props.labels,
+				onDateChange: props.onDateChange,
+				onViewChange: props.onViewChange,
+				navigationHandlers: createHeaderNavigation(props.date, "week"),
+				previousControlProps: props.previousControlProps,
+				nextControlProps: props.nextControlProps,
+				todayControlProps: props.todayControlProps,
+				viewSelectProps: props.viewSelectProps,
+				control: { title: getWeekLabel({
+					weekdays: days,
+					locale: props.locale || "en",
+					weekLabelFormat: props.weekLabelFormat,
+					renderWeekLabel: props.renderWeekLabel ?? (slots.weekLabel ? (params) => slots.weekLabel(params) : void 0)
+				}) }
+			}) : null, (0, vue.h)(_mantine_vue_core.Box, {
+				class: WeekView_module_default.weekViewRoot,
+				style: {
+					"--number-of-days": String(days.length),
+					"--indicator-offset-index": currentWeekdayIndex === -1 ? void 0 : String(currentWeekdayIndex + 1)
+				},
+				mod: { "with-weekends": props.withWeekendDays }
+			}, () => [(0, vue.h)(_mantine_vue_core.ScrollArea.Autosize, {
+				class: WeekView_module_default.weekViewScrollArea,
+				scrollbarSize: 4
+			}, () => [
+				(0, vue.h)("div", { class: WeekView_module_default.weekViewHeader }, [(0, vue.h)("div", { class: WeekView_module_default.weekViewCorner }, [withWeekNumber ? (0, vue.h)("div", { class: WeekView_module_default.weekViewWeekLabel }, props.labels?.week || "Week") : null, withWeekNumber ? (0, vue.h)("div", { class: WeekView_module_default.weekViewWeekNumber }, String(getWeekNumber(days))) : null]), ...days.map((date, dayIndex) => (0, vue.h)(_mantine_vue_core.UnstyledButton, {
+					type: "button",
+					class: WeekView_module_default.weekViewDayLabel,
+					"data-weekday-index": dayIndex,
+					"data-weekend": props.weekendDays.includes((0, dayjs.default)(date).day()) || void 0,
+					"aria-label": `${getLabel("weekday", props.labels)} ${(0, dayjs.default)(date).format("YYYY-MM-DD")}`,
+					tabindex: props.mode === "static" ? -1 : dayIndex === 0 ? 0 : -1,
+					onKeydown: props.mode === "static" ? void 0 : (event) => {
+						const next = event.key === "ArrowRight" ? dayIndex + 1 : event.key === "ArrowLeft" ? dayIndex - 1 : -1;
+						if (next >= 0 && next < days.length) focusWeekControl(event, `[data-weekday-index="${next}"]`);
+					},
+					onClick: props.mode === "static" ? void 0 : () => {
+						props.onViewChange?.("day");
+						props.onDateChange?.(date);
+					}
+				}, () => [(0, vue.h)("span", { class: WeekView_module_default.weekViewDayWeekday }, formatDate({
+					date,
+					locale: props.locale || "en",
+					format: props.weekdayFormat
+				})), (0, vue.h)("span", {
+					class: WeekView_module_default.weekViewDayNumber,
+					"data-today": (0, dayjs.default)(date).isSame(now, "day") || void 0
+				}, formatDate({
+					date,
+					locale: props.locale || "en",
+					format: props.dayFormat
+				}))]))]),
+				withAllDaySlots ? (0, vue.h)("div", { class: WeekView_module_default.weekViewAllDaySlots }, [(0, vue.h)("div", { class: WeekView_module_default.weekViewAllDaySlotsLabel }, props.labels?.allDay || "All day"), (0, vue.h)("div", { class: WeekView_module_default.weekViewAllDaySlotsList }, [(0, vue.h)("div", { class: WeekView_module_default.weekViewAllDaySlotsEvents }, grouped.allDayEvents.map((event) => eventNode(event, props, {
+					key: event.id,
+					nowrap: true,
+					hanging: event.position.hanging,
+					style: {
+						position: "absolute",
+						insetInlineStart: `${event.position.offset}%`,
+						width: `${event.position.width}%`,
+						top: `${event.position.row * 22}px`
+					}
+				}, slots))), ...days.map((date, dayIndex) => (0, vue.h)(_mantine_vue_core.UnstyledButton, {
+					type: "button",
+					class: WeekView_module_default.weekViewDaySlot,
+					disabled: props.mode === "static",
+					"data-all-day-index": dayIndex,
+					"aria-label": `${getLabel("allDay", props.labels)} ${(0, dayjs.default)(date).format("YYYY-MM-DD")}`,
+					tabindex: props.mode === "static" ? -1 : dayIndex === 0 ? 0 : -1,
+					onKeydown: props.mode === "static" ? void 0 : (event) => {
+						if (event.key === "ArrowDown") {
+							focusWeekControl(event, `[data-week-day-index="${dayIndex}"][data-time-slot-index="0"]`);
+							return;
+						}
+						const next = event.key === "ArrowRight" ? dayIndex + 1 : event.key === "ArrowLeft" ? dayIndex - 1 : -1;
+						if (next >= 0 && next < days.length) focusWeekControl(event, `[data-all-day-index="${next}"]`);
+					},
+					onClick: (event) => props.onAllDaySlotClick?.(date, event),
+					onDragover: (event) => event.preventDefault(),
+					onDrop: (event) => emitAllDayDrop(event, date)
+				}))])]) : null,
+				(0, vue.h)(_mantine_vue_core.Box, { class: WeekView_module_default.weekViewInner }, () => [
+					(0, vue.h)("div", { class: WeekView_module_default.weekViewSlotLabels }, intervals.map((slot) => (0, vue.h)("div", { class: WeekView_module_default.weekViewSlotLabel }, formatDate({
+						date: `${(0, dayjs.default)(days[0]).format("YYYY-MM-DD")} ${slot.startTime}`,
+						locale: props.locale || "en",
+						format: props.slotLabelFormat
+					})))),
+					props.withCurrentTimeIndicator && currentWeekdayIndex !== -1 ? (0, vue.h)(CurrentTimeIndicator, {
+						startOffset: "calc(100% - (100% / var(--number-of-days)) * (var(--number-of-days) - var(--indicator-offset-index) + 1) + ((var(--number-of-days) - var(--indicator-offset-index) + 1) * var(--indicator-labels-offset)))",
+						endOffset: "calc((100% / var(--number-of-days)) * (var(--number-of-days) - var(--indicator-offset-index)) - (var(--number-of-days) - var(--indicator-offset-index)) * var(--indicator-labels-offset))",
+						timeBubbleStartOffset: "calc(var(--week-view-slots-label-width) - var(--time-bubble-width))",
+						currentTimeFormat: props.slotLabelFormat,
+						withTimeBubble: props.withCurrentTimeBubble,
+						withThumb: props.withCurrentTimeBubble ? currentWeekdayIndex !== 0 : true,
+						locale: props.locale,
+						startTime: props.startTime,
+						endTime: props.endTime,
+						intervalMinutes: props.intervalMinutes,
+						getCurrentTime: props.getCurrentTime
+					}) : null,
+					...days.map((date, dayIndex) => (0, vue.h)("div", { class: WeekView_module_default.weekViewDay }, [(0, vue.h)("div", {
+						class: WeekView_module_default.weekViewDaySlots,
+						ref: (element) => {
+							if (element instanceof HTMLElement) daySlotsContainers.set(date, element);
+							else daySlotsContainers.delete(date);
+						},
+						onDragover: withDragHandlers ? (event) => {
+							event.preventDefault();
+							const container = daySlotsContainers.get(date);
+							if (!container) return;
+							const target = getTimeSlotDropTarget({
+								nativeEvent: event,
+								container,
+								intervals,
+								date: (0, dayjs.default)(date).format("YYYY-MM-DD")
+							});
+							dropTarget.value = target ? {
+								date,
+								slotIndex: target.slotIndex
+							} : null;
+							if (event.dataTransfer) event.dataTransfer.dropEffect = event.dataTransfer.types.includes("application/json") ? "move" : "copy";
+						} : void 0,
+						onDragleave: withDragHandlers ? (event) => {
+							const container = daySlotsContainers.get(date);
+							if (!(event.relatedTarget instanceof Node) || !container?.contains(event.relatedTarget)) dropTarget.value = null;
+						} : void 0,
+						onDrop: withDragHandlers ? (event) => {
+							const container = daySlotsContainers.get(date);
+							if (!container) return;
+							const target = getTimeSlotDropTarget({
+								nativeEvent: event,
+								container,
+								intervals,
+								date: (0, dayjs.default)(date).format("YYYY-MM-DD")
+							});
+							dropTarget.value = null;
+							if (target) emitDrop(event, target.target);
+						} : void 0
+					}, [
+						...intervals.map((slot, slotIndex) => {
+							const datePart = (0, dayjs.default)(date).format("YYYY-MM-DD");
+							const start = (0, dayjs.default)(`${datePart} ${slot.startTime}`);
+							const end = (0, dayjs.default)(`${datePart} ${slot.endTime}`);
+							const mod = getBusinessHoursMod({
+								time: slot.startTime,
+								businessHours: props.businessHours || ["09:00:00", "17:00:00"],
+								highlightBusinessHours: props.highlightBusinessHours,
+								dayOfWeek: start.day()
+							});
+							return (0, vue.h)(_mantine_vue_core.UnstyledButton, {
+								type: "button",
+								class: WeekView_module_default.weekViewDaySlot,
+								"data-week-day-index": dayIndex,
+								"data-time-slot-index": slotIndex,
+								"data-drag-slot-index": withSlotSelect ? slotIndex : void 0,
+								"data-drag-slot-group": withSlotSelect ? datePart : void 0,
+								"data-drop-target": dropTarget.value?.date === date && dropTarget.value.slotIndex === slotIndex || void 0,
+								"data-drag-selected": slotDragSelect.isSlotSelected(slotIndex, datePart) || void 0,
+								disabled: props.mode === "static",
+								"aria-label": `${getLabel("timeSlot", props.labels)} ${datePart} ${slot.startTime} - ${slot.endTime}`,
+								tabindex: props.mode === "static" ? -1 : dayIndex === 0 && slotIndex === 0 ? 0 : -1,
+								onKeydown: props.mode === "static" ? void 0 : (event) => {
+									if (event.key === "ArrowUp" && slotIndex === 0 && withAllDaySlots) {
+										focusWeekControl(event, `[data-all-day-index="${dayIndex}"]`);
+										return;
+									}
+									const nextDay = event.key === "ArrowRight" ? dayIndex + 1 : event.key === "ArrowLeft" ? dayIndex - 1 : dayIndex;
+									const nextSlot = event.key === "ArrowDown" ? slotIndex + 1 : event.key === "ArrowUp" ? slotIndex - 1 : slotIndex;
+									if (nextDay >= 0 && nextDay < days.length && nextSlot >= 0 && nextSlot < intervals.length && (nextDay !== dayIndex || nextSlot !== slotIndex)) focusWeekControl(event, `[data-week-day-index="${nextDay}"][data-time-slot-index="${nextSlot}"]`);
+								},
+								"data-business-hours": mod["business-hours"] || void 0,
+								"data-non-business-hours": mod["non-business-hours"] || void 0,
+								onClick: (nativeEvent) => props.onTimeSlotClick?.({
+									slotStart: start.format("YYYY-MM-DD HH:mm:ss"),
+									slotEnd: end.format("YYYY-MM-DD HH:mm:ss"),
+									nativeEvent
+								}),
+								onPointerdown: withSlotSelect ? (nativeEvent) => slotDragSelect.handleSlotPointerDown(nativeEvent, slotIndex, datePart) : void 0,
+								onDragover: (event) => event.preventDefault()
+							});
+						}),
+						...(grouped.backgroundEvents[date] || []).map((event) => (0, vue.h)("div", {
+							class: WeekView_module_default.weekViewBackgroundEvent,
+							style: {
+								top: `${event.position.top}%`,
+								height: `${event.position.height}%`,
+								width: "100%"
+							}
+						})),
+						...(grouped.regularEvents[date] || []).map((event) => {
+							const resizePosition = eventResize.getResizePosition(event.id);
+							const isResizable = eventResize.isResizableEvent(event);
+							return eventNode(event, props, {
+								key: `${event.id}-${date}`,
+								autoSize: true,
+								style: {
+									position: "absolute",
+									top: `${resizePosition?.top ?? event.position.top}%`,
+									height: `${resizePosition?.height ?? event.position.height}%`,
+									width: `${event.position.width}%`,
+									insetInlineStart: `${event.position.offset}%`
+								},
+								withResize: isResizable,
+								isResizing: resizePosition !== null,
+								onClick: props.onEventClick ? (nativeEvent) => {
+									if (!eventResize.wasResizing()) props.onEventClick?.(event, nativeEvent);
+								} : void 0,
+								onResizeStart: (edge, pointerEvent) => {
+									const container = daySlotsContainers.get(date);
+									if (!container) return;
+									eventResize.handleResizeStart({
+										event,
+										edge,
+										container,
+										originalTop: event.position.top,
+										originalHeight: event.position.height,
+										eventDate: (0, dayjs.default)(date).format("YYYY-MM-DD"),
+										pointerEvent
+									});
+								}
+							}, slots);
+						})
+					])]))
+				])
+			])])]);
+		};
+	}
+});
+//#endregion
+//#region src/components/YearView/get-year-view-events/get-year-view-events.ts
+function groupEventByDate(event, groupedEvents) {
+	if (isMultidayEvent(event)) {
+		const startDate = (0, dayjs.default)(event.start).startOf("day");
+		const endDate = (0, dayjs.default)(event.end).startOf("day");
+		for (let date = startDate; date.isBefore(endDate) || date.isSame(endDate); date = date.add(1, "day")) {
+			const dateKey = date.format("YYYY-MM-DD");
+			if (!groupedEvents[dateKey]) groupedEvents[dateKey] = [];
+			groupedEvents[dateKey].push(event);
+		}
+		return;
+	}
+	const eventDate = (0, dayjs.default)(event.start).format("YYYY-MM-DD");
+	if (!groupedEvents[eventDate]) groupedEvents[eventDate] = [];
+	groupedEvents[eventDate].push(event);
+}
+function getYearViewEvents({ date, events }) {
+	const groupedEvents = {};
+	if (events === void 0) return groupedEvents;
+	const ids = /* @__PURE__ */ new Set();
+	for (const event of events) if ((0, dayjs.default)(event.start).isSame((0, dayjs.default)(date), "year")) {
+		groupEventByDate(validateEvent(event), groupedEvents);
+		if (!ids.has(event.id)) ids.add(event.id);
+		else throw new Error(`[@mantine/schedule] YearView: Duplicated event ids found: ${event.id}`);
+	}
+	return groupedEvents;
+}
+var YearView_module_default = {
+	yearView: "_yearView_1y6ar_1",
+	yearViewMonths: "_yearViewMonths_1y6ar_15",
+	yearViewMonth: "_yearViewMonth_1y6ar_15",
+	yearViewWeekdays: "_yearViewWeekdays_1y6ar_92",
+	yearViewWeek: "_yearViewWeek_1y6ar_92",
+	yearViewWeekNumber: "_yearViewWeekNumber_1y6ar_100",
+	yearViewWeekday: "_yearViewWeekday_1y6ar_92",
+	yearViewWeekdaysCorner: "_yearViewWeekdaysCorner_1y6ar_154",
+	yearViewDay: "_yearViewDay_1y6ar_158",
+	yearViewMonthCaption: "_yearViewMonthCaption_1y6ar_217",
+	yearViewDayIndicators: "_yearViewDayIndicators_1y6ar_243",
+	yearViewDayIndicator: "_yearViewDayIndicator_1y6ar_243"
+};
+//#endregion
+//#region src/components/YearView/YearView.ts
+var YearView = (0, vue.defineComponent)({
+	name: "YearView",
+	inheritAttrs: false,
+	props: {
+		...baseViewProps,
+		firstDayOfWeek: {
+			type: Number,
+			default: 1
+		},
+		weekdayFormat: {
+			type: [String, Function],
+			default: "dd"
+		},
+		weekendDays: {
+			type: Array,
+			default: () => [0, 6]
+		},
+		withWeekNumbers: Boolean,
+		withWeekDays: {
+			type: Boolean,
+			default: true
+		},
+		consistentWeeks: Boolean,
+		highlightToday: {
+			type: Boolean,
+			default: true
+		},
+		withOutsideDays: {
+			type: Boolean,
+			default: true
+		},
+		monthsListFormat: {
+			type: [String, Function],
+			default: "MMMM"
+		},
+		getDayProps: Function,
+		getWeekNumberProps: Function,
+		onDayClick: Function,
+		onMonthClick: Function,
+		onWeekNumberClick: Function
+	},
+	setup(props, { attrs }) {
+		const yearGrid = (0, vue.ref)(null);
+		return () => {
+			const year = (0, dayjs.default)(props.date).startOf("year");
+			const eventsByDay = getYearViewEvents({
+				date: year,
+				events: getExpandedEvents(props.events, year.startOf("year").format("YYYY-MM-DD HH:mm:ss"), year.endOf("year").format("YYYY-MM-DD HH:mm:ss"), props.recurrenceExpansionLimit)
+			});
+			const weekdays = getWeekdaysNames({
+				locale: props.locale || "en",
+				format: props.weekdayFormat,
+				firstDayOfWeek: props.firstDayOfWeek
+			});
+			let totalYearGridCells = 0;
+			const months = Array.from({ length: 12 }, (_, monthIndex) => {
+				const month = year.month(monthIndex);
+				const weeks = getMonthDays({
+					month,
+					firstDayOfWeek: props.firstDayOfWeek,
+					consistentWeeks: props.consistentWeeks
+				});
+				const offset = totalYearGridCells;
+				totalYearGridCells += weeks.length * 7;
+				return {
+					month,
+					monthIndex,
+					weeks,
+					offset
+				};
+			});
+			return (0, vue.h)(_mantine_vue_core.Box, {
+				...attrs,
+				class: [YearView_module_default.yearView, attrs.class],
+				style: [{ "--year-view-radius": resolveScheduleRadius(props.radius) }, attrs.style]
+			}, () => [props.withHeader ? (0, vue.h)(ScheduleHeaderBase, {
+				view: "year",
+				labels: props.labels,
+				onDateChange: props.onDateChange,
+				onViewChange: props.onViewChange,
+				navigationHandlers: createHeaderNavigation(props.date, "year"),
+				previousControlProps: props.previousControlProps,
+				nextControlProps: props.nextControlProps,
+				todayControlProps: props.todayControlProps,
+				viewSelectProps: props.viewSelectProps,
+				control: { monthYearSelect: {
+					locale: props.locale,
+					yearValue: year.year(),
+					withMonths: false,
+					labelFormat: "YYYY",
+					onYearChange: (value) => props.onDateChange?.(toDateString(year.year(value)))
+				} }
+			}) : null, (0, vue.h)("div", {
+				ref: yearGrid,
+				class: YearView_module_default.yearViewMonths
+			}, months.map(({ month, weeks, offset }) => {
+				return (0, vue.h)("section", {
+					class: YearView_module_default.yearViewMonth,
+					"data-with-week-numbers": props.withWeekNumbers || void 0
+				}, [
+					(0, vue.h)(_mantine_vue_core.UnstyledButton, {
+						type: "button",
+						class: YearView_module_default.yearViewMonthCaption,
+						onClick: () => props.onMonthClick?.(toDateString(month))
+					}, () => formatDate({
+						date: month,
+						locale: props.locale || "en",
+						format: props.monthsListFormat
+					})),
+					props.withWeekDays ? (0, vue.h)("div", { class: YearView_module_default.yearViewWeekdays }, [props.withWeekNumbers ? (0, vue.h)("span", { class: YearView_module_default.yearViewWeekdaysCorner }) : null, ...weekdays.map((weekday) => (0, vue.h)("span", { class: YearView_module_default.yearViewWeekday }, [weekday]))]) : null,
+					...weeks.map((week, weekIndex) => (0, vue.h)("div", { class: YearView_module_default.yearViewWeek }, [props.withWeekNumbers ? (0, vue.h)(_mantine_vue_core.UnstyledButton, {
+						type: "button",
+						class: YearView_module_default.yearViewWeekNumber,
+						...props.getWeekNumberProps?.(toDateString(week[0])),
+						onClick: (event) => props.onWeekNumberClick?.(toDateString(week[0]), event)
+					}, () => String(getWeekNumber(week))) : null, ...week.map((date, dayIndex) => {
+						const events = eventsByDay[(0, dayjs.default)(date).format("YYYY-MM-DD")] || [];
+						const outside = !(0, dayjs.default)(date).isSame(month, "month");
+						const gridIndex = offset + weekIndex * 7 + dayIndex;
+						const extra = props.getDayProps?.(toDateString(date)) || {};
+						if (outside && !props.withOutsideDays) return (0, vue.h)("div", {
+							class: YearView_module_default.yearViewDay,
+							"data-day-placeholder": true,
+							key: toDateString(date)
+						});
+						return (0, vue.h)(_mantine_vue_core.UnstyledButton, {
+							type: "button",
+							...extra,
+							class: [YearView_module_default.yearViewDay, extra.class],
+							disabled: props.mode === "static",
+							"data-year-grid-index": gridIndex,
+							"data-outside": outside || void 0,
+							"data-weekend": props.weekendDays.includes((0, dayjs.default)(date).day()) || void 0,
+							"data-today": props.highlightToday && (0, dayjs.default)(date).isSame((0, dayjs.default)(), "day") || void 0,
+							"aria-label": formatDate({
+								date,
+								locale: props.locale || "en",
+								format: "MMMM D, YYYY"
+							}),
+							tabindex: props.mode === "static" || outside ? -1 : (0, dayjs.default)(date).date() === 1 ? 0 : -1,
+							onKeydown: props.mode === "static" ? void 0 : (event) => {
+								handleGridKeydown({
+									event,
+									index: gridIndex,
+									columns: 7,
+									total: totalYearGridCells,
+									getControl: (index) => {
+										const control = yearGrid.value?.querySelector(`[data-year-grid-index="${index}"]`) ?? null;
+										return control?.hasAttribute("data-outside") ? null : control;
+									}
+								});
+								extra.onKeydown?.(event);
+							},
+							onClick: (event) => props.onDayClick?.(toDateString(date), event)
+						}, () => [String((0, dayjs.default)(date).date()), events.length ? (0, vue.h)("span", { class: YearView_module_default.yearViewDayIndicators }, events.slice(0, 3).map((event) => (0, vue.h)("span", {
+							class: YearView_module_default.yearViewDayIndicator,
+							style: { background: `var(--mantine-color-${event.color}-6, ${event.color})` }
+						}))) : null]);
+					})]))
+				]);
+			}))]);
+		};
+	}
+});
+var Schedule_module_default = {
+	root: "_root_j1q6m_1",
+	desktopView: "_desktopView_j1q6m_7",
+	mobileView: "_mobileView_j1q6m_16"
+};
+//#endregion
+//#region src/components/Schedule/Schedule.ts
+var Schedule = (0, vue.defineComponent)({
+	name: "Schedule",
+	inheritAttrs: false,
+	slots: Object,
+	props: {
+		date: [String, Date],
+		defaultDate: [String, Date],
+		onDateChange: Function,
+		view: String,
+		defaultView: {
+			type: String,
+			default: "week"
+		},
+		onViewChange: Function,
+		events: Array,
+		locale: String,
+		radius: [String, Number],
+		labels: Object,
+		renderEventBody: Function,
+		withEventsDragAndDrop: Boolean,
+		onEventDrop: Function,
+		canDragEvent: Function,
+		onEventDragStart: Function,
+		onEventDragEnd: Function,
+		onTimeSlotClick: Function,
+		onAllDaySlotClick: Function,
+		onEventClick: Function,
+		onDayClick: Function,
+		onMonthClick: Function,
+		withDragSlotSelect: Boolean,
+		onSlotDragEnd: Function,
+		mode: {
+			type: String,
+			default: "default"
+		},
+		onExternalEventDrop: Function,
+		withEventResize: Boolean,
+		onEventResize: Function,
+		canResizeEvent: Function,
+		recurrenceExpansionLimit: {
+			type: Number,
+			default: 2e3
+		},
+		layout: {
+			type: String,
+			default: "default"
+		},
+		dayViewProps: Object,
+		weekViewProps: Object,
+		monthViewProps: Object,
+		yearViewProps: Object,
+		mobileMonthViewProps: Object
+	},
+	setup(props, { attrs, slots }) {
+		const currentDate = (0, vue.ref)(toDateString(props.date || props.defaultDate || (0, dayjs.default)()));
+		const currentView = (0, vue.ref)(props.view || props.defaultView);
+		(0, vue.watch)(() => props.date, (value) => {
+			if (value !== void 0) currentDate.value = toDateString(value);
+		});
+		(0, vue.watch)(() => props.view, (value) => {
+			if (value !== void 0) currentView.value = value;
+		});
+		const changeDate = (date) => {
+			if (props.date === void 0) currentDate.value = date;
+			props.onDateChange?.(date);
+		};
+		const changeView = (view) => {
+			if (props.view === void 0) currentView.value = view;
+			props.onViewChange?.(view);
+		};
+		return () => {
+			const shared = {
+				date: currentDate.value,
+				onDateChange: changeDate,
+				onViewChange: changeView,
+				events: props.events,
+				locale: props.locale,
+				radius: props.radius,
+				labels: props.labels,
+				renderEventBody: props.renderEventBody,
+				withEventsDragAndDrop: props.withEventsDragAndDrop,
+				onEventDrop: props.onEventDrop,
+				canDragEvent: props.canDragEvent,
+				onEventDragStart: props.onEventDragStart,
+				onEventDragEnd: props.onEventDragEnd,
+				onTimeSlotClick: props.onTimeSlotClick,
+				onAllDaySlotClick: props.onAllDaySlotClick,
+				onEventClick: props.onEventClick,
+				onDayClick: props.onDayClick,
+				onMonthClick: props.onMonthClick,
+				withDragSlotSelect: props.withDragSlotSelect,
+				onSlotDragEnd: props.onSlotDragEnd,
+				mode: props.mode,
+				onExternalEventDrop: props.onExternalEventDrop,
+				withEventResize: props.withEventResize,
+				onEventResize: props.onEventResize,
+				canResizeEvent: props.canResizeEvent,
+				recurrenceExpansionLimit: props.recurrenceExpansionLimit
+			};
+			const components = {
+				day: [DayView, props.dayViewProps],
+				week: [WeekView, props.weekViewProps],
+				month: [MonthView, props.monthViewProps],
+				year: [YearView, props.yearViewProps]
+			};
+			const viewSlots = {};
+			if (slots.eventBody) viewSlots.eventBody = slots.eventBody;
+			if (slots.event) viewSlots.event = slots.event;
+			if (slots.weekLabel) viewSlots.weekLabel = slots.weekLabel;
+			if (slots.header) viewSlots.header = slots.header;
+			const forwardedSlots = Object.keys(viewSlots).length ? viewSlots : void 0;
+			const [component, viewProps] = components[currentView.value];
+			const desktop = (0, vue.h)(component, {
+				...shared,
+				...viewProps
+			}, forwardedSlots);
+			if (props.layout !== "responsive") return (0, vue.h)(_mantine_vue_core.Box, {
+				...attrs,
+				class: [Schedule_module_default.root, attrs.class],
+				style: attrs.style
+			}, () => [desktop]);
+			const mobile = currentView.value === "year" ? (0, vue.h)(YearView, {
+				...shared,
+				...props.yearViewProps
+			}, forwardedSlots) : (0, vue.h)(MobileMonthView, {
+				...shared,
+				...props.mobileMonthViewProps,
+				onYearClick: () => changeView("year"),
+				onDayClick: (date, event) => {
+					props.onDayClick?.(date, event);
+					props.mobileMonthViewProps?.onDayClick?.(date, event);
+				}
+			}, forwardedSlots);
+			return (0, vue.h)(_mantine_vue_core.Box, {
+				...attrs,
+				mod: { layout: props.layout },
+				class: [Schedule_module_default.root, attrs.class],
+				style: attrs.style
+			}, () => [(0, vue.h)(_mantine_vue_core.Box, { class: Schedule_module_default.desktopView }, () => [desktop]), (0, vue.h)(_mantine_vue_core.Box, { class: Schedule_module_default.mobileView }, () => [mobile])]);
+		};
+	}
+});
+//#endregion
+//#region src/components/DragContext/DragContext.ts
+var DragContext = Symbol("mantine-schedule-drag-context");
+function provideDragContext(value) {
+	(0, vue.provide)(DragContext, value);
+}
+function useDragContext() {
+	return (0, vue.inject)(DragContext, {
+		draggedEvent: null,
+		dragOverTarget: null,
+		isDragging: false,
+		isSlotDragging: false
+	});
+}
+//#endregion
+exports.CurrentTimeIndicator = CurrentTimeIndicator;
+exports.DEFAULT_SCHEDULE_LABELS = DEFAULT_SCHEDULE_LABELS;
+exports.DayView = DayView;
+exports.DragContext = DragContext;
+exports.HeaderControl = HeaderControl;
+exports.MobileMonthView = MobileMonthView;
+exports.MonthView = MonthView;
+exports.MonthYearSelect = MonthYearSelect;
+exports.MoreEvents = MoreEvents;
+exports.Schedule = Schedule;
+exports.ScheduleEvent = ScheduleEvent;
+exports.ScheduleHeader = ScheduleHeader;
+exports.ScheduleHeaderBase = ScheduleHeaderBase;
+exports.ScheduleHeaderNext = ScheduleHeaderNext;
+exports.ScheduleHeaderPrevious = ScheduleHeaderPrevious;
+exports.ScheduleHeaderToday = ScheduleHeaderToday;
+exports.ViewSelect = ViewSelect;
+exports.WeekView = WeekView;
+exports.YearView = YearView;
+exports.calculateDropTime = calculateDropTime;
+exports.calculateMonthDropDate = calculateMonthDropDate;
+exports.clampIntervalMinutes = clampIntervalMinutes;
+exports.createHeaderNavigation = createHeaderNavigation;
+exports.expandRecurringEvents = expandRecurringEvents;
+exports.formatDate = formatDate;
+exports.getBusinessHoursMod = getBusinessHoursMod;
+exports.getCurrentTimePosition = getCurrentTimePosition;
+exports.getDayPosition = getDayPosition;
+exports.getDayPositionedEvents = getDayPositionedEvents;
+exports.getDayTimeIntervals = getDayTimeIntervals;
+exports.getDayViewEvents = getDayViewEvents;
+exports.getEndOfWeek = getEndOfWeek;
+exports.getLabel = getLabel;
+exports.getMonthDays = getMonthDays;
+exports.getMonthPositionedEvents = getMonthPositionedEvents;
+exports.getMonthRange = getMonthRange;
+exports.getMonthViewEvents = getMonthViewEvents;
+exports.getMonthsByQuarter = getMonthsByQuarter;
+exports.getMonthsList = getMonthsList;
+exports.getRenderableMonthEventSegments = getRenderableMonthEventSegments;
+exports.getStartOfWeek = getStartOfWeek;
+exports.getVisibleEvents = getVisibleEvents;
+exports.getWeekDays = getWeekDays;
+exports.getWeekLabel = getWeekLabel;
+exports.getWeekNumber = getWeekNumber;
+exports.getWeekPositionedEvents = getWeekPositionedEvents;
+exports.getWeekViewEvents = getWeekViewEvents;
+exports.getWeekdaysNames = getWeekdaysNames;
+exports.getYearsList = getYearsList;
+exports.isAfterMinDate = isAfterMinDate;
+exports.isAllDayEvent = isAllDayEvent;
+exports.isBeforeMaxDate = isBeforeMaxDate;
+exports.isEventInTimeRange = isEventInTimeRange;
+exports.isEventsOverlap = isEventsOverlap;
+exports.isInTimeRange = isInTimeRange;
+exports.isMultidayEvent = isMultidayEvent;
+exports.isSameMonth = isSameMonth;
+exports.isWithinWeek = isWithinWeek;
+exports.nextWeek = nextWeek;
+exports.parseTimeString = parseTimeString;
+exports.previousWeek = previousWeek;
+exports.provideDragContext = provideDragContext;
+exports.sortEvents = sortEvents;
+exports.toDateString = toDateString;
+exports.toTimeString = toTimeString;
+exports.useDragContext = useDragContext;
+exports.validateEvent = validateEvent;
+
+//# sourceMappingURL=index.cjs.map