@arc-ui/components 12.0.0-beta.13 → 12.0.0-beta.14.1

package/lib/_shared/cjs/Calendar-BC-wjsFG.cjs

@@ -0,0 +1,1924 @@
+'use strict';
+
+var filterAttrs = require('./filter-attrs-eK6E_34o.cjs');
+var React = require('react');
+var index = require('./index-BLRjGROQ.cjs');
+var index_es = require('./index.es-gP1lKcqE.cjs');
+var useMediaQuery = require('./use-media-query-BsUfHjPZ.cjs');
+var index$1 = require('./index-CTlXMLug.cjs');
+var Text = require('./Text-Cr5nmYmx.cjs');
+var VisuallyHidden = require('./VisuallyHidden-B4XCvPYP.cjs');
+require('./index-DR8Rkav9.cjs');
+var Surface = require('./Surface-BFx1yNsq.cjs');
+var Heading = require('./Heading-ByiXEHGj.cjs');
+var BtIconChevronRightMid = require('./BtIconChevronRightMid-Dol_sskt.cjs');
+var Icon = require('./Icon-DdqFr6bT.cjs');
+
+/**
+ * @name addMonths
+ * @category Month Helpers
+ * @summary Add the specified number of months to the given date.
+ *
+ * @description
+ * Add the specified number of months to the given date.
+ *
+ * @param {Date|Number} date - the date to be changed
+ * @param {Number} amount - the amount of months to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns {Date} the new date with the months added
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Add 5 months to 1 September 2014:
+ * const result = addMonths(new Date(2014, 8, 1), 5)
+ * //=> Sun Feb 01 2015 00:00:00
+ */
+function addMonths(dirtyDate, dirtyAmount) {
+  index.requiredArgs(2, arguments);
+  var date = index.toDate(dirtyDate);
+  var amount = index.toInteger(dirtyAmount);
+  if (isNaN(amount)) {
+    return new Date(NaN);
+  }
+  if (!amount) {
+    // If 0 months, no-op to avoid changing times in the hour before end of DST
+    return date;
+  }
+  var dayOfMonth = date.getDate();
+
+  // The JS Date object supports date math by accepting out-of-bounds values for
+  // month, day, etc. For example, new Date(2020, 0, 0) returns 31 Dec 2019 and
+  // new Date(2020, 13, 1) returns 1 Feb 2021.  This is *almost* the behavior we
+  // want except that dates will wrap around the end of a month, meaning that
+  // new Date(2020, 13, 31) will return 3 Mar 2021 not 28 Feb 2021 as desired. So
+  // we'll default to the end of the desired month by adding 1 to the desired
+  // month and using a date of 0 to back up one day to the end of the desired
+  // month.
+  var endOfDesiredMonth = new Date(date.getTime());
+  endOfDesiredMonth.setMonth(date.getMonth() + amount + 1, 0);
+  var daysInMonth = endOfDesiredMonth.getDate();
+  if (dayOfMonth >= daysInMonth) {
+    // If we're already at the end of the month, then this is the correct date
+    // and we're done.
+    return endOfDesiredMonth;
+  } else {
+    // Otherwise, we now know that setting the original day-of-month value won't
+    // cause an overflow, so set the desired day-of-month. Note that we can't
+    // just set the date of `endOfDesiredMonth` because that object may have had
+    // its time changed in the unusual case where where a DST transition was on
+    // the last day of the month and its local time was in the hour skipped or
+    // repeated next to a DST transition.  So we use `date` instead which is
+    // guaranteed to still have the original time.
+    date.setFullYear(endOfDesiredMonth.getFullYear(), endOfDesiredMonth.getMonth(), dayOfMonth);
+    return date;
+  }
+}
+
+/**
+ * @name subMonths
+ * @category Month Helpers
+ * @summary Subtract the specified number of months from the given date.
+ *
+ * @description
+ * Subtract the specified number of months from the given date.
+ *
+ * @param {Date|Number} date - the date to be changed
+ * @param {Number} amount - the amount of months to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns {Date} the new date with the months subtracted
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Subtract 5 months from 1 February 2015:
+ * const result = subMonths(new Date(2015, 1, 1), 5)
+ * //=> Mon Sep 01 2014 00:00:00
+ */
+function subMonths(dirtyDate, dirtyAmount) {
+  index.requiredArgs(2, arguments);
+  var amount = index.toInteger(dirtyAmount);
+  return addMonths(dirtyDate, -amount);
+}
+
+/**
+ * @name startOfMonth
+ * @category Month Helpers
+ * @summary Return the start of a month for the given date.
+ *
+ * @description
+ * Return the start of a month for the given date.
+ * The result will be in the local timezone.
+ *
+ * @param {Date|Number} date - the original date
+ * @returns {Date} the start of a month
+ * @throws {TypeError} 1 argument required
+ *
+ * @example
+ * // The start of a month for 2 September 2014 11:55:00:
+ * const result = startOfMonth(new Date(2014, 8, 2, 11, 55, 0))
+ * //=> Mon Sep 01 2014 00:00:00
+ */
+function startOfMonth(dirtyDate) {
+  index.requiredArgs(1, arguments);
+  var date = index.toDate(dirtyDate);
+  date.setDate(1);
+  date.setHours(0, 0, 0, 0);
+  return date;
+}
+
+var containsDate = function (dates, compareDate) {
+    return dates.map(function (date) { return date.getTime(); }).includes(compareDate.getTime());
+};
+
+/**
+ * @name getMonth
+ * @category Month Helpers
+ * @summary Get the month of the given date.
+ *
+ * @description
+ * Get the month of the given date.
+ *
+ * @param {Date|Number} date - the given date
+ * @returns {Number} the month
+ * @throws {TypeError} 1 argument required
+ *
+ * @example
+ * // Which month is 29 February 2012?
+ * const result = getMonth(new Date(2012, 1, 29))
+ * //=> 1
+ */
+function getMonth(dirtyDate) {
+  index.requiredArgs(1, arguments);
+  var date = index.toDate(dirtyDate);
+  var month = date.getMonth();
+  return month;
+}
+
+/**
+ * @name getYear
+ * @category Year Helpers
+ * @summary Get the year of the given date.
+ *
+ * @description
+ * Get the year of the given date.
+ *
+ * @param {Date|Number} date - the given date
+ * @returns {Number} the year
+ * @throws {TypeError} 1 argument required
+ *
+ * @example
+ * // Which year is 2 July 2014?
+ * const result = getYear(new Date(2014, 6, 2))
+ * //=> 2014
+ */
+function getYear(dirtyDate) {
+  index.requiredArgs(1, arguments);
+  return index.toDate(dirtyDate).getFullYear();
+}
+
+/**
+ * @name getDaysInMonth
+ * @category Month Helpers
+ * @summary Get the number of days in a month of the given date.
+ *
+ * @description
+ * Get the number of days in a month of the given date.
+ *
+ * @param {Date|Number} date - the given date
+ * @returns {Number} the number of days in a month
+ * @throws {TypeError} 1 argument required
+ *
+ * @example
+ * // How many days are in February 2000?
+ * const result = getDaysInMonth(new Date(2000, 1))
+ * //=> 29
+ */
+function getDaysInMonth(dirtyDate) {
+  index.requiredArgs(1, arguments);
+  var date = index.toDate(dirtyDate);
+  var year = date.getFullYear();
+  var monthIndex = date.getMonth();
+  var lastDayOfMonth = new Date(0);
+  lastDayOfMonth.setFullYear(year, monthIndex + 1, 0);
+  lastDayOfMonth.setHours(0, 0, 0, 0);
+  return lastDayOfMonth.getDate();
+}
+
+/**
+ * @name setMonth
+ * @category Month Helpers
+ * @summary Set the month to the given date.
+ *
+ * @description
+ * Set the month to the given date.
+ *
+ * @param {Date|Number} date - the date to be changed
+ * @param {Number} month - the month of the new date
+ * @returns {Date} the new date with the month set
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Set February to 1 September 2014:
+ * const result = setMonth(new Date(2014, 8, 1), 1)
+ * //=> Sat Feb 01 2014 00:00:00
+ */
+function setMonth(dirtyDate, dirtyMonth) {
+  index.requiredArgs(2, arguments);
+  var date = index.toDate(dirtyDate);
+  var month = index.toInteger(dirtyMonth);
+  var year = date.getFullYear();
+  var day = date.getDate();
+  var dateWithDesiredMonth = new Date(0);
+  dateWithDesiredMonth.setFullYear(year, month, 15);
+  dateWithDesiredMonth.setHours(0, 0, 0, 0);
+  var daysInMonth = getDaysInMonth(dateWithDesiredMonth);
+  // Set the last day of the new month
+  // if the original date was the last day of the longer month
+  date.setMonth(month, Math.min(day, daysInMonth));
+  return date;
+}
+
+/**
+ * @name set
+ * @category Common Helpers
+ * @summary Set date values to a given date.
+ *
+ * @description
+ * Set date values to a given date.
+ *
+ * Sets time values to date from object `values`.
+ * A value is not set if it is undefined or null or doesn't exist in `values`.
+ *
+ * Note about bundle size: `set` does not internally use `setX` functions from date-fns but instead opts
+ * to use native `Date#setX` methods. If you use this function, you may not want to include the
+ * other `setX` functions that date-fns provides if you are concerned about the bundle size.
+ *
+ * @param {Date|Number} date - the date to be changed
+ * @param {Object} values - an object with options
+ * @param {Number} [values.year] - the number of years to be set
+ * @param {Number} [values.month] - the number of months to be set
+ * @param {Number} [values.date] - the number of days to be set
+ * @param {Number} [values.hours] - the number of hours to be set
+ * @param {Number} [values.minutes] - the number of minutes to be set
+ * @param {Number} [values.seconds] - the number of seconds to be set
+ * @param {Number} [values.milliseconds] - the number of milliseconds to be set
+ * @returns {Date} the new date with options set
+ * @throws {TypeError} 2 arguments required
+ * @throws {RangeError} `values` must be an object
+ *
+ * @example
+ * // Transform 1 September 2014 into 20 October 2015 in a single line:
+ * const result = set(new Date(2014, 8, 20), { year: 2015, month: 9, date: 20 })
+ * //=> Tue Oct 20 2015 00:00:00
+ *
+ * @example
+ * // Set 12 PM to 1 September 2014 01:23:45 to 1 September 2014 12:00:00:
+ * const result = set(new Date(2014, 8, 1, 1, 23, 45), { hours: 12 })
+ * //=> Mon Sep 01 2014 12:23:45
+ */
+function set(dirtyDate, values) {
+  index.requiredArgs(2, arguments);
+  if (index._typeof(values) !== 'object' || values === null) {
+    throw new RangeError('values parameter must be an object');
+  }
+  var date = index.toDate(dirtyDate);
+
+  // Check if date is Invalid Date because Date.prototype.setFullYear ignores the value of Invalid Date
+  if (isNaN(date.getTime())) {
+    return new Date(NaN);
+  }
+  if (values.year != null) {
+    date.setFullYear(values.year);
+  }
+  if (values.month != null) {
+    date = setMonth(date, values.month);
+  }
+  if (values.date != null) {
+    date.setDate(index.toInteger(values.date));
+  }
+  if (values.hours != null) {
+    date.setHours(index.toInteger(values.hours));
+  }
+  if (values.minutes != null) {
+    date.setMinutes(index.toInteger(values.minutes));
+  }
+  if (values.seconds != null) {
+    date.setSeconds(index.toInteger(values.seconds));
+  }
+  if (values.milliseconds != null) {
+    date.setMilliseconds(index.toInteger(values.milliseconds));
+  }
+  return date;
+}
+
+var dateWithoutTime = function (date) {
+    return set(new Date(date), {
+        hours: 0,
+        minutes: 0,
+        milliseconds: 0,
+        seconds: 0,
+    });
+};
+
+var getDatesInMonth = function (date) {
+    var dateYear = getYear(date);
+    var dateMonth = getMonth(date);
+    return Array.from({ length: getDaysInMonth(date) }, function (_, i) {
+        return dateWithoutTime(new Date(dateYear, dateMonth, i + 1));
+    });
+};
+
+/**
+ * @name getDay
+ * @category Weekday Helpers
+ * @summary Get the day of the week of the given date.
+ *
+ * @description
+ * Get the day of the week of the given date.
+ *
+ * @param {Date|Number} date - the given date
+ * @returns {0|1|2|3|4|5|6} the day of week, 0 represents Sunday
+ * @throws {TypeError} 1 argument required
+ *
+ * @example
+ * // Which day of the week is 29 February 2012?
+ * const result = getDay(new Date(2012, 1, 29))
+ * //=> 3
+ */
+function getDay(dirtyDate) {
+  index.requiredArgs(1, arguments);
+  var date = index.toDate(dirtyDate);
+  var day = date.getDay();
+  return day;
+}
+
+var WeekDaysAbbr;
+(function (WeekDaysAbbr) {
+    WeekDaysAbbr["MON"] = "Mon";
+    WeekDaysAbbr["TUE"] = "Tue";
+    WeekDaysAbbr["WED"] = "Wed";
+    WeekDaysAbbr["THUR"] = "Thur";
+    WeekDaysAbbr["FRI"] = "Fri";
+    WeekDaysAbbr["SAT"] = "Sat";
+    WeekDaysAbbr["SUN"] = "Sun";
+})(WeekDaysAbbr || (WeekDaysAbbr = {}));
+var WeekDays;
+(function (WeekDays) {
+    WeekDays["MONDAY"] = "Monday";
+    WeekDays["TUESDAY"] = "Tuesday";
+    WeekDays["WEDNESDAY"] = "Wednesday";
+    WeekDays["THURSDAY"] = "Thursday";
+    WeekDays["FRIDAY"] = "Friday";
+    WeekDays["SATURDAY"] = "Saturday";
+    WeekDays["SUNDAY"] = "Sunday";
+})(WeekDays || (WeekDays = {}));
+
+var isDay = function (date, day) {
+    var _a;
+    var dayMap = (_a = {},
+        _a[WeekDays.MONDAY] = 1,
+        _a[WeekDays.TUESDAY] = 2,
+        _a[WeekDays.WEDNESDAY] = 3,
+        _a[WeekDays.THURSDAY] = 4,
+        _a[WeekDays.FRIDAY] = 5,
+        _a[WeekDays.SATURDAY] = 6,
+        _a[WeekDays.SUNDAY] = 0,
+        _a);
+    return getDay(date) === dayMap[day];
+};
+
+/**
+ * @name isBefore
+ * @category Common Helpers
+ * @summary Is the first date before the second one?
+ *
+ * @description
+ * Is the first date before the second one?
+ *
+ * @param {Date|Number} date - the date that should be before the other one to return true
+ * @param {Date|Number} dateToCompare - the date to compare with
+ * @returns {Boolean} the first date is before the second date
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Is 10 July 1989 before 11 February 1987?
+ * const result = isBefore(new Date(1989, 6, 10), new Date(1987, 1, 11))
+ * //=> false
+ */
+function isBefore(dirtyDate, dirtyDateToCompare) {
+  index.requiredArgs(2, arguments);
+  var date = index.toDate(dirtyDate);
+  var dateToCompare = index.toDate(dirtyDateToCompare);
+  return date.getTime() < dateToCompare.getTime();
+}
+
+/**
+ * @name isAfter
+ * @category Common Helpers
+ * @summary Is the first date after the second one?
+ *
+ * @description
+ * Is the first date after the second one?
+ *
+ * @param {Date|Number} date - the date that should be after the other one to return true
+ * @param {Date|Number} dateToCompare - the date to compare with
+ * @returns {Boolean} the first date is after the second date
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Is 10 July 1989 after 11 February 1987?
+ * const result = isAfter(new Date(1989, 6, 10), new Date(1987, 1, 11))
+ * //=> true
+ */
+function isAfter(dirtyDate, dirtyDateToCompare) {
+  index.requiredArgs(2, arguments);
+  var date = index.toDate(dirtyDate);
+  var dateToCompare = index.toDate(dirtyDateToCompare);
+  return date.getTime() > dateToCompare.getTime();
+}
+
+var isDisabledDate = function (date, disabledDates, minDate, maxDate) {
+    return ((minDate && isBefore(date, minDate)) ||
+        (maxDate && isAfter(date, maxDate)) ||
+        (disabledDates && containsDate(disabledDates, date)));
+};
+
+var isMonthBeforeMinDate = function (month, minDate) {
+    return getDatesInMonth(month).every(function (date) {
+        return isBefore(date, minDate);
+    });
+};
+
+var isMonthAfterMaxDate = function (date, maxDate) {
+    return getDatesInMonth(date).every(function (date) {
+        return isAfter(date, maxDate);
+    });
+};
+
+/**
+ * @name compareAsc
+ * @category Common Helpers
+ * @summary Compare the two dates and return -1, 0 or 1.
+ *
+ * @description
+ * Compare the two dates and return 1 if the first date is after the second,
+ * -1 if the first date is before the second or 0 if dates are equal.
+ *
+ * @param {Date|Number} dateLeft - the first date to compare
+ * @param {Date|Number} dateRight - the second date to compare
+ * @returns {Number} the result of the comparison
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Compare 11 February 1987 and 10 July 1989:
+ * const result = compareAsc(new Date(1987, 1, 11), new Date(1989, 6, 10))
+ * //=> -1
+ *
+ * @example
+ * // Sort the array of dates:
+ * const result = [
+ *   new Date(1995, 6, 2),
+ *   new Date(1987, 1, 11),
+ *   new Date(1989, 6, 10)
+ * ].sort(compareAsc)
+ * //=> [
+ * //   Wed Feb 11 1987 00:00:00,
+ * //   Mon Jul 10 1989 00:00:00,
+ * //   Sun Jul 02 1995 00:00:00
+ * // ]
+ */
+function compareAsc(dirtyDateLeft, dirtyDateRight) {
+  index.requiredArgs(2, arguments);
+  var dateLeft = index.toDate(dirtyDateLeft);
+  var dateRight = index.toDate(dirtyDateRight);
+  var diff = dateLeft.getTime() - dateRight.getTime();
+  if (diff < 0) {
+    return -1;
+  } else if (diff > 0) {
+    return 1;
+    // Return 0 if diff is 0; return NaN if diff is NaN
+  } else {
+    return diff;
+  }
+}
+
+/**
+ * @name eachDayOfInterval
+ * @category Interval Helpers
+ * @summary Return the array of dates within the specified time interval.
+ *
+ * @description
+ * Return the array of dates within the specified time interval.
+ *
+ * @param {Interval} interval - the interval. See [Interval]{@link https://date-fns.org/docs/Interval}
+ * @param {Object} [options] - an object with options.
+ * @param {Number} [options.step=1] - the step to increment by. The value should be more than 1.
+ * @returns {Date[]} the array with starts of days from the day of the interval start to the day of the interval end
+ * @throws {TypeError} 1 argument required
+ * @throws {RangeError} `options.step` must be a number greater than 1
+ * @throws {RangeError} The start of an interval cannot be after its end
+ * @throws {RangeError} Date in interval cannot be `Invalid Date`
+ *
+ * @example
+ * // Each day between 6 October 2014 and 10 October 2014:
+ * const result = eachDayOfInterval({
+ *   start: new Date(2014, 9, 6),
+ *   end: new Date(2014, 9, 10)
+ * })
+ * //=> [
+ * //   Mon Oct 06 2014 00:00:00,
+ * //   Tue Oct 07 2014 00:00:00,
+ * //   Wed Oct 08 2014 00:00:00,
+ * //   Thu Oct 09 2014 00:00:00,
+ * //   Fri Oct 10 2014 00:00:00
+ * // ]
+ */
+function eachDayOfInterval(dirtyInterval, options) {
+  var _options$step;
+  index.requiredArgs(1, arguments);
+  var interval = dirtyInterval || {};
+  var startDate = index.toDate(interval.start);
+  var endDate = index.toDate(interval.end);
+  var endTime = endDate.getTime();
+
+  // Throw an exception if start date is after end date or if any date is `Invalid Date`
+  if (!(startDate.getTime() <= endTime)) {
+    throw new RangeError('Invalid interval');
+  }
+  var dates = [];
+  var currentDate = startDate;
+  currentDate.setHours(0, 0, 0, 0);
+  var step = Number((_options$step = void 0 ) !== null && _options$step !== void 0 ? _options$step : 1);
+  if (step < 1 || isNaN(step)) throw new RangeError('`options.step` must be a number greater than 1');
+  while (currentDate.getTime() <= endTime) {
+    dates.push(index.toDate(currentDate));
+    currentDate.setDate(currentDate.getDate() + step);
+    currentDate.setHours(0, 0, 0, 0);
+  }
+  return dates;
+}
+
+var processSelectedRange = function (_a) {
+    var range = _a.range, value = _a.value, disabledDates = _a.disabledDates;
+    var exisitingRange = range.filter(function (date) { return Boolean(date); });
+    var newRange = filterAttrs.__spreadArray(filterAttrs.__spreadArray([], (exisitingRange.length === 2 ? [] : exisitingRange), true), [
+        value,
+    ], false).sort(compareAsc);
+    var isSelectionComplete = newRange.length === 2;
+    var allDaysInRange = isSelectionComplete
+        ? eachDayOfInterval({
+            start: newRange[0],
+            end: newRange[1],
+        })
+        : [];
+    var rangeOnChangeValue = {
+        dates: allDaysInRange.map(function (date) { return ({
+            value: date,
+            disabled: disabledDates ? containsDate(disabledDates, date) : false,
+        }); }),
+        selectedDate: value,
+        start: newRange[0],
+        end: newRange[1],
+        isSelectionComplete: isSelectionComplete,
+    };
+    return {
+        rangeValue: newRange,
+        rangeOnChangeValue: rangeOnChangeValue,
+    };
+};
+
+var getCalendarType = function (type, isDesktop) {
+    if (type === "double" && !isDesktop) {
+        return "month";
+    }
+    if (type === "double" && isDesktop) {
+        return "double";
+    }
+    return type;
+};
+
+var getDoubleMonthDisplayRange = function (date) {
+    var firstMonth = getMonth(date) % 2 !== 0 ? subMonths(date, 1) : date;
+    var secondMonth = addMonths(firstMonth, 1);
+    return [firstMonth, secondMonth];
+};
+
+var getFocusDate = function (_a) {
+    var minDate = _a.minDate, maxDate = _a.maxDate, date = _a.date;
+    var isFocusDateBeforeMinDate = minDate && isBefore(date, minDate);
+    var isFocusDateAfterMaxDate = maxDate && isAfter(date, maxDate);
+    if (isFocusDateBeforeMinDate) {
+        return minDate;
+    }
+    if (isFocusDateAfterMaxDate) {
+        return maxDate;
+    }
+    return date;
+};
+
+var getHighlightRange = function (_a) {
+    var date = _a.date, minDate = _a.minDate, maxDate = _a.maxDate, range = _a.range;
+    var existingRange = range.filter(function (date) { return Boolean(date); });
+    if (existingRange.filter(function (date) { return Boolean(date); }).length === 1) {
+        var isDateBeforeMinDate = minDate && isBefore(date, minDate);
+        var isDateAfterMaxDate = maxDate && isAfter(date, maxDate);
+        if (isDateBeforeMinDate) {
+            return [minDate, existingRange[0]].sort(compareAsc);
+        }
+        if (isDateAfterMaxDate) {
+            return [maxDate, existingRange[0]].sort(compareAsc);
+        }
+        return [date, existingRange[0]].sort(compareAsc);
+    }
+    return existingRange;
+};
+
+/**
+ * @name addDays
+ * @category Day Helpers
+ * @summary Add the specified number of days to the given date.
+ *
+ * @description
+ * Add the specified number of days to the given date.
+ *
+ * @param {Date|Number} date - the date to be changed
+ * @param {Number} amount - the amount of days to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns {Date} - the new date with the days added
+ * @throws {TypeError} - 2 arguments required
+ *
+ * @example
+ * // Add 10 days to 1 September 2014:
+ * const result = addDays(new Date(2014, 8, 1), 10)
+ * //=> Thu Sep 11 2014 00:00:00
+ */
+function addDays(dirtyDate, dirtyAmount) {
+  index.requiredArgs(2, arguments);
+  var date = index.toDate(dirtyDate);
+  var amount = index.toInteger(dirtyAmount);
+  if (isNaN(amount)) {
+    return new Date(NaN);
+  }
+  if (!amount) {
+    // If 0 days, no-op to avoid changing times in the hour before end of DST
+    return date;
+  }
+  date.setDate(date.getDate() + amount);
+  return date;
+}
+
+/**
+ * @name addWeeks
+ * @category Week Helpers
+ * @summary Add the specified number of weeks to the given date.
+ *
+ * @description
+ * Add the specified number of week to the given date.
+ *
+ * @param {Date|Number} date - the date to be changed
+ * @param {Number} amount - the amount of weeks to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns {Date} the new date with the weeks added
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Add 4 weeks to 1 September 2014:
+ * const result = addWeeks(new Date(2014, 8, 1), 4)
+ * //=> Mon Sep 29 2014 00:00:00
+ */
+function addWeeks(dirtyDate, dirtyAmount) {
+  index.requiredArgs(2, arguments);
+  var amount = index.toInteger(dirtyAmount);
+  var days = amount * 7;
+  return addDays(dirtyDate, days);
+}
+
+/**
+ * @name subDays
+ * @category Day Helpers
+ * @summary Subtract the specified number of days from the given date.
+ *
+ * @description
+ * Subtract the specified number of days from the given date.
+ *
+ * @param {Date|Number} date - the date to be changed
+ * @param {Number} amount - the amount of days to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns {Date} the new date with the days subtracted
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Subtract 10 days from 1 September 2014:
+ * const result = subDays(new Date(2014, 8, 1), 10)
+ * //=> Fri Aug 22 2014 00:00:00
+ */
+function subDays(dirtyDate, dirtyAmount) {
+  index.requiredArgs(2, arguments);
+  var amount = index.toInteger(dirtyAmount);
+  return addDays(dirtyDate, -amount);
+}
+
+/**
+ * @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.
+ *
+ * @param {Date|Number} date - the original date
+ * @param {Object} [options] - an object with options.
+ * @param {Locale} [options.locale=defaultLocale] - the locale object. See [Locale]{@link https://date-fns.org/docs/Locale}
+ * @param {0|1|2|3|4|5|6} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)
+ * @returns {Date} the start of a week
+ * @throws {TypeError} 1 argument required
+ * @throws {RangeError} `options.weekStartsOn` must be between 0 and 6
+ *
+ * @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(dirtyDate, options) {
+  var _ref, _ref2, _ref3, _options$weekStartsOn, _options$locale, _options$locale$optio, _defaultOptions$local, _defaultOptions$local2;
+  index.requiredArgs(1, arguments);
+  var defaultOptions = index.getDefaultOptions();
+  var weekStartsOn = index.toInteger((_ref = (_ref2 = (_ref3 = (_options$weekStartsOn = options === null || options === void 0 ? void 0 : options.weekStartsOn) !== null && _options$weekStartsOn !== void 0 ? _options$weekStartsOn : options === null || options === void 0 ? void 0 : (_options$locale = options.locale) === null || _options$locale === void 0 ? void 0 : (_options$locale$optio = _options$locale.options) === null || _options$locale$optio === void 0 ? void 0 : _options$locale$optio.weekStartsOn) !== null && _ref3 !== void 0 ? _ref3 : defaultOptions.weekStartsOn) !== null && _ref2 !== void 0 ? _ref2 : (_defaultOptions$local = defaultOptions.locale) === null || _defaultOptions$local === void 0 ? void 0 : (_defaultOptions$local2 = _defaultOptions$local.options) === null || _defaultOptions$local2 === void 0 ? void 0 : _defaultOptions$local2.weekStartsOn) !== null && _ref !== void 0 ? _ref : 0);
+
+  // Test if weekStartsOn is between 0 and 6 _and_ is not NaN
+  if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {
+    throw new RangeError('weekStartsOn must be between 0 and 6 inclusively');
+  }
+  var date = index.toDate(dirtyDate);
+  var day = date.getDay();
+  var diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
+  date.setDate(date.getDate() - diff);
+  date.setHours(0, 0, 0, 0);
+  return date;
+}
+
+/**
+ * @name endOfWeek
+ * @category Week Helpers
+ * @summary Return the end of a week for the given date.
+ *
+ * @description
+ * Return the end of a week for the given date.
+ * The result will be in the local timezone.
+ *
+ * @param {Date|Number} date - the original date
+ * @param {Object} [options] - an object with options.
+ * @param {Locale} [options.locale=defaultLocale] - the locale object. See [Locale]{@link https://date-fns.org/docs/Locale}
+ * @param {0|1|2|3|4|5|6} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)
+ * @returns {Date} the end of a week
+ * @throws {TypeError} 1 argument required
+ * @throws {RangeError} `options.weekStartsOn` must be between 0 and 6
+ *
+ * @example
+ * // The end of a week for 2 September 2014 11:55:00:
+ * const result = endOfWeek(new Date(2014, 8, 2, 11, 55, 0))
+ * //=> Sat Sep 06 2014 23:59:59.999
+ *
+ * @example
+ * // If the week starts on Monday, the end of the week for 2 September 2014 11:55:00:
+ * const result = endOfWeek(new Date(2014, 8, 2, 11, 55, 0), { weekStartsOn: 1 })
+ * //=> Sun Sep 07 2014 23:59:59.999
+ */
+function endOfWeek(dirtyDate, options) {
+  var _ref, _ref2, _ref3, _options$weekStartsOn, _options$locale, _options$locale$optio, _defaultOptions$local, _defaultOptions$local2;
+  index.requiredArgs(1, arguments);
+  var defaultOptions = index.getDefaultOptions();
+  var weekStartsOn = index.toInteger((_ref = (_ref2 = (_ref3 = (_options$weekStartsOn = options === null || options === void 0 ? void 0 : options.weekStartsOn) !== null && _options$weekStartsOn !== void 0 ? _options$weekStartsOn : options === null || options === void 0 ? void 0 : (_options$locale = options.locale) === null || _options$locale === void 0 ? void 0 : (_options$locale$optio = _options$locale.options) === null || _options$locale$optio === void 0 ? void 0 : _options$locale$optio.weekStartsOn) !== null && _ref3 !== void 0 ? _ref3 : defaultOptions.weekStartsOn) !== null && _ref2 !== void 0 ? _ref2 : (_defaultOptions$local = defaultOptions.locale) === null || _defaultOptions$local === void 0 ? void 0 : (_defaultOptions$local2 = _defaultOptions$local.options) === null || _defaultOptions$local2 === void 0 ? void 0 : _defaultOptions$local2.weekStartsOn) !== null && _ref !== void 0 ? _ref : 0);
+
+  // Test if weekStartsOn is between 0 and 6 _and_ is not NaN
+  if (!(weekStartsOn >= 0 && weekStartsOn <= 6)) {
+    throw new RangeError('weekStartsOn must be between 0 and 6 inclusively');
+  }
+  var date = index.toDate(dirtyDate);
+  var day = date.getDay();
+  var diff = (day < weekStartsOn ? -7 : 0) + 6 - (day - weekStartsOn);
+  date.setDate(date.getDate() + diff);
+  date.setHours(23, 59, 59, 999);
+  return date;
+}
+
+/**
+ * @name subWeeks
+ * @category Week Helpers
+ * @summary Subtract the specified number of weeks from the given date.
+ *
+ * @description
+ * Subtract the specified number of weeks from the given date.
+ *
+ * @param {Date|Number} date - the date to be changed
+ * @param {Number} amount - the amount of weeks to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns {Date} the new date with the weeks subtracted
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Subtract 4 weeks from 1 September 2014:
+ * const result = subWeeks(new Date(2014, 8, 1), 4)
+ * //=> Mon Aug 04 2014 00:00:00
+ */
+function subWeeks(dirtyDate, dirtyAmount) {
+  index.requiredArgs(2, arguments);
+  var amount = index.toInteger(dirtyAmount);
+  return addWeeks(dirtyDate, -amount);
+}
+
+/**
+ * @name addYears
+ * @category Year Helpers
+ * @summary Add the specified number of years to the given date.
+ *
+ * @description
+ * Add the specified number of years to the given date.
+ *
+ * @param {Date|Number} date - the date to be changed
+ * @param {Number} amount - the amount of years to be added. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns {Date} the new date with the years added
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Add 5 years to 1 September 2014:
+ * const result = addYears(new Date(2014, 8, 1), 5)
+ * //=> Sun Sep 01 2019 00:00:00
+ */
+function addYears(dirtyDate, dirtyAmount) {
+  index.requiredArgs(2, arguments);
+  var amount = index.toInteger(dirtyAmount);
+  return addMonths(dirtyDate, amount * 12);
+}
+
+/**
+ * @name subYears
+ * @category Year Helpers
+ * @summary Subtract the specified number of years from the given date.
+ *
+ * @description
+ * Subtract the specified number of years from the given date.
+ *
+ * @param {Date|Number} date - the date to be changed
+ * @param {Number} amount - the amount of years to be subtracted. Positive decimals will be rounded using `Math.floor`, decimals less than zero will be rounded using `Math.ceil`.
+ * @returns {Date} the new date with the years subtracted
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Subtract 5 years from 1 September 2014:
+ * const result = subYears(new Date(2014, 8, 1), 5)
+ * //=> Tue Sep 01 2009 00:00:00
+ */
+function subYears(dirtyDate, dirtyAmount) {
+  index.requiredArgs(2, arguments);
+  var amount = index.toInteger(dirtyAmount);
+  return addYears(dirtyDate, -amount);
+}
+
+var KeyNames;
+(function (KeyNames) {
+    KeyNames["ArrowUp"] = "ArrowUp";
+    KeyNames["ArrowDown"] = "ArrowDown";
+    KeyNames["ArrowLeft"] = "ArrowLeft";
+    KeyNames["ArrowRight"] = "ArrowRight";
+    KeyNames["Home"] = "Home";
+    KeyNames["End"] = "End";
+    KeyNames["PageUp"] = "PageUp";
+    KeyNames["PageDown"] = "PageDown";
+    KeyNames["Tab"] = "Tab";
+    KeyNames["Enter"] = "Enter";
+    KeyNames["Space"] = " ";
+})(KeyNames || (KeyNames = {}));
+
+var getKeyDownDate = function (_a) {
+    var key = _a.key, shiftKey = _a.shiftKey, focusDate = _a.focusDate;
+    switch (key) {
+        case KeyNames.ArrowDown:
+            return addWeeks(focusDate, 1);
+        case KeyNames.ArrowLeft:
+            return subDays(focusDate, 1);
+        case KeyNames.ArrowRight:
+            return addDays(focusDate, 1);
+        case KeyNames.ArrowUp:
+            return subWeeks(focusDate, 1);
+        case KeyNames.Home:
+            return dateWithoutTime(startOfWeek(focusDate, { weekStartsOn: 1 }));
+        case KeyNames.End:
+            return dateWithoutTime(endOfWeek(focusDate, { weekStartsOn: 1 }));
+        case KeyNames.PageUp:
+            return shiftKey ? subYears(focusDate, 1) : subMonths(focusDate, 1);
+        case KeyNames.PageDown:
+            return shiftKey ? addYears(focusDate, 1) : addMonths(focusDate, 1);
+        default:
+            return focusDate;
+    }
+};
+
+/**
+ * @name endOfDay
+ * @category Day Helpers
+ * @summary Return the end of a day for the given date.
+ *
+ * @description
+ * Return the end of a day for the given date.
+ * The result will be in the local timezone.
+ *
+ * @param {Date|Number} date - the original date
+ * @returns {Date} the end of a day
+ * @throws {TypeError} 1 argument required
+ *
+ * @example
+ * // The end of a day for 2 September 2014 11:55:00:
+ * const result = endOfDay(new Date(2014, 8, 2, 11, 55, 0))
+ * //=> Tue Sep 02 2014 23:59:59.999
+ */
+function endOfDay(dirtyDate) {
+  index.requiredArgs(1, arguments);
+  var date = index.toDate(dirtyDate);
+  date.setHours(23, 59, 59, 999);
+  return date;
+}
+
+/**
+ * @name endOfMonth
+ * @category Month Helpers
+ * @summary Return the end of a month for the given date.
+ *
+ * @description
+ * Return the end of a month for the given date.
+ * The result will be in the local timezone.
+ *
+ * @param {Date|Number} date - the original date
+ * @returns {Date} the end of a month
+ * @throws {TypeError} 1 argument required
+ *
+ * @example
+ * // The end of a month for 2 September 2014 11:55:00:
+ * const result = endOfMonth(new Date(2014, 8, 2, 11, 55, 0))
+ * //=> Tue Sep 30 2014 23:59:59.999
+ */
+function endOfMonth(dirtyDate) {
+  index.requiredArgs(1, arguments);
+  var date = index.toDate(dirtyDate);
+  var month = date.getMonth();
+  date.setFullYear(date.getFullYear(), month + 1, 0);
+  date.setHours(23, 59, 59, 999);
+  return date;
+}
+
+/**
+ * @name isLastDayOfMonth
+ * @category Month Helpers
+ * @summary Is the given date the last day of a month?
+ *
+ * @description
+ * Is the given date the last day of a month?
+ *
+ * @param {Date|Number} date - the date to check
+ * @returns {Boolean} the date is the last day of a month
+ * @throws {TypeError} 1 argument required
+ *
+ * @example
+ * // Is 28 February 2014 the last day of a month?
+ * const result = isLastDayOfMonth(new Date(2014, 1, 28))
+ * //=> true
+ */
+function isLastDayOfMonth(dirtyDate) {
+  index.requiredArgs(1, arguments);
+  var date = index.toDate(dirtyDate);
+  return endOfDay(date).getTime() === endOfMonth(date).getTime();
+}
+
+/**
+ * @name isFirstDayOfMonth
+ * @category Month Helpers
+ * @summary Is the given date the first day of a month?
+ *
+ * @description
+ * Is the given date the first day of a month?
+ *
+ * @param {Date|Number} date - the date to check
+ * @returns {Boolean} the date is the first day of a month
+ * @throws {TypeError} 1 argument required
+ *
+ * @example
+ * // Is 1 September 2014 the first day of a month?
+ * const result = isFirstDayOfMonth(new Date(2014, 8, 1))
+ * //=> true
+ */
+function isFirstDayOfMonth(dirtyDate) {
+  index.requiredArgs(1, arguments);
+  return index.toDate(dirtyDate).getDate() === 1;
+}
+
+/**
+ * @name getDate
+ * @category Day Helpers
+ * @summary Get the day of the month of the given date.
+ *
+ * @description
+ * Get the day of the month of the given date.
+ *
+ * @param {Date|Number} date - the given date
+ * @returns {Number} the day of month
+ * @throws {TypeError} 1 argument required
+ *
+ * @example
+ * // Which day of the month is 29 February 2012?
+ * const result = getDate(new Date(2012, 1, 29))
+ * //=> 29
+ */
+function getDate(dirtyDate) {
+  index.requiredArgs(1, arguments);
+  var date = index.toDate(dirtyDate);
+  var dayOfMonth = date.getDate();
+  return dayOfMonth;
+}
+
+/**
+ * @name isEqual
+ * @category Common Helpers
+ * @summary Are the given dates equal?
+ *
+ * @description
+ * Are the given dates equal?
+ *
+ * @param {Date|Number} dateLeft - the first date to compare
+ * @param {Date|Number} dateRight - the second date to compare
+ * @returns {Boolean} the dates are equal
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Are 2 July 2014 06:30:45.000 and 2 July 2014 06:30:45.500 equal?
+ * const result = isEqual(
+ *   new Date(2014, 6, 2, 6, 30, 45, 0),
+ *   new Date(2014, 6, 2, 6, 30, 45, 500)
+ * )
+ * //=> false
+ */
+function isEqual(dirtyLeftDate, dirtyRightDate) {
+  index.requiredArgs(2, arguments);
+  var dateLeft = index.toDate(dirtyLeftDate);
+  var dateRight = index.toDate(dirtyRightDate);
+  return dateLeft.getTime() === dateRight.getTime();
+}
+
+var ArcCalendarContext = React.createContext(null);
+
+var CalendarDayNumber = React.forwardRef(function (_a, autoFocusRef) {
+    var date = _a.date, shouldRender = _a.shouldRender, isFocusWithinDayGrid = _a.isFocusWithinDayGrid;
+    var context = React.useContext(ArcCalendarContext);
+    var isFocusDate = context && isEqual(date, context.focusDate);
+    var tableCellRef = React.useCallback(function (el) {
+        if (el && isFocusDate && isFocusWithinDayGrid) {
+            el.focus();
+        }
+    }, [isFocusDate, isFocusWithinDayGrid]);
+    if (!context) {
+        return null;
+    }
+    var handleRefs = function (el) {
+        tableCellRef(el);
+        if (autoFocusRef && typeof autoFocusRef === "function") {
+            autoFocusRef(el);
+        }
+    };
+    var disabledDates = context.disabledDates, selectedDate = context.selectedDate, selectionType = context.selectionType, selectedRange = context.selectedRange, highlightedRange = context.highlightedRange, todayDate = context.todayDate, onDayNumberClick = context.onDayNumberClick, onDayNumberHover = context.onDayNumberHover, minDate = context.minDate, maxDate = context.maxDate;
+    var highlightedRangeStart = highlightedRange[0];
+    var highlightedRangeEnd = highlightedRange[1];
+    var isSelectedDate = selectionType === "single"
+        ? isEqual(date, selectedDate)
+        : selectedRange.length &&
+            containsDate(selectedRange.filter(function (date) { return Boolean(date); }), date);
+    var isTodayDate = isEqual(date, todayDate);
+    var dateIsWithinHighlightedRange = selectionType === "range" &&
+        highlightedRange.length === 2 &&
+        !isAfter(date, highlightedRangeEnd) &&
+        !isBefore(date, highlightedRangeStart);
+    var isRoundedLeft = selectionType === "range" &&
+        (isDay(date, WeekDays.MONDAY) ||
+            isFirstDayOfMonth(date) ||
+            isEqual(date, highlightedRangeStart));
+    var isRoundedRight = selectionType === "range" &&
+        (isDay(date, WeekDays.SUNDAY) ||
+            isLastDayOfMonth(date) ||
+            isEqual(date, highlightedRangeEnd));
+    var conditionalClasses = {
+        "arc-CalendarDayNumber--selected": isSelectedDate,
+        "arc-CalendarDayNumber--todayDate": isTodayDate,
+        "arc-CalendarDayNumber--hightlightedRange": dateIsWithinHighlightedRange,
+        "arc-CalendarDayNumber--hightlightedRangeRoundedLeft": isRoundedLeft,
+        "arc-CalendarDayNumber--hightlightedRangeRoundedRight": isRoundedRight,
+    };
+    var isAriaSelected = isSelectedDate ||
+        (dateIsWithinHighlightedRange && selectedRange.length === 2);
+    var tableCellProps = {
+        className: index$1.classNames("arc-CalendarDayNumber", conditionalClasses),
+        tabIndex: isFocusDate && shouldRender ? 0 : -1,
+        "aria-current": isTodayDate ? "date" : undefined,
+        "aria-selected": isAriaSelected,
+        "aria-disabled": isDisabledDate(date, disabledDates, minDate, maxDate),
+        onClick: onDayNumberClick(date),
+        onMouseEnter: onDayNumberHover(date),
+    };
+    return (React.createElement("td", filterAttrs.__assign({ ref: handleRefs, "data-date": date.getTime() }, (shouldRender ? tableCellProps : {}), { role: "gridcell" }), shouldRender && (React.createElement(React.Fragment, null,
+        React.createElement(VisuallyHidden.VisuallyHidden, null, index.format(date, "MMMM do, yyyy")),
+        React.createElement("div", { className: "arc-CalendarDayNumber-buttonOuter" },
+            React.createElement("div", { className: "arc-CalendarDayNumber-buttonInner" },
+                React.createElement(Text.Text, { size: "s" },
+                    React.createElement("span", { "aria-hidden": true }, getDate(date)))))))));
+});
+
+const BtIconChevronDownMid = (props) =>
+  /*#__PURE__*/ React.createElement(
+    "svg",
+    Object.assign(
+      {
+        viewBox: "0 0 32 32",
+        fill: "none",
+        xmlns: "http://www.w3.org/2000/svg",
+      },
+      props,
+    ),
+    /*#__PURE__*/ React.createElement("path", {
+      fillRule: "evenodd",
+      clipRule: "evenodd",
+      d: "M16.0001 18.0909L21.7041 12.3935C21.9566 12.1415 22.2987 12 22.6554 12C23.0121 12 23.3543 12.1415 23.6068 12.3935C23.7316 12.5181 23.8306 12.6661 23.8982 12.829C23.9657 12.9919 24.0005 13.1665 24.0005 13.3429C24.0005 13.5192 23.9657 13.6938 23.8982 13.8567C23.8306 14.0196 23.7316 14.1676 23.6068 14.2922L16.9508 20.9402C16.6983 21.1918 16.3565 21.3331 16.0001 21.3331C15.6437 21.3331 15.3018 21.1918 15.0494 20.9402L8.39342 14.2922C8.26861 14.1676 8.16959 14.0196 8.10202 13.8567C8.03446 13.6938 7.99969 13.5192 7.99969 13.3429C7.99969 13.1665 8.03446 12.9919 8.10202 12.829C8.16959 12.6661 8.26861 12.5181 8.39342 12.3935C8.6459 12.1415 8.98804 12 9.34475 12C9.70147 12 10.0436 12.1415 10.2961 12.3935L16.0001 18.0909Z",
+      fill: "currentColor",
+    }),
+  );
+
+var CalendarDateSelect = function (_a) {
+    var ariaLabel = _a.ariaLabel, onChange = _a.onChange, name = _a.name, value = _a.value, displayValue = _a.displayValue, options = _a.options;
+    return (React.createElement("div", { className: "arc-CalendarDateSelect-wrapper" },
+        React.createElement("select", { "aria-label": ariaLabel, onChange: onChange, className: "arc-CalendarDateSelect", value: value, name: name }, options.map(function (_a) {
+            var text = _a.text, value = _a.value;
+            return (React.createElement("option", { className: "arc-CalendarDateSelect-option", key: "arc-calendar-year-select-".concat(value), value: value }, text));
+        })),
+        React.createElement("div", { "aria-hidden": true, className: "arc-CalendarDateSelect-label" },
+            React.createElement(Heading.Heading, { size: "s" }, displayValue || value),
+            React.createElement("div", { className: "arc-CalendarDateSelect-icon" },
+                React.createElement(Icon.Icon, { size: 24, icon: BtIconChevronDownMid })))));
+};
+
+/**
+ * @name isSameMonth
+ * @category Month Helpers
+ * @summary Are the given dates in the same month (and year)?
+ *
+ * @description
+ * Are the given dates in the same month (and year)?
+ *
+ * @param {Date|Number} dateLeft - the first date to check
+ * @param {Date|Number} dateRight - the second date to check
+ * @returns {Boolean} the dates are in the same month (and year)
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Are 2 September 2014 and 25 September 2014 in the same month?
+ * const result = isSameMonth(new Date(2014, 8, 2), new Date(2014, 8, 25))
+ * //=> true
+ *
+ * @example
+ * // Are 2 September 2014 and 25 September 2015 in the same month?
+ * const result = isSameMonth(new Date(2014, 8, 2), new Date(2015, 8, 25))
+ * //=> false
+ */
+function isSameMonth(dirtyDateLeft, dirtyDateRight) {
+  index.requiredArgs(2, arguments);
+  var dateLeft = index.toDate(dirtyDateLeft);
+  var dateRight = index.toDate(dirtyDateRight);
+  return dateLeft.getFullYear() === dateRight.getFullYear() && dateLeft.getMonth() === dateRight.getMonth();
+}
+
+/**
+ * @name eachWeekOfInterval
+ * @category Interval Helpers
+ * @summary Return the array of weeks within the specified time interval.
+ *
+ * @description
+ * Return the array of weeks within the specified time interval.
+ *
+ * @param {Interval} interval - the interval. See [Interval]{@link https://date-fns.org/docs/Interval}
+ * @param {Object} [options] - an object with options.
+ * @param {Locale} [options.locale=defaultLocale] - the locale object. See [Locale]{@link https://date-fns.org/docs/Locale}
+ * @param {0|1|2|3|4|5|6} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)
+ * @returns {Date[]} the array with starts of weeks from the week of the interval start to the week of the interval end
+ * @throws {TypeError} 1 argument required
+ * @throws {RangeError} `options.weekStartsOn` must be 0, 1, ..., 6
+ * @throws {RangeError} The start of an interval cannot be after its end
+ * @throws {RangeError} Date in interval cannot be `Invalid Date`
+ *
+ * @example
+ * // Each week within interval 6 October 2014 - 23 November 2014:
+ * const result = eachWeekOfInterval({
+ *   start: new Date(2014, 9, 6),
+ *   end: new Date(2014, 10, 23)
+ * })
+ * //=> [
+ * //   Sun Oct 05 2014 00:00:00,
+ * //   Sun Oct 12 2014 00:00:00,
+ * //   Sun Oct 19 2014 00:00:00,
+ * //   Sun Oct 26 2014 00:00:00,
+ * //   Sun Nov 02 2014 00:00:00,
+ * //   Sun Nov 09 2014 00:00:00,
+ * //   Sun Nov 16 2014 00:00:00,
+ * //   Sun Nov 23 2014 00:00:00
+ * // ]
+ */
+function eachWeekOfInterval(dirtyInterval, options) {
+  index.requiredArgs(1, arguments);
+  var interval = dirtyInterval || {};
+  var startDate = index.toDate(interval.start);
+  var endDate = index.toDate(interval.end);
+  var endTime = endDate.getTime();
+
+  // Throw an exception if start date is after end date or if any date is `Invalid Date`
+  if (!(startDate.getTime() <= endTime)) {
+    throw new RangeError('Invalid interval');
+  }
+  var startDateWeek = startOfWeek(startDate, options);
+  var endDateWeek = startOfWeek(endDate, options);
+
+  // Some timezones switch DST at midnight, making start of day unreliable in these timezones, 3pm is a safe bet
+  startDateWeek.setHours(15);
+  endDateWeek.setHours(15);
+  endTime = endDateWeek.getTime();
+  var weeks = [];
+  var currentWeek = startDateWeek;
+  while (currentWeek.getTime() <= endTime) {
+    currentWeek.setHours(0);
+    weeks.push(index.toDate(currentWeek));
+    currentWeek = addWeeks(currentWeek, 1);
+    currentWeek.setHours(15);
+  }
+  return weeks;
+}
+
+var DAY_NAMES = [
+    {
+        value: WeekDays.MONDAY,
+        displayValue: WeekDaysAbbr.MON,
+    },
+    {
+        value: WeekDays.TUESDAY,
+        displayValue: WeekDaysAbbr.TUE,
+    },
+    {
+        value: WeekDays.WEDNESDAY,
+        displayValue: WeekDaysAbbr.WED,
+    },
+    {
+        value: WeekDays.THURSDAY,
+        displayValue: WeekDaysAbbr.THUR,
+    },
+    {
+        value: WeekDays.FRIDAY,
+        displayValue: WeekDaysAbbr.FRI,
+    },
+    {
+        value: WeekDays.SATURDAY,
+        displayValue: WeekDaysAbbr.SAT,
+    },
+    {
+        value: WeekDays.SUNDAY,
+        displayValue: WeekDaysAbbr.SUN,
+    },
+];
+
+var CalendarDayGrid = function (_a) {
+    var displayRange = _a.displayRange;
+    var hasAutoFocused = React.useRef(false);
+    var dayNumberGridRef = React.useRef(null);
+    var context = React.useContext(ArcCalendarContext);
+    var autoFocusRef = React.useCallback(function (el) {
+        if (el &&
+            el.tabIndex === 0 &&
+            (context === null || context === void 0 ? void 0 : context.autoFocusOnMount) &&
+            !hasAutoFocused.current) {
+            el.focus();
+        }
+        if (document.activeElement === el) {
+            hasAutoFocused.current = true;
+        }
+    }, [context === null || context === void 0 ? void 0 : context.autoFocusOnMount]);
+    if (!context) {
+        return null;
+    }
+    var onKeyboardNavigate = context.onKeyboardNavigate, onDayNumberClick = context.onDayNumberClick, onDayGridLeave = context.onDayGridLeave;
+    var isFocusWithinDayGrid = Boolean(dayNumberGridRef &&
+        dayNumberGridRef.current &&
+        dayNumberGridRef.current.contains(document.activeElement));
+    var handleKeyDown = function (e) {
+        var key = e.key;
+        var newDate = e.target.getAttribute("data-date");
+        if (key === KeyNames.Tab) {
+            return;
+        }
+        if (Object.values(KeyNames).includes(key)) {
+            e.preventDefault();
+        }
+        if ([KeyNames.Space, KeyNames.Enter].includes(key) && newDate) {
+            onDayNumberClick(dateWithoutTime(new Date(parseInt(newDate))))();
+        }
+        else {
+            onKeyboardNavigate(e.key, e.shiftKey);
+        }
+    };
+    var getWeeksInMonth = function (month) {
+        return eachWeekOfInterval({ start: startOfMonth(month), end: endOfMonth(month) }, { weekStartsOn: 1 }).map(function (week) { return eachDayOfInterval({ start: week, end: addDays(week, 6) }); });
+    };
+    return (React.createElement("div", { ref: dayNumberGridRef, onMouseLeave: onDayGridLeave, className: index$1.classNames("arc-CalendarDayGrid", {
+            "arc-CalendarDayGrid--dual": displayRange.length > 1,
+        }) }, displayRange.map(function (month) { return (React.createElement("div", { key: month.getTime(), className: "arc-CalendarDayGrid-month" },
+        React.createElement("table", { className: "arc-CalendarDayGrid-table" },
+            React.createElement("thead", null,
+                React.createElement("tr", null, DAY_NAMES.map(function (dayName) { return (React.createElement("th", { key: "".concat(month.getTime(), "-").concat(dayName.displayValue) },
+                    React.createElement(Text.Text, { key: dayName.displayValue, size: "s" },
+                        React.createElement("b", { "aria-hidden": true }, dayName.displayValue)),
+                    React.createElement(VisuallyHidden.VisuallyHidden, null, dayName.value))); }))),
+            React.createElement("tbody", { onKeyDown: handleKeyDown }, getWeeksInMonth(month).map(function (week, i) { return (React.createElement("tr", { key: "".concat(month.getTime(), "-week-").concat(i) }, week.map(function (day) { return (React.createElement(CalendarDayNumber, { ref: autoFocusRef, shouldRender: isSameMonth(month, day), key: day.getTime(), date: day, isFocusWithinDayGrid: isFocusWithinDayGrid })); }))); }))))); })));
+};
+
+const BtIconChevronLeftMid = (props) =>
+  /*#__PURE__*/ React.createElement(
+    "svg",
+    Object.assign(
+      {
+        viewBox: "0 0 16 16",
+        fill: "none",
+        xmlns: "http://www.w3.org/2000/svg",
+      },
+      props,
+    ),
+    /*#__PURE__*/ React.createElement("path", {
+      fillRule: "evenodd",
+      clipRule: "evenodd",
+      d: "M7.62107 8.00023L10.4697 10.8522C10.5957 10.9785 10.6665 11.1495 10.6665 11.3279C10.6665 11.5063 10.5957 11.6773 10.4697 11.8036C10.4074 11.866 10.3335 11.9155 10.252 11.9493C10.1706 11.983 10.0833 12.0004 9.99507 12.0004C9.9069 12.0004 9.81959 11.983 9.73814 11.9493C9.65669 11.9155 9.5827 11.866 9.52041 11.8036L6.19641 8.47556C6.07061 8.34935 5.99998 8.17842 5.99998 8.00023C5.99998 7.82203 6.07061 7.6511 6.19641 7.52489L9.52041 4.19689C9.5827 4.13449 9.65669 4.08498 9.73814 4.0512C9.81959 4.01741 9.9069 4.00003 9.99507 4.00003C10.0832 4.00003 10.1706 4.01741 10.252 4.0512C10.3335 4.08498 10.4074 4.13449 10.4697 4.19689C10.5957 4.32313 10.6665 4.4942 10.6665 4.67256C10.6665 4.85092 10.5957 5.02199 10.4697 5.14823L7.62107 8.00023Z",
+      fill: "currentColor",
+    }),
+  );
+
+var CalendarNavButton = function (_a) {
+    var isDisabled = _a.isDisabled, onClick = _a.onClick, direction = _a.direction, ariaLabel = _a.ariaLabel;
+    var icons = {
+        previous: BtIconChevronLeftMid,
+        next: BtIconChevronRightMid.BtIconChevronRightMid,
+    };
+    return (React.createElement("button", { "aria-label": ariaLabel, disabled: isDisabled, onClick: onClick, type: "button", className: index$1.classNames("arc-CalendarNavButton", {
+            "arc-CalendarNavButton--previous": direction === "previous",
+            "arc-CalendarNavButton--next": direction === "next",
+        }) },
+        React.createElement(Icon.Icon, { size: 32, icon: icons[direction] })));
+};
+
+var CalendarDoubleMonthView = function (_a) {
+    var isPreviousMonthDisabled = _a.isPreviousMonthDisabled, isNextMonthDisabled = _a.isNextMonthDisabled, onNextMonthClick = _a.onNextMonthClick, onPreviousMonthClick = _a.onPreviousMonthClick;
+    var context = React.useContext(ArcCalendarContext);
+    if (!context) {
+        return null;
+    }
+    var displayDate = context.displayDate;
+    var displayRange = getDoubleMonthDisplayRange(displayDate);
+    var getAriaLabel = function (date) {
+        var months = getDoubleMonthDisplayRange(date);
+        return "show ".concat(index.format(months[0], "MMMM yyyy"), " to ").concat(index.format(months[1], "MMMM yyyy"));
+    };
+    return (React.createElement(React.Fragment, null,
+        React.createElement(VisuallyHidden.VisuallyHidden, null,
+            React.createElement(Heading.Heading, { level: "2" },
+                React.createElement("span", { "aria-live": "polite" },
+                    "showing ",
+                    index.format(displayRange[0], "MMMM yyyy"),
+                    " to",
+                    " ",
+                    index.format(displayRange[1], "MMMM yyyy")))),
+        React.createElement("div", { className: "arc-CalendarDoubleMonthView-header" },
+            React.createElement("div", { className: "arc-CalendarDoubleMonthView-headerMonth" },
+                React.createElement("div", { className: "arc-CalendarDoubleMonthView-headerMonthItem" },
+                    React.createElement(CalendarNavButton, { ariaLabel: getAriaLabel(subMonths(displayDate, 2)), direction: "previous", isDisabled: isPreviousMonthDisabled, onClick: onPreviousMonthClick })),
+                React.createElement("div", { "aria-hidden": true, className: "arc-CalendarDoubleMonthView-headerMonthItem" },
+                    React.createElement(Heading.Heading, { level: "2", size: "s" }, index.format(displayRange[0], "MMM yyyy")))),
+            React.createElement("div", { className: "arc-CalendarDoubleMonthView-headerMonth" },
+                React.createElement("div", { "aria-hidden": true, className: "arc-CalendarDoubleMonthView-headerMonthItem" },
+                    React.createElement(Heading.Heading, { level: "2", size: "s" }, index.format(displayRange[1], "MMM yyyy"))),
+                React.createElement("div", { className: "arc-CalendarDoubleMonthView-headerMonthItem" },
+                    React.createElement(CalendarNavButton, { ariaLabel: getAriaLabel(addMonths(displayDate, 2)), direction: "next", isDisabled: isNextMonthDisabled, onClick: onNextMonthClick })))),
+        React.createElement(CalendarDayGrid, { displayRange: displayRange })));
+};
+
+var CalendarMonthView = function (_a) {
+    var isPreviousMonthDisabled = _a.isPreviousMonthDisabled, isNextMonthDisabled = _a.isNextMonthDisabled, onNextMonthClick = _a.onNextMonthClick, onPreviousMonthClick = _a.onPreviousMonthClick;
+    var context = React.useContext(ArcCalendarContext);
+    if (!context) {
+        return null;
+    }
+    var displayDate = context.displayDate;
+    return (React.createElement(React.Fragment, null,
+        React.createElement("div", { className: "arc-CalendarMonthView-header" },
+            React.createElement(CalendarNavButton, { ariaLabel: "Show ".concat(index.format(subMonths(displayDate, 1), "MMMM yyyy")), direction: "previous", isDisabled: isPreviousMonthDisabled, onClick: onPreviousMonthClick }),
+            React.createElement("div", { className: "arc-CalendarMonthView-headingContainer" },
+                React.createElement(VisuallyHidden.VisuallyHidden, null,
+                    React.createElement(Heading.Heading, { level: "2" },
+                        React.createElement("span", { "aria-live": "polite" },
+                            "showing ",
+                            index.format(displayDate, "MMMM yyyy")))),
+                React.createElement("div", { "aria-hidden": true },
+                    React.createElement(Heading.Heading, { size: "s", level: "2" }, index.format(displayDate, "MMM yyyy")))),
+            React.createElement(CalendarNavButton, { direction: "next", ariaLabel: "Show ".concat(index.format(addMonths(displayDate, 1), "MMMM yyyy")), isDisabled: isNextMonthDisabled, onClick: onNextMonthClick })),
+        React.createElement(CalendarDayGrid, { displayRange: [displayDate] })));
+};
+
+var CalendarMonthYearView = function (_a) {
+    var isPreviousMonthDisabled = _a.isPreviousMonthDisabled, isNextMonthDisabled = _a.isNextMonthDisabled, onMonthChange = _a.onMonthChange, onYearChange = _a.onYearChange, onNextMonthClick = _a.onNextMonthClick, onPreviousMonthClick = _a.onPreviousMonthClick;
+    var context = React.useContext(ArcCalendarContext);
+    if (!context) {
+        return null;
+    }
+    var displayDate = context.displayDate, minDate = context.minDate, maxDate = context.maxDate;
+    var monthOptions = Array.from({ length: 12 })
+        .map(function (_, i) { return ({
+        value: i,
+        text: index.format(new Date(2023, i, 1), "MMMM"),
+    }); })
+        .filter(function (_a) {
+        var value = _a.value;
+        var currentDateYear = getYear(displayDate);
+        var date = dateWithoutTime(new Date(currentDateYear, value, 1));
+        return ((!minDate || !isMonthBeforeMinDate(date, minDate)) &&
+            (!maxDate || !isMonthAfterMaxDate(date, maxDate)));
+    });
+    var yearOptions = Array.from({ length: 21 }, function (_, i) {
+        var value = getYear(displayDate) - 10 + i;
+        return {
+            value: value,
+            text: value,
+        };
+    }).filter(function (_a) {
+        var value = _a.value;
+        return ((minDate ? value >= getYear(minDate) : true) &&
+            (maxDate ? value <= getYear(maxDate) : true));
+    });
+    return (React.createElement(React.Fragment, null,
+        React.createElement("div", { className: "arc-CalendarMonthYearView-header" },
+            React.createElement(VisuallyHidden.VisuallyHidden, null,
+                React.createElement(Heading.Heading, { level: "2" },
+                    React.createElement("span", { "aria-live": "polite" },
+                        "showing ",
+                        index.format(displayDate, "MMMM yyyy")))),
+            React.createElement("div", { className: "arc-CalendarMonthYearView-selectWrapper" },
+                React.createElement("div", null,
+                    React.createElement(CalendarDateSelect, { options: monthOptions, ariaLabel: "month", onChange: function (e) { return onMonthChange(parseInt(e.target.value)); }, name: "arc-CalendarMonthYearView-monthSelect", displayValue: index.format(displayDate, "MMM"), value: "".concat(getMonth(displayDate)) })),
+                React.createElement("div", { className: "arc-CalendarMonthYearView-yearSelectContainer" },
+                    React.createElement(CalendarDateSelect, { options: yearOptions, ariaLabel: "year", onChange: function (e) { return onYearChange(parseInt(e.target.value)); }, name: "arc-CalendarMonthYearView-yearSelect", value: getYear(displayDate) }))),
+            React.createElement("div", { className: "arc-CalendarMonthYearView-navButtonContainer" },
+                React.createElement(CalendarNavButton, { direction: "previous", ariaLabel: "Show ".concat(index.format(subMonths(displayDate, 1), "MMMM yyyy")), isDisabled: isPreviousMonthDisabled, onClick: onPreviousMonthClick }),
+                React.createElement(CalendarNavButton, { direction: "next", ariaLabel: "Show ".concat(index.format(addMonths(displayDate, 1), "MMMM yyyy")), isDisabled: isNextMonthDisabled, onClick: onNextMonthClick }))),
+        React.createElement(CalendarDayGrid, { displayRange: [displayDate] })));
+};
+
+var showPreviousMonthHandler = function (payload, state) {
+    return filterAttrs.__assign(filterAttrs.__assign({}, state), { focusDate: getFocusDate({
+            date: subMonths(state.focusDate, 1),
+            minDate: payload.minDate,
+        }), displayDate: subMonths(state.displayDate, 1) });
+};
+
+var showNextMonthHandler = function (payload, state) {
+    return filterAttrs.__assign(filterAttrs.__assign({}, state), { focusDate: getFocusDate({
+            date: addMonths(state.focusDate, 1),
+            maxDate: payload.maxDate,
+        }), displayDate: addMonths(state.displayDate, 1) });
+};
+
+var showPreviousDoubleMonthHandler = function (payload, state) {
+    return filterAttrs.__assign(filterAttrs.__assign({}, state), { focusDate: getFocusDate({
+            date: subMonths(state.focusDate, 2),
+            minDate: payload.minDate,
+        }), displayDate: subMonths(state.displayDate, 2) });
+};
+
+var showNextDoubleMonthHandler = function (payload, state) {
+    return filterAttrs.__assign(filterAttrs.__assign({}, state), { focusDate: getFocusDate({
+            date: addMonths(state.focusDate, 2),
+            maxDate: payload.maxDate,
+        }), displayDate: addMonths(state.displayDate, 2) });
+};
+
+var rangeSelectHandler = function (payload, state) {
+    return filterAttrs.__assign(filterAttrs.__assign({}, state), { focusDate: payload.date, highlightedRange: payload.range });
+};
+
+var highlightRangeHandler = function (payload, state) {
+    return filterAttrs.__assign(filterAttrs.__assign({}, state), { highlightedRange: getHighlightRange({
+            date: payload.date,
+            range: payload.range,
+            minDate: payload.minDate,
+            maxDate: payload.maxDate,
+        }) });
+};
+
+var dayNumberSelectHandler = function (payload, state) {
+    return filterAttrs.__assign(filterAttrs.__assign({}, state), { focusDate: payload });
+};
+
+var dayGridLeaveHandler = function (payload, state) {
+    if (payload.selectionType === "range" &&
+        payload.range.filter(function (date) { return Boolean(date); }).length === 1) {
+        return filterAttrs.__assign(filterAttrs.__assign({}, state), { highlightedRange: [] });
+    }
+    return filterAttrs.__assign({}, state);
+};
+
+var dropDownChangeYearHandler = function (payload, state) {
+    var year = payload.year, minDate = payload.minDate, maxDate = payload.maxDate;
+    var yearsToAdd = year - getYear(state.displayDate);
+    var newDisplayDate = addYears(state.displayDate, yearsToAdd);
+    var focusDate = getFocusDate({
+        date: addYears(state.focusDate, yearsToAdd),
+        minDate: payload.minDate,
+        maxDate: payload.maxDate,
+    });
+    if (minDate && isBefore(newDisplayDate, minDate)) {
+        return filterAttrs.__assign(filterAttrs.__assign({}, state), { focusDate: focusDate, displayDate: minDate });
+    }
+    if (maxDate && isAfter(newDisplayDate, maxDate)) {
+        return filterAttrs.__assign(filterAttrs.__assign({}, state), { focusDate: focusDate, displayDate: maxDate });
+    }
+    return filterAttrs.__assign(filterAttrs.__assign({}, state), { focusDate: focusDate, displayDate: newDisplayDate });
+};
+
+var dropDownChangeMonthHandler = function (payload, state) {
+    return filterAttrs.__assign(filterAttrs.__assign({}, state), { focusDate: getFocusDate({
+            date: setMonth(state.focusDate, payload.month),
+            minDate: payload.minDate,
+            maxDate: payload.maxDate,
+        }), displayDate: setMonth(state.displayDate, payload.month) });
+};
+
+/**
+ * @name isWithinInterval
+ * @category Interval Helpers
+ * @summary Is the given date within the interval?
+ *
+ * @description
+ * Is the given date within the interval? (Including start and end.)
+ *
+ * @param {Date|Number} date - the date to check
+ * @param {Interval} interval - the interval to check
+ * @returns {Boolean} the date is within the interval
+ * @throws {TypeError} 2 arguments required
+ * @throws {RangeError} The start of an interval cannot be after its end
+ * @throws {RangeError} Date in interval cannot be `Invalid Date`
+ *
+ * @example
+ * // For the date within the interval:
+ * isWithinInterval(new Date(2014, 0, 3), {
+ *   start: new Date(2014, 0, 1),
+ *   end: new Date(2014, 0, 7)
+ * })
+ * //=> true
+ *
+ * @example
+ * // For the date outside of the interval:
+ * isWithinInterval(new Date(2014, 0, 10), {
+ *   start: new Date(2014, 0, 1),
+ *   end: new Date(2014, 0, 7)
+ * })
+ * //=> false
+ *
+ * @example
+ * // For date equal to interval start:
+ * isWithinInterval(date, { start, end: date }) // => true
+ *
+ * @example
+ * // For date equal to interval end:
+ * isWithinInterval(date, { start: date, end }) // => true
+ */
+function isWithinInterval(dirtyDate, interval) {
+  index.requiredArgs(2, arguments);
+  var time = index.toDate(dirtyDate).getTime();
+  var startTime = index.toDate(interval.start).getTime();
+  var endTime = index.toDate(interval.end).getTime();
+
+  // Throw an exception if start date is after end date or if any date is `Invalid Date`
+  if (!(startTime <= endTime)) {
+    throw new RangeError('Invalid interval');
+  }
+  return time >= startTime && time <= endTime;
+}
+
+/**
+ * @name setYear
+ * @category Year Helpers
+ * @summary Set the year to the given date.
+ *
+ * @description
+ * Set the year to the given date.
+ *
+ * @param {Date|Number} date - the date to be changed
+ * @param {Number} year - the year of the new date
+ * @returns {Date} the new date with the year set
+ * @throws {TypeError} 2 arguments required
+ *
+ * @example
+ * // Set year 2013 to 1 September 2014:
+ * const result = setYear(new Date(2014, 8, 1), 2013)
+ * //=> Sun Sep 01 2013 00:00:00
+ */
+function setYear(dirtyDate, dirtyYear) {
+  index.requiredArgs(2, arguments);
+  var date = index.toDate(dirtyDate);
+  var year = index.toInteger(dirtyYear);
+
+  // Check if date is Invalid Date because Date.prototype.setFullYear ignores the value of Invalid Date
+  if (isNaN(date.getTime())) {
+    return new Date(NaN);
+  }
+  date.setFullYear(year);
+  return date;
+}
+
+var calendarKeydownHandler = function (payload, state) {
+    var displayDate = state.displayDate, focusDate = state.focusDate, highlightedRange = state.highlightedRange;
+    var minDate = payload.minDate, maxDate = payload.maxDate, calendarType = payload.calendarType, key = payload.key, shiftKey = payload.shiftKey, range = payload.range, selectionType = payload.selectionType;
+    var isNavigatingByYear = shiftKey && [KeyNames.PageUp, KeyNames.PageDown].includes(key);
+    var keyDownDate = getKeyDownDate({
+        focusDate: focusDate,
+        key: key,
+        shiftKey: shiftKey,
+    });
+    var newFocusDate = getFocusDate({
+        minDate: minDate,
+        maxDate: maxDate,
+        date: keyDownDate,
+    });
+    var newHighlightedRange = selectionType === "range"
+        ? getHighlightRange({
+            date: keyDownDate,
+            range: range,
+            minDate: minDate,
+            maxDate: maxDate,
+        })
+        : highlightedRange;
+    var focusDateIsMinOrMax = (maxDate && isEqual(newFocusDate, maxDate)) ||
+        (minDate && isEqual(newFocusDate, minDate));
+    var _a = getDoubleMonthDisplayRange(displayDate), doubleMonthFirstMonth = _a[0], doubleMonthSecondMonth = _a[1];
+    var doubleMonthVisibleRange = {
+        start: startOfMonth(doubleMonthFirstMonth),
+        end: endOfMonth(doubleMonthSecondMonth),
+    };
+    var singleMonthVisibleRange = {
+        start: startOfMonth(displayDate),
+        end: endOfMonth(displayDate),
+    };
+    var isNewFocusDateVisible = isWithinInterval(newFocusDate, calendarType === "double"
+        ? doubleMonthVisibleRange
+        : singleMonthVisibleRange);
+    var commonState = filterAttrs.__assign(filterAttrs.__assign({}, state), { focusDate: newFocusDate, highlightedRange: newHighlightedRange });
+    if (!isNewFocusDateVisible &&
+        !focusDateIsMinOrMax &&
+        isNavigatingByYear &&
+        calendarType === "double") {
+        return filterAttrs.__assign(filterAttrs.__assign({}, commonState), { displayDate: setYear(displayDate, getYear(newFocusDate)) });
+    }
+    if (!isNewFocusDateVisible) {
+        return filterAttrs.__assign(filterAttrs.__assign({}, commonState), { displayDate: startOfMonth(newFocusDate) });
+    }
+    return commonState;
+};
+
+var defaultHandler = function (state) {
+    return filterAttrs.__assign({}, state);
+};
+
+var reducer = function (state, action) {
+    switch (action.type) {
+        case "DAY_NUMBER_SELECT":
+            return dayNumberSelectHandler(action.payload, state);
+        case "RANGE_SELECT":
+            return rangeSelectHandler(action.payload, state);
+        case "HIGHLIGHT_RANGE":
+            return highlightRangeHandler(action.payload, state);
+        case "DAY_GRID_LEAVE":
+            return dayGridLeaveHandler(action.payload, state);
+        case "SHOW_PREVIOUS_MONTH":
+            return showPreviousMonthHandler(action.payload, state);
+        case "SHOW_NEXT_MONTH":
+            return showNextMonthHandler(action.payload, state);
+        case "SHOW_PREVIOUS_DOUBLE_MONTH":
+            return showPreviousDoubleMonthHandler(action.payload, state);
+        case "SHOW_NEXT_DOUBLE_MONTH":
+            return showNextDoubleMonthHandler(action.payload, state);
+        case "DROPDOWN_CHANGE_YEAR":
+            return dropDownChangeYearHandler(action.payload, state);
+        case "DROPDOWN_CHANGE_MONTH":
+            return dropDownChangeMonthHandler(action.payload, state);
+        case "CALENDAR_KEYDOWN":
+            return calendarKeydownHandler(action.payload, state);
+        default:
+            return defaultHandler(state);
+    }
+};
+
+var CalendarFooter = function (_a) {
+    var onCancelClick = _a.onCancelClick;
+    return (React.createElement("div", { className: "arc-CalendarFooter" },
+        React.createElement("button", { type: "button", className: "arc-CalendarFooter-button", onClick: onCancelClick }, "Cancel")));
+};
+
+var CalendarWrapper = function (_a) {
+    var children = _a.children;
+    return (React.createElement("div", { className: "arc-CalendarWrapper" },
+        React.createElement(Surface.Surface, { background: "light-white" },
+            React.createElement("div", { className: "arc-CalendarWrapper-inner" }, children))));
+};
+
+/** Use `Calendar` to clearly present available dates and allowing users to choose a way to enter information. */
+var Calendar = function (_a) {
+    var _b = _a.type, type = _b === void 0 ? "month" : _b, _c = _a.selectionType, selectionType = _c === void 0 ? "single" : _c, _d = _a.autoFocusOnMount, autoFocusOnMount = _d === void 0 ? false : _d, _e = _a.selectedRange, rawSelectedRange = _e === void 0 ? [] : _e, _f = _a.selectedDate, rawSelectedDate = _f === void 0 ? new Date() : _f, rawDisabledDates = _a.disabledDates, rawMinDate = _a.minDate, rawMaxDate = _a.maxDate, onCancelClick = _a.onCancelClick, onDateSelect = _a.onDateSelect, onRangeSelect = _a.onRangeSelect, props = filterAttrs.__rest(_a, ["type", "selectionType", "autoFocusOnMount", "selectedRange", "selectedDate", "disabledDates", "minDate", "maxDate", "onCancelClick", "onDateSelect", "onRangeSelect"]);
+    var todayDate = dateWithoutTime(new Date());
+    var selectedDate = dateWithoutTime(rawSelectedDate);
+    var selectedRange = rawSelectedRange
+        .filter(function (rangeDate) { return Boolean(rangeDate); })
+        .map(function (rangeDate) { return dateWithoutTime(rangeDate); });
+    var _g = React.useState(false), isClientLoaded = _g[0], setIsClientLoaded = _g[1];
+    var _h = React.useReducer(reducer, {
+        displayDate: selectionType === "single"
+            ? startOfMonth(selectedDate)
+            : startOfMonth(selectedRange[0] || todayDate),
+        focusDate: selectionType === "single"
+            ? selectedDate
+            : selectedRange[0] || todayDate,
+        highlightedRange: selectedRange,
+    }), _j = _h[0], displayDate = _j.displayDate, focusDate = _j.focusDate, highlightedRange = _j.highlightedRange, dispatch = _h[1];
+    var isMinWidthArcBreakpointM = useMediaQuery.useMediaQuery("(min-width: ".concat(index_es.ArcSizeBreakpointsM, ")"));
+    React.useEffect(function () {
+        setIsClientLoaded(true);
+    }, []);
+    var disabledDates = rawDisabledDates === null || rawDisabledDates === void 0 ? void 0 : rawDisabledDates.map(function (date) { return dateWithoutTime(date); });
+    var minDate = rawMinDate && dateWithoutTime(rawMinDate);
+    var maxDate = rawMaxDate && dateWithoutTime(rawMaxDate);
+    var calendarType = getCalendarType(type, isMinWidthArcBreakpointM);
+    var doubleMonthDisplayRange = getDoubleMonthDisplayRange(displayDate);
+    var isPreviousMonthDisabled = minDate
+        ? isMonthBeforeMinDate(subMonths(displayDate, 1), minDate)
+        : false;
+    var isNextMonthDisabled = maxDate
+        ? isMonthAfterMaxDate(addMonths(displayDate, 1), maxDate)
+        : false;
+    var isDoubleMonthPreviousDisabled = minDate
+        ? isMonthBeforeMinDate(subMonths(doubleMonthDisplayRange[0], 1), minDate)
+        : false;
+    var isDoubleMonthNextDisabled = maxDate
+        ? isMonthAfterMaxDate(addMonths(doubleMonthDisplayRange[1], 1), maxDate)
+        : false;
+    var setDateRange = function (value) {
+        var _a = processSelectedRange({
+            value: value,
+            range: selectedRange,
+            disabledDates: disabledDates,
+        }), rangeOnChangeValue = _a.rangeOnChangeValue, rangeValue = _a.rangeValue;
+        dispatch({
+            type: "RANGE_SELECT",
+            payload: {
+                date: value,
+                range: rangeValue,
+            },
+        });
+        onRangeSelect && onRangeSelect(rangeOnChangeValue);
+    };
+    var setNewDate = function (value) {
+        dispatch({
+            type: "DAY_NUMBER_SELECT",
+            payload: value,
+        });
+        onDateSelect && onDateSelect(value);
+    };
+    var onDayNumberHover = function (date) { return function () {
+        selectionType === "range" &&
+            dispatch({
+                type: "HIGHLIGHT_RANGE",
+                payload: {
+                    date: date,
+                    minDate: minDate,
+                    maxDate: maxDate,
+                    range: selectedRange,
+                },
+            });
+    }; };
+    var handleDateSelection = function (date) {
+        var isDisabled = isDisabledDate(date, disabledDates, minDate, maxDate);
+        if (isDisabled)
+            return;
+        selectionType === "single" ? setNewDate(date) : setDateRange(date);
+    };
+    var onDayNumberClick = function (date) { return function () {
+        handleDateSelection(date);
+    }; };
+    var onCancelButtonClick = function () {
+        onCancelClick && onCancelClick();
+    };
+    var onDayGridLeave = function () {
+        dispatch({
+            type: "DAY_GRID_LEAVE",
+            payload: {
+                selectionType: selectionType,
+                range: selectedRange,
+            },
+        });
+    };
+    var onPreviousMonthClick = function () {
+        dispatch({
+            type: "SHOW_PREVIOUS_MONTH",
+            payload: {
+                minDate: minDate,
+            },
+        });
+    };
+    var onNextMonthClick = function () {
+        dispatch({
+            type: "SHOW_NEXT_MONTH",
+            payload: {
+                maxDate: maxDate,
+            },
+        });
+    };
+    var onDoubleViewPreviousClick = function () {
+        dispatch({
+            type: "SHOW_PREVIOUS_DOUBLE_MONTH",
+            payload: {
+                minDate: minDate,
+            },
+        });
+    };
+    var onDoubleViewNextClick = function () {
+        dispatch({
+            type: "SHOW_NEXT_DOUBLE_MONTH",
+            payload: {
+                maxDate: maxDate,
+            },
+        });
+    };
+    var onYearChange = function (year) {
+        dispatch({
+            type: "DROPDOWN_CHANGE_YEAR",
+            payload: {
+                year: year,
+                minDate: minDate,
+                maxDate: maxDate,
+            },
+        });
+    };
+    var onMonthChange = function (month) {
+        dispatch({
+            type: "DROPDOWN_CHANGE_MONTH",
+            payload: {
+                month: month,
+                minDate: minDate,
+                maxDate: maxDate,
+            },
+        });
+    };
+    var onKeyboardNavigate = function (key, shiftKey) {
+        dispatch({
+            type: "CALENDAR_KEYDOWN",
+            payload: {
+                minDate: minDate,
+                maxDate: maxDate,
+                selectionType: selectionType,
+                calendarType: calendarType,
+                key: key,
+                shiftKey: shiftKey,
+                range: selectedRange,
+            },
+        });
+    };
+    return (React.createElement(ArcCalendarContext.Provider, filterAttrs.__assign({ value: {
+            minDate: minDate,
+            maxDate: maxDate,
+            focusDate: focusDate,
+            todayDate: todayDate,
+            displayDate: displayDate,
+            onDayGridLeave: onDayGridLeave,
+            disabledDates: disabledDates,
+            selectedDate: selectedDate,
+            selectionType: selectionType,
+            selectedRange: selectedRange,
+            highlightedRange: highlightedRange,
+            onDayNumberClick: onDayNumberClick,
+            onDayNumberHover: onDayNumberHover,
+            onKeyboardNavigate: onKeyboardNavigate,
+            autoFocusOnMount: autoFocusOnMount,
+        } }, filterAttrs.filterAttrs(props)),
+        React.createElement("div", { style: { display: isClientLoaded ? "block" : "none" } },
+            React.createElement(CalendarWrapper, null,
+                calendarType === "year" && (React.createElement(CalendarMonthYearView, { isPreviousMonthDisabled: isPreviousMonthDisabled, isNextMonthDisabled: isNextMonthDisabled, onPreviousMonthClick: onPreviousMonthClick, onNextMonthClick: onNextMonthClick, onMonthChange: onMonthChange, onYearChange: onYearChange })),
+                calendarType === "month" && (React.createElement(CalendarMonthView, { isPreviousMonthDisabled: isPreviousMonthDisabled, isNextMonthDisabled: isNextMonthDisabled, onPreviousMonthClick: onPreviousMonthClick, onNextMonthClick: onNextMonthClick })),
+                calendarType === "double" && (React.createElement(CalendarDoubleMonthView, { isPreviousMonthDisabled: isDoubleMonthPreviousDisabled, isNextMonthDisabled: isDoubleMonthNextDisabled, onPreviousMonthClick: onDoubleViewPreviousClick, onNextMonthClick: onDoubleViewNextClick })),
+                onCancelClick && (React.createElement(CalendarFooter, { onCancelClick: onCancelButtonClick }))))));
+};
+
+exports.Calendar = Calendar;
+exports.compareAsc = compareAsc;
+exports.isAfter = isAfter;
+exports.isBefore = isBefore;