@fde-desktop/fde-core 0.3.7 → 0.4.1

package/dist/chunk-D7R55WWT.js

@@ -0,0 +1,1601 @@
+import { createVarsResolver, getSize, factory, useProps, UnstyledButton, useStyles, getSpacing, getFontSize, Box, useResolvedStylesApi, AccordionChevron, useUncontrolled, useMergedRef, clamp } from './chunk-BQL3YXMV.js';
+import dayjs27 from 'dayjs';
+import { createContext, createElement, useRef, useImperativeHandle, useEffect, use, useCallback } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import isoWeek from 'dayjs/plugin/isoWeek.js';
+
+// ../../node_modules/.bun/@mantine+dates@9.0.0+7c0e6e23d8f8fc3c/node_modules/@mantine/dates/esm/utils/handle-control-key-down/handle-control-key-down.mjs
+function getNextIndex({ direction, levelIndex, rowIndex, cellIndex, size }) {
+  switch (direction) {
+    case "up":
+      if (levelIndex === 0 && rowIndex === 0) return null;
+      if (rowIndex === 0) return {
+        levelIndex: levelIndex - 1,
+        rowIndex: cellIndex <= size[levelIndex - 1][size[levelIndex - 1].length - 1] - 1 ? size[levelIndex - 1].length - 1 : size[levelIndex - 1].length - 2,
+        cellIndex
+      };
+      return {
+        levelIndex,
+        rowIndex: rowIndex - 1,
+        cellIndex
+      };
+    case "down":
+      if (rowIndex === size[levelIndex].length - 1) return {
+        levelIndex: levelIndex + 1,
+        rowIndex: 0,
+        cellIndex
+      };
+      if (rowIndex === size[levelIndex].length - 2 && cellIndex >= size[levelIndex][size[levelIndex].length - 1]) return {
+        levelIndex: levelIndex + 1,
+        rowIndex: 0,
+        cellIndex
+      };
+      return {
+        levelIndex,
+        rowIndex: rowIndex + 1,
+        cellIndex
+      };
+    case "left":
+      if (levelIndex === 0 && rowIndex === 0 && cellIndex === 0) return null;
+      if (rowIndex === 0 && cellIndex === 0) return {
+        levelIndex: levelIndex - 1,
+        rowIndex: size[levelIndex - 1].length - 1,
+        cellIndex: size[levelIndex - 1][size[levelIndex - 1].length - 1] - 1
+      };
+      if (cellIndex === 0) return {
+        levelIndex,
+        rowIndex: rowIndex - 1,
+        cellIndex: size[levelIndex][rowIndex - 1] - 1
+      };
+      return {
+        levelIndex,
+        rowIndex,
+        cellIndex: cellIndex - 1
+      };
+    case "right":
+      if (rowIndex === size[levelIndex].length - 1 && cellIndex === size[levelIndex][rowIndex] - 1) return {
+        levelIndex: levelIndex + 1,
+        rowIndex: 0,
+        cellIndex: 0
+      };
+      if (cellIndex === size[levelIndex][rowIndex] - 1) return {
+        levelIndex,
+        rowIndex: rowIndex + 1,
+        cellIndex: 0
+      };
+      return {
+        levelIndex,
+        rowIndex,
+        cellIndex: cellIndex + 1
+      };
+    default:
+      return {
+        levelIndex,
+        rowIndex,
+        cellIndex
+      };
+  }
+}
+function focusOnNextFocusableControl({ controlsRef, direction, levelIndex, rowIndex, cellIndex, size }) {
+  const nextIndex = getNextIndex({
+    direction,
+    size,
+    rowIndex,
+    cellIndex,
+    levelIndex
+  });
+  if (!nextIndex) return;
+  const controlToFocus = controlsRef.current?.[nextIndex.levelIndex]?.[nextIndex.rowIndex]?.[nextIndex.cellIndex];
+  if (!controlToFocus) return;
+  if (controlToFocus.disabled || controlToFocus.getAttribute("data-hidden") || controlToFocus.getAttribute("data-outside")) focusOnNextFocusableControl({
+    controlsRef,
+    direction,
+    levelIndex: nextIndex.levelIndex,
+    cellIndex: nextIndex.cellIndex,
+    rowIndex: nextIndex.rowIndex,
+    size
+  });
+  else controlToFocus.focus();
+}
+function getDirection(key) {
+  switch (key) {
+    case "ArrowDown":
+      return "down";
+    case "ArrowUp":
+      return "up";
+    case "ArrowRight":
+      return "right";
+    case "ArrowLeft":
+      return "left";
+    default:
+      return null;
+  }
+}
+function getControlsSize(controlsRef) {
+  return controlsRef.current?.map((column) => column.map((row) => row.length));
+}
+function handleControlKeyDown({ controlsRef, levelIndex, rowIndex, cellIndex, event }) {
+  const direction = getDirection(event.key);
+  if (direction) {
+    event.preventDefault();
+    focusOnNextFocusableControl({
+      controlsRef,
+      direction,
+      levelIndex,
+      rowIndex,
+      cellIndex,
+      size: getControlsSize(controlsRef)
+    });
+  }
+}
+function toDateString(value) {
+  return value == null || value === "" ? value : dayjs27(value).format("YYYY-MM-DD");
+}
+function toDateTimeString(value) {
+  return value == null || value === "" ? value : dayjs27(value).format("YYYY-MM-DD HH:mm:ss");
+}
+var DATES_PROVIDER_DEFAULT_SETTINGS = {
+  locale: "en",
+  firstDayOfWeek: 1,
+  weekendDays: [0, 6],
+  labelSeparator: "\u2013",
+  consistentWeeks: false
+};
+var DatesProviderContext = createContext(DATES_PROVIDER_DEFAULT_SETTINGS);
+function useDatesContext() {
+  const ctx = use(DatesProviderContext);
+  const getLocale = useCallback((input) => input || ctx.locale, [ctx.locale]);
+  const getFirstDayOfWeek = useCallback((input) => typeof input === "number" ? input : ctx.firstDayOfWeek, [ctx.firstDayOfWeek]);
+  const getWeekendDays = useCallback((input) => Array.isArray(input) ? input : ctx.weekendDays, [ctx.weekendDays]);
+  const getLabelSeparator = useCallback((input) => typeof input === "string" ? input : ctx.labelSeparator, [ctx.labelSeparator]);
+  return {
+    ...ctx,
+    getLocale,
+    getFirstDayOfWeek,
+    getWeekendDays,
+    getLabelSeparator
+  };
+}
+
+// ../../node_modules/.bun/@mantine+dates@9.0.0+7c0e6e23d8f8fc3c/node_modules/@mantine/dates/esm/components/Day/Day.module.mjs
+var Day_module_default = { "day": "m_396ce5cb" };
+var varsResolver = createVarsResolver((_, { size }) => ({ day: { "--day-size": getSize(size, "day-size") } }));
+var Day = factory((_props) => {
+  const props = useProps("Day", null, _props);
+  const { classNames, className, style, styles, unstyled, vars, date, disabled, __staticSelector, weekend, outside, selected, renderDay, inRange, firstInRange, lastInRange, hidden, static: isStatic, highlightToday, fullWidth, attributes, ...others } = props;
+  return /* @__PURE__ */ jsx(UnstyledButton, {
+    ...useStyles({
+      name: __staticSelector || "Day",
+      classes: Day_module_default,
+      props,
+      className,
+      style,
+      classNames,
+      styles,
+      unstyled,
+      attributes,
+      vars,
+      varsResolver,
+      rootSelector: "day"
+    })("day", { style: hidden ? { display: "none" } : void 0 }),
+    component: isStatic ? "div" : "button",
+    disabled,
+    "data-today": dayjs27(date).isSame(/* @__PURE__ */ new Date(), "day") || void 0,
+    "data-hidden": hidden || void 0,
+    "data-highlight-today": highlightToday || void 0,
+    "data-disabled": disabled || void 0,
+    "data-weekend": !disabled && !outside && weekend || void 0,
+    "data-outside": !disabled && outside || void 0,
+    "data-selected": !disabled && selected || void 0,
+    "data-in-range": inRange && !disabled || void 0,
+    "data-first-in-range": firstInRange && !disabled || void 0,
+    "data-last-in-range": lastInRange && !disabled || void 0,
+    "data-static": isStatic || void 0,
+    "data-full-width": fullWidth || void 0,
+    unstyled,
+    ...others,
+    children: renderDay?.(date) || dayjs27(date).date()
+  });
+});
+Day.classes = Day_module_default;
+Day.varsResolver = varsResolver;
+Day.displayName = "@mantine/dates/Day";
+function getWeekdayNames({ locale, format = "dd", firstDayOfWeek = 1 }) {
+  const baseDate = dayjs27().day(firstDayOfWeek);
+  const labels = [];
+  for (let i = 0; i < 7; i += 1) if (typeof format === "string") labels.push(dayjs27(baseDate).add(i, "days").locale(locale).format(format));
+  else labels.push(format(dayjs27(baseDate).add(i, "days").format("YYYY-MM-DD")));
+  return labels;
+}
+
+// ../../node_modules/.bun/@mantine+dates@9.0.0+7c0e6e23d8f8fc3c/node_modules/@mantine/dates/esm/components/WeekdaysRow/WeekdaysRow.module.mjs
+var WeekdaysRow_module_default = { "weekday": "m_18a3eca" };
+var varsResolver2 = createVarsResolver((_, { size }) => ({ weekdaysRow: {
+  "--wr-fz": getFontSize(size),
+  "--wr-spacing": getSpacing(size)
+} }));
+var WeekdaysRow = factory((_props) => {
+  const props = useProps("WeekdaysRow", null, _props);
+  const { classNames, className, style, styles, unstyled, vars, locale, firstDayOfWeek, weekdayFormat, cellComponent: CellComponent = "th", __staticSelector, withWeekNumbers, attributes, ...others } = props;
+  const getStyles = useStyles({
+    name: __staticSelector || "WeekdaysRow",
+    classes: WeekdaysRow_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver: varsResolver2,
+    rootSelector: "weekdaysRow"
+  });
+  const ctx = useDatesContext();
+  const weekdays = getWeekdayNames({
+    locale: ctx.getLocale(locale),
+    format: weekdayFormat,
+    firstDayOfWeek: ctx.getFirstDayOfWeek(firstDayOfWeek)
+  }).map((weekday, index) => /* @__PURE__ */ jsx(CellComponent, {
+    ...getStyles("weekday"),
+    children: weekday
+  }, index));
+  return /* @__PURE__ */ jsxs(Box, {
+    component: "tr",
+    ...getStyles("weekdaysRow"),
+    ...others,
+    children: [withWeekNumbers && /* @__PURE__ */ jsx(CellComponent, {
+      ...getStyles("weekday"),
+      children: "#"
+    }), weekdays]
+  });
+});
+WeekdaysRow.classes = WeekdaysRow_module_default;
+WeekdaysRow.varsResolver = varsResolver2;
+WeekdaysRow.displayName = "@mantine/dates/WeekdaysRow";
+function getEndOfWeek(date, firstDayOfWeek = 1) {
+  let value = dayjs27(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");
+}
+function getStartOfWeek(date, firstDayOfWeek = 1) {
+  let value = dayjs27(date);
+  while (value.day() !== firstDayOfWeek) value = value.subtract(1, "day");
+  return value.format("YYYY-MM-DD");
+}
+function getMonthDays({ month, firstDayOfWeek = 1, consistentWeeks }) {
+  const start = dayjs27(dayjs27(month).subtract(dayjs27(month).date() - 1, "day").format("YYYY-M-D"));
+  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 = dayjs27(getStartOfWeek(startOfMonth, firstDayOfWeek));
+  while (dayjs27(date).isBefore(endDate, "day")) {
+    const days = [];
+    for (let i = 0; i < 7; i += 1) {
+      days.push(date.format("YYYY-MM-DD"));
+      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 = dayjs27(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"));
+        nextDay = nextDay.add(1, "day");
+      }
+      weeks.push(days);
+    }
+  }
+  return weeks;
+}
+function isSameMonth(date, comparison) {
+  return dayjs27(date).format("YYYY-MM") === dayjs27(comparison).format("YYYY-MM");
+}
+function isAfterMinDate(date, minDate) {
+  return minDate ? dayjs27(date).isAfter(dayjs27(minDate).subtract(1, "day"), "day") : true;
+}
+function isBeforeMaxDate(date, maxDate) {
+  return maxDate ? dayjs27(date).isBefore(dayjs27(maxDate).add(1, "day"), "day") : true;
+}
+function getDateInTabOrder({ dates, minDate, maxDate, getDayProps, excludeDate, hideOutsideDates, month }) {
+  const enabledDates = dates.flat().filter((date) => isBeforeMaxDate(date, maxDate) && isAfterMinDate(date, minDate) && !excludeDate?.(date) && !getDayProps?.(date)?.disabled && (!hideOutsideDates || isSameMonth(date, month)));
+  const selectedDate = enabledDates.find((date) => getDayProps?.(date)?.selected);
+  if (selectedDate) return selectedDate;
+  const currentDate = enabledDates.find((date) => dayjs27().isSame(date, "date"));
+  if (currentDate) return currentDate;
+  return enabledDates[0];
+}
+dayjs27.extend(isoWeek);
+function getWeekNumber(week) {
+  return dayjs27(week.find((date) => dayjs27(date).day() === 1)).isoWeek();
+}
+
+// ../../node_modules/.bun/@mantine+dates@9.0.0+7c0e6e23d8f8fc3c/node_modules/@mantine/dates/esm/components/Month/Month.module.mjs
+var Month_module_default = {
+  "month": "m_cc9820d3",
+  "monthCell": "m_8f457cd5",
+  "weekNumber": "m_6cff9dea"
+};
+var defaultProps = { withCellSpacing: true };
+var varsResolver3 = createVarsResolver((_, { size }) => ({ weekNumber: {
+  "--wn-fz": getFontSize(size),
+  "--wn-size": getSize(size, "wn-size")
+} }));
+var Month = factory((_props) => {
+  const props = useProps("Month", defaultProps, _props);
+  const { classNames, className, style, styles, unstyled, vars, __staticSelector, locale, firstDayOfWeek, weekdayFormat, month, weekendDays, getDayProps, excludeDate, minDate, maxDate, renderDay, hideOutsideDates, hideWeekdays, getDayAriaLabel, static: isStatic, __getDayRef, __onDayKeyDown, __onDayClick, __onDayMouseEnter, __preventFocus, __stopPropagation, withCellSpacing, size, highlightToday, withWeekNumbers, fullWidth, attributes, ...others } = props;
+  const getStyles = useStyles({
+    name: __staticSelector || "Month",
+    classes: Month_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver: varsResolver3,
+    rootSelector: "month"
+  });
+  const ctx = useDatesContext();
+  const dates = getMonthDays({
+    month,
+    firstDayOfWeek: ctx.getFirstDayOfWeek(firstDayOfWeek),
+    consistentWeeks: ctx.consistentWeeks
+  });
+  const dateInTabOrder = getDateInTabOrder({
+    dates,
+    minDate: toDateString(minDate),
+    maxDate: toDateString(maxDate),
+    getDayProps,
+    excludeDate,
+    hideOutsideDates,
+    month
+  });
+  const { resolvedClassNames, resolvedStyles } = useResolvedStylesApi({
+    classNames,
+    styles,
+    props
+  });
+  const rows = dates.map((row, rowIndex) => {
+    const cells = row.map((date, cellIndex) => {
+      const outside = !isSameMonth(date, month);
+      const ariaLabel = getDayAriaLabel?.(date) || dayjs27(date).locale(locale || ctx.locale).format("D MMMM YYYY");
+      const dayProps = getDayProps?.(date);
+      const isDateInTabOrder = dayjs27(date).isSame(dateInTabOrder, "date");
+      return /* @__PURE__ */ jsx("td", {
+        ...getStyles("monthCell"),
+        "data-with-spacing": withCellSpacing || void 0,
+        children: /* @__PURE__ */ jsx(Day, {
+          __staticSelector: __staticSelector || "Month",
+          classNames: resolvedClassNames,
+          styles: resolvedStyles,
+          attributes,
+          unstyled,
+          "data-mantine-stop-propagation": __stopPropagation || void 0,
+          highlightToday,
+          renderDay,
+          date,
+          size,
+          weekend: ctx.getWeekendDays(weekendDays).includes(dayjs27(date).get("day")),
+          outside,
+          hidden: hideOutsideDates ? outside : false,
+          "aria-label": ariaLabel,
+          static: isStatic,
+          fullWidth,
+          disabled: excludeDate?.(date) || !isBeforeMaxDate(date, toDateString(maxDate)) || !isAfterMinDate(date, toDateString(minDate)),
+          ref: (node) => {
+            if (node) __getDayRef?.(rowIndex, cellIndex, node);
+          },
+          ...dayProps,
+          onKeyDown: (event) => {
+            dayProps?.onKeyDown?.(event);
+            __onDayKeyDown?.(event, {
+              rowIndex,
+              cellIndex,
+              date
+            });
+          },
+          onMouseEnter: (event) => {
+            dayProps?.onMouseEnter?.(event);
+            __onDayMouseEnter?.(event, date);
+          },
+          onClick: (event) => {
+            dayProps?.onClick?.(event);
+            __onDayClick?.(event, date);
+          },
+          onMouseDown: (event) => {
+            dayProps?.onMouseDown?.(event);
+            __preventFocus && event.preventDefault();
+          },
+          tabIndex: __preventFocus || !isDateInTabOrder ? -1 : 0
+        })
+      }, date.toString());
+    });
+    return /* @__PURE__ */ jsxs("tr", {
+      ...getStyles("monthRow"),
+      children: [withWeekNumbers && /* @__PURE__ */ jsx("td", {
+        ...getStyles("weekNumber"),
+        children: getWeekNumber(row)
+      }), cells]
+    }, rowIndex);
+  });
+  return /* @__PURE__ */ jsxs(Box, {
+    component: "table",
+    ...getStyles("month"),
+    size,
+    "data-full-width": fullWidth || void 0,
+    ...others,
+    children: [!hideWeekdays && /* @__PURE__ */ jsx("thead", {
+      ...getStyles("monthThead"),
+      children: /* @__PURE__ */ jsx(WeekdaysRow, {
+        __staticSelector: __staticSelector || "Month",
+        locale,
+        firstDayOfWeek,
+        weekdayFormat,
+        withWeekNumbers,
+        size,
+        classNames: resolvedClassNames,
+        styles: resolvedStyles,
+        unstyled,
+        attributes
+      })
+    }), /* @__PURE__ */ jsx("tbody", {
+      ...getStyles("monthTbody"),
+      children: rows
+    })]
+  });
+});
+Month.classes = Month_module_default;
+Month.varsResolver = varsResolver3;
+Month.displayName = "@mantine/dates/Month";
+
+// ../../node_modules/.bun/@mantine+dates@9.0.0+7c0e6e23d8f8fc3c/node_modules/@mantine/dates/esm/components/PickerControl/PickerControl.module.mjs
+var PickerControl_module_default = { "pickerControl": "m_dc6a3c71" };
+var varsResolver4 = createVarsResolver((_, { size }) => ({ pickerControl: {
+  "--dpc-fz": getFontSize(size),
+  "--dpc-size": getSize(size, "dpc-size")
+} }));
+var PickerControl = factory((_props) => {
+  const props = useProps("PickerControl", null, _props);
+  const { classNames, className, style, styles, unstyled, vars, firstInRange, lastInRange, inRange, __staticSelector, selected, disabled, fullWidth, attributes, ...others } = props;
+  return /* @__PURE__ */ jsx(UnstyledButton, {
+    ...useStyles({
+      name: __staticSelector || "PickerControl",
+      classes: PickerControl_module_default,
+      props,
+      className,
+      style,
+      classNames,
+      styles,
+      unstyled,
+      attributes,
+      vars,
+      varsResolver: varsResolver4,
+      rootSelector: "pickerControl"
+    })("pickerControl"),
+    unstyled,
+    "data-picker-control": true,
+    "data-full-width": fullWidth || void 0,
+    "data-selected": selected && !disabled || void 0,
+    "data-disabled": disabled || void 0,
+    "data-in-range": inRange && !disabled && !selected || void 0,
+    "data-first-in-range": firstInRange && !disabled || void 0,
+    "data-last-in-range": lastInRange && !disabled || void 0,
+    disabled,
+    ...others
+  });
+});
+PickerControl.classes = PickerControl_module_default;
+PickerControl.varsResolver = varsResolver4;
+PickerControl.displayName = "@mantine/dates/PickerControl";
+function isYearDisabled({ year, minDate, maxDate }) {
+  if (!minDate && !maxDate) return false;
+  if (minDate && dayjs27(year).isBefore(minDate, "year")) return true;
+  if (maxDate && dayjs27(year).isAfter(maxDate, "year")) return true;
+  return false;
+}
+function getYearInTabOrder({ years, minDate, maxDate, getYearControlProps }) {
+  const enabledYears = years.flat().filter((year) => !isYearDisabled({
+    year,
+    minDate,
+    maxDate
+  }) && !getYearControlProps?.(year)?.disabled);
+  const selectedYear = enabledYears.find((year) => getYearControlProps?.(year)?.selected);
+  if (selectedYear) return selectedYear;
+  const currentYear = enabledYears.find((year) => dayjs27().isSame(year, "year"));
+  if (currentYear) return currentYear;
+  return enabledYears[0];
+}
+function getYearsData(decade) {
+  const year = dayjs27(decade).year();
+  const rounded = year - year % 10;
+  let currentYearIndex = 0;
+  const results = [
+    [],
+    [],
+    [],
+    []
+  ];
+  for (let i = 0; i < 4; i += 1) {
+    const max = i === 3 ? 1 : 3;
+    for (let j = 0; j < max; j += 1) {
+      results[i].push(dayjs27(new Date(rounded + currentYearIndex, 0)).format("YYYY-MM-DD"));
+      currentYearIndex += 1;
+    }
+  }
+  return results;
+}
+
+// ../../node_modules/.bun/@mantine+dates@9.0.0+7c0e6e23d8f8fc3c/node_modules/@mantine/dates/esm/components/YearsList/YearsList.module.mjs
+var YearsList_module_default = {
+  "yearsList": "m_9206547b",
+  "yearsListCell": "m_c5a19c7d"
+};
+var defaultProps2 = {
+  yearsListFormat: "YYYY",
+  withCellSpacing: true
+};
+var YearsList = factory((_props) => {
+  const props = useProps("YearsList", defaultProps2, _props);
+  const { classNames, className, style, styles, unstyled, vars, decade, yearsListFormat, locale, minDate, maxDate, getYearControlProps, __staticSelector, __getControlRef, __onControlKeyDown, __onControlClick, __onControlMouseEnter, __preventFocus, __stopPropagation, withCellSpacing, fullWidth, size, attributes, ...others } = props;
+  const getStyles = useStyles({
+    name: __staticSelector || "YearsList",
+    classes: YearsList_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    rootSelector: "yearsList"
+  });
+  const ctx = useDatesContext();
+  const years = getYearsData(decade);
+  const yearInTabOrder = getYearInTabOrder({
+    years,
+    minDate,
+    maxDate,
+    getYearControlProps
+  });
+  const rows = years.map((yearsRow, rowIndex) => {
+    const cells = yearsRow.map((year, cellIndex) => {
+      const controlProps = getYearControlProps?.(year);
+      const isYearInTabOrder = dayjs27(year).isSame(yearInTabOrder, "year");
+      return /* @__PURE__ */ jsx("td", {
+        ...getStyles("yearsListCell"),
+        "data-with-spacing": withCellSpacing || void 0,
+        children: /* @__PURE__ */ jsx(PickerControl, {
+          ...getStyles("yearsListControl"),
+          size,
+          unstyled,
+          fullWidth,
+          "data-mantine-stop-propagation": __stopPropagation || void 0,
+          disabled: isYearDisabled({
+            year,
+            minDate,
+            maxDate
+          }),
+          ref: (node) => {
+            if (node) __getControlRef?.(rowIndex, cellIndex, node);
+          },
+          ...controlProps,
+          onKeyDown: (event) => {
+            controlProps?.onKeyDown?.(event);
+            __onControlKeyDown?.(event, {
+              rowIndex,
+              cellIndex,
+              date: year
+            });
+          },
+          onClick: (event) => {
+            controlProps?.onClick?.(event);
+            __onControlClick?.(event, year);
+          },
+          onMouseEnter: (event) => {
+            controlProps?.onMouseEnter?.(event);
+            __onControlMouseEnter?.(event, year);
+          },
+          onMouseDown: (event) => {
+            controlProps?.onMouseDown?.(event);
+            __preventFocus && event.preventDefault();
+          },
+          tabIndex: __preventFocus || !isYearInTabOrder ? -1 : 0,
+          children: controlProps?.children ?? dayjs27(year).locale(ctx.getLocale(locale)).format(yearsListFormat)
+        })
+      }, cellIndex);
+    });
+    return /* @__PURE__ */ jsx("tr", {
+      ...getStyles("yearsListRow"),
+      children: cells
+    }, rowIndex);
+  });
+  return /* @__PURE__ */ jsx(Box, {
+    component: "table",
+    size,
+    ...getStyles("yearsList"),
+    "data-full-width": fullWidth || void 0,
+    ...others,
+    children: /* @__PURE__ */ jsx("tbody", { children: rows })
+  });
+});
+YearsList.classes = YearsList_module_default;
+YearsList.displayName = "@mantine/dates/YearsList";
+function isMonthDisabled({ month, minDate, maxDate }) {
+  if (!minDate && !maxDate) return false;
+  if (minDate && dayjs27(month).isBefore(minDate, "month")) return true;
+  if (maxDate && dayjs27(month).isAfter(maxDate, "month")) return true;
+  return false;
+}
+function getMonthInTabOrder({ months, minDate, maxDate, getMonthControlProps }) {
+  const enabledMonths = months.flat().filter((month) => !isMonthDisabled({
+    month,
+    minDate,
+    maxDate
+  }) && !getMonthControlProps?.(month)?.disabled);
+  const selectedMonth = enabledMonths.find((month) => getMonthControlProps?.(month)?.selected);
+  if (selectedMonth) return selectedMonth;
+  const currentMonth = enabledMonths.find((month) => dayjs27().isSame(month, "month"));
+  if (currentMonth) return currentMonth;
+  return enabledMonths[0];
+}
+function getMonthsData(year) {
+  const startOfYear = dayjs27(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(dayjs27(startOfYear).add(currentMonthIndex, "months").format("YYYY-MM-DD"));
+    currentMonthIndex += 1;
+  }
+  return results;
+}
+
+// ../../node_modules/.bun/@mantine+dates@9.0.0+7c0e6e23d8f8fc3c/node_modules/@mantine/dates/esm/components/MonthsList/MonthsList.module.mjs
+var MonthsList_module_default = {
+  "monthsList": "m_2a6c32d",
+  "monthsListCell": "m_fe27622f"
+};
+var defaultProps3 = {
+  monthsListFormat: "MMM",
+  withCellSpacing: true
+};
+var MonthsList = factory((_props) => {
+  const props = useProps("MonthsList", defaultProps3, _props);
+  const { classNames, className, style, styles, unstyled, vars, __staticSelector, year, monthsListFormat, locale, minDate, maxDate, getMonthControlProps, __getControlRef, __onControlKeyDown, __onControlClick, __onControlMouseEnter, __preventFocus, __stopPropagation, withCellSpacing, fullWidth, size, attributes, ...others } = props;
+  const getStyles = useStyles({
+    name: __staticSelector || "MonthsList",
+    classes: MonthsList_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    rootSelector: "monthsList"
+  });
+  const ctx = useDatesContext();
+  const months = getMonthsData(year);
+  const monthInTabOrder = getMonthInTabOrder({
+    months,
+    minDate: toDateString(minDate),
+    maxDate: toDateString(maxDate),
+    getMonthControlProps
+  });
+  const rows = months.map((monthsRow, rowIndex) => {
+    const cells = monthsRow.map((month, cellIndex) => {
+      const controlProps = getMonthControlProps?.(month);
+      const isMonthInTabOrder = dayjs27(month).isSame(monthInTabOrder, "month");
+      return /* @__PURE__ */ jsx("td", {
+        ...getStyles("monthsListCell"),
+        "data-with-spacing": withCellSpacing || void 0,
+        children: /* @__PURE__ */ jsx(PickerControl, {
+          ...getStyles("monthsListControl"),
+          size,
+          unstyled,
+          fullWidth,
+          __staticSelector: __staticSelector || "MonthsList",
+          "data-mantine-stop-propagation": __stopPropagation || void 0,
+          disabled: isMonthDisabled({
+            month,
+            minDate: toDateString(minDate),
+            maxDate: toDateString(maxDate)
+          }),
+          ref: (node) => {
+            if (node) __getControlRef?.(rowIndex, cellIndex, node);
+          },
+          ...controlProps,
+          onKeyDown: (event) => {
+            controlProps?.onKeyDown?.(event);
+            __onControlKeyDown?.(event, {
+              rowIndex,
+              cellIndex,
+              date: month
+            });
+          },
+          onClick: (event) => {
+            controlProps?.onClick?.(event);
+            __onControlClick?.(event, month);
+          },
+          onMouseEnter: (event) => {
+            controlProps?.onMouseEnter?.(event);
+            __onControlMouseEnter?.(event, month);
+          },
+          onMouseDown: (event) => {
+            controlProps?.onMouseDown?.(event);
+            __preventFocus && event.preventDefault();
+          },
+          tabIndex: __preventFocus || !isMonthInTabOrder ? -1 : 0,
+          children: controlProps?.children ?? dayjs27(month).locale(ctx.getLocale(locale)).format(monthsListFormat)
+        })
+      }, cellIndex);
+    });
+    return /* @__PURE__ */ jsx("tr", {
+      ...getStyles("monthsListRow"),
+      children: cells
+    }, rowIndex);
+  });
+  return /* @__PURE__ */ jsx(Box, {
+    component: "table",
+    size,
+    ...getStyles("monthsList"),
+    "data-full-width": fullWidth || void 0,
+    ...others,
+    children: /* @__PURE__ */ jsx("tbody", { children: rows })
+  });
+});
+MonthsList.classes = MonthsList_module_default;
+MonthsList.displayName = "@mantine/dates/MonthsList";
+
+// ../../node_modules/.bun/@mantine+dates@9.0.0+7c0e6e23d8f8fc3c/node_modules/@mantine/dates/esm/components/CalendarHeader/CalendarHeader.module.mjs
+var CalendarHeader_module_default = {
+  "calendarHeader": "m_730a79ed",
+  "calendarHeaderLevel": "m_f6645d97",
+  "calendarHeaderControl": "m_2351eeb0",
+  "calendarHeaderControlIcon": "m_367dc749"
+};
+var defaultProps4 = {
+  hasNextLevel: true,
+  withNext: true,
+  withPrevious: true,
+  headerControlsOrder: [
+    "previous",
+    "level",
+    "next"
+  ]
+};
+var varsResolver5 = createVarsResolver((_, { size }) => ({ calendarHeader: {
+  "--dch-control-size": getSize(size, "dch-control-size"),
+  "--dch-fz": getFontSize(size)
+} }));
+var CalendarHeader = factory((_props) => {
+  const props = useProps("CalendarHeader", defaultProps4, _props);
+  const { classNames, className, style, styles, unstyled, vars, nextIcon, previousIcon, nextLabel, previousLabel, onNext, onPrevious, onLevelClick, label, nextDisabled, previousDisabled, hasNextLevel, levelControlAriaLabel, withNext, withPrevious, headerControlsOrder, fullWidth, __staticSelector, __preventFocus, __stopPropagation, attributes, ...others } = props;
+  const getStyles = useStyles({
+    name: __staticSelector || "CalendarHeader",
+    classes: CalendarHeader_module_default,
+    props,
+    className,
+    style,
+    classNames,
+    styles,
+    unstyled,
+    attributes,
+    vars,
+    varsResolver: varsResolver5,
+    rootSelector: "calendarHeader"
+  });
+  const preventFocus = __preventFocus ? (event) => event.preventDefault() : void 0;
+  const previousControl = withPrevious && /* @__PURE__ */ createElement(UnstyledButton, {
+    ...getStyles("calendarHeaderControl"),
+    key: "previous",
+    "data-direction": "previous",
+    "aria-label": previousLabel,
+    onClick: onPrevious,
+    unstyled,
+    onMouseDown: preventFocus,
+    disabled: previousDisabled,
+    "data-disabled": previousDisabled || void 0,
+    tabIndex: __preventFocus || previousDisabled ? -1 : 0,
+    "data-mantine-stop-propagation": __stopPropagation || void 0
+  }, previousIcon || /* @__PURE__ */ jsx(AccordionChevron, {
+    ...getStyles("calendarHeaderControlIcon"),
+    "data-direction": "previous",
+    size: "45%"
+  }));
+  const levelControl = /* @__PURE__ */ createElement(UnstyledButton, {
+    component: hasNextLevel ? "button" : "div",
+    ...getStyles("calendarHeaderLevel"),
+    key: "level",
+    onClick: hasNextLevel ? onLevelClick : void 0,
+    unstyled,
+    onMouseDown: hasNextLevel ? preventFocus : void 0,
+    disabled: !hasNextLevel,
+    "data-static": !hasNextLevel || void 0,
+    "aria-label": levelControlAriaLabel,
+    tabIndex: __preventFocus || !hasNextLevel ? -1 : 0,
+    "data-mantine-stop-propagation": __stopPropagation || void 0
+  }, label);
+  const nextControl = withNext && /* @__PURE__ */ createElement(UnstyledButton, {
+    ...getStyles("calendarHeaderControl"),
+    key: "next",
+    "data-direction": "next",
+    "aria-label": nextLabel,
+    onClick: onNext,
+    unstyled,
+    onMouseDown: preventFocus,
+    disabled: nextDisabled,
+    "data-disabled": nextDisabled || void 0,
+    tabIndex: __preventFocus || nextDisabled ? -1 : 0,
+    "data-mantine-stop-propagation": __stopPropagation || void 0
+  }, nextIcon || /* @__PURE__ */ jsx(AccordionChevron, {
+    ...getStyles("calendarHeaderControlIcon"),
+    "data-direction": "next",
+    size: "45%"
+  }));
+  const controls = headerControlsOrder.map((control) => {
+    if (control === "previous") return previousControl;
+    if (control === "level") return levelControl;
+    if (control === "next") return nextControl;
+    return null;
+  });
+  return /* @__PURE__ */ jsx(Box, {
+    ...getStyles("calendarHeader"),
+    "data-full-width": fullWidth || void 0,
+    ...others,
+    children: controls
+  });
+});
+CalendarHeader.classes = CalendarHeader_module_default;
+CalendarHeader.varsResolver = varsResolver5;
+CalendarHeader.displayName = "@mantine/dates/CalendarHeader";
+
+// ../../node_modules/.bun/@mantine+dates@9.0.0+7c0e6e23d8f8fc3c/node_modules/@mantine/dates/esm/components/DecadeLevel/get-decade-range/get-decade-range.mjs
+function getDecadeRange(decade) {
+  const years = getYearsData(decade);
+  return [years[0][0], years[3][0]];
+}
+var defaultProps5 = { decadeLabelFormat: "YYYY" };
+var DecadeLevel = factory((_props) => {
+  const { decade, locale, minDate, maxDate, yearsListFormat, getYearControlProps, __getControlRef, __onControlKeyDown, __onControlClick, __onControlMouseEnter, withCellSpacing, __preventFocus, nextIcon, previousIcon, nextLabel, previousLabel, onNext, onPrevious, nextDisabled, previousDisabled, levelControlAriaLabel, withNext, withPrevious, headerControlsOrder, decadeLabelFormat, classNames, styles, unstyled, __staticSelector, __stopPropagation, size, fullWidth, attributes, ...others } = useProps("DecadeLevel", defaultProps5, _props);
+  const ctx = useDatesContext();
+  const [startOfDecade, endOfDecade] = getDecadeRange(decade);
+  const stylesApiProps = {
+    __staticSelector: __staticSelector || "DecadeLevel",
+    classNames,
+    styles,
+    unstyled,
+    size,
+    attributes
+  };
+  const _nextDisabled = typeof nextDisabled === "boolean" ? nextDisabled : maxDate ? !dayjs27(endOfDecade).endOf("year").isBefore(maxDate) : false;
+  const _previousDisabled = typeof previousDisabled === "boolean" ? previousDisabled : minDate ? !dayjs27(startOfDecade).startOf("year").isAfter(minDate) : false;
+  const formatDecade = (date, format) => dayjs27(date).locale(locale || ctx.locale).format(format);
+  return /* @__PURE__ */ jsxs(Box, {
+    "data-decade-level": true,
+    size,
+    ...others,
+    children: [/* @__PURE__ */ jsx(CalendarHeader, {
+      label: typeof decadeLabelFormat === "function" ? decadeLabelFormat(startOfDecade, endOfDecade) : `${formatDecade(startOfDecade, decadeLabelFormat)} \u2013 ${formatDecade(endOfDecade, decadeLabelFormat)}`,
+      __preventFocus,
+      __stopPropagation,
+      nextIcon,
+      previousIcon,
+      nextLabel,
+      previousLabel,
+      onNext,
+      onPrevious,
+      nextDisabled: _nextDisabled,
+      previousDisabled: _previousDisabled,
+      hasNextLevel: false,
+      levelControlAriaLabel,
+      withNext,
+      withPrevious,
+      headerControlsOrder,
+      fullWidth,
+      ...stylesApiProps
+    }), /* @__PURE__ */ jsx(YearsList, {
+      decade,
+      locale,
+      minDate,
+      maxDate,
+      yearsListFormat,
+      getYearControlProps,
+      __getControlRef,
+      __onControlKeyDown,
+      __onControlClick,
+      __onControlMouseEnter,
+      __preventFocus,
+      __stopPropagation,
+      withCellSpacing,
+      fullWidth,
+      ...stylesApiProps
+    })]
+  });
+});
+DecadeLevel.classes = {
+  ...YearsList.classes,
+  ...CalendarHeader.classes
+};
+DecadeLevel.displayName = "@mantine/dates/DecadeLevel";
+var defaultProps6 = { yearLabelFormat: "YYYY" };
+var YearLevel = factory((_props) => {
+  const { year, locale, minDate, maxDate, monthsListFormat, getMonthControlProps, __getControlRef, __onControlKeyDown, __onControlClick, __onControlMouseEnter, withCellSpacing, __preventFocus, nextIcon, previousIcon, nextLabel, previousLabel, onNext, onPrevious, onLevelClick, nextDisabled, previousDisabled, hasNextLevel, levelControlAriaLabel, withNext, withPrevious, headerControlsOrder, yearLabelFormat, __staticSelector, __stopPropagation, size, classNames, styles, unstyled, fullWidth, attributes, ...others } = useProps("YearLevel", defaultProps6, _props);
+  const ctx = useDatesContext();
+  const stylesApiProps = {
+    __staticSelector: __staticSelector || "YearLevel",
+    classNames,
+    styles,
+    unstyled,
+    size,
+    attributes
+  };
+  const _nextDisabled = typeof nextDisabled === "boolean" ? nextDisabled : maxDate ? !dayjs27(year).endOf("year").isBefore(maxDate) : false;
+  const _previousDisabled = typeof previousDisabled === "boolean" ? previousDisabled : minDate ? !dayjs27(year).startOf("year").isAfter(minDate) : false;
+  return /* @__PURE__ */ jsxs(Box, {
+    "data-year-level": true,
+    size,
+    ...others,
+    children: [/* @__PURE__ */ jsx(CalendarHeader, {
+      label: typeof yearLabelFormat === "function" ? yearLabelFormat(year) : dayjs27(year).locale(locale || ctx.locale).format(yearLabelFormat),
+      __preventFocus,
+      __stopPropagation,
+      nextIcon,
+      previousIcon,
+      nextLabel,
+      previousLabel,
+      onNext,
+      onPrevious,
+      onLevelClick,
+      nextDisabled: _nextDisabled,
+      previousDisabled: _previousDisabled,
+      hasNextLevel,
+      levelControlAriaLabel,
+      withNext,
+      withPrevious,
+      headerControlsOrder,
+      fullWidth,
+      ...stylesApiProps
+    }), /* @__PURE__ */ jsx(MonthsList, {
+      year,
+      locale,
+      minDate,
+      maxDate,
+      monthsListFormat,
+      getMonthControlProps,
+      __getControlRef,
+      __onControlKeyDown,
+      __onControlClick,
+      __onControlMouseEnter,
+      __preventFocus,
+      __stopPropagation,
+      withCellSpacing,
+      fullWidth,
+      ...stylesApiProps
+    })]
+  });
+});
+YearLevel.classes = {
+  ...CalendarHeader.classes,
+  ...MonthsList.classes
+};
+YearLevel.displayName = "@mantine/dates/YearLevel";
+var defaultProps7 = { monthLabelFormat: "MMMM YYYY" };
+var MonthLevel = factory((_props) => {
+  const { month, locale, firstDayOfWeek, weekdayFormat, weekendDays, getDayProps, excludeDate, minDate, maxDate, renderDay, hideOutsideDates, hideWeekdays, getDayAriaLabel, __getDayRef, __onDayKeyDown, __onDayClick, __onDayMouseEnter, withCellSpacing, highlightToday, withWeekNumbers, __preventFocus, __stopPropagation, nextIcon, previousIcon, nextLabel, previousLabel, onNext, onPrevious, onLevelClick, nextDisabled, previousDisabled, hasNextLevel, levelControlAriaLabel, withNext, withPrevious, headerControlsOrder, monthLabelFormat, classNames, styles, unstyled, __staticSelector, size, static: isStatic, fullWidth, attributes, ...others } = useProps("MonthLevel", defaultProps7, _props);
+  const ctx = useDatesContext();
+  const stylesApiProps = {
+    __staticSelector: __staticSelector || "MonthLevel",
+    classNames,
+    styles,
+    unstyled,
+    size,
+    attributes
+  };
+  const _nextDisabled = typeof nextDisabled === "boolean" ? nextDisabled : maxDate ? !dayjs27(month).endOf("month").isBefore(maxDate) : false;
+  const _previousDisabled = typeof previousDisabled === "boolean" ? previousDisabled : minDate ? !dayjs27(month).startOf("month").isAfter(minDate) : false;
+  return /* @__PURE__ */ jsxs(Box, {
+    "data-month-level": true,
+    size,
+    ...others,
+    children: [/* @__PURE__ */ jsx(CalendarHeader, {
+      label: typeof monthLabelFormat === "function" ? monthLabelFormat(month) : dayjs27(month).locale(locale || ctx.locale).format(monthLabelFormat),
+      __preventFocus,
+      __stopPropagation,
+      nextIcon,
+      previousIcon,
+      nextLabel,
+      previousLabel,
+      onNext,
+      onPrevious,
+      onLevelClick,
+      nextDisabled: _nextDisabled,
+      previousDisabled: _previousDisabled,
+      hasNextLevel,
+      levelControlAriaLabel,
+      withNext,
+      withPrevious,
+      headerControlsOrder,
+      fullWidth,
+      ...stylesApiProps
+    }), /* @__PURE__ */ jsx(Month, {
+      month,
+      locale,
+      firstDayOfWeek,
+      weekdayFormat,
+      weekendDays,
+      getDayProps,
+      excludeDate,
+      minDate,
+      maxDate,
+      renderDay,
+      hideOutsideDates,
+      hideWeekdays,
+      getDayAriaLabel,
+      __getDayRef,
+      __onDayKeyDown,
+      __onDayClick,
+      __onDayMouseEnter,
+      __preventFocus,
+      __stopPropagation,
+      static: isStatic,
+      withCellSpacing,
+      highlightToday,
+      withWeekNumbers,
+      fullWidth,
+      ...stylesApiProps
+    })]
+  });
+});
+MonthLevel.classes = {
+  ...Month.classes,
+  ...CalendarHeader.classes
+};
+MonthLevel.displayName = "@mantine/dates/MonthLevel";
+
+// ../../node_modules/.bun/@mantine+dates@9.0.0+7c0e6e23d8f8fc3c/node_modules/@mantine/dates/esm/components/LevelsGroup/LevelsGroup.module.mjs
+var LevelsGroup_module_default = { "levelsGroup": "m_30b26e33" };
+var LevelsGroup = factory((_props) => {
+  const props = useProps("LevelsGroup", null, _props);
+  const { classNames, className, style, styles, unstyled, vars, __staticSelector, fullWidth, attributes, ...others } = props;
+  return /* @__PURE__ */ jsx(Box, {
+    ...useStyles({
+      name: __staticSelector || "LevelsGroup",
+      classes: LevelsGroup_module_default,
+      props,
+      className,
+      style,
+      classNames,
+      styles,
+      unstyled,
+      attributes,
+      vars,
+      rootSelector: "levelsGroup"
+    })("levelsGroup"),
+    "data-full-width": fullWidth || void 0,
+    ...others
+  });
+});
+LevelsGroup.classes = LevelsGroup_module_default;
+LevelsGroup.displayName = "@mantine/dates/LevelsGroup";
+var defaultProps8 = { numberOfColumns: 1 };
+var DecadeLevelGroup = factory((_props) => {
+  const { decade, locale, minDate, maxDate, yearsListFormat, getYearControlProps, __onControlClick, __onControlMouseEnter, withCellSpacing, __preventFocus, nextIcon, previousIcon, nextLabel, previousLabel, onNext, onPrevious, nextDisabled, previousDisabled, headerControlsOrder, classNames, styles, unstyled, __staticSelector, __stopPropagation, numberOfColumns, levelControlAriaLabel, decadeLabelFormat, size, fullWidth, vars, attributes, ...others } = useProps("DecadeLevelGroup", defaultProps8, _props);
+  const controlsRef = useRef([]);
+  const decades = Array(numberOfColumns).fill(0).map((_, decadeIndex) => {
+    const currentDecade = dayjs27(decade).add(decadeIndex * 10, "years").format("YYYY-MM-DD");
+    return /* @__PURE__ */ jsx(DecadeLevel, {
+      size,
+      yearsListFormat,
+      decade: currentDecade,
+      withNext: decadeIndex === numberOfColumns - 1,
+      withPrevious: decadeIndex === 0,
+      decadeLabelFormat,
+      __onControlClick,
+      __onControlMouseEnter,
+      __onControlKeyDown: (event, payload) => handleControlKeyDown({
+        levelIndex: decadeIndex,
+        rowIndex: payload.rowIndex,
+        cellIndex: payload.cellIndex,
+        event,
+        controlsRef
+      }),
+      __getControlRef: (rowIndex, cellIndex, node) => {
+        if (!Array.isArray(controlsRef.current[decadeIndex])) controlsRef.current[decadeIndex] = [];
+        if (!Array.isArray(controlsRef.current[decadeIndex][rowIndex])) controlsRef.current[decadeIndex][rowIndex] = [];
+        controlsRef.current[decadeIndex][rowIndex][cellIndex] = node;
+      },
+      levelControlAriaLabel: typeof levelControlAriaLabel === "function" ? levelControlAriaLabel(currentDecade) : levelControlAriaLabel,
+      locale,
+      minDate,
+      maxDate,
+      __preventFocus,
+      __stopPropagation,
+      nextIcon,
+      previousIcon,
+      nextLabel,
+      previousLabel,
+      onNext,
+      onPrevious,
+      nextDisabled,
+      previousDisabled,
+      getYearControlProps,
+      __staticSelector: __staticSelector || "DecadeLevelGroup",
+      classNames,
+      styles,
+      unstyled,
+      withCellSpacing,
+      headerControlsOrder,
+      fullWidth,
+      attributes
+    }, decadeIndex);
+  });
+  return /* @__PURE__ */ jsx(LevelsGroup, {
+    classNames,
+    styles,
+    __staticSelector: __staticSelector || "DecadeLevelGroup",
+    size,
+    unstyled,
+    fullWidth,
+    attributes,
+    ...others,
+    children: decades
+  });
+});
+DecadeLevelGroup.classes = {
+  ...LevelsGroup.classes,
+  ...DecadeLevel.classes
+};
+DecadeLevelGroup.displayName = "@mantine/dates/DecadeLevelGroup";
+var defaultProps9 = { numberOfColumns: 1 };
+var YearLevelGroup = factory((_props) => {
+  const { year, locale, minDate, maxDate, monthsListFormat, getMonthControlProps, __onControlClick, __onControlMouseEnter, withCellSpacing, __preventFocus, nextIcon, previousIcon, nextLabel, previousLabel, onNext, onPrevious, onLevelClick, nextDisabled, previousDisabled, hasNextLevel, headerControlsOrder, classNames, styles, unstyled, __staticSelector, __stopPropagation, numberOfColumns, levelControlAriaLabel, yearLabelFormat, size, fullWidth, vars, attributes, ...others } = useProps("YearLevelGroup", defaultProps9, _props);
+  const controlsRef = useRef([]);
+  const years = Array(numberOfColumns).fill(0).map((_, yearIndex) => {
+    const currentYear = dayjs27(year).add(yearIndex, "years").format("YYYY-MM-DD");
+    return /* @__PURE__ */ jsx(YearLevel, {
+      size,
+      monthsListFormat,
+      year: currentYear,
+      withNext: yearIndex === numberOfColumns - 1,
+      withPrevious: yearIndex === 0,
+      yearLabelFormat,
+      __stopPropagation,
+      __onControlClick,
+      __onControlMouseEnter,
+      __onControlKeyDown: (event, payload) => handleControlKeyDown({
+        levelIndex: yearIndex,
+        rowIndex: payload.rowIndex,
+        cellIndex: payload.cellIndex,
+        event,
+        controlsRef
+      }),
+      __getControlRef: (rowIndex, cellIndex, node) => {
+        if (!Array.isArray(controlsRef.current[yearIndex])) controlsRef.current[yearIndex] = [];
+        if (!Array.isArray(controlsRef.current[yearIndex][rowIndex])) controlsRef.current[yearIndex][rowIndex] = [];
+        controlsRef.current[yearIndex][rowIndex][cellIndex] = node;
+      },
+      levelControlAriaLabel: typeof levelControlAriaLabel === "function" ? levelControlAriaLabel(currentYear) : levelControlAriaLabel,
+      locale,
+      minDate,
+      maxDate,
+      __preventFocus,
+      nextIcon,
+      previousIcon,
+      nextLabel,
+      previousLabel,
+      onNext,
+      onPrevious,
+      onLevelClick,
+      nextDisabled,
+      previousDisabled,
+      hasNextLevel,
+      getMonthControlProps,
+      classNames,
+      styles,
+      unstyled,
+      __staticSelector: __staticSelector || "YearLevelGroup",
+      withCellSpacing,
+      headerControlsOrder,
+      fullWidth,
+      attributes
+    }, yearIndex);
+  });
+  return /* @__PURE__ */ jsx(LevelsGroup, {
+    classNames,
+    styles,
+    __staticSelector: __staticSelector || "YearLevelGroup",
+    size,
+    unstyled,
+    fullWidth,
+    attributes,
+    ...others,
+    children: years
+  });
+});
+YearLevelGroup.classes = {
+  ...YearLevel.classes,
+  ...LevelsGroup.classes
+};
+YearLevelGroup.displayName = "@mantine/dates/YearLevelGroup";
+var defaultProps10 = { numberOfColumns: 1 };
+var MonthLevelGroup = factory((_props) => {
+  const { month, locale, firstDayOfWeek, weekdayFormat, weekendDays, getDayProps, excludeDate, minDate, maxDate, renderDay, hideOutsideDates, hideWeekdays, getDayAriaLabel, __onDayClick, __onDayMouseEnter, withCellSpacing, highlightToday, withWeekNumbers, __preventFocus, nextIcon, previousIcon, nextLabel, previousLabel, onNext, onPrevious, onLevelClick, nextDisabled, previousDisabled, hasNextLevel, headerControlsOrder, classNames, styles, unstyled, numberOfColumns, levelControlAriaLabel, monthLabelFormat, __staticSelector, __stopPropagation, size, static: isStatic, fullWidth, vars, attributes, ...others } = useProps("MonthLevelGroup", defaultProps10, _props);
+  const daysRefs = useRef([]);
+  const months = Array(numberOfColumns).fill(0).map((_, monthIndex) => {
+    const currentMonth = dayjs27(month).add(monthIndex, "months").format("YYYY-MM-DD");
+    return /* @__PURE__ */ jsx(MonthLevel, {
+      month: currentMonth,
+      withNext: monthIndex === numberOfColumns - 1,
+      withPrevious: monthIndex === 0,
+      monthLabelFormat,
+      __stopPropagation,
+      __onDayClick,
+      __onDayMouseEnter,
+      __onDayKeyDown: (event, payload) => handleControlKeyDown({
+        levelIndex: monthIndex,
+        rowIndex: payload.rowIndex,
+        cellIndex: payload.cellIndex,
+        event,
+        controlsRef: daysRefs
+      }),
+      __getDayRef: (rowIndex, cellIndex, node) => {
+        if (!Array.isArray(daysRefs.current[monthIndex])) daysRefs.current[monthIndex] = [];
+        if (!Array.isArray(daysRefs.current[monthIndex][rowIndex])) daysRefs.current[monthIndex][rowIndex] = [];
+        daysRefs.current[monthIndex][rowIndex][cellIndex] = node;
+      },
+      levelControlAriaLabel: typeof levelControlAriaLabel === "function" ? levelControlAriaLabel(currentMonth) : levelControlAriaLabel,
+      locale,
+      firstDayOfWeek,
+      weekdayFormat,
+      weekendDays,
+      getDayProps,
+      excludeDate,
+      minDate,
+      maxDate,
+      renderDay,
+      hideOutsideDates,
+      hideWeekdays,
+      getDayAriaLabel,
+      __preventFocus,
+      nextIcon,
+      previousIcon,
+      nextLabel,
+      previousLabel,
+      onNext,
+      onPrevious,
+      onLevelClick,
+      nextDisabled,
+      previousDisabled,
+      hasNextLevel,
+      classNames,
+      styles,
+      unstyled,
+      __staticSelector: __staticSelector || "MonthLevelGroup",
+      size,
+      static: isStatic,
+      withCellSpacing,
+      highlightToday,
+      withWeekNumbers,
+      headerControlsOrder,
+      fullWidth,
+      attributes
+    }, monthIndex);
+  });
+  return /* @__PURE__ */ jsx(LevelsGroup, {
+    classNames,
+    styles,
+    __staticSelector: __staticSelector || "MonthLevelGroup",
+    size,
+    fullWidth,
+    attributes,
+    ...others,
+    children: months
+  });
+});
+MonthLevelGroup.classes = {
+  ...LevelsGroup.classes,
+  ...MonthLevel.classes
+};
+MonthLevelGroup.displayName = "@mantine/dates/MonthLevelGroup";
+var getEmptyValue = (type) => type === "range" ? [null, null] : type === "multiple" ? [] : null;
+var convertDatesValue = (value, withTime) => {
+  const converter = withTime ? toDateTimeString : toDateString;
+  return Array.isArray(value) ? value.map(converter) : converter(value);
+};
+function useUncontrolledDates({ type, value, defaultValue, onChange, withTime = false }) {
+  const storedType = useRef(type);
+  const [_value, _setValue, controlled] = useUncontrolled({
+    value: convertDatesValue(value, withTime),
+    defaultValue: convertDatesValue(defaultValue, withTime),
+    finalValue: getEmptyValue(type),
+    onChange
+  });
+  let _finalValue = _value;
+  if (storedType.current !== type) {
+    storedType.current = type;
+    if (value === void 0) {
+      _finalValue = defaultValue !== void 0 ? defaultValue : getEmptyValue(type);
+      _setValue(_finalValue);
+    }
+  }
+  return [
+    _finalValue,
+    _setValue,
+    controlled
+  ];
+}
+
+// ../../node_modules/.bun/@mantine+dates@9.0.0+7c0e6e23d8f8fc3c/node_modules/@mantine/dates/esm/components/Calendar/clamp-level/clamp-level.mjs
+function levelToNumber(level, fallback) {
+  if (!level) return fallback || 0;
+  return level === "month" ? 0 : level === "year" ? 1 : 2;
+}
+function levelNumberToLevel(levelNumber) {
+  return levelNumber === 0 ? "month" : levelNumber === 1 ? "year" : "decade";
+}
+function clampLevel(level, minLevel, maxLevel) {
+  return levelNumberToLevel(clamp(levelToNumber(level, 0), levelToNumber(minLevel, 0), levelToNumber(maxLevel, 2)));
+}
+var defaultProps11 = {
+  maxLevel: "decade",
+  minLevel: "month",
+  __updateDateOnYearSelect: true,
+  __updateDateOnMonthSelect: true,
+  enableKeyboardNavigation: true
+};
+var Calendar = factory((_props) => {
+  const props = useProps("Calendar", defaultProps11, _props);
+  const { vars, maxLevel, minLevel, defaultLevel, level, onLevelChange, date, defaultDate, onDateChange, numberOfColumns, columnsToScroll, ariaLabels, nextLabel, previousLabel, onYearSelect, onMonthSelect, onYearMouseEnter, onMonthMouseEnter, headerControlsOrder, __updateDateOnYearSelect, __updateDateOnMonthSelect, __setDateRef, __setLevelRef, firstDayOfWeek, weekdayFormat, weekendDays, getDayProps, excludeDate, renderDay, hideOutsideDates, hideWeekdays, getDayAriaLabel, monthLabelFormat, nextIcon, previousIcon, __onDayClick, __onDayMouseEnter, withCellSpacing, highlightToday, withWeekNumbers, monthsListFormat, getMonthControlProps, yearLabelFormat, yearsListFormat, getYearControlProps, decadeLabelFormat, classNames, styles, unstyled, minDate, maxDate, locale, __staticSelector, size, __preventFocus, __stopPropagation, onNextDecade, onPreviousDecade, onNextYear, onPreviousYear, onNextMonth, onPreviousMonth, static: isStatic, enableKeyboardNavigation, fullWidth, attributes, ref, ...others } = props;
+  const { resolvedClassNames, resolvedStyles } = useResolvedStylesApi({
+    classNames,
+    styles,
+    props
+  });
+  const [_level, setLevel] = useUncontrolled({
+    value: level ? clampLevel(level, minLevel, maxLevel) : void 0,
+    defaultValue: defaultLevel ? clampLevel(defaultLevel, minLevel, maxLevel) : void 0,
+    finalValue: clampLevel(void 0, minLevel, maxLevel),
+    onChange: onLevelChange
+  });
+  const [_date, setDate] = useUncontrolledDates({
+    type: "default",
+    value: toDateString(date),
+    defaultValue: toDateString(defaultDate),
+    onChange: onDateChange
+  });
+  useImperativeHandle(__setDateRef, () => (date2) => {
+    setDate(date2);
+  });
+  useImperativeHandle(__setLevelRef, () => (level2) => {
+    setLevel(level2);
+  });
+  const stylesApiProps = {
+    __staticSelector: __staticSelector || "Calendar",
+    styles: resolvedStyles,
+    classNames: resolvedClassNames,
+    unstyled,
+    size,
+    attributes
+  };
+  const _columnsToScroll = columnsToScroll || numberOfColumns || 1;
+  const fallbackDateRef = useRef(null);
+  if (fallbackDateRef.current === null) {
+    const now = /* @__PURE__ */ new Date();
+    fallbackDateRef.current = minDate && dayjs27(now).isAfter(minDate) ? minDate : dayjs27(now).format("YYYY-MM-DD");
+  }
+  const currentDate = _date || fallbackDateRef.current;
+  const handleNextMonth = () => {
+    const nextDate = dayjs27(currentDate).add(_columnsToScroll, "month").format("YYYY-MM-DD");
+    onNextMonth?.(nextDate);
+    setDate(nextDate);
+  };
+  const handlePreviousMonth = () => {
+    const nextDate = dayjs27(currentDate).subtract(_columnsToScroll, "month").format("YYYY-MM-DD");
+    onPreviousMonth?.(nextDate);
+    setDate(nextDate);
+  };
+  const handleNextYear = () => {
+    const nextDate = dayjs27(currentDate).add(_columnsToScroll, "year").format("YYYY-MM-DD");
+    onNextYear?.(nextDate);
+    setDate(nextDate);
+  };
+  const handlePreviousYear = () => {
+    const nextDate = dayjs27(currentDate).subtract(_columnsToScroll, "year").format("YYYY-MM-DD");
+    onPreviousYear?.(nextDate);
+    setDate(nextDate);
+  };
+  const handleNextDecade = () => {
+    const nextDate = dayjs27(currentDate).add(10 * _columnsToScroll, "year").format("YYYY-MM-DD");
+    onNextDecade?.(nextDate);
+    setDate(nextDate);
+  };
+  const handlePreviousDecade = () => {
+    const nextDate = dayjs27(currentDate).subtract(10 * _columnsToScroll, "year").format("YYYY-MM-DD");
+    onPreviousDecade?.(nextDate);
+    setDate(nextDate);
+  };
+  const calendarRef = useRef(null);
+  useEffect(() => {
+    if (!enableKeyboardNavigation || isStatic) return;
+    const handleKeyDown = (event) => {
+      if (!calendarRef.current?.contains(document.activeElement)) return;
+      const isCtrlOrCmd = event.ctrlKey || event.metaKey;
+      const isShift = event.shiftKey;
+      switch (event.key) {
+        case "ArrowUp":
+          if (isCtrlOrCmd && isShift) {
+            event.preventDefault();
+            handlePreviousDecade();
+          } else if (isCtrlOrCmd) {
+            event.preventDefault();
+            handlePreviousYear();
+          }
+          break;
+        case "ArrowDown":
+          if (isCtrlOrCmd && isShift) {
+            event.preventDefault();
+            handleNextDecade();
+          } else if (isCtrlOrCmd) {
+            event.preventDefault();
+            handleNextYear();
+          }
+          break;
+        case "y":
+        case "Y":
+          if (_level === "month") {
+            event.preventDefault();
+            setLevel("year");
+          }
+          break;
+      }
+    };
+    document.addEventListener("keydown", handleKeyDown);
+    return () => {
+      document.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [
+    enableKeyboardNavigation,
+    isStatic,
+    _level,
+    handleNextYear,
+    handlePreviousYear,
+    handleNextDecade,
+    handlePreviousDecade
+  ]);
+  return /* @__PURE__ */ jsxs(Box, {
+    ref: useMergedRef(calendarRef, ref),
+    size,
+    "data-calendar": true,
+    "data-full-width": fullWidth || void 0,
+    ...others,
+    children: [
+      _level === "month" && /* @__PURE__ */ jsx(MonthLevelGroup, {
+        month: currentDate,
+        minDate,
+        maxDate,
+        firstDayOfWeek,
+        weekdayFormat,
+        weekendDays,
+        getDayProps,
+        excludeDate,
+        renderDay,
+        hideOutsideDates,
+        hideWeekdays,
+        getDayAriaLabel,
+        onNext: handleNextMonth,
+        onPrevious: handlePreviousMonth,
+        hasNextLevel: maxLevel !== "month",
+        onLevelClick: () => setLevel("year"),
+        numberOfColumns,
+        locale,
+        levelControlAriaLabel: ariaLabels?.monthLevelControl,
+        nextLabel: ariaLabels?.nextMonth ?? nextLabel,
+        nextIcon,
+        previousLabel: ariaLabels?.previousMonth ?? previousLabel,
+        previousIcon,
+        monthLabelFormat,
+        __onDayClick,
+        __onDayMouseEnter,
+        __preventFocus,
+        __stopPropagation,
+        static: isStatic,
+        withCellSpacing,
+        highlightToday,
+        withWeekNumbers,
+        headerControlsOrder,
+        fullWidth,
+        ...stylesApiProps
+      }),
+      _level === "year" && /* @__PURE__ */ jsx(YearLevelGroup, {
+        year: currentDate,
+        numberOfColumns,
+        minDate,
+        maxDate,
+        monthsListFormat,
+        getMonthControlProps,
+        locale,
+        onNext: handleNextYear,
+        onPrevious: handlePreviousYear,
+        hasNextLevel: maxLevel !== "month" && maxLevel !== "year",
+        onLevelClick: () => setLevel("decade"),
+        levelControlAriaLabel: ariaLabels?.yearLevelControl,
+        nextLabel: ariaLabels?.nextYear ?? nextLabel,
+        nextIcon,
+        previousLabel: ariaLabels?.previousYear ?? previousLabel,
+        previousIcon,
+        yearLabelFormat,
+        __onControlMouseEnter: onMonthMouseEnter,
+        __onControlClick: (_event, payload) => {
+          __updateDateOnMonthSelect && setDate(payload);
+          setLevel(clampLevel("month", minLevel, maxLevel));
+          onMonthSelect?.(payload);
+        },
+        __preventFocus,
+        __stopPropagation,
+        withCellSpacing,
+        headerControlsOrder,
+        fullWidth,
+        ...stylesApiProps
+      }),
+      _level === "decade" && /* @__PURE__ */ jsx(DecadeLevelGroup, {
+        decade: currentDate,
+        minDate,
+        maxDate,
+        yearsListFormat,
+        getYearControlProps,
+        locale,
+        onNext: handleNextDecade,
+        onPrevious: handlePreviousDecade,
+        numberOfColumns,
+        nextLabel: ariaLabels?.nextDecade ?? nextLabel,
+        nextIcon,
+        previousLabel: ariaLabels?.previousDecade ?? previousLabel,
+        previousIcon,
+        decadeLabelFormat,
+        __onControlMouseEnter: onYearMouseEnter,
+        __onControlClick: (_event, payload) => {
+          __updateDateOnYearSelect && setDate(payload);
+          setLevel(clampLevel("year", minLevel, maxLevel));
+          onYearSelect?.(payload);
+        },
+        __preventFocus,
+        __stopPropagation,
+        withCellSpacing,
+        headerControlsOrder,
+        fullWidth,
+        ...stylesApiProps
+      })
+    ]
+  });
+});
+Calendar.classes = {
+  ...DecadeLevelGroup.classes,
+  ...YearLevelGroup.classes,
+  ...MonthLevelGroup.classes
+};
+Calendar.displayName = "@mantine/dates/Calendar";
+
+// src/components/Apps/CalendarApp/CalendarApp.module.css
+var CalendarApp_default = {};
+var CalendarApp = () => {
+  return /* @__PURE__ */ jsx("div", { className: CalendarApp_default.root, children: /* @__PURE__ */ jsx(Calendar, {}) });
+};
+var CalendarApp_default2 = CalendarApp;
+
+export { CalendarApp_default2 as CalendarApp_default };