@stokr/components-library 3.0.66 → 3.0.67

package/dist/node_modules/react-day-picker/dist/esm/formatters/formatMonthDropdown.js

@@ -0,0 +1,7 @@
+import { defaultDateLib } from "../classes/DateLib.js";
+function formatMonthDropdown(month, dateLib = defaultDateLib) {
+  return dateLib.format(month, "LLLL");
+}
+export {
+  formatMonthDropdown
+};

package/dist/node_modules/react-day-picker/dist/esm/formatters/formatWeekNumber.js

@@ -0,0 +1,10 @@
+import { defaultDateLib } from "../classes/DateLib.js";
+function formatWeekNumber(weekNumber, dateLib = defaultDateLib) {
+  if (weekNumber < 10) {
+    return dateLib.formatNumber(`0${weekNumber.toLocaleString()}`);
+  }
+  return dateLib.formatNumber(`${weekNumber.toLocaleString()}`);
+}
+export {
+  formatWeekNumber
+};

package/dist/node_modules/react-day-picker/dist/esm/formatters/formatWeekNumberHeader.js

@@ -0,0 +1,6 @@
+function formatWeekNumberHeader() {
+  return ``;
+}
+export {
+  formatWeekNumberHeader
+};

package/dist/node_modules/react-day-picker/dist/esm/formatters/formatWeekdayName.js

@@ -0,0 +1,7 @@
+import { DateLib } from "../classes/DateLib.js";
+function formatWeekdayName(weekday, options, dateLib) {
+  return (dateLib ?? new DateLib(options)).format(weekday, "cccccc");
+}
+export {
+  formatWeekdayName
+};

package/dist/node_modules/react-day-picker/dist/esm/formatters/formatYearDropdown.js

@@ -0,0 +1,9 @@
+import { defaultDateLib } from "../classes/DateLib.js";
+function formatYearDropdown(year, dateLib = defaultDateLib) {
+  return dateLib.format(year, "yyyy");
+}
+const formatYearCaption = formatYearDropdown;
+export {
+  formatYearCaption,
+  formatYearDropdown
+};

package/dist/node_modules/react-day-picker/dist/esm/formatters/index.js

@@ -0,0 +1,18 @@
+import { formatCaption, formatMonthCaption } from "./formatCaption.js";
+import { formatDay } from "./formatDay.js";
+import { formatMonthDropdown } from "./formatMonthDropdown.js";
+import { formatWeekdayName } from "./formatWeekdayName.js";
+import { formatWeekNumber } from "./formatWeekNumber.js";
+import { formatWeekNumberHeader } from "./formatWeekNumberHeader.js";
+import { formatYearCaption, formatYearDropdown } from "./formatYearDropdown.js";
+export {
+  formatCaption,
+  formatDay,
+  formatMonthCaption,
+  formatMonthDropdown,
+  formatWeekNumber,
+  formatWeekNumberHeader,
+  formatWeekdayName,
+  formatYearCaption,
+  formatYearDropdown
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/calculateFocusTarget.js

@@ -0,0 +1,40 @@
+import { DayFlag } from "../UI.js";
+var FocusTargetPriority;
+(function(FocusTargetPriority2) {
+  FocusTargetPriority2[FocusTargetPriority2["Today"] = 0] = "Today";
+  FocusTargetPriority2[FocusTargetPriority2["Selected"] = 1] = "Selected";
+  FocusTargetPriority2[FocusTargetPriority2["LastFocused"] = 2] = "LastFocused";
+  FocusTargetPriority2[FocusTargetPriority2["FocusedModifier"] = 3] = "FocusedModifier";
+})(FocusTargetPriority || (FocusTargetPriority = {}));
+function isFocusableDay(modifiers) {
+  return !modifiers[DayFlag.disabled] && !modifiers[DayFlag.hidden] && !modifiers[DayFlag.outside];
+}
+function calculateFocusTarget(days, getModifiers, isSelected, lastFocused) {
+  let focusTarget;
+  let foundFocusTargetPriority = -1;
+  for (const day of days) {
+    const modifiers = getModifiers(day);
+    if (isFocusableDay(modifiers)) {
+      if (modifiers[DayFlag.focused] && foundFocusTargetPriority < FocusTargetPriority.FocusedModifier) {
+        focusTarget = day;
+        foundFocusTargetPriority = FocusTargetPriority.FocusedModifier;
+      } else if (lastFocused?.isEqualTo(day) && foundFocusTargetPriority < FocusTargetPriority.LastFocused) {
+        focusTarget = day;
+        foundFocusTargetPriority = FocusTargetPriority.LastFocused;
+      } else if (isSelected(day.date) && foundFocusTargetPriority < FocusTargetPriority.Selected) {
+        focusTarget = day;
+        foundFocusTargetPriority = FocusTargetPriority.Selected;
+      } else if (modifiers[DayFlag.today] && foundFocusTargetPriority < FocusTargetPriority.Today) {
+        focusTarget = day;
+        foundFocusTargetPriority = FocusTargetPriority.Today;
+      }
+    }
+  }
+  if (!focusTarget) {
+    focusTarget = days.find((day) => isFocusableDay(getModifiers(day)));
+  }
+  return focusTarget;
+}
+export {
+  calculateFocusTarget
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/createGetModifiers.js

@@ -0,0 +1,72 @@
+import { DayFlag } from "../UI.js";
+import { dateMatchModifiers } from "../utils/dateMatchModifiers.js";
+function createGetModifiers(days, props, navStart, navEnd, dateLib) {
+  const { disabled, hidden, modifiers, showOutsideDays, broadcastCalendar, today = dateLib.today() } = props;
+  const { isSameDay, isSameMonth, startOfMonth, isBefore, endOfMonth, isAfter } = dateLib;
+  const computedNavStart = navStart && startOfMonth(navStart);
+  const computedNavEnd = navEnd && endOfMonth(navEnd);
+  const internalModifiersMap = {
+    [DayFlag.focused]: [],
+    [DayFlag.outside]: [],
+    [DayFlag.disabled]: [],
+    [DayFlag.hidden]: [],
+    [DayFlag.today]: []
+  };
+  const customModifiersMap = {};
+  for (const day of days) {
+    const { date, displayMonth } = day;
+    const isOutside = Boolean(displayMonth && !isSameMonth(date, displayMonth));
+    const isBeforeNavStart = Boolean(computedNavStart && isBefore(date, computedNavStart));
+    const isAfterNavEnd = Boolean(computedNavEnd && isAfter(date, computedNavEnd));
+    const isDisabled = Boolean(disabled && dateMatchModifiers(date, disabled, dateLib));
+    const isHidden = Boolean(hidden && dateMatchModifiers(date, hidden, dateLib)) || isBeforeNavStart || isAfterNavEnd || // Broadcast calendar will show outside days as default
+    !broadcastCalendar && !showOutsideDays && isOutside || broadcastCalendar && showOutsideDays === false && isOutside;
+    const isToday = isSameDay(date, today);
+    if (isOutside)
+      internalModifiersMap.outside.push(day);
+    if (isDisabled)
+      internalModifiersMap.disabled.push(day);
+    if (isHidden)
+      internalModifiersMap.hidden.push(day);
+    if (isToday)
+      internalModifiersMap.today.push(day);
+    if (modifiers) {
+      Object.keys(modifiers).forEach((name) => {
+        const modifierValue = modifiers?.[name];
+        const isMatch = modifierValue ? dateMatchModifiers(date, modifierValue, dateLib) : false;
+        if (!isMatch)
+          return;
+        if (customModifiersMap[name]) {
+          customModifiersMap[name].push(day);
+        } else {
+          customModifiersMap[name] = [day];
+        }
+      });
+    }
+  }
+  return (day) => {
+    const dayFlags = {
+      [DayFlag.focused]: false,
+      [DayFlag.disabled]: false,
+      [DayFlag.hidden]: false,
+      [DayFlag.outside]: false,
+      [DayFlag.today]: false
+    };
+    const customModifiers = {};
+    for (const name in internalModifiersMap) {
+      const days2 = internalModifiersMap[name];
+      dayFlags[name] = days2.some((d) => d === day);
+    }
+    for (const name in customModifiersMap) {
+      customModifiers[name] = customModifiersMap[name].some((d) => d === day);
+    }
+    return {
+      ...dayFlags,
+      // custom modifiers should override all the previous ones
+      ...customModifiers
+    };
+  };
+}
+export {
+  createGetModifiers
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/endOfBroadcastWeek.js

@@ -0,0 +1,11 @@
+import { getBroadcastWeeksInMonth } from "./getBroadcastWeeksInMonth.js";
+import { startOfBroadcastWeek } from "./startOfBroadcastWeek.js";
+function endOfBroadcastWeek(date, dateLib) {
+  const startDate = startOfBroadcastWeek(date, dateLib);
+  const numberOfWeeks = getBroadcastWeeksInMonth(date, dateLib);
+  const endDate = dateLib.addDays(startDate, numberOfWeeks * 7 - 1);
+  return endDate;
+}
+export {
+  endOfBroadcastWeek
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getBroadcastWeeksInMonth.js

@@ -0,0 +1,13 @@
+const FIVE_WEEKS = 5;
+const FOUR_WEEKS = 4;
+function getBroadcastWeeksInMonth(month, dateLib) {
+  const firstDayOfMonth = dateLib.startOfMonth(month);
+  const firstDayOfWeek = firstDayOfMonth.getDay() > 0 ? firstDayOfMonth.getDay() : 7;
+  const broadcastStartDate = dateLib.addDays(month, -firstDayOfWeek + 1);
+  const lastDateOfLastWeek = dateLib.addDays(broadcastStartDate, FIVE_WEEKS * 7 - 1);
+  const numberOfWeeks = dateLib.getMonth(month) === dateLib.getMonth(lastDateOfLastWeek) ? FIVE_WEEKS : FOUR_WEEKS;
+  return numberOfWeeks;
+}
+export {
+  getBroadcastWeeksInMonth
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getClassNamesForModifiers.js

@@ -0,0 +1,17 @@
+import { DayFlag, SelectionState, UI } from "../UI.js";
+function getClassNamesForModifiers(modifiers, classNames, modifiersClassNames = {}) {
+  const modifierClassNames = Object.entries(modifiers).filter(([, active]) => active === true).reduce((previousValue, [key]) => {
+    if (modifiersClassNames[key]) {
+      previousValue.push(modifiersClassNames[key]);
+    } else if (classNames[DayFlag[key]]) {
+      previousValue.push(classNames[DayFlag[key]]);
+    } else if (classNames[SelectionState[key]]) {
+      previousValue.push(classNames[SelectionState[key]]);
+    }
+    return previousValue;
+  }, [classNames[UI.Day]]);
+  return modifierClassNames;
+}
+export {
+  getClassNamesForModifiers
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getComponents.js

@@ -0,0 +1,10 @@
+import * as customComponents from "../components/custom-components.js";
+function getComponents(customComponents$1) {
+  return {
+    ...customComponents,
+    ...customComponents$1
+  };
+}
+export {
+  getComponents
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getDataAttributes.js

@@ -0,0 +1,19 @@
+function getDataAttributes(props) {
+  const dataAttributes = {
+    "data-mode": props.mode ?? void 0,
+    "data-required": "required" in props ? props.required : void 0,
+    "data-multiple-months": props.numberOfMonths && props.numberOfMonths > 1 || void 0,
+    "data-week-numbers": props.showWeekNumber || void 0,
+    "data-broadcast-calendar": props.broadcastCalendar || void 0,
+    "data-nav-layout": props.navLayout || void 0
+  };
+  Object.entries(props).forEach(([key, val]) => {
+    if (key.startsWith("data-")) {
+      dataAttributes[key] = val;
+    }
+  });
+  return dataAttributes;
+}
+export {
+  getDataAttributes
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getDates.js

@@ -0,0 +1,30 @@
+function getDates(displayMonths, maxDate, props, dateLib) {
+  const firstMonth = displayMonths[0];
+  const lastMonth = displayMonths[displayMonths.length - 1];
+  const { ISOWeek, fixedWeeks, broadcastCalendar } = props ?? {};
+  const { addDays, differenceInCalendarDays, differenceInCalendarMonths, endOfBroadcastWeek, endOfISOWeek, endOfMonth, endOfWeek, isAfter, startOfBroadcastWeek, startOfISOWeek, startOfWeek } = dateLib;
+  const startWeekFirstDate = broadcastCalendar ? startOfBroadcastWeek(firstMonth, dateLib) : ISOWeek ? startOfISOWeek(firstMonth) : startOfWeek(firstMonth);
+  const displayMonthsWeekEnd = broadcastCalendar ? endOfBroadcastWeek(lastMonth) : ISOWeek ? endOfISOWeek(endOfMonth(lastMonth)) : endOfWeek(endOfMonth(lastMonth));
+  const constraintWeekEnd = maxDate && (broadcastCalendar ? endOfBroadcastWeek(maxDate) : ISOWeek ? endOfISOWeek(maxDate) : endOfWeek(maxDate));
+  const gridEndDate = constraintWeekEnd && isAfter(displayMonthsWeekEnd, constraintWeekEnd) ? constraintWeekEnd : displayMonthsWeekEnd;
+  const nOfDays = differenceInCalendarDays(gridEndDate, startWeekFirstDate);
+  const nOfMonths = differenceInCalendarMonths(lastMonth, firstMonth) + 1;
+  const dates = [];
+  for (let i = 0; i <= nOfDays; i++) {
+    const date = addDays(startWeekFirstDate, i);
+    dates.push(date);
+  }
+  const nrOfDaysWithFixedWeeks = broadcastCalendar ? 35 : 42;
+  const extraDates = nrOfDaysWithFixedWeeks * nOfMonths;
+  if (fixedWeeks && dates.length < extraDates) {
+    const daysToAdd = extraDates - dates.length;
+    for (let i = 0; i < daysToAdd; i++) {
+      const date = addDays(dates[dates.length - 1], 1);
+      dates.push(date);
+    }
+  }
+  return dates;
+}
+export {
+  getDates
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getDays.js

@@ -0,0 +1,12 @@
+function getDays(calendarMonths) {
+  const initialDays = [];
+  return calendarMonths.reduce((days, month) => {
+    const weekDays = month.weeks.reduce((weekDays2, week) => {
+      return weekDays2.concat(week.days.slice());
+    }, initialDays.slice());
+    return days.concat(weekDays.slice());
+  }, initialDays.slice());
+}
+export {
+  getDays
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getDefaultClassNames.js

@@ -0,0 +1,20 @@
+import { UI, DayFlag, SelectionState, Animation } from "../UI.js";
+function getDefaultClassNames() {
+  const classNames = {};
+  for (const key in UI) {
+    classNames[UI[key]] = `rdp-${UI[key]}`;
+  }
+  for (const key in DayFlag) {
+    classNames[DayFlag[key]] = `rdp-${DayFlag[key]}`;
+  }
+  for (const key in SelectionState) {
+    classNames[SelectionState[key]] = `rdp-${SelectionState[key]}`;
+  }
+  for (const key in Animation) {
+    classNames[Animation[key]] = `rdp-${Animation[key]}`;
+  }
+  return classNames;
+}
+export {
+  getDefaultClassNames
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getDisplayMonths.js

@@ -0,0 +1,15 @@
+function getDisplayMonths(firstDisplayedMonth, calendarEndMonth, props, dateLib) {
+  const { numberOfMonths = 1 } = props;
+  const months = [];
+  for (let i = 0; i < numberOfMonths; i++) {
+    const month = dateLib.addMonths(firstDisplayedMonth, i);
+    if (calendarEndMonth && month > calendarEndMonth) {
+      break;
+    }
+    months.push(month);
+  }
+  return months;
+}
+export {
+  getDisplayMonths
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getFocusableDate.js

@@ -0,0 +1,22 @@
+function getFocusableDate(moveBy, moveDir, refDate, navStart, navEnd, props, dateLib) {
+  const { ISOWeek, broadcastCalendar } = props;
+  const { addDays, addMonths, addWeeks, addYears, endOfBroadcastWeek, endOfISOWeek, endOfWeek, max, min, startOfBroadcastWeek, startOfISOWeek, startOfWeek } = dateLib;
+  const moveFns = {
+    day: addDays,
+    week: addWeeks,
+    month: addMonths,
+    year: addYears,
+    startOfWeek: (date) => broadcastCalendar ? startOfBroadcastWeek(date, dateLib) : ISOWeek ? startOfISOWeek(date) : startOfWeek(date),
+    endOfWeek: (date) => broadcastCalendar ? endOfBroadcastWeek(date) : ISOWeek ? endOfISOWeek(date) : endOfWeek(date)
+  };
+  let focusableDate = moveFns[moveBy](refDate, moveDir === "after" ? 1 : -1);
+  if (moveDir === "before" && navStart) {
+    focusableDate = max([navStart, focusableDate]);
+  } else if (moveDir === "after" && navEnd) {
+    focusableDate = min([navEnd, focusableDate]);
+  }
+  return focusableDate;
+}
+export {
+  getFocusableDate
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getFormatters.js

@@ -0,0 +1,16 @@
+import * as index from "../formatters/index.js";
+function getFormatters(customFormatters) {
+  if (customFormatters?.formatMonthCaption && !customFormatters.formatCaption) {
+    customFormatters.formatCaption = customFormatters.formatMonthCaption;
+  }
+  if (customFormatters?.formatYearCaption && !customFormatters.formatYearDropdown) {
+    customFormatters.formatYearDropdown = customFormatters.formatYearCaption;
+  }
+  return {
+    ...index,
+    ...customFormatters
+  };
+}
+export {
+  getFormatters
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getInitialMonth.js

@@ -0,0 +1,16 @@
+function getInitialMonth(props, navStart, navEnd, dateLib) {
+  const { month, defaultMonth, today = dateLib.today(), numberOfMonths = 1 } = props;
+  let initialMonth = month || defaultMonth || today;
+  const { differenceInCalendarMonths, addMonths, startOfMonth } = dateLib;
+  if (navEnd && differenceInCalendarMonths(navEnd, initialMonth) < numberOfMonths - 1) {
+    const offset = -1 * (numberOfMonths - 1);
+    initialMonth = addMonths(navEnd, offset);
+  }
+  if (navStart && differenceInCalendarMonths(initialMonth, navStart) < 0) {
+    initialMonth = navStart;
+  }
+  return startOfMonth(initialMonth);
+}
+export {
+  getInitialMonth
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getLabels.js

@@ -0,0 +1,41 @@
+import * as index from "../labels/index.js";
+import { labelWeekday } from "../labels/labelWeekday.js";
+import { labelWeekNumberHeader } from "../labels/labelWeekNumberHeader.js";
+import { labelNav } from "../labels/labelNav.js";
+import { labelGridcell } from "../labels/labelGridcell.js";
+import { labelGrid } from "../labels/labelGrid.js";
+import { labelYearDropdown } from "../labels/labelYearDropdown.js";
+import { labelWeekNumber } from "../labels/labelWeekNumber.js";
+import { labelPrevious } from "../labels/labelPrevious.js";
+import { labelNext } from "../labels/labelNext.js";
+import { labelMonthDropdown } from "../labels/labelMonthDropdown.js";
+import { labelDayButton } from "../labels/labelDayButton.js";
+const resolveLabel = (defaultLabel, customLabel, localeLabel) => {
+  if (customLabel)
+    return customLabel;
+  if (localeLabel) {
+    return typeof localeLabel === "function" ? localeLabel : (..._args) => localeLabel;
+  }
+  return defaultLabel;
+};
+function getLabels(customLabels, options) {
+  const localeLabels = options.locale?.labels ?? {};
+  return {
+    ...index,
+    ...customLabels ?? {},
+    labelDayButton: resolveLabel(labelDayButton, customLabels?.labelDayButton, localeLabels.labelDayButton),
+    labelMonthDropdown: resolveLabel(labelMonthDropdown, customLabels?.labelMonthDropdown, localeLabels.labelMonthDropdown),
+    labelNext: resolveLabel(labelNext, customLabels?.labelNext, localeLabels.labelNext),
+    labelPrevious: resolveLabel(labelPrevious, customLabels?.labelPrevious, localeLabels.labelPrevious),
+    labelWeekNumber: resolveLabel(labelWeekNumber, customLabels?.labelWeekNumber, localeLabels.labelWeekNumber),
+    labelYearDropdown: resolveLabel(labelYearDropdown, customLabels?.labelYearDropdown, localeLabels.labelYearDropdown),
+    labelGrid: resolveLabel(labelGrid, customLabels?.labelGrid, localeLabels.labelGrid),
+    labelGridcell: resolveLabel(labelGridcell, customLabels?.labelGridcell, localeLabels.labelGridcell),
+    labelNav: resolveLabel(labelNav, customLabels?.labelNav, localeLabels.labelNav),
+    labelWeekNumberHeader: resolveLabel(labelWeekNumberHeader, customLabels?.labelWeekNumberHeader, localeLabels.labelWeekNumberHeader),
+    labelWeekday: resolveLabel(labelWeekday, customLabels?.labelWeekday, localeLabels.labelWeekday)
+  };
+}
+export {
+  getLabels
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getMonthOptions.js

@@ -0,0 +1,17 @@
+function getMonthOptions(displayMonth, navStart, navEnd, formatters, dateLib) {
+  const { startOfMonth, startOfYear, endOfYear, eachMonthOfInterval, getMonth } = dateLib;
+  const months = eachMonthOfInterval({
+    start: startOfYear(displayMonth),
+    end: endOfYear(displayMonth)
+  });
+  const options = months.map((month) => {
+    const label = formatters.formatMonthDropdown(month, dateLib);
+    const value = getMonth(month);
+    const disabled = navStart && month < startOfMonth(navStart) || navEnd && month > startOfMonth(navEnd) || false;
+    return { value, label, disabled };
+  });
+  return options;
+}
+export {
+  getMonthOptions
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getMonths.js

@@ -0,0 +1,43 @@
+import { CalendarDay } from "../classes/CalendarDay.js";
+import { CalendarWeek } from "../classes/CalendarWeek.js";
+import { CalendarMonth } from "../classes/CalendarMonth.js";
+function getMonths(displayMonths, dates, props, dateLib) {
+  const { addDays, endOfBroadcastWeek, endOfISOWeek, endOfMonth, endOfWeek, getISOWeek, getWeek, startOfBroadcastWeek, startOfISOWeek, startOfWeek } = dateLib;
+  const dayPickerMonths = displayMonths.reduce((months, month) => {
+    const firstDateOfFirstWeek = props.broadcastCalendar ? startOfBroadcastWeek(month, dateLib) : props.ISOWeek ? startOfISOWeek(month) : startOfWeek(month);
+    const lastDateOfLastWeek = props.broadcastCalendar ? endOfBroadcastWeek(month) : props.ISOWeek ? endOfISOWeek(endOfMonth(month)) : endOfWeek(endOfMonth(month));
+    const monthDates = dates.filter((date) => {
+      return date >= firstDateOfFirstWeek && date <= lastDateOfLastWeek;
+    });
+    const nrOfDaysWithFixedWeeks = props.broadcastCalendar ? 35 : 42;
+    if (props.fixedWeeks && monthDates.length < nrOfDaysWithFixedWeeks) {
+      const extraDates = dates.filter((date) => {
+        const daysToAdd = nrOfDaysWithFixedWeeks - monthDates.length;
+        return date > lastDateOfLastWeek && date <= addDays(lastDateOfLastWeek, daysToAdd);
+      });
+      monthDates.push(...extraDates);
+    }
+    const weeks = monthDates.reduce((weeks2, date) => {
+      const weekNumber = props.ISOWeek ? getISOWeek(date) : getWeek(date);
+      const week = weeks2.find((week2) => week2.weekNumber === weekNumber);
+      const day = new CalendarDay(date, month, dateLib);
+      if (!week) {
+        weeks2.push(new CalendarWeek(weekNumber, [day]));
+      } else {
+        week.days.push(day);
+      }
+      return weeks2;
+    }, []);
+    const dayPickerMonth = new CalendarMonth(month, weeks);
+    months.push(dayPickerMonth);
+    return months;
+  }, []);
+  if (!props.reverseMonths) {
+    return dayPickerMonths;
+  } else {
+    return dayPickerMonths.reverse();
+  }
+}
+export {
+  getMonths
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getNavMonth.js

@@ -0,0 +1,39 @@
+function getNavMonths(props, dateLib) {
+  let { startMonth, endMonth } = props;
+  const { startOfYear, startOfDay, startOfMonth, endOfMonth, addYears, endOfYear, newDate, today } = dateLib;
+  const { fromYear, toYear, fromMonth, toMonth } = props;
+  if (!startMonth && fromMonth) {
+    startMonth = fromMonth;
+  }
+  if (!startMonth && fromYear) {
+    startMonth = dateLib.newDate(fromYear, 0, 1);
+  }
+  if (!endMonth && toMonth) {
+    endMonth = toMonth;
+  }
+  if (!endMonth && toYear) {
+    endMonth = newDate(toYear, 11, 31);
+  }
+  const hasYearDropdown = props.captionLayout === "dropdown" || props.captionLayout === "dropdown-years";
+  if (startMonth) {
+    startMonth = startOfMonth(startMonth);
+  } else if (fromYear) {
+    startMonth = newDate(fromYear, 0, 1);
+  } else if (!startMonth && hasYearDropdown) {
+    startMonth = startOfYear(addYears(props.today ?? today(), -100));
+  }
+  if (endMonth) {
+    endMonth = endOfMonth(endMonth);
+  } else if (toYear) {
+    endMonth = newDate(toYear, 11, 31);
+  } else if (!endMonth && hasYearDropdown) {
+    endMonth = endOfYear(props.today ?? today());
+  }
+  return [
+    startMonth ? startOfDay(startMonth) : startMonth,
+    endMonth ? startOfDay(endMonth) : endMonth
+  ];
+}
+export {
+  getNavMonths
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getNextFocus.js

@@ -0,0 +1,20 @@
+import { dateMatchModifiers } from "../utils/dateMatchModifiers.js";
+import { getFocusableDate } from "./getFocusableDate.js";
+import { CalendarDay } from "../classes/CalendarDay.js";
+function getNextFocus(moveBy, moveDir, refDay, calendarStartMonth, calendarEndMonth, props, dateLib, attempt = 0) {
+  if (attempt > 365) {
+    return void 0;
+  }
+  const focusableDate = getFocusableDate(moveBy, moveDir, refDay.date, calendarStartMonth, calendarEndMonth, props, dateLib);
+  const isDisabled = Boolean(props.disabled && dateMatchModifiers(focusableDate, props.disabled, dateLib));
+  const isHidden = Boolean(props.hidden && dateMatchModifiers(focusableDate, props.hidden, dateLib));
+  const targetMonth = focusableDate;
+  const focusDay = new CalendarDay(focusableDate, targetMonth, dateLib);
+  if (!isDisabled && !isHidden) {
+    return focusDay;
+  }
+  return getNextFocus(moveBy, moveDir, focusDay, calendarStartMonth, calendarEndMonth, props, dateLib, attempt + 1);
+}
+export {
+  getNextFocus
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getNextMonth.js

@@ -0,0 +1,20 @@
+function getNextMonth(firstDisplayedMonth, calendarEndMonth, options, dateLib) {
+  if (options.disableNavigation) {
+    return void 0;
+  }
+  const { pagedNavigation, numberOfMonths = 1 } = options;
+  const { startOfMonth, addMonths, differenceInCalendarMonths } = dateLib;
+  const offset = pagedNavigation ? numberOfMonths : 1;
+  const month = startOfMonth(firstDisplayedMonth);
+  if (!calendarEndMonth) {
+    return addMonths(month, offset);
+  }
+  const monthsDiff = differenceInCalendarMonths(calendarEndMonth, firstDisplayedMonth);
+  if (monthsDiff < numberOfMonths) {
+    return void 0;
+  }
+  return addMonths(month, offset);
+}
+export {
+  getNextMonth
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getPreviousMonth.js

@@ -0,0 +1,20 @@
+function getPreviousMonth(firstDisplayedMonth, calendarStartMonth, options, dateLib) {
+  if (options.disableNavigation) {
+    return void 0;
+  }
+  const { pagedNavigation, numberOfMonths } = options;
+  const { startOfMonth, addMonths, differenceInCalendarMonths } = dateLib;
+  const offset = pagedNavigation ? numberOfMonths ?? 1 : 1;
+  const month = startOfMonth(firstDisplayedMonth);
+  if (!calendarStartMonth) {
+    return addMonths(month, -offset);
+  }
+  const monthsDiff = differenceInCalendarMonths(month, calendarStartMonth);
+  if (monthsDiff <= 0) {
+    return void 0;
+  }
+  return addMonths(month, -offset);
+}
+export {
+  getPreviousMonth
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getStyleForModifiers.js

@@ -0,0 +1,14 @@
+import { UI } from "../UI.js";
+function getStyleForModifiers(dayModifiers, styles = {}, modifiersStyles = {}) {
+  let style = { ...styles?.[UI.Day] };
+  Object.entries(dayModifiers).filter(([, active]) => active === true).forEach(([modifier]) => {
+    style = {
+      ...style,
+      ...modifiersStyles?.[modifier]
+    };
+  });
+  return style;
+}
+export {
+  getStyleForModifiers
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getWeekdays.js

@@ -0,0 +1,13 @@
+function getWeekdays(dateLib, ISOWeek, broadcastCalendar, today) {
+  const referenceToday = today ?? dateLib.today();
+  const start = broadcastCalendar ? dateLib.startOfBroadcastWeek(referenceToday, dateLib) : ISOWeek ? dateLib.startOfISOWeek(referenceToday) : dateLib.startOfWeek(referenceToday);
+  const days = [];
+  for (let i = 0; i < 7; i++) {
+    const day = dateLib.addDays(start, i);
+    days.push(day);
+  }
+  return days;
+}
+export {
+  getWeekdays
+};

package/dist/node_modules/react-day-picker/dist/esm/helpers/getWeeks.js

@@ -0,0 +1,9 @@
+function getWeeks(months) {
+  const initialWeeks = [];
+  return months.reduce((weeks, month) => {
+    return weeks.concat(month.weeks.slice());
+  }, initialWeeks.slice());
+}
+export {
+  getWeeks
+};