@timmbr/ui 1.17.6 → 1.18.0

package/dist/node_modules/.pnpm/date-fns@4.4.0/node_modules/date-fns/startOfWeek.js

@@ -0,0 +1,53 @@
+import { getDefaultOptions } from './_lib/defaultOptions.js';
+import { toDate } from './toDate.js';
+
+/**
+ * The {@link startOfWeek} function options.
+ */
+
+/**
+ * @name startOfWeek
+ * @category Week Helpers
+ * @summary Return the start of a week for the given date.
+ *
+ * @description
+ * Return the start of a week for the given date.
+ * The result will be in the local timezone.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The original date
+ * @param options - An object with options
+ *
+ * @returns The start of a week
+ *
+ * @example
+ * // The start of a week for 2 September 2014 11:55:00:
+ * const result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0))
+ * //=> Sun Aug 31 2014 00:00:00
+ *
+ * @example
+ * // If the week starts on Monday, the start of the week for 2 September 2014 11:55:00:
+ * const result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0), { weekStartsOn: 1 })
+ * //=> Mon Sep 01 2014 00:00:00
+ */
+function startOfWeek(date, options) {
+  const defaultOptions = getDefaultOptions();
+  const weekStartsOn =
+    options?.weekStartsOn ??
+    options?.locale?.options?.weekStartsOn ??
+    defaultOptions.weekStartsOn ??
+    defaultOptions.locale?.options?.weekStartsOn ??
+    0;
+
+  const _date = toDate(date, options?.in);
+  const day = _date.getDay();
+  const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
+
+  _date.setDate(_date.getDate() - diff);
+  _date.setHours(0, 0, 0, 0);
+  return _date;
+}
+
+export { startOfWeek };

package/dist/node_modules/.pnpm/date-fns@4.4.0/node_modules/date-fns/startOfWeekYear.js

@@ -0,0 +1,64 @@
+import { getDefaultOptions } from './_lib/defaultOptions.js';
+import { constructFrom } from './constructFrom.js';
+import { getWeekYear } from './getWeekYear.js';
+import { startOfWeek } from './startOfWeek.js';
+
+/**
+ * The {@link startOfWeekYear} function options.
+ */
+
+/**
+ * @name startOfWeekYear
+ * @category Week-Numbering Year Helpers
+ * @summary Return the start of a local week-numbering year for the given date.
+ *
+ * @description
+ * Return the start of a local week-numbering year.
+ * The exact calculation depends on the values of
+ * `options.weekStartsOn` (which is the index of the first day of the week)
+ * and `options.firstWeekContainsDate` (which is the day of January, which is always in
+ * the first week of the week-numbering year)
+ *
+ * Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type.
+ *
+ * @param date - The original date
+ * @param options - An object with options
+ *
+ * @returns The start of a week-numbering year
+ *
+ * @example
+ * // The start of an a week-numbering year for 2 July 2005 with default settings:
+ * const result = startOfWeekYear(new Date(2005, 6, 2))
+ * //=> Sun Dec 26 2004 00:00:00
+ *
+ * @example
+ * // The start of a week-numbering year for 2 July 2005
+ * // if Monday is the first day of week
+ * // and 4 January is always in the first week of the year:
+ * const result = startOfWeekYear(new Date(2005, 6, 2), {
+ *   weekStartsOn: 1,
+ *   firstWeekContainsDate: 4
+ * })
+ * //=> Mon Jan 03 2005 00:00:00
+ */
+function startOfWeekYear(date, options) {
+  const defaultOptions = getDefaultOptions();
+  const firstWeekContainsDate =
+    options?.firstWeekContainsDate ??
+    options?.locale?.options?.firstWeekContainsDate ??
+    defaultOptions.firstWeekContainsDate ??
+    defaultOptions.locale?.options?.firstWeekContainsDate ??
+    1;
+
+  const year = getWeekYear(date, options);
+  const firstWeek = constructFrom(options?.in || date, 0);
+  firstWeek.setFullYear(year, 0, firstWeekContainsDate);
+  firstWeek.setHours(0, 0, 0, 0);
+  const _date = startOfWeek(firstWeek, options);
+  return _date;
+}
+
+export { startOfWeekYear };

package/dist/node_modules/.pnpm/date-fns@4.4.0/node_modules/date-fns/startOfYear.js

@@ -0,0 +1,36 @@
+import { toDate } from './toDate.js';
+
+/**
+ * The {@link startOfYear} function options.
+ */
+
+/**
+ * @name startOfYear
+ * @category Year Helpers
+ * @summary Return the start of a year for the given date.
+ *
+ * @description
+ * Return the start of a year for the given date.
+ * The result will be in the local timezone.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The original date
+ * @param options - The options
+ *
+ * @returns The start of a year
+ *
+ * @example
+ * // The start of a year for 2 September 2014 11:55:00:
+ * const result = startOfYear(new Date(2014, 8, 2, 11, 55, 00))
+ * //=> Wed Jan 01 2014 00:00:00
+ */
+function startOfYear(date, options) {
+  const date_ = toDate(date, options?.in);
+  date_.setFullYear(date_.getFullYear(), 0, 1);
+  date_.setHours(0, 0, 0, 0);
+  return date_;
+}
+
+export { startOfYear };

package/dist/node_modules/.pnpm/date-fns@4.4.0/node_modules/date-fns/toDate.js

@@ -0,0 +1,46 @@
+import { constructFrom } from './constructFrom.js';
+
+/**
+ * @name toDate
+ * @category Common Helpers
+ * @summary Convert the given argument to an instance of Date.
+ *
+ * @description
+ * Convert the given argument to an instance of Date.
+ *
+ * If the argument is an instance of Date, the function returns its clone.
+ *
+ * If the argument is a number, it is treated as a timestamp.
+ *
+ * If the argument is none of the above, the function returns Invalid Date.
+ *
+ * Starting from v3.7.0, it clones a date using `[Symbol.for("constructDateFrom")]`
+ * enabling to transfer extra properties from the reference date to the new date.
+ * It's useful for extensions like [`TZDate`](https://github.com/date-fns/tz)
+ * that accept a time zone as a constructor argument.
+ *
+ * **Note**: *all* Date arguments passed to any *date-fns* function is processed by `toDate`.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param argument - The value to convert
+ *
+ * @returns The parsed date in the local time zone
+ *
+ * @example
+ * // Clone the date:
+ * const result = toDate(new Date(2014, 1, 11, 11, 30, 30))
+ * //=> Tue Feb 11 2014 11:30:30
+ *
+ * @example
+ * // Convert the timestamp to date:
+ * const result = toDate(1392098430000)
+ * //=> Tue Feb 11 2014 11:30:30
+ */
+function toDate(argument, context) {
+  // [TODO] Get rid of `toDate` or `constructFrom`?
+  return constructFrom(context || argument, argument);
+}
+
+export { toDate };

package/dist/node_modules/.pnpm/react-day-picker@10.0.2_@types_react@19.3.0_react@19.3.0/node_modules/react-day-picker/dist/esm/DayPicker.js

@@ -0,0 +1,346 @@
+import React__default, { useMemo, useCallback, useRef } from 'react';
+import { DateLib } from './classes/DateLib.js';
+import { createGetModifiers } from './helpers/createGetModifiers.js';
+import { getClassNamesForModifiers } from './helpers/getClassNamesForModifiers.js';
+import { getComponents } from './helpers/getComponents.js';
+import { getDataAttributes } from './helpers/getDataAttributes.js';
+import { getDefaultClassNames } from './helpers/getDefaultClassNames.js';
+import { getFormatters } from './helpers/getFormatters.js';
+import { getLabels } from './helpers/getLabels.js';
+import { getMonthOptions } from './helpers/getMonthOptions.js';
+import { getStyleForModifiers } from './helpers/getStyleForModifiers.js';
+import { getWeekdays } from './helpers/getWeekdays.js';
+import { getYearOptions } from './helpers/getYearOptions.js';
+import { createNoonOverrides } from './noonDateLib.js';
+import { UI, DayFlag, SelectionState } from './UI.js';
+import { useAnimation } from './useAnimation.js';
+import { useCalendar } from './useCalendar.js';
+import { dayPickerContext } from './useDayPicker.js';
+import { useFocus } from './useFocus.js';
+import { useSelection } from './useSelection.js';
+import { convertMatchersToTimeZone } from './utils/convertMatchersToTimeZone.js';
+import { rangeIncludesDate } from './utils/rangeIncludesDate.js';
+import { toTimeZone } from './utils/toTimeZone.js';
+import { isDateRange } from './utils/typeguards.js';
+import { enUS } from './locale/en-US.js';
+
+/**
+ * Renders the DayPicker calendar component.
+ *
+ * @param initialProps - The props for the DayPicker component.
+ * @returns The rendered DayPicker component.
+ * @group DayPicker
+ * @see https://daypicker.dev
+ */
+function DayPicker(initialProps) {
+    let props = initialProps;
+    const timeZone = props.timeZone;
+    if (timeZone) {
+        props = {
+            ...initialProps,
+            timeZone,
+        };
+        if (props.today) {
+            props.today = toTimeZone(props.today, timeZone);
+        }
+        if (props.month) {
+            props.month = toTimeZone(props.month, timeZone);
+        }
+        if (props.defaultMonth) {
+            props.defaultMonth = toTimeZone(props.defaultMonth, timeZone);
+        }
+        if (props.startMonth) {
+            props.startMonth = toTimeZone(props.startMonth, timeZone);
+        }
+        if (props.endMonth) {
+            props.endMonth = toTimeZone(props.endMonth, timeZone);
+        }
+        if (props.mode === "single" && props.selected) {
+            props.selected = toTimeZone(props.selected, timeZone);
+        }
+        else if (props.mode === "multiple" && props.selected) {
+            props.selected = props.selected?.map((date) => toTimeZone(date, timeZone));
+        }
+        else if (props.mode === "range" && props.selected) {
+            props.selected = {
+                from: props.selected.from
+                    ? toTimeZone(props.selected.from, timeZone)
+                    : props.selected.from,
+                to: props.selected.to
+                    ? toTimeZone(props.selected.to, timeZone)
+                    : props.selected.to,
+            };
+        }
+        if (props.disabled !== undefined) {
+            props.disabled = convertMatchersToTimeZone(props.disabled, timeZone);
+        }
+        if (props.hidden !== undefined) {
+            props.hidden = convertMatchersToTimeZone(props.hidden, timeZone);
+        }
+        if (props.modifiers) {
+            const nextModifiers = {};
+            Object.keys(props.modifiers).forEach((key) => {
+                nextModifiers[key] = convertMatchersToTimeZone(props.modifiers?.[key], timeZone);
+            });
+            props.modifiers = nextModifiers;
+        }
+    }
+    const { components, formatters, labels, dateLib, locale, classNames } = useMemo(() => {
+        const locale = { ...enUS, ...props.locale };
+        const weekStartsOn = props.broadcastCalendar ? 1 : props.weekStartsOn;
+        const noonOverrides = props.noonSafe && props.timeZone
+            ? createNoonOverrides(props.timeZone, {
+                weekStartsOn,
+                locale,
+            })
+            : undefined;
+        const overrides = props.dateLib && noonOverrides
+            ? { ...noonOverrides, ...props.dateLib }
+            : (props.dateLib ?? noonOverrides);
+        const dateLib = new DateLib({
+            locale,
+            weekStartsOn,
+            firstWeekContainsDate: props.firstWeekContainsDate,
+            useAdditionalWeekYearTokens: props.useAdditionalWeekYearTokens,
+            useAdditionalDayOfYearTokens: props.useAdditionalDayOfYearTokens,
+            timeZone: props.timeZone,
+            numerals: props.numerals,
+        }, overrides);
+        return {
+            dateLib,
+            components: getComponents(props.components),
+            formatters: getFormatters(props.formatters),
+            labels: getLabels(props.labels, dateLib.options),
+            locale,
+            classNames: { ...getDefaultClassNames(), ...props.classNames },
+        };
+    }, [
+        props.locale,
+        props.broadcastCalendar,
+        props.weekStartsOn,
+        props.firstWeekContainsDate,
+        props.useAdditionalWeekYearTokens,
+        props.useAdditionalDayOfYearTokens,
+        props.timeZone,
+        props.numerals,
+        props.dateLib,
+        props.noonSafe,
+        props.components,
+        props.formatters,
+        props.labels,
+        props.classNames,
+    ]);
+    if (!props.today) {
+        props = { ...props, today: dateLib.today() };
+    }
+    const { captionLayout, mode, navLayout, numberOfMonths = 1, onDayBlur, onDayClick, onDayFocus, onDayKeyDown, onDayMouseEnter, onDayMouseLeave, onNextClick, onPrevClick, showWeekNumber, styles, } = props;
+    const { formatCaption, formatDay, formatMonthDropdown, formatWeekNumber, formatWeekNumberHeader, formatWeekdayName, formatYearDropdown, } = formatters;
+    const calendar = useCalendar(props, dateLib);
+    const { days, months, navStart, navEnd, previousMonth, nextMonth, goToMonth, } = calendar;
+    const getModifiers = createGetModifiers(days, props, navStart, navEnd, dateLib);
+    const { isSelected, select, selected: selectedValue, } = useSelection(props, dateLib) ?? {};
+    const { blur, focused, isFocusTarget, moveFocus, setFocused } = useFocus(props, calendar, getModifiers, isSelected ?? (() => false), dateLib);
+    const { labelDayButton, labelGridcell, labelGrid, labelMonthDropdown, labelNav, labelPrevious, labelNext, labelWeekday, labelWeekNumber, labelWeekNumberHeader, labelYearDropdown, } = labels;
+    const weekdays = useMemo(() => getWeekdays(dateLib, props.ISOWeek, props.broadcastCalendar, props.today), [dateLib, props.ISOWeek, props.broadcastCalendar, props.today]);
+    const isInteractive = mode !== undefined || onDayClick !== undefined;
+    const handlePreviousClick = useCallback(() => {
+        if (!previousMonth)
+            return;
+        goToMonth(previousMonth);
+        onPrevClick?.(previousMonth);
+    }, [previousMonth, goToMonth, onPrevClick]);
+    const handleNextClick = useCallback(() => {
+        if (!nextMonth)
+            return;
+        goToMonth(nextMonth);
+        onNextClick?.(nextMonth);
+    }, [goToMonth, nextMonth, onNextClick]);
+    const handleDayClick = useCallback((day, m) => (e) => {
+        e.preventDefault();
+        e.stopPropagation();
+        setFocused(day);
+        if (m.disabled) {
+            return;
+        }
+        select?.(day.date, m, e);
+        onDayClick?.(day.date, m, e);
+    }, [select, onDayClick, setFocused]);
+    const handleDayFocus = useCallback((day, m) => (e) => {
+        setFocused(day);
+        onDayFocus?.(day.date, m, e);
+    }, [onDayFocus, setFocused]);
+    const handleDayBlur = useCallback((day, m) => (e) => {
+        blur();
+        onDayBlur?.(day.date, m, e);
+    }, [blur, onDayBlur]);
+    const handleDayKeyDown = useCallback((day, modifiers) => (e) => {
+        const keyMap = {
+            ArrowLeft: [
+                e.shiftKey ? "month" : "day",
+                props.dir === "rtl" ? "after" : "before",
+            ],
+            ArrowRight: [
+                e.shiftKey ? "month" : "day",
+                props.dir === "rtl" ? "before" : "after",
+            ],
+            ArrowDown: [e.shiftKey ? "year" : "week", "after"],
+            ArrowUp: [e.shiftKey ? "year" : "week", "before"],
+            PageUp: [e.shiftKey ? "year" : "month", "before"],
+            PageDown: [e.shiftKey ? "year" : "month", "after"],
+            Home: ["startOfWeek", "before"],
+            End: ["endOfWeek", "after"],
+        };
+        if (keyMap[e.key]) {
+            e.preventDefault();
+            e.stopPropagation();
+            const [moveBy, moveDir] = keyMap[e.key];
+            moveFocus(moveBy, moveDir);
+        }
+        onDayKeyDown?.(day.date, modifiers, e);
+    }, [moveFocus, onDayKeyDown, props.dir]);
+    const handleDayMouseEnter = useCallback((day, modifiers) => (e) => {
+        onDayMouseEnter?.(day.date, modifiers, e);
+    }, [onDayMouseEnter]);
+    const handleDayMouseLeave = useCallback((day, modifiers) => (e) => {
+        onDayMouseLeave?.(day.date, modifiers, e);
+    }, [onDayMouseLeave]);
+    const handleMonthChange = useCallback((date, monthOffset) => (e) => {
+        const selectedMonth = Number(e.target.value);
+        const month = dateLib.setMonth(dateLib.startOfMonth(date), selectedMonth);
+        goToMonth(dateLib.addMonths(month, -monthOffset));
+    }, [dateLib, goToMonth]);
+    const handleYearChange = useCallback((date, monthOffset) => (e) => {
+        const selectedYear = Number(e.target.value);
+        const month = dateLib.setYear(dateLib.startOfMonth(date), selectedYear);
+        goToMonth(dateLib.addMonths(month, -monthOffset));
+    }, [dateLib, goToMonth]);
+    const { className, style } = useMemo(() => ({
+        className: [classNames[UI.Root], props.className]
+            .filter(Boolean)
+            .join(" "),
+        style: { ...styles?.[UI.Root], ...props.style },
+    }), [classNames, props.className, props.style, styles]);
+    const dataAttributes = getDataAttributes(props);
+    const getDropdownStyle = (dropdown) => {
+        const dropdownStyle = styles?.[UI.Dropdown];
+        const specificDropdownStyle = styles?.[dropdown];
+        if (!dropdownStyle && !specificDropdownStyle) {
+            return undefined;
+        }
+        return {
+            ...dropdownStyle,
+            ...specificDropdownStyle,
+        };
+    };
+    const rootElRef = useRef(null);
+    useAnimation(rootElRef, Boolean(props.animate), {
+        classNames,
+        months,
+        focused,
+        dateLib,
+    });
+    const contextValue = {
+        dayPickerProps: props,
+        selected: selectedValue,
+        select: select,
+        isSelected,
+        months,
+        nextMonth,
+        previousMonth,
+        goToMonth,
+        getModifiers,
+        components,
+        classNames,
+        styles,
+        labels,
+        formatters,
+    };
+    return (React__default.createElement(dayPickerContext.Provider, { value: contextValue },
+        React__default.createElement(components.Root, { rootRef: props.animate ? rootElRef : undefined, className: className, style: style, dir: props.dir, id: props.id, lang: props.lang ?? locale.code, nonce: props.nonce, title: props.title, role: props.role, "aria-label": props["aria-label"], "aria-labelledby": props["aria-labelledby"], ...dataAttributes },
+            React__default.createElement(components.Months, { className: classNames[UI.Months], style: styles?.[UI.Months] },
+                !props.hideNavigation && !navLayout && (React__default.createElement(components.Nav, { "data-animated-nav": props.animate ? "true" : undefined, className: classNames[UI.Nav], style: styles?.[UI.Nav], "aria-label": labelNav(), onPreviousClick: handlePreviousClick, onNextClick: handleNextClick, previousMonth: previousMonth, nextMonth: nextMonth })),
+                months.map((calendarMonth, displayIndex) => {
+                    const monthOffset = props.reverseMonths
+                        ? months.length - 1 - displayIndex
+                        : displayIndex;
+                    return (React__default.createElement(components.Month, { "data-animated-month": props.animate ? "true" : undefined, className: classNames[UI.Month], style: styles?.[UI.Month], 
+                        // biome-ignore lint/suspicious/noArrayIndexKey: breaks animation
+                        key: displayIndex, displayIndex: displayIndex, calendarMonth: calendarMonth },
+                        navLayout === "around" &&
+                            !props.hideNavigation &&
+                            displayIndex === 0 && (React__default.createElement(components.PreviousMonthButton, { type: "button", className: classNames[UI.PreviousMonthButton], style: styles?.[UI.PreviousMonthButton], tabIndex: previousMonth ? undefined : -1, "aria-disabled": previousMonth ? undefined : true, "aria-label": labelPrevious(previousMonth), onClick: handlePreviousClick, "data-animated-button": props.animate ? "true" : undefined },
+                            React__default.createElement(components.Chevron, { disabled: previousMonth ? undefined : true, className: classNames[UI.Chevron], style: styles?.[UI.Chevron], orientation: props.dir === "rtl" ? "right" : "left" }))),
+                        React__default.createElement(components.MonthCaption, { "data-animated-caption": props.animate ? "true" : undefined, className: classNames[UI.MonthCaption], style: styles?.[UI.MonthCaption], calendarMonth: calendarMonth, displayIndex: displayIndex }, captionLayout?.startsWith("dropdown") ? (React__default.createElement(components.DropdownNav, { className: classNames[UI.Dropdowns], style: styles?.[UI.Dropdowns] },
+                            (() => {
+                                const monthControl = captionLayout === "dropdown" ||
+                                    captionLayout === "dropdown-months" ? (React__default.createElement(components.MonthsDropdown, { key: "month", className: classNames[UI.MonthsDropdown], "aria-label": labelMonthDropdown(), disabled: Boolean(props.disableNavigation), onChange: handleMonthChange(calendarMonth.date, monthOffset), options: getMonthOptions(calendarMonth.date, navStart, navEnd, formatters, dateLib), style: getDropdownStyle(UI.MonthsDropdown), value: dateLib.getMonth(calendarMonth.date) })) : (React__default.createElement("span", { key: "month" }, formatMonthDropdown(calendarMonth.date, dateLib)));
+                                const yearControl = captionLayout === "dropdown" ||
+                                    captionLayout === "dropdown-years" ? (React__default.createElement(components.YearsDropdown, { key: "year", className: classNames[UI.YearsDropdown], "aria-label": labelYearDropdown(dateLib.options), disabled: Boolean(props.disableNavigation), onChange: handleYearChange(calendarMonth.date, monthOffset), options: getYearOptions(navStart, navEnd, formatters, dateLib, Boolean(props.reverseYears)), style: getDropdownStyle(UI.YearsDropdown), value: dateLib.getYear(calendarMonth.date) })) : (React__default.createElement("span", { key: "year" }, formatYearDropdown(calendarMonth.date, dateLib)));
+                                const controls = dateLib.getMonthYearOrder() === "year-first"
+                                    ? [yearControl, monthControl]
+                                    : [monthControl, yearControl];
+                                return controls;
+                            })(),
+                            React__default.createElement("span", { role: "status", "aria-live": "polite", style: {
+                                    border: 0,
+                                    clip: "rect(0 0 0 0)",
+                                    height: "1px",
+                                    margin: "-1px",
+                                    overflow: "hidden",
+                                    padding: 0,
+                                    position: "absolute",
+                                    width: "1px",
+                                    whiteSpace: "nowrap",
+                                    wordWrap: "normal",
+                                } }, formatCaption(calendarMonth.date, dateLib.options, dateLib)))) : (React__default.createElement(components.CaptionLabel, { className: classNames[UI.CaptionLabel], style: styles?.[UI.CaptionLabel], role: "status", "aria-live": "polite" }, formatCaption(calendarMonth.date, dateLib.options, dateLib)))),
+                        navLayout === "around" &&
+                            !props.hideNavigation &&
+                            displayIndex === numberOfMonths - 1 && (React__default.createElement(components.NextMonthButton, { type: "button", className: classNames[UI.NextMonthButton], style: styles?.[UI.NextMonthButton], tabIndex: nextMonth ? undefined : -1, "aria-disabled": nextMonth ? undefined : true, "aria-label": labelNext(nextMonth), onClick: handleNextClick, "data-animated-button": props.animate ? "true" : undefined },
+                            React__default.createElement(components.Chevron, { disabled: nextMonth ? undefined : true, className: classNames[UI.Chevron], style: styles?.[UI.Chevron], orientation: props.dir === "rtl" ? "left" : "right" }))),
+                        displayIndex === numberOfMonths - 1 &&
+                            navLayout === "after" &&
+                            !props.hideNavigation && (React__default.createElement(components.Nav, { "data-animated-nav": props.animate ? "true" : undefined, className: classNames[UI.Nav], style: styles?.[UI.Nav], "aria-label": labelNav(), onPreviousClick: handlePreviousClick, onNextClick: handleNextClick, previousMonth: previousMonth, nextMonth: nextMonth })),
+                        React__default.createElement(components.MonthGrid, { role: "grid", "aria-multiselectable": mode === "multiple" || mode === "range", "aria-label": labelGrid(calendarMonth.date, dateLib.options, dateLib) ||
+                                undefined, className: classNames[UI.MonthGrid], style: styles?.[UI.MonthGrid] },
+                            !props.hideWeekdays && (React__default.createElement(components.Weekdays, { "data-animated-weekdays": props.animate ? "true" : undefined, className: classNames[UI.Weekdays], style: styles?.[UI.Weekdays] },
+                                showWeekNumber && (React__default.createElement(components.WeekNumberHeader, { "aria-label": labelWeekNumberHeader(dateLib.options), className: classNames[UI.WeekNumberHeader], style: styles?.[UI.WeekNumberHeader], scope: "col" }, formatWeekNumberHeader())),
+                                weekdays.map((weekday) => (React__default.createElement(components.Weekday, { "aria-label": labelWeekday(weekday, dateLib.options, dateLib), className: classNames[UI.Weekday], key: String(weekday), style: styles?.[UI.Weekday], scope: "col" }, formatWeekdayName(weekday, dateLib.options, dateLib)))))),
+                            React__default.createElement(components.Weeks, { "data-animated-weeks": props.animate ? "true" : undefined, className: classNames[UI.Weeks], style: styles?.[UI.Weeks] }, calendarMonth.weeks.map((week) => {
+                                return (React__default.createElement(components.Week, { className: classNames[UI.Week], key: week.weekNumber, style: styles?.[UI.Week], week: week },
+                                    showWeekNumber && (React__default.createElement(components.WeekNumber, { week: week, style: styles?.[UI.WeekNumber], "aria-label": labelWeekNumber(week.weekNumber, {
+                                            locale,
+                                        }), className: classNames[UI.WeekNumber], scope: "row", role: "rowheader" }, formatWeekNumber(week.weekNumber, dateLib))),
+                                    week.days.map((day) => {
+                                        const { date } = day;
+                                        const modifiers = getModifiers(day);
+                                        modifiers[DayFlag.focused] =
+                                            !modifiers.hidden &&
+                                                Boolean(focused?.isEqualTo(day));
+                                        modifiers[SelectionState.selected] =
+                                            isSelected?.(date) || modifiers.selected;
+                                        if (isDateRange(selectedValue)) {
+                                            // add range modifiers
+                                            const { from, to } = selectedValue;
+                                            modifiers[SelectionState.range_start] = Boolean(from && to && dateLib.isSameDay(date, from));
+                                            modifiers[SelectionState.range_end] = Boolean(from && to && dateLib.isSameDay(date, to));
+                                            modifiers[SelectionState.range_middle] =
+                                                rangeIncludesDate(selectedValue, date, true, dateLib);
+                                        }
+                                        const style = getStyleForModifiers(modifiers, styles, props.modifiersStyles);
+                                        const className = getClassNamesForModifiers(modifiers, classNames, props.modifiersClassNames);
+                                        const ariaLabel = !isInteractive && !modifiers.hidden
+                                            ? labelGridcell(date, modifiers, dateLib.options, dateLib)
+                                            : undefined;
+                                        return (React__default.createElement(components.Day, { key: `${day.isoDate}_${day.displayMonthId}`, day: day, modifiers: modifiers, className: className.join(" "), style: style, role: "gridcell", "aria-selected": modifiers.selected || undefined, "aria-label": ariaLabel, "data-day": day.isoDate, "data-month": day.outside ? day.dateMonthId : undefined, "data-selected": modifiers.selected || undefined, "data-disabled": modifiers.disabled || undefined, "data-hidden": modifiers.hidden || undefined, "data-outside": day.outside || undefined, "data-focused": modifiers.focused || undefined, "data-today": modifiers.today || undefined }, !modifiers.hidden && isInteractive ? (React__default.createElement(components.DayButton, { className: classNames[UI.DayButton], style: styles?.[UI.DayButton], type: "button", day: day, modifiers: modifiers, disabled: (!modifiers.focused &&
+                                                modifiers.disabled) ||
+                                                undefined, "aria-disabled": (modifiers.focused &&
+                                                modifiers.disabled) ||
+                                                undefined, tabIndex: isFocusTarget(day) ? 0 : -1, "aria-label": labelDayButton(date, modifiers, dateLib.options, dateLib), onClick: handleDayClick(day, modifiers), onBlur: handleDayBlur(day, modifiers), onFocus: handleDayFocus(day, modifiers), onKeyDown: handleDayKeyDown(day, modifiers), onMouseEnter: handleDayMouseEnter(day, modifiers), onMouseLeave: handleDayMouseLeave(day, modifiers) }, formatDay(date, dateLib.options, dateLib))) : (!modifiers.hidden &&
+                                            formatDay(day.date, dateLib.options, dateLib))));
+                                    })));
+                            })))));
+                })),
+            props.footer && (React__default.createElement(components.Footer, { className: classNames[UI.Footer], style: styles?.[UI.Footer], role: "status", "aria-live": "polite" }, props.footer)))));
+}
+
+export { DayPicker };