@helsenorge/datepicker 13.4.0 → 13.6.0

package/lib/components/DatePicker/index.js

@@ -1,5 +1,6 @@
-import React, { createContext, useCallback, useContext, useEffect, useId, useLayoutEffect, useMemo, useRef, useState } from "react";
-import { addDays, addMonths, addWeeks, addYears, differenceInCalendarDays, differenceInCalendarMonths, eachMonthOfInterval, eachYearOfInterval, endOfISOWeek, endOfMonth, endOfWeek, endOfYear, format, getISOWeek, getMonth, getWeek, getYear, isAfter, isBefore, isDate, isSameDay, isSameMonth, isSameYear, isValid, isWithinInterval, max, min, parse, setMonth, setYear, startOfDay, startOfISOWeek, startOfMonth, startOfWeek, startOfYear } from "date-fns";
+import { t as DayPicker } from "../../DayPicker.js";
+import React, { useEffect, useId, useRef, useState } from "react";
+import { format, isAfter, isBefore, isSameDay, isValid, isWithinInterval, parse } from "date-fns";
 import { nb } from "date-fns/locale";
 import Button from "@helsenorge/designsystem-react/components/Button";
 import Icon from "@helsenorge/designsystem-react/components/Icon";
@@ -14,7 +15,6 @@ import { useLanguage } from "@helsenorge/designsystem-react/utils/language";
 import { isMobileUA } from "@helsenorge/designsystem-react/utils/mobile";
 import { isMutableRefObject, mergeRefs } from "@helsenorge/designsystem-react/utils/refs";
 import classNames from "classnames";
-import { enUS, enUS as defaultLocale } from "date-fns/locale/en-US";
 import reactdaypickerstyles from "react-day-picker/dist/style.module.css";
 import { useInterval } from "@helsenorge/designsystem-react/hooks/useInterval";
 import { useIsVisible } from "@helsenorge/designsystem-react/hooks/useIsVisible";
@@ -26,1969 +26,6 @@ import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { LanguageLocales as LanguageLocales$1 } from "@helsenorge/designsystem-react";
 import ErrorWrapper from "@helsenorge/designsystem-react/components/ErrorWrapper";
 import { isComponent } from "@helsenorge/designsystem-react/utils/component";
-var __defProp = Object.defineProperty;
-var __export = (all, symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-function tzName(timeZone, date, format$1 = "long") {
-	return new Intl.DateTimeFormat("en-US", {
-		hour: "numeric",
-		timeZone,
-		timeZoneName: format$1
-	}).format(date).split(/\s/g).slice(2).join(" ");
-}
-var offsetFormatCache = {};
-var offsetCache = {};
-function tzOffset(timeZone, date) {
-	try {
-		const offsetStr = (offsetFormatCache[timeZone] ||= new Intl.DateTimeFormat("en-US", {
-			timeZone,
-			timeZoneName: "longOffset"
-		}).format)(date).split("GMT")[1];
-		if (offsetStr in offsetCache) return offsetCache[offsetStr];
-		return calcOffset(offsetStr, offsetStr.split(":"));
-	} catch {
-		if (timeZone in offsetCache) return offsetCache[timeZone];
-		const captures = timeZone?.match(offsetRe);
-		if (captures) return calcOffset(timeZone, captures.slice(1));
-		return NaN;
-	}
-}
-var offsetRe = /([+-]\d\d):?(\d\d)?/;
-function calcOffset(cacheStr, values) {
-	const hours = +(values[0] || 0);
-	const minutes = +(values[1] || 0);
-	const seconds = +(values[2] || 0) / 60;
-	return offsetCache[cacheStr] = hours * 60 + minutes > 0 ? hours * 60 + minutes + seconds : hours * 60 - minutes - seconds;
-}
-var TZDateMini = class TZDateMini extends Date {
-	constructor(...args) {
-		super();
-		if (args.length > 1 && typeof args[args.length - 1] === "string") this.timeZone = args.pop();
-		this.internal = /* @__PURE__ */ new Date();
-		if (isNaN(tzOffset(this.timeZone, this))) this.setTime(NaN);
-		else if (!args.length) this.setTime(Date.now());
-		else if (typeof args[0] === "number" && (args.length === 1 || args.length === 2 && typeof args[1] !== "number")) this.setTime(args[0]);
-		else if (typeof args[0] === "string") this.setTime(+new Date(args[0]));
-		else if (args[0] instanceof Date) this.setTime(+args[0]);
-		else {
-			this.setTime(+new Date(...args));
-			adjustToSystemTZ(this, NaN);
-			syncToInternal(this);
-		}
-	}
-	static tz(tz, ...args) {
-		return args.length ? new TZDateMini(...args, tz) : new TZDateMini(Date.now(), tz);
-	}
-	withTimeZone(timeZone) {
-		return new TZDateMini(+this, timeZone);
-	}
-	getTimezoneOffset() {
-		const offset = -tzOffset(this.timeZone, this);
-		return offset > 0 ? Math.floor(offset) : Math.ceil(offset);
-	}
-	setTime(time) {
-		Date.prototype.setTime.apply(this, arguments);
-		syncToInternal(this);
-		return +this;
-	}
-	[Symbol.for("constructDateFrom")](date) {
-		return new TZDateMini(+new Date(date), this.timeZone);
-	}
-};
-var re = /^(get|set)(?!UTC)/;
-Object.getOwnPropertyNames(Date.prototype).forEach((method) => {
-	if (!re.test(method)) return;
-	const utcMethod = method.replace(re, "$1UTC");
-	if (!TZDateMini.prototype[utcMethod]) return;
-	if (method.startsWith("get")) TZDateMini.prototype[method] = function() {
-		return this.internal[utcMethod]();
-	};
-	else {
-		TZDateMini.prototype[method] = function() {
-			Date.prototype[utcMethod].apply(this.internal, arguments);
-			syncFromInternal(this);
-			return +this;
-		};
-		TZDateMini.prototype[utcMethod] = function() {
-			Date.prototype[utcMethod].apply(this, arguments);
-			syncToInternal(this);
-			return +this;
-		};
-	}
-});
-function syncToInternal(date) {
-	date.internal.setTime(+date);
-	date.internal.setUTCSeconds(date.internal.getUTCSeconds() - Math.round(-tzOffset(date.timeZone, date) * 60));
-}
-function syncFromInternal(date) {
-	Date.prototype.setFullYear.call(date, date.internal.getUTCFullYear(), date.internal.getUTCMonth(), date.internal.getUTCDate());
-	Date.prototype.setHours.call(date, date.internal.getUTCHours(), date.internal.getUTCMinutes(), date.internal.getUTCSeconds(), date.internal.getUTCMilliseconds());
-	adjustToSystemTZ(date);
-}
-function adjustToSystemTZ(date) {
-	const baseOffset = tzOffset(date.timeZone, date);
-	const offset = baseOffset > 0 ? Math.floor(baseOffset) : Math.ceil(baseOffset);
-	const prevHour = /* @__PURE__ */ new Date(+date);
-	prevHour.setUTCHours(prevHour.getUTCHours() - 1);
-	const systemOffset = -(/* @__PURE__ */ new Date(+date)).getTimezoneOffset();
-	const systemDSTChange = systemOffset - -(/* @__PURE__ */ new Date(+prevHour)).getTimezoneOffset();
-	const dstShift = Date.prototype.getHours.apply(date) !== date.internal.getUTCHours();
-	if (systemDSTChange && dstShift) date.internal.setUTCMinutes(date.internal.getUTCMinutes() + systemDSTChange);
-	const offsetDiff = systemOffset - offset;
-	if (offsetDiff) Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + offsetDiff);
-	const systemDate = /* @__PURE__ */ new Date(+date);
-	systemDate.setUTCSeconds(0);
-	const systemSecondsOffset = systemOffset > 0 ? systemDate.getSeconds() : (systemDate.getSeconds() - 60) % 60;
-	const secondsOffset = Math.round(-(tzOffset(date.timeZone, date) * 60)) % 60;
-	if (secondsOffset || systemSecondsOffset) {
-		date.internal.setUTCSeconds(date.internal.getUTCSeconds() + secondsOffset);
-		Date.prototype.setUTCSeconds.call(date, Date.prototype.getUTCSeconds.call(date) + secondsOffset + systemSecondsOffset);
-	}
-	const postBaseOffset = tzOffset(date.timeZone, date);
-	const postOffset = postBaseOffset > 0 ? Math.floor(postBaseOffset) : Math.ceil(postBaseOffset);
-	const postOffsetDiff = -(/* @__PURE__ */ new Date(+date)).getTimezoneOffset() - postOffset;
-	const offsetChanged = postOffset !== offset;
-	const postDiff = postOffsetDiff - offsetDiff;
-	if (offsetChanged && postDiff) {
-		Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + postDiff);
-		const newBaseOffset = tzOffset(date.timeZone, date);
-		const offsetChange = postOffset - (newBaseOffset > 0 ? Math.floor(newBaseOffset) : Math.ceil(newBaseOffset));
-		if (offsetChange) {
-			date.internal.setUTCMinutes(date.internal.getUTCMinutes() + offsetChange);
-			Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + offsetChange);
-		}
-	}
-}
-var TZDate = class TZDate extends TZDateMini {
-	static tz(tz, ...args) {
-		return args.length ? new TZDate(...args, tz) : new TZDate(Date.now(), tz);
-	}
-	toISOString() {
-		const [sign, hours, minutes] = this.tzComponents();
-		const tz = `${sign}${hours}:${minutes}`;
-		return this.internal.toISOString().slice(0, -1) + tz;
-	}
-	toString() {
-		return `${this.toDateString()} ${this.toTimeString()}`;
-	}
-	toDateString() {
-		const [day, date, month, year] = this.internal.toUTCString().split(" ");
-		return `${day?.slice(0, -1)} ${month} ${date} ${year}`;
-	}
-	toTimeString() {
-		const time = this.internal.toUTCString().split(" ")[4];
-		const [sign, hours, minutes] = this.tzComponents();
-		return `${time} GMT${sign}${hours}${minutes} (${tzName(this.timeZone, this)})`;
-	}
-	toLocaleString(locales, options) {
-		return Date.prototype.toLocaleString.call(this, locales, {
-			...options,
-			timeZone: options?.timeZone || this.timeZone
-		});
-	}
-	toLocaleDateString(locales, options) {
-		return Date.prototype.toLocaleDateString.call(this, locales, {
-			...options,
-			timeZone: options?.timeZone || this.timeZone
-		});
-	}
-	toLocaleTimeString(locales, options) {
-		return Date.prototype.toLocaleTimeString.call(this, locales, {
-			...options,
-			timeZone: options?.timeZone || this.timeZone
-		});
-	}
-	tzComponents() {
-		const offset = this.getTimezoneOffset();
-		return [
-			offset > 0 ? "-" : "+",
-			String(Math.floor(Math.abs(offset) / 60)).padStart(2, "0"),
-			String(Math.abs(offset) % 60).padStart(2, "0")
-		];
-	}
-	withTimeZone(timeZone) {
-		return new TZDate(+this, timeZone);
-	}
-	[Symbol.for("constructDateFrom")](date) {
-		return new TZDate(+new Date(date), this.timeZone);
-	}
-};
-var FIVE_WEEKS = 5;
-var 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);
-	return dateLib.getMonth(month) === dateLib.getMonth(lastDateOfLastWeek) ? FIVE_WEEKS : FOUR_WEEKS;
-}
-function startOfBroadcastWeek(date, dateLib) {
-	const firstOfMonth = dateLib.startOfMonth(date);
-	const dayOfWeek = firstOfMonth.getDay();
-	if (dayOfWeek === 1) return firstOfMonth;
-	else if (dayOfWeek === 0) return dateLib.addDays(firstOfMonth, -6);
-	else return dateLib.addDays(firstOfMonth, -1 * (dayOfWeek - 1));
-}
-function endOfBroadcastWeek(date, dateLib) {
-	const startDate = startOfBroadcastWeek(date, dateLib);
-	const numberOfWeeks = getBroadcastWeeksInMonth(date, dateLib);
-	return dateLib.addDays(startDate, numberOfWeeks * 7 - 1);
-}
-var DateLib = class DateLib {
-	constructor(options, overrides) {
-		this.Date = Date;
-		this.today = () => {
-			if (this.overrides?.today) return this.overrides.today();
-			if (this.options.timeZone) return TZDate.tz(this.options.timeZone);
-			return new this.Date();
-		};
-		this.newDate = (year, monthIndex, date) => {
-			if (this.overrides?.newDate) return this.overrides.newDate(year, monthIndex, date);
-			if (this.options.timeZone) return new TZDate(year, monthIndex, date, this.options.timeZone);
-			return new Date(year, monthIndex, date);
-		};
-		this.addDays = (date, amount) => {
-			return this.overrides?.addDays ? this.overrides.addDays(date, amount) : addDays(date, amount);
-		};
-		this.addMonths = (date, amount) => {
-			return this.overrides?.addMonths ? this.overrides.addMonths(date, amount) : addMonths(date, amount);
-		};
-		this.addWeeks = (date, amount) => {
-			return this.overrides?.addWeeks ? this.overrides.addWeeks(date, amount) : addWeeks(date, amount);
-		};
-		this.addYears = (date, amount) => {
-			return this.overrides?.addYears ? this.overrides.addYears(date, amount) : addYears(date, amount);
-		};
-		this.differenceInCalendarDays = (dateLeft, dateRight) => {
-			return this.overrides?.differenceInCalendarDays ? this.overrides.differenceInCalendarDays(dateLeft, dateRight) : differenceInCalendarDays(dateLeft, dateRight);
-		};
-		this.differenceInCalendarMonths = (dateLeft, dateRight) => {
-			return this.overrides?.differenceInCalendarMonths ? this.overrides.differenceInCalendarMonths(dateLeft, dateRight) : differenceInCalendarMonths(dateLeft, dateRight);
-		};
-		this.eachMonthOfInterval = (interval) => {
-			return this.overrides?.eachMonthOfInterval ? this.overrides.eachMonthOfInterval(interval) : eachMonthOfInterval(interval);
-		};
-		this.eachYearOfInterval = (interval) => {
-			const years = this.overrides?.eachYearOfInterval ? this.overrides.eachYearOfInterval(interval) : eachYearOfInterval(interval);
-			const uniqueYears = new Set(years.map((d) => this.getYear(d)));
-			if (uniqueYears.size === years.length) return years;
-			const yearsArray = [];
-			uniqueYears.forEach((y) => {
-				yearsArray.push(new Date(y, 0, 1));
-			});
-			return yearsArray;
-		};
-		this.endOfBroadcastWeek = (date) => {
-			return this.overrides?.endOfBroadcastWeek ? this.overrides.endOfBroadcastWeek(date) : endOfBroadcastWeek(date, this);
-		};
-		this.endOfISOWeek = (date) => {
-			return this.overrides?.endOfISOWeek ? this.overrides.endOfISOWeek(date) : endOfISOWeek(date);
-		};
-		this.endOfMonth = (date) => {
-			return this.overrides?.endOfMonth ? this.overrides.endOfMonth(date) : endOfMonth(date);
-		};
-		this.endOfWeek = (date, options$1) => {
-			return this.overrides?.endOfWeek ? this.overrides.endOfWeek(date, options$1) : endOfWeek(date, this.options);
-		};
-		this.endOfYear = (date) => {
-			return this.overrides?.endOfYear ? this.overrides.endOfYear(date) : endOfYear(date);
-		};
-		this.format = (date, formatStr, _options) => {
-			const formatted = this.overrides?.format ? this.overrides.format(date, formatStr, this.options) : format(date, formatStr, this.options);
-			if (this.options.numerals && this.options.numerals !== "latn") return this.replaceDigits(formatted);
-			return formatted;
-		};
-		this.getISOWeek = (date) => {
-			return this.overrides?.getISOWeek ? this.overrides.getISOWeek(date) : getISOWeek(date);
-		};
-		this.getMonth = (date, _options) => {
-			return this.overrides?.getMonth ? this.overrides.getMonth(date, this.options) : getMonth(date, this.options);
-		};
-		this.getYear = (date, _options) => {
-			return this.overrides?.getYear ? this.overrides.getYear(date, this.options) : getYear(date, this.options);
-		};
-		this.getWeek = (date, _options) => {
-			return this.overrides?.getWeek ? this.overrides.getWeek(date, this.options) : getWeek(date, this.options);
-		};
-		this.isAfter = (date, dateToCompare) => {
-			return this.overrides?.isAfter ? this.overrides.isAfter(date, dateToCompare) : isAfter(date, dateToCompare);
-		};
-		this.isBefore = (date, dateToCompare) => {
-			return this.overrides?.isBefore ? this.overrides.isBefore(date, dateToCompare) : isBefore(date, dateToCompare);
-		};
-		this.isDate = (value) => {
-			return this.overrides?.isDate ? this.overrides.isDate(value) : isDate(value);
-		};
-		this.isSameDay = (dateLeft, dateRight) => {
-			return this.overrides?.isSameDay ? this.overrides.isSameDay(dateLeft, dateRight) : isSameDay(dateLeft, dateRight);
-		};
-		this.isSameMonth = (dateLeft, dateRight) => {
-			return this.overrides?.isSameMonth ? this.overrides.isSameMonth(dateLeft, dateRight) : isSameMonth(dateLeft, dateRight);
-		};
-		this.isSameYear = (dateLeft, dateRight) => {
-			return this.overrides?.isSameYear ? this.overrides.isSameYear(dateLeft, dateRight) : isSameYear(dateLeft, dateRight);
-		};
-		this.max = (dates) => {
-			return this.overrides?.max ? this.overrides.max(dates) : max(dates);
-		};
-		this.min = (dates) => {
-			return this.overrides?.min ? this.overrides.min(dates) : min(dates);
-		};
-		this.setMonth = (date, month) => {
-			return this.overrides?.setMonth ? this.overrides.setMonth(date, month) : setMonth(date, month);
-		};
-		this.setYear = (date, year) => {
-			return this.overrides?.setYear ? this.overrides.setYear(date, year) : setYear(date, year);
-		};
-		this.startOfBroadcastWeek = (date, _dateLib) => {
-			return this.overrides?.startOfBroadcastWeek ? this.overrides.startOfBroadcastWeek(date, this) : startOfBroadcastWeek(date, this);
-		};
-		this.startOfDay = (date) => {
-			return this.overrides?.startOfDay ? this.overrides.startOfDay(date) : startOfDay(date);
-		};
-		this.startOfISOWeek = (date) => {
-			return this.overrides?.startOfISOWeek ? this.overrides.startOfISOWeek(date) : startOfISOWeek(date);
-		};
-		this.startOfMonth = (date) => {
-			return this.overrides?.startOfMonth ? this.overrides.startOfMonth(date) : startOfMonth(date);
-		};
-		this.startOfWeek = (date, _options) => {
-			return this.overrides?.startOfWeek ? this.overrides.startOfWeek(date, this.options) : startOfWeek(date, this.options);
-		};
-		this.startOfYear = (date) => {
-			return this.overrides?.startOfYear ? this.overrides.startOfYear(date) : startOfYear(date);
-		};
-		this.options = {
-			locale: enUS,
-			...options
-		};
-		this.overrides = overrides;
-	}
-	getDigitMap() {
-		const { numerals = "latn" } = this.options;
-		const formatter = new Intl.NumberFormat("en-US", { numberingSystem: numerals });
-		const digitMap = {};
-		for (let i = 0; i < 10; i++) digitMap[i.toString()] = formatter.format(i);
-		return digitMap;
-	}
-	replaceDigits(input) {
-		const digitMap = this.getDigitMap();
-		return input.replace(/\d/g, (digit) => digitMap[digit] || digit);
-	}
-	formatNumber(value) {
-		return this.replaceDigits(value.toString());
-	}
-	getMonthYearOrder() {
-		const code = this.options.locale?.code;
-		if (!code) return "month-first";
-		return DateLib.yearFirstLocales.has(code) ? "year-first" : "month-first";
-	}
-	formatMonthYear(date) {
-		const { locale, timeZone, numerals } = this.options;
-		const localeCode = locale?.code;
-		if (localeCode && DateLib.yearFirstLocales.has(localeCode)) try {
-			return new Intl.DateTimeFormat(localeCode, {
-				month: "long",
-				year: "numeric",
-				timeZone,
-				numberingSystem: numerals
-			}).format(date);
-		} catch {}
-		const pattern = this.getMonthYearOrder() === "year-first" ? "y LLLL" : "LLLL y";
-		return this.format(date, pattern);
-	}
-};
-DateLib.yearFirstLocales = new Set([
-	"eu",
-	"hu",
-	"ja",
-	"ja-Hira",
-	"ja-JP",
-	"ko",
-	"ko-KR",
-	"lt",
-	"lt-LT",
-	"lv",
-	"lv-LV",
-	"mn",
-	"mn-MN",
-	"zh",
-	"zh-CN",
-	"zh-HK",
-	"zh-TW"
-]);
-const defaultDateLib = new DateLib();
-var CalendarDay = class {
-	constructor(date, displayMonth, dateLib = defaultDateLib) {
-		this.date = date;
-		this.displayMonth = displayMonth;
-		this.outside = Boolean(displayMonth && !dateLib.isSameMonth(date, displayMonth));
-		this.dateLib = dateLib;
-		this.isoDate = dateLib.format(date, "yyyy-MM-dd");
-		this.displayMonthId = dateLib.format(displayMonth, "yyyy-MM");
-		this.dateMonthId = dateLib.format(date, "yyyy-MM");
-	}
-	isEqualTo(day) {
-		return this.dateLib.isSameDay(day.date, this.date) && this.dateLib.isSameMonth(day.displayMonth, this.displayMonth);
-	}
-};
-var CalendarMonth = class {
-	constructor(month, weeks) {
-		this.date = month;
-		this.weeks = weeks;
-	}
-};
-var CalendarWeek = class {
-	constructor(weekNumber, days) {
-		this.days = days;
-		this.weekNumber = weekNumber;
-	}
-};
-function Button$1(props) {
-	return React.createElement("button", { ...props });
-}
-function CaptionLabel(props) {
-	return React.createElement("span", { ...props });
-}
-function Chevron(props) {
-	const { size = 24, orientation = "left", className } = props;
-	return React.createElement("svg", {
-		className,
-		width: size,
-		height: size,
-		viewBox: "0 0 24 24"
-	}, orientation === "up" && React.createElement("polygon", { points: "6.77 17 12.5 11.43 18.24 17 20 15.28 12.5 8 5 15.28" }), orientation === "down" && React.createElement("polygon", { points: "6.77 8 12.5 13.57 18.24 8 20 9.72 12.5 17 5 9.72" }), orientation === "left" && React.createElement("polygon", { points: "16 18.112 9.81111111 12 16 5.87733333 14.0888889 4 6 12 14.0888889 20" }), orientation === "right" && React.createElement("polygon", { points: "8 18.112 14.18888889 12 8 5.87733333 9.91111111 4 18 12 9.91111111 20" }));
-}
-function Day(props) {
-	const { day, modifiers, ...tdProps } = props;
-	return React.createElement("td", { ...tdProps });
-}
-function DayButton(props) {
-	const { day, modifiers, ...buttonProps } = props;
-	const ref = React.useRef(null);
-	React.useEffect(() => {
-		if (modifiers.focused) ref.current?.focus();
-	}, [modifiers.focused]);
-	return React.createElement("button", {
-		ref,
-		...buttonProps
-	});
-}
-var UI;
-(function(UI$1) {
-	UI$1["Root"] = "root";
-	UI$1["Chevron"] = "chevron";
-	UI$1["Day"] = "day";
-	UI$1["DayButton"] = "day_button";
-	UI$1["CaptionLabel"] = "caption_label";
-	UI$1["Dropdowns"] = "dropdowns";
-	UI$1["Dropdown"] = "dropdown";
-	UI$1["DropdownRoot"] = "dropdown_root";
-	UI$1["Footer"] = "footer";
-	UI$1["MonthGrid"] = "month_grid";
-	UI$1["MonthCaption"] = "month_caption";
-	UI$1["MonthsDropdown"] = "months_dropdown";
-	UI$1["Month"] = "month";
-	UI$1["Months"] = "months";
-	UI$1["Nav"] = "nav";
-	UI$1["NextMonthButton"] = "button_next";
-	UI$1["PreviousMonthButton"] = "button_previous";
-	UI$1["Week"] = "week";
-	UI$1["Weeks"] = "weeks";
-	UI$1["Weekday"] = "weekday";
-	UI$1["Weekdays"] = "weekdays";
-	UI$1["WeekNumber"] = "week_number";
-	UI$1["WeekNumberHeader"] = "week_number_header";
-	UI$1["YearsDropdown"] = "years_dropdown";
-})(UI || (UI = {}));
-var DayFlag;
-(function(DayFlag$1) {
-	DayFlag$1["disabled"] = "disabled";
-	DayFlag$1["hidden"] = "hidden";
-	DayFlag$1["outside"] = "outside";
-	DayFlag$1["focused"] = "focused";
-	DayFlag$1["today"] = "today";
-})(DayFlag || (DayFlag = {}));
-var SelectionState;
-(function(SelectionState$1) {
-	SelectionState$1["range_end"] = "range_end";
-	SelectionState$1["range_middle"] = "range_middle";
-	SelectionState$1["range_start"] = "range_start";
-	SelectionState$1["selected"] = "selected";
-})(SelectionState || (SelectionState = {}));
-var Animation;
-(function(Animation$1) {
-	Animation$1["weeks_before_enter"] = "weeks_before_enter";
-	Animation$1["weeks_before_exit"] = "weeks_before_exit";
-	Animation$1["weeks_after_enter"] = "weeks_after_enter";
-	Animation$1["weeks_after_exit"] = "weeks_after_exit";
-	Animation$1["caption_after_enter"] = "caption_after_enter";
-	Animation$1["caption_after_exit"] = "caption_after_exit";
-	Animation$1["caption_before_enter"] = "caption_before_enter";
-	Animation$1["caption_before_exit"] = "caption_before_exit";
-})(Animation || (Animation = {}));
-function Dropdown(props) {
-	const { options, className, components, classNames: classNames$1, ...selectProps } = props;
-	const cssClassSelect = [classNames$1[UI.Dropdown], className].join(" ");
-	const selectedOption = options?.find(({ value }) => value === selectProps.value);
-	return React.createElement("span", {
-		"data-disabled": selectProps.disabled,
-		className: classNames$1[UI.DropdownRoot]
-	}, React.createElement(components.Select, {
-		className: cssClassSelect,
-		...selectProps
-	}, options?.map(({ value, label, disabled }) => React.createElement(components.Option, {
-		key: value,
-		value,
-		disabled
-	}, label))), React.createElement("span", {
-		className: classNames$1[UI.CaptionLabel],
-		"aria-hidden": true
-	}, selectedOption?.label, React.createElement(components.Chevron, {
-		orientation: "down",
-		size: 18,
-		className: classNames$1[UI.Chevron]
-	})));
-}
-function DropdownNav(props) {
-	return React.createElement("div", { ...props });
-}
-function Footer(props) {
-	return React.createElement("div", { ...props });
-}
-function Month(props) {
-	const { calendarMonth, displayIndex, ...divProps } = props;
-	return React.createElement("div", { ...divProps }, props.children);
-}
-function MonthCaption(props) {
-	const { calendarMonth, displayIndex, ...divProps } = props;
-	return React.createElement("div", { ...divProps });
-}
-function MonthGrid(props) {
-	return React.createElement("table", { ...props });
-}
-function Months(props) {
-	return React.createElement("div", { ...props });
-}
-const dayPickerContext = createContext(void 0);
-function useDayPicker() {
-	const context = useContext(dayPickerContext);
-	if (context === void 0) throw new Error("useDayPicker() must be used within a custom component.");
-	return context;
-}
-function MonthsDropdown(props) {
-	const { components } = useDayPicker();
-	return React.createElement(components.Dropdown, { ...props });
-}
-function Nav(props) {
-	const { onPreviousClick, onNextClick, previousMonth: previousMonth$2, nextMonth: nextMonth$2, ...navProps } = props;
-	const { components, classNames: classNames$1, labels: { labelPrevious: labelPrevious$1, labelNext: labelNext$1 } } = useDayPicker();
-	const handleNextClick = useCallback((e) => {
-		if (nextMonth$2) onNextClick?.(e);
-	}, [nextMonth$2, onNextClick]);
-	const handlePreviousClick = useCallback((e) => {
-		if (previousMonth$2) onPreviousClick?.(e);
-	}, [previousMonth$2, onPreviousClick]);
-	return React.createElement("nav", { ...navProps }, React.createElement(components.PreviousMonthButton, {
-		type: "button",
-		className: classNames$1[UI.PreviousMonthButton],
-		tabIndex: previousMonth$2 ? void 0 : -1,
-		"aria-disabled": previousMonth$2 ? void 0 : true,
-		"aria-label": labelPrevious$1(previousMonth$2),
-		onClick: handlePreviousClick
-	}, React.createElement(components.Chevron, {
-		disabled: previousMonth$2 ? void 0 : true,
-		className: classNames$1[UI.Chevron],
-		orientation: "left"
-	})), React.createElement(components.NextMonthButton, {
-		type: "button",
-		className: classNames$1[UI.NextMonthButton],
-		tabIndex: nextMonth$2 ? void 0 : -1,
-		"aria-disabled": nextMonth$2 ? void 0 : true,
-		"aria-label": labelNext$1(nextMonth$2),
-		onClick: handleNextClick
-	}, React.createElement(components.Chevron, {
-		disabled: nextMonth$2 ? void 0 : true,
-		orientation: "right",
-		className: classNames$1[UI.Chevron]
-	})));
-}
-function NextMonthButton(props) {
-	const { components } = useDayPicker();
-	return React.createElement(components.Button, { ...props });
-}
-function Option(props) {
-	return React.createElement("option", { ...props });
-}
-function PreviousMonthButton(props) {
-	const { components } = useDayPicker();
-	return React.createElement(components.Button, { ...props });
-}
-function Root(props) {
-	const { rootRef, ...rest } = props;
-	return React.createElement("div", {
-		...rest,
-		ref: rootRef
-	});
-}
-function Select(props) {
-	return React.createElement("select", { ...props });
-}
-function Week(props) {
-	const { week, ...trProps } = props;
-	return React.createElement("tr", { ...trProps });
-}
-function Weekday(props) {
-	return React.createElement("th", { ...props });
-}
-function Weekdays(props) {
-	return React.createElement("thead", { "aria-hidden": true }, React.createElement("tr", { ...props }));
-}
-function WeekNumber(props) {
-	const { week, ...thProps } = props;
-	return React.createElement("th", { ...thProps });
-}
-function WeekNumberHeader(props) {
-	return React.createElement("th", { ...props });
-}
-function Weeks(props) {
-	return React.createElement("tbody", { ...props });
-}
-function YearsDropdown(props) {
-	const { components } = useDayPicker();
-	return React.createElement(components.Dropdown, { ...props });
-}
-var custom_components_exports = /* @__PURE__ */ __export({
-	Button: () => Button$1,
-	CaptionLabel: () => CaptionLabel,
-	Chevron: () => Chevron,
-	Day: () => Day,
-	DayButton: () => DayButton,
-	Dropdown: () => Dropdown,
-	DropdownNav: () => DropdownNav,
-	Footer: () => Footer,
-	Month: () => Month,
-	MonthCaption: () => MonthCaption,
-	MonthGrid: () => MonthGrid,
-	Months: () => Months,
-	MonthsDropdown: () => MonthsDropdown,
-	Nav: () => Nav,
-	NextMonthButton: () => NextMonthButton,
-	Option: () => Option,
-	PreviousMonthButton: () => PreviousMonthButton,
-	Root: () => Root,
-	Select: () => Select,
-	Week: () => Week,
-	WeekNumber: () => WeekNumber,
-	WeekNumberHeader: () => WeekNumberHeader,
-	Weekday: () => Weekday,
-	Weekdays: () => Weekdays,
-	Weeks: () => Weeks,
-	YearsDropdown: () => YearsDropdown
-});
-function rangeIncludesDate(range, date, excludeEnds = false, dateLib = defaultDateLib) {
-	let { from, to } = range;
-	const { differenceInCalendarDays: differenceInCalendarDays$1, isSameDay: isSameDay$1 } = dateLib;
-	if (from && to) {
-		if (differenceInCalendarDays$1(to, from) < 0) [from, to] = [to, from];
-		return differenceInCalendarDays$1(date, from) >= (excludeEnds ? 1 : 0) && differenceInCalendarDays$1(to, date) >= (excludeEnds ? 1 : 0);
-	}
-	if (!excludeEnds && to) return isSameDay$1(to, date);
-	if (!excludeEnds && from) return isSameDay$1(from, date);
-	return false;
-}
-function isDateInterval(matcher) {
-	return Boolean(matcher && typeof matcher === "object" && "before" in matcher && "after" in matcher);
-}
-function isDateRange(value) {
-	return Boolean(value && typeof value === "object" && "from" in value);
-}
-function isDateAfterType(value) {
-	return Boolean(value && typeof value === "object" && "after" in value);
-}
-function isDateBeforeType(value) {
-	return Boolean(value && typeof value === "object" && "before" in value);
-}
-function isDayOfWeekType(value) {
-	return Boolean(value && typeof value === "object" && "dayOfWeek" in value);
-}
-function isDatesArray(value, dateLib) {
-	return Array.isArray(value) && value.every(dateLib.isDate);
-}
-function dateMatchModifiers(date, matchers, dateLib = defaultDateLib) {
-	const matchersArr = !Array.isArray(matchers) ? [matchers] : matchers;
-	const { isSameDay: isSameDay$1, differenceInCalendarDays: differenceInCalendarDays$1, isAfter: isAfter$1 } = dateLib;
-	return matchersArr.some((matcher) => {
-		if (typeof matcher === "boolean") return matcher;
-		if (dateLib.isDate(matcher)) return isSameDay$1(date, matcher);
-		if (isDatesArray(matcher, dateLib)) return matcher.includes(date);
-		if (isDateRange(matcher)) return rangeIncludesDate(matcher, date, false, dateLib);
-		if (isDayOfWeekType(matcher)) {
-			if (!Array.isArray(matcher.dayOfWeek)) return matcher.dayOfWeek === date.getDay();
-			return matcher.dayOfWeek.includes(date.getDay());
-		}
-		if (isDateInterval(matcher)) {
-			const diffBefore = differenceInCalendarDays$1(matcher.before, date);
-			const diffAfter = differenceInCalendarDays$1(matcher.after, date);
-			const isDayBefore = diffBefore > 0;
-			const isDayAfter = diffAfter < 0;
-			if (isAfter$1(matcher.before, matcher.after)) return isDayAfter && isDayBefore;
-			else return isDayBefore || isDayAfter;
-		}
-		if (isDateAfterType(matcher)) return differenceInCalendarDays$1(date, matcher.after) > 0;
-		if (isDateBeforeType(matcher)) return differenceInCalendarDays$1(matcher.before, date) > 0;
-		if (typeof matcher === "function") return matcher(date);
-		return false;
-	});
-}
-function createGetModifiers(days, props, navStart, navEnd, dateLib) {
-	const { disabled, hidden, modifiers, showOutsideDays, broadcastCalendar, today = dateLib.today() } = props;
-	const { isSameDay: isSameDay$1, isSameMonth: isSameMonth$1, startOfMonth: startOfMonth$1, isBefore: isBefore$1, endOfMonth: endOfMonth$1, isAfter: isAfter$1 } = dateLib;
-	const computedNavStart = navStart && startOfMonth$1(navStart);
-	const computedNavEnd = navEnd && endOfMonth$1(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$1(date, displayMonth));
-		const isBeforeNavStart = Boolean(computedNavStart && isBefore$1(date, computedNavStart));
-		const isAfterNavEnd = Boolean(computedNavEnd && isAfter$1(date, computedNavEnd));
-		const isDisabled = Boolean(disabled && dateMatchModifiers(date, disabled, dateLib));
-		const isHidden = Boolean(hidden && dateMatchModifiers(date, hidden, dateLib)) || isBeforeNavStart || isAfterNavEnd || !broadcastCalendar && !showOutsideDays && isOutside || broadcastCalendar && showOutsideDays === false && isOutside;
-		const isToday = isSameDay$1(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];
-			if (!(modifierValue ? dateMatchModifiers(date, modifierValue, dateLib) : false)) 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) dayFlags[name] = internalModifiersMap[name].some((d) => d === day);
-		for (const name in customModifiersMap) customModifiers[name] = customModifiersMap[name].some((d) => d === day);
-		return {
-			...dayFlags,
-			...customModifiers
-		};
-	};
-}
-function getClassNamesForModifiers(modifiers, classNames$1, modifiersClassNames = {}) {
-	return Object.entries(modifiers).filter(([, active]) => active === true).reduce((previousValue, [key]) => {
-		if (modifiersClassNames[key]) previousValue.push(modifiersClassNames[key]);
-		else if (classNames$1[DayFlag[key]]) previousValue.push(classNames$1[DayFlag[key]]);
-		else if (classNames$1[SelectionState[key]]) previousValue.push(classNames$1[SelectionState[key]]);
-		return previousValue;
-	}, [classNames$1[UI.Day]]);
-}
-function getComponents(customComponents) {
-	return {
-		...custom_components_exports,
-		...customComponents
-	};
-}
-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;
-}
-function getDefaultClassNames() {
-	const classNames$1 = {};
-	for (const key in UI) classNames$1[UI[key]] = `rdp-${UI[key]}`;
-	for (const key in DayFlag) classNames$1[DayFlag[key]] = `rdp-${DayFlag[key]}`;
-	for (const key in SelectionState) classNames$1[SelectionState[key]] = `rdp-${SelectionState[key]}`;
-	for (const key in Animation) classNames$1[Animation[key]] = `rdp-${Animation[key]}`;
-	return classNames$1;
-}
-function formatCaption(month, options, dateLib) {
-	return (dateLib ?? new DateLib(options)).formatMonthYear(month);
-}
-const formatMonthCaption = formatCaption;
-function formatDay(date, options, dateLib) {
-	return (dateLib ?? new DateLib(options)).format(date, "d");
-}
-function formatMonthDropdown(month, dateLib = defaultDateLib) {
-	return dateLib.format(month, "LLLL");
-}
-function formatWeekdayName(weekday, options, dateLib) {
-	return (dateLib ?? new DateLib(options)).format(weekday, "cccccc");
-}
-function formatWeekNumber(weekNumber, dateLib = defaultDateLib) {
-	if (weekNumber < 10) return dateLib.formatNumber(`0${weekNumber.toLocaleString()}`);
-	return dateLib.formatNumber(`${weekNumber.toLocaleString()}`);
-}
-function formatWeekNumberHeader() {
-	return ``;
-}
-function formatYearDropdown(year, dateLib = defaultDateLib) {
-	return dateLib.format(year, "yyyy");
-}
-const formatYearCaption = formatYearDropdown;
-var formatters_exports = /* @__PURE__ */ __export({
-	formatCaption: () => formatCaption,
-	formatDay: () => formatDay,
-	formatMonthCaption: () => formatMonthCaption,
-	formatMonthDropdown: () => formatMonthDropdown,
-	formatWeekNumber: () => formatWeekNumber,
-	formatWeekNumberHeader: () => formatWeekNumberHeader,
-	formatWeekdayName: () => formatWeekdayName,
-	formatYearCaption: () => formatYearCaption,
-	formatYearDropdown: () => formatYearDropdown
-});
-function getFormatters(customFormatters) {
-	if (customFormatters?.formatMonthCaption && !customFormatters.formatCaption) customFormatters.formatCaption = customFormatters.formatMonthCaption;
-	if (customFormatters?.formatYearCaption && !customFormatters.formatYearDropdown) customFormatters.formatYearDropdown = customFormatters.formatYearCaption;
-	return {
-		...formatters_exports,
-		...customFormatters
-	};
-}
-function getMonthOptions(displayMonth, navStart, navEnd, formatters, dateLib) {
-	const { startOfMonth: startOfMonth$1, startOfYear: startOfYear$1, endOfYear: endOfYear$1, eachMonthOfInterval: eachMonthOfInterval$1, getMonth: getMonth$1 } = dateLib;
-	return eachMonthOfInterval$1({
-		start: startOfYear$1(displayMonth),
-		end: endOfYear$1(displayMonth)
-	}).map((month) => {
-		const label = formatters.formatMonthDropdown(month, dateLib);
-		return {
-			value: getMonth$1(month),
-			label,
-			disabled: navStart && month < startOfMonth$1(navStart) || navEnd && month > startOfMonth$1(navEnd) || false
-		};
-	});
-}
-function getStyleForModifiers(dayModifiers, styles$1 = {}, modifiersStyles = {}) {
-	let style = { ...styles$1?.[UI.Day] };
-	Object.entries(dayModifiers).filter(([, active]) => active === true).forEach(([modifier]) => {
-		style = {
-			...style,
-			...modifiersStyles?.[modifier]
-		};
-	});
-	return style;
-}
-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;
-}
-function getYearOptions(navStart, navEnd, formatters, dateLib, reverse = false) {
-	if (!navStart) return void 0;
-	if (!navEnd) return void 0;
-	const { startOfYear: startOfYear$1, endOfYear: endOfYear$1, eachYearOfInterval: eachYearOfInterval$1, getYear: getYear$1 } = dateLib;
-	const years = eachYearOfInterval$1({
-		start: startOfYear$1(navStart),
-		end: endOfYear$1(navEnd)
-	});
-	if (reverse) years.reverse();
-	return years.map((year) => {
-		const label = formatters.formatYearDropdown(year, dateLib);
-		return {
-			value: getYear$1(year),
-			label,
-			disabled: false
-		};
-	});
-}
-function labelDayButton(date, modifiers, options, dateLib) {
-	let label = (dateLib ?? new DateLib(options)).format(date, "PPPP");
-	if (modifiers.today) label = `Today, ${label}`;
-	if (modifiers.selected) label = `${label}, selected`;
-	return label;
-}
-const labelDay = labelDayButton;
-function labelGrid(date, options, dateLib) {
-	return (dateLib ?? new DateLib(options)).formatMonthYear(date);
-}
-const labelCaption = labelGrid;
-function labelGridcell(date, modifiers, options, dateLib) {
-	let label = (dateLib ?? new DateLib(options)).format(date, "PPPP");
-	if (modifiers?.today) label = `Today, ${label}`;
-	return label;
-}
-function labelMonthDropdown(_options) {
-	return "Choose the Month";
-}
-function labelNav() {
-	return "";
-}
-function labelNext(_month) {
-	return "Go to the Next Month";
-}
-function labelPrevious(_month) {
-	return "Go to the Previous Month";
-}
-function labelWeekday(date, options, dateLib) {
-	return (dateLib ?? new DateLib(options)).format(date, "cccc");
-}
-function labelWeekNumber(weekNumber, _options) {
-	return `Week ${weekNumber}`;
-}
-function labelWeekNumberHeader(_options) {
-	return "Week Number";
-}
-function labelYearDropdown(_options) {
-	return "Choose the Year";
-}
-var labels_exports = /* @__PURE__ */ __export({
-	labelCaption: () => labelCaption,
-	labelDay: () => labelDay,
-	labelDayButton: () => labelDayButton,
-	labelGrid: () => labelGrid,
-	labelGridcell: () => labelGridcell,
-	labelMonthDropdown: () => labelMonthDropdown,
-	labelNav: () => labelNav,
-	labelNext: () => labelNext,
-	labelPrevious: () => labelPrevious,
-	labelWeekNumber: () => labelWeekNumber,
-	labelWeekNumberHeader: () => labelWeekNumberHeader,
-	labelWeekday: () => labelWeekday,
-	labelYearDropdown: () => labelYearDropdown
-});
-var asHtmlElement = (element) => {
-	if (element instanceof HTMLElement) return element;
-	return null;
-};
-var queryMonthEls = (element) => [...element.querySelectorAll("[data-animated-month]") ?? []];
-var queryMonthEl = (element) => asHtmlElement(element.querySelector("[data-animated-month]"));
-var queryCaptionEl = (element) => asHtmlElement(element.querySelector("[data-animated-caption]"));
-var queryWeeksEl = (element) => asHtmlElement(element.querySelector("[data-animated-weeks]"));
-var queryNavEl = (element) => asHtmlElement(element.querySelector("[data-animated-nav]"));
-var queryWeekdaysEl = (element) => asHtmlElement(element.querySelector("[data-animated-weekdays]"));
-function useAnimation(rootElRef, enabled, { classNames: classNames$1, months, focused, dateLib }) {
-	const previousRootElSnapshotRef = useRef(null);
-	const previousMonthsRef = useRef(months);
-	const animatingRef = useRef(false);
-	useLayoutEffect(() => {
-		const previousMonths = previousMonthsRef.current;
-		previousMonthsRef.current = months;
-		if (!enabled || !rootElRef.current || !(rootElRef.current instanceof HTMLElement) || months.length === 0 || previousMonths.length === 0 || months.length !== previousMonths.length) return;
-		const isSameMonth$1 = dateLib.isSameMonth(months[0].date, previousMonths[0].date);
-		const isAfterPreviousMonth = dateLib.isAfter(months[0].date, previousMonths[0].date);
-		const captionAnimationClass = isAfterPreviousMonth ? classNames$1[Animation.caption_after_enter] : classNames$1[Animation.caption_before_enter];
-		const weeksAnimationClass = isAfterPreviousMonth ? classNames$1[Animation.weeks_after_enter] : classNames$1[Animation.weeks_before_enter];
-		const previousRootElSnapshot = previousRootElSnapshotRef.current;
-		const rootElSnapshot = rootElRef.current.cloneNode(true);
-		if (rootElSnapshot instanceof HTMLElement) {
-			queryMonthEls(rootElSnapshot).forEach((currentMonthElSnapshot) => {
-				if (!(currentMonthElSnapshot instanceof HTMLElement)) return;
-				const previousMonthElSnapshot = queryMonthEl(currentMonthElSnapshot);
-				if (previousMonthElSnapshot && currentMonthElSnapshot.contains(previousMonthElSnapshot)) currentMonthElSnapshot.removeChild(previousMonthElSnapshot);
-				const captionEl = queryCaptionEl(currentMonthElSnapshot);
-				if (captionEl) captionEl.classList.remove(captionAnimationClass);
-				const weeksEl = queryWeeksEl(currentMonthElSnapshot);
-				if (weeksEl) weeksEl.classList.remove(weeksAnimationClass);
-			});
-			previousRootElSnapshotRef.current = rootElSnapshot;
-		} else previousRootElSnapshotRef.current = null;
-		if (animatingRef.current || isSameMonth$1 || focused) return;
-		const previousMonthEls = previousRootElSnapshot instanceof HTMLElement ? queryMonthEls(previousRootElSnapshot) : [];
-		const currentMonthEls = queryMonthEls(rootElRef.current);
-		if (currentMonthEls?.every((el) => el instanceof HTMLElement) && previousMonthEls && previousMonthEls.every((el) => el instanceof HTMLElement)) {
-			animatingRef.current = true;
-			const cleanUpFunctions = [];
-			rootElRef.current.style.isolation = "isolate";
-			const navEl = queryNavEl(rootElRef.current);
-			if (navEl) navEl.style.zIndex = "1";
-			currentMonthEls.forEach((currentMonthEl, index) => {
-				const previousMonthEl = previousMonthEls[index];
-				if (!previousMonthEl) return;
-				currentMonthEl.style.position = "relative";
-				currentMonthEl.style.overflow = "hidden";
-				const captionEl = queryCaptionEl(currentMonthEl);
-				if (captionEl) captionEl.classList.add(captionAnimationClass);
-				const weeksEl = queryWeeksEl(currentMonthEl);
-				if (weeksEl) weeksEl.classList.add(weeksAnimationClass);
-				const cleanUp = () => {
-					animatingRef.current = false;
-					if (rootElRef.current) rootElRef.current.style.isolation = "";
-					if (navEl) navEl.style.zIndex = "";
-					if (captionEl) captionEl.classList.remove(captionAnimationClass);
-					if (weeksEl) weeksEl.classList.remove(weeksAnimationClass);
-					currentMonthEl.style.position = "";
-					currentMonthEl.style.overflow = "";
-					if (currentMonthEl.contains(previousMonthEl)) currentMonthEl.removeChild(previousMonthEl);
-				};
-				cleanUpFunctions.push(cleanUp);
-				previousMonthEl.style.pointerEvents = "none";
-				previousMonthEl.style.position = "absolute";
-				previousMonthEl.style.overflow = "hidden";
-				previousMonthEl.setAttribute("aria-hidden", "true");
-				const previousWeekdaysEl = queryWeekdaysEl(previousMonthEl);
-				if (previousWeekdaysEl) previousWeekdaysEl.style.opacity = "0";
-				const previousCaptionEl = queryCaptionEl(previousMonthEl);
-				if (previousCaptionEl) {
-					previousCaptionEl.classList.add(isAfterPreviousMonth ? classNames$1[Animation.caption_before_exit] : classNames$1[Animation.caption_after_exit]);
-					previousCaptionEl.addEventListener("animationend", cleanUp);
-				}
-				const previousWeeksEl = queryWeeksEl(previousMonthEl);
-				if (previousWeeksEl) previousWeeksEl.classList.add(isAfterPreviousMonth ? classNames$1[Animation.weeks_before_exit] : classNames$1[Animation.weeks_after_exit]);
-				currentMonthEl.insertBefore(previousMonthEl, currentMonthEl.firstChild);
-			});
-		}
-	});
-}
-function getDates(displayMonths, maxDate, props, dateLib) {
-	const firstMonth = displayMonths[0];
-	const lastMonth = displayMonths[displayMonths.length - 1];
-	const { ISOWeek, fixedWeeks, broadcastCalendar } = props ?? {};
-	const { addDays: addDays$1, differenceInCalendarDays: differenceInCalendarDays$1, differenceInCalendarMonths: differenceInCalendarMonths$1, endOfBroadcastWeek: endOfBroadcastWeek$1, endOfISOWeek: endOfISOWeek$1, endOfMonth: endOfMonth$1, endOfWeek: endOfWeek$1, isAfter: isAfter$1, startOfBroadcastWeek: startOfBroadcastWeek$1, startOfISOWeek: startOfISOWeek$1, startOfWeek: startOfWeek$1 } = dateLib;
-	const startWeekFirstDate = broadcastCalendar ? startOfBroadcastWeek$1(firstMonth, dateLib) : ISOWeek ? startOfISOWeek$1(firstMonth) : startOfWeek$1(firstMonth);
-	const nOfDays = differenceInCalendarDays$1(broadcastCalendar ? endOfBroadcastWeek$1(lastMonth) : ISOWeek ? endOfISOWeek$1(endOfMonth$1(lastMonth)) : endOfWeek$1(endOfMonth$1(lastMonth)), startWeekFirstDate);
-	const nOfMonths = differenceInCalendarMonths$1(lastMonth, firstMonth) + 1;
-	const dates = [];
-	for (let i = 0; i <= nOfDays; i++) {
-		const date = addDays$1(startWeekFirstDate, i);
-		if (maxDate && isAfter$1(date, maxDate)) break;
-		dates.push(date);
-	}
-	const extraDates = (broadcastCalendar ? 35 : 42) * nOfMonths;
-	if (fixedWeeks && dates.length < extraDates) {
-		const daysToAdd = extraDates - dates.length;
-		for (let i = 0; i < daysToAdd; i++) {
-			const date = addDays$1(dates[dates.length - 1], 1);
-			dates.push(date);
-		}
-	}
-	return dates;
-}
-function getDays(calendarMonths) {
-	const initialDays = [];
-	return calendarMonths.reduce((days, month) => {
-		const weekDays = month.weeks.reduce((weekDays$1, week) => {
-			return weekDays$1.concat(week.days.slice());
-		}, initialDays.slice());
-		return days.concat(weekDays.slice());
-	}, initialDays.slice());
-}
-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;
-}
-function getInitialMonth(props, navStart, navEnd, dateLib) {
-	const { month, defaultMonth, today = dateLib.today(), numberOfMonths = 1 } = props;
-	let initialMonth = month || defaultMonth || today;
-	const { differenceInCalendarMonths: differenceInCalendarMonths$1, addMonths: addMonths$1, startOfMonth: startOfMonth$1 } = dateLib;
-	if (navEnd && differenceInCalendarMonths$1(navEnd, initialMonth) < numberOfMonths - 1) initialMonth = addMonths$1(navEnd, -1 * (numberOfMonths - 1));
-	if (navStart && differenceInCalendarMonths$1(initialMonth, navStart) < 0) initialMonth = navStart;
-	return startOfMonth$1(initialMonth);
-}
-function getMonths(displayMonths, dates, props, dateLib) {
-	const { addDays: addDays$1, endOfBroadcastWeek: endOfBroadcastWeek$1, endOfISOWeek: endOfISOWeek$1, endOfMonth: endOfMonth$1, endOfWeek: endOfWeek$1, getISOWeek: getISOWeek$1, getWeek: getWeek$1, startOfBroadcastWeek: startOfBroadcastWeek$1, startOfISOWeek: startOfISOWeek$1, startOfWeek: startOfWeek$1 } = dateLib;
-	const dayPickerMonths = displayMonths.reduce((months, month) => {
-		const firstDateOfFirstWeek = props.broadcastCalendar ? startOfBroadcastWeek$1(month, dateLib) : props.ISOWeek ? startOfISOWeek$1(month) : startOfWeek$1(month);
-		const lastDateOfLastWeek = props.broadcastCalendar ? endOfBroadcastWeek$1(month) : props.ISOWeek ? endOfISOWeek$1(endOfMonth$1(month)) : endOfWeek$1(endOfMonth$1(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$1(lastDateOfLastWeek, daysToAdd);
-			});
-			monthDates.push(...extraDates);
-		}
-		const dayPickerMonth = new CalendarMonth(month, monthDates.reduce((weeks, date) => {
-			const weekNumber = props.ISOWeek ? getISOWeek$1(date) : getWeek$1(date);
-			const week = weeks.find((week$1) => week$1.weekNumber === weekNumber);
-			const day = new CalendarDay(date, month, dateLib);
-			if (!week) weeks.push(new CalendarWeek(weekNumber, [day]));
-			else week.days.push(day);
-			return weeks;
-		}, []));
-		months.push(dayPickerMonth);
-		return months;
-	}, []);
-	if (!props.reverseMonths) return dayPickerMonths;
-	else return dayPickerMonths.reverse();
-}
-function getNavMonths(props, dateLib) {
-	let { startMonth, endMonth } = props;
-	const { startOfYear: startOfYear$1, startOfDay: startOfDay$1, startOfMonth: startOfMonth$1, endOfMonth: endOfMonth$1, addYears: addYears$1, endOfYear: endOfYear$1, 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$1(startMonth);
-	else if (fromYear) startMonth = newDate(fromYear, 0, 1);
-	else if (!startMonth && hasYearDropdown) startMonth = startOfYear$1(addYears$1(props.today ?? today(), -100));
-	if (endMonth) endMonth = endOfMonth$1(endMonth);
-	else if (toYear) endMonth = newDate(toYear, 11, 31);
-	else if (!endMonth && hasYearDropdown) endMonth = endOfYear$1(props.today ?? today());
-	return [startMonth ? startOfDay$1(startMonth) : startMonth, endMonth ? startOfDay$1(endMonth) : endMonth];
-}
-function getNextMonth(firstDisplayedMonth, calendarEndMonth, options, dateLib) {
-	if (options.disableNavigation) return;
-	const { pagedNavigation, numberOfMonths = 1 } = options;
-	const { startOfMonth: startOfMonth$1, addMonths: addMonths$1, differenceInCalendarMonths: differenceInCalendarMonths$1 } = dateLib;
-	const offset = pagedNavigation ? numberOfMonths : 1;
-	const month = startOfMonth$1(firstDisplayedMonth);
-	if (!calendarEndMonth) return addMonths$1(month, offset);
-	if (differenceInCalendarMonths$1(calendarEndMonth, firstDisplayedMonth) < numberOfMonths) return;
-	return addMonths$1(month, offset);
-}
-function getPreviousMonth(firstDisplayedMonth, calendarStartMonth, options, dateLib) {
-	if (options.disableNavigation) return;
-	const { pagedNavigation, numberOfMonths } = options;
-	const { startOfMonth: startOfMonth$1, addMonths: addMonths$1, differenceInCalendarMonths: differenceInCalendarMonths$1 } = dateLib;
-	const offset = pagedNavigation ? numberOfMonths ?? 1 : 1;
-	const month = startOfMonth$1(firstDisplayedMonth);
-	if (!calendarStartMonth) return addMonths$1(month, -offset);
-	if (differenceInCalendarMonths$1(month, calendarStartMonth) <= 0) return;
-	return addMonths$1(month, -offset);
-}
-function getWeeks(months) {
-	return months.reduce((weeks, month) => {
-		return weeks.concat(month.weeks.slice());
-	}, [].slice());
-}
-function useControlledValue(defaultValue, controlledValue) {
-	const [uncontrolledValue, setValue] = useState(defaultValue);
-	return [controlledValue === void 0 ? uncontrolledValue : controlledValue, setValue];
-}
-function useCalendar(props, dateLib) {
-	const [navStart, navEnd] = getNavMonths(props, dateLib);
-	const { startOfMonth: startOfMonth$1, endOfMonth: endOfMonth$1 } = dateLib;
-	const initialMonth = getInitialMonth(props, navStart, navEnd, dateLib);
-	const [firstMonth, setFirstMonth] = useControlledValue(initialMonth, props.month ? initialMonth : void 0);
-	useEffect(() => {
-		setFirstMonth(getInitialMonth(props, navStart, navEnd, dateLib));
-	}, [props.timeZone]);
-	const { months, weeks, days, previousMonth: previousMonth$2, nextMonth: nextMonth$2 } = useMemo(() => {
-		const displayMonths = getDisplayMonths(firstMonth, navEnd, { numberOfMonths: props.numberOfMonths }, dateLib);
-		const months$1 = getMonths(displayMonths, getDates(displayMonths, props.endMonth ? endOfMonth$1(props.endMonth) : void 0, {
-			ISOWeek: props.ISOWeek,
-			fixedWeeks: props.fixedWeeks,
-			broadcastCalendar: props.broadcastCalendar
-		}, dateLib), {
-			broadcastCalendar: props.broadcastCalendar,
-			fixedWeeks: props.fixedWeeks,
-			ISOWeek: props.ISOWeek,
-			reverseMonths: props.reverseMonths
-		}, dateLib);
-		return {
-			months: months$1,
-			weeks: getWeeks(months$1),
-			days: getDays(months$1),
-			previousMonth: getPreviousMonth(firstMonth, navStart, props, dateLib),
-			nextMonth: getNextMonth(firstMonth, navEnd, props, dateLib)
-		};
-	}, [
-		dateLib,
-		firstMonth.getTime(),
-		navEnd?.getTime(),
-		navStart?.getTime(),
-		props.disableNavigation,
-		props.broadcastCalendar,
-		props.endMonth?.getTime(),
-		props.fixedWeeks,
-		props.ISOWeek,
-		props.numberOfMonths,
-		props.pagedNavigation,
-		props.reverseMonths
-	]);
-	const { disableNavigation, onMonthChange } = props;
-	const isDayInCalendar = (day) => weeks.some((week) => week.days.some((d) => d.isEqualTo(day)));
-	const goToMonth = (date) => {
-		if (disableNavigation) return;
-		let newMonth = startOfMonth$1(date);
-		if (navStart && newMonth < startOfMonth$1(navStart)) newMonth = startOfMonth$1(navStart);
-		if (navEnd && newMonth > startOfMonth$1(navEnd)) newMonth = startOfMonth$1(navEnd);
-		setFirstMonth(newMonth);
-		onMonthChange?.(newMonth);
-	};
-	const goToDay = (day) => {
-		if (isDayInCalendar(day)) return;
-		goToMonth(day.date);
-	};
-	return {
-		months,
-		weeks,
-		days,
-		navStart,
-		navEnd,
-		previousMonth: previousMonth$2,
-		nextMonth: nextMonth$2,
-		goToMonth,
-		goToDay
-	};
-}
-var FocusTargetPriority;
-(function(FocusTargetPriority$1) {
-	FocusTargetPriority$1[FocusTargetPriority$1["Today"] = 0] = "Today";
-	FocusTargetPriority$1[FocusTargetPriority$1["Selected"] = 1] = "Selected";
-	FocusTargetPriority$1[FocusTargetPriority$1["LastFocused"] = 2] = "LastFocused";
-	FocusTargetPriority$1[FocusTargetPriority$1["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;
-}
-function getFocusableDate(moveBy, moveDir, refDate, navStart, navEnd, props, dateLib) {
-	const { ISOWeek, broadcastCalendar } = props;
-	const { addDays: addDays$1, addMonths: addMonths$1, addWeeks: addWeeks$1, addYears: addYears$1, endOfBroadcastWeek: endOfBroadcastWeek$1, endOfISOWeek: endOfISOWeek$1, endOfWeek: endOfWeek$1, max: max$1, min: min$1, startOfBroadcastWeek: startOfBroadcastWeek$1, startOfISOWeek: startOfISOWeek$1, startOfWeek: startOfWeek$1 } = dateLib;
-	let focusableDate = {
-		day: addDays$1,
-		week: addWeeks$1,
-		month: addMonths$1,
-		year: addYears$1,
-		startOfWeek: (date) => broadcastCalendar ? startOfBroadcastWeek$1(date, dateLib) : ISOWeek ? startOfISOWeek$1(date) : startOfWeek$1(date),
-		endOfWeek: (date) => broadcastCalendar ? endOfBroadcastWeek$1(date) : ISOWeek ? endOfISOWeek$1(date) : endOfWeek$1(date)
-	}[moveBy](refDate, moveDir === "after" ? 1 : -1);
-	if (moveDir === "before" && navStart) focusableDate = max$1([navStart, focusableDate]);
-	else if (moveDir === "after" && navEnd) focusableDate = min$1([navEnd, focusableDate]);
-	return focusableDate;
-}
-function getNextFocus(moveBy, moveDir, refDay, calendarStartMonth, calendarEndMonth, props, dateLib, attempt = 0) {
-	if (attempt > 365) return;
-	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 focusDay = new CalendarDay(focusableDate, focusableDate, dateLib);
-	if (!isDisabled && !isHidden) return focusDay;
-	return getNextFocus(moveBy, moveDir, focusDay, calendarStartMonth, calendarEndMonth, props, dateLib, attempt + 1);
-}
-function useFocus(props, calendar, getModifiers, isSelected, dateLib) {
-	const { autoFocus } = props;
-	const [lastFocused, setLastFocused] = useState();
-	const focusTarget = calculateFocusTarget(calendar.days, getModifiers, isSelected || (() => false), lastFocused);
-	const [focusedDay, setFocused] = useState(autoFocus ? focusTarget : void 0);
-	const blur = () => {
-		setLastFocused(focusedDay);
-		setFocused(void 0);
-	};
-	const moveFocus = (moveBy, moveDir) => {
-		if (!focusedDay) return;
-		const nextFocus = getNextFocus(moveBy, moveDir, focusedDay, calendar.navStart, calendar.navEnd, props, dateLib);
-		if (!nextFocus) return;
-		if (props.disableNavigation) {
-			if (!calendar.days.some((day) => day.isEqualTo(nextFocus))) return;
-		}
-		calendar.goToDay(nextFocus);
-		setFocused(nextFocus);
-	};
-	const isFocusTarget = (day) => {
-		return Boolean(focusTarget?.isEqualTo(day));
-	};
-	return {
-		isFocusTarget,
-		setFocused,
-		focused: focusedDay,
-		blur,
-		moveFocus
-	};
-}
-function useMulti(props, dateLib) {
-	const { selected: initiallySelected, required, onSelect } = props;
-	const [internallySelected, setSelected] = useControlledValue(initiallySelected, onSelect ? initiallySelected : void 0);
-	const selected = !onSelect ? internallySelected : initiallySelected;
-	const { isSameDay: isSameDay$1 } = dateLib;
-	const isSelected = (date) => {
-		return selected?.some((d) => isSameDay$1(d, date)) ?? false;
-	};
-	const { min: min$1, max: max$1 } = props;
-	const select = (triggerDate, modifiers, e) => {
-		let newDates = [...selected ?? []];
-		if (isSelected(triggerDate)) {
-			if (selected?.length === min$1) return;
-			if (required && selected?.length === 1) return;
-			newDates = selected?.filter((d) => !isSameDay$1(d, triggerDate));
-		} else if (selected?.length === max$1) newDates = [triggerDate];
-		else newDates = [...newDates, triggerDate];
-		if (!onSelect) setSelected(newDates);
-		onSelect?.(newDates, triggerDate, modifiers, e);
-		return newDates;
-	};
-	return {
-		selected,
-		select,
-		isSelected
-	};
-}
-function addToRange(date, initialRange, min$1 = 0, max$1 = 0, required = false, dateLib = defaultDateLib) {
-	const { from, to } = initialRange || {};
-	const { isSameDay: isSameDay$1, isAfter: isAfter$1, isBefore: isBefore$1 } = dateLib;
-	let range;
-	if (!from && !to) range = {
-		from: date,
-		to: min$1 > 0 ? void 0 : date
-	};
-	else if (from && !to) if (isSameDay$1(from, date)) if (min$1 === 0) range = {
-		from,
-		to: date
-	};
-	else if (required) range = {
-		from,
-		to: void 0
-	};
-	else range = void 0;
-	else if (isBefore$1(date, from)) range = {
-		from: date,
-		to: from
-	};
-	else range = {
-		from,
-		to: date
-	};
-	else if (from && to) if (isSameDay$1(from, date) && isSameDay$1(to, date)) if (required) range = {
-		from,
-		to
-	};
-	else range = void 0;
-	else if (isSameDay$1(from, date)) range = {
-		from,
-		to: min$1 > 0 ? void 0 : date
-	};
-	else if (isSameDay$1(to, date)) range = {
-		from: date,
-		to: min$1 > 0 ? void 0 : date
-	};
-	else if (isBefore$1(date, from)) range = {
-		from: date,
-		to
-	};
-	else if (isAfter$1(date, from)) range = {
-		from,
-		to: date
-	};
-	else if (isAfter$1(date, to)) range = {
-		from,
-		to: date
-	};
-	else throw new Error("Invalid range");
-	if (range?.from && range?.to) {
-		const diff = dateLib.differenceInCalendarDays(range.to, range.from);
-		if (max$1 > 0 && diff > max$1) range = {
-			from: date,
-			to: void 0
-		};
-		else if (min$1 > 1 && diff < min$1) range = {
-			from: date,
-			to: void 0
-		};
-	}
-	return range;
-}
-function rangeContainsDayOfWeek(range, dayOfWeek, dateLib = defaultDateLib) {
-	const dayOfWeekArr = !Array.isArray(dayOfWeek) ? [dayOfWeek] : dayOfWeek;
-	let date = range.from;
-	const totalDays = dateLib.differenceInCalendarDays(range.to, range.from);
-	const totalDaysLimit = Math.min(totalDays, 6);
-	for (let i = 0; i <= totalDaysLimit; i++) {
-		if (dayOfWeekArr.includes(date.getDay())) return true;
-		date = dateLib.addDays(date, 1);
-	}
-	return false;
-}
-function rangeOverlaps(rangeLeft, rangeRight, dateLib = defaultDateLib) {
-	return rangeIncludesDate(rangeLeft, rangeRight.from, false, dateLib) || rangeIncludesDate(rangeLeft, rangeRight.to, false, dateLib) || rangeIncludesDate(rangeRight, rangeLeft.from, false, dateLib) || rangeIncludesDate(rangeRight, rangeLeft.to, false, dateLib);
-}
-function rangeContainsModifiers(range, modifiers, dateLib = defaultDateLib) {
-	const matchers = Array.isArray(modifiers) ? modifiers : [modifiers];
-	if (matchers.filter((matcher) => typeof matcher !== "function").some((matcher) => {
-		if (typeof matcher === "boolean") return matcher;
-		if (dateLib.isDate(matcher)) return rangeIncludesDate(range, matcher, false, dateLib);
-		if (isDatesArray(matcher, dateLib)) return matcher.some((date) => rangeIncludesDate(range, date, false, dateLib));
-		if (isDateRange(matcher)) {
-			if (matcher.from && matcher.to) return rangeOverlaps(range, {
-				from: matcher.from,
-				to: matcher.to
-			}, dateLib);
-			return false;
-		}
-		if (isDayOfWeekType(matcher)) return rangeContainsDayOfWeek(range, matcher.dayOfWeek, dateLib);
-		if (isDateInterval(matcher)) {
-			if (dateLib.isAfter(matcher.before, matcher.after)) return rangeOverlaps(range, {
-				from: dateLib.addDays(matcher.after, 1),
-				to: dateLib.addDays(matcher.before, -1)
-			}, dateLib);
-			return dateMatchModifiers(range.from, matcher, dateLib) || dateMatchModifiers(range.to, matcher, dateLib);
-		}
-		if (isDateAfterType(matcher) || isDateBeforeType(matcher)) return dateMatchModifiers(range.from, matcher, dateLib) || dateMatchModifiers(range.to, matcher, dateLib);
-		return false;
-	})) return true;
-	const functionMatchers = matchers.filter((matcher) => typeof matcher === "function");
-	if (functionMatchers.length) {
-		let date = range.from;
-		const totalDays = dateLib.differenceInCalendarDays(range.to, range.from);
-		for (let i = 0; i <= totalDays; i++) {
-			if (functionMatchers.some((matcher) => matcher(date))) return true;
-			date = dateLib.addDays(date, 1);
-		}
-	}
-	return false;
-}
-function useRange(props, dateLib) {
-	const { disabled, excludeDisabled, selected: initiallySelected, required, onSelect } = props;
-	const [internallySelected, setSelected] = useControlledValue(initiallySelected, onSelect ? initiallySelected : void 0);
-	const selected = !onSelect ? internallySelected : initiallySelected;
-	const isSelected = (date) => selected && rangeIncludesDate(selected, date, false, dateLib);
-	const select = (triggerDate, modifiers, e) => {
-		const { min: min$1, max: max$1 } = props;
-		const newRange = triggerDate ? addToRange(triggerDate, selected, min$1, max$1, required, dateLib) : void 0;
-		if (excludeDisabled && disabled && newRange?.from && newRange.to) {
-			if (rangeContainsModifiers({
-				from: newRange.from,
-				to: newRange.to
-			}, disabled, dateLib)) {
-				newRange.from = triggerDate;
-				newRange.to = void 0;
-			}
-		}
-		if (!onSelect) setSelected(newRange);
-		onSelect?.(newRange, triggerDate, modifiers, e);
-		return newRange;
-	};
-	return {
-		selected,
-		select,
-		isSelected
-	};
-}
-function useSingle(props, dateLib) {
-	const { selected: initiallySelected, required, onSelect } = props;
-	const [internallySelected, setSelected] = useControlledValue(initiallySelected, onSelect ? initiallySelected : void 0);
-	const selected = !onSelect ? internallySelected : initiallySelected;
-	const { isSameDay: isSameDay$1 } = dateLib;
-	const isSelected = (compareDate) => {
-		return selected ? isSameDay$1(selected, compareDate) : false;
-	};
-	const select = (triggerDate, modifiers, e) => {
-		let newDate = triggerDate;
-		if (!required && selected && selected && isSameDay$1(triggerDate, selected)) newDate = void 0;
-		if (!onSelect) setSelected(newDate);
-		if (required) onSelect?.(newDate, triggerDate, modifiers, e);
-		else onSelect?.(newDate, triggerDate, modifiers, e);
-		return newDate;
-	};
-	return {
-		selected,
-		select,
-		isSelected
-	};
-}
-function useSelection(props, dateLib) {
-	const single = useSingle(props, dateLib);
-	const multi = useMulti(props, dateLib);
-	const range = useRange(props, dateLib);
-	switch (props.mode) {
-		case "single": return single;
-		case "multiple": return multi;
-		case "range": return range;
-		default: return;
-	}
-}
-function toTimeZone(date, timeZone) {
-	if (date instanceof TZDate && date.timeZone === timeZone) return date;
-	return new TZDate(date, timeZone);
-}
-function convertMatcher(matcher, timeZone) {
-	if (typeof matcher === "boolean" || typeof matcher === "function") return matcher;
-	if (matcher instanceof Date) return toTimeZone(matcher, timeZone);
-	if (Array.isArray(matcher)) return matcher.map((value) => value instanceof Date ? toTimeZone(value, timeZone) : value);
-	if (isDateRange(matcher)) return {
-		...matcher,
-		from: matcher.from ? toTimeZone(matcher.from, timeZone) : matcher.from,
-		to: matcher.to ? toTimeZone(matcher.to, timeZone) : matcher.to
-	};
-	if (isDateInterval(matcher)) return {
-		before: toTimeZone(matcher.before, timeZone),
-		after: toTimeZone(matcher.after, timeZone)
-	};
-	if (isDateAfterType(matcher)) return { after: toTimeZone(matcher.after, timeZone) };
-	if (isDateBeforeType(matcher)) return { before: toTimeZone(matcher.before, timeZone) };
-	return matcher;
-}
-function convertMatchersToTimeZone(matchers, timeZone) {
-	if (!matchers) return matchers;
-	if (Array.isArray(matchers)) return matchers.map((matcher) => convertMatcher(matcher, timeZone));
-	return convertMatcher(matchers, timeZone);
-}
-function DayPicker(initialProps) {
-	let props = initialProps;
-	const timeZone = props.timeZone;
-	if (timeZone) {
-		props = {
-			...initialProps,
-			timeZone
-		};
-		if (props.today) props.today = toTimeZone(props.today, timeZone);
-		if (props.month) props.month = toTimeZone(props.month, timeZone);
-		if (props.defaultMonth) props.defaultMonth = toTimeZone(props.defaultMonth, timeZone);
-		if (props.startMonth) props.startMonth = toTimeZone(props.startMonth, timeZone);
-		if (props.endMonth) props.endMonth = toTimeZone(props.endMonth, timeZone);
-		if (props.mode === "single" && props.selected) props.selected = toTimeZone(props.selected, timeZone);
-		else if (props.mode === "multiple" && props.selected) props.selected = props.selected?.map((date) => toTimeZone(date, timeZone));
-		else if (props.mode === "range" && props.selected) props.selected = {
-			from: props.selected.from ? toTimeZone(props.selected.from, timeZone) : props.selected.from,
-			to: props.selected.to ? toTimeZone(props.selected.to, timeZone) : props.selected.to
-		};
-		if (props.disabled !== void 0) props.disabled = convertMatchersToTimeZone(props.disabled, timeZone);
-		if (props.hidden !== void 0) props.hidden = convertMatchersToTimeZone(props.hidden, timeZone);
-		if (props.modifiers) {
-			const nextModifiers = {};
-			Object.keys(props.modifiers).forEach((key) => {
-				nextModifiers[key] = convertMatchersToTimeZone(props.modifiers?.[key], timeZone);
-			});
-			props.modifiers = nextModifiers;
-		}
-	}
-	const { components, formatters, labels, dateLib, locale, classNames: classNames$1 } = useMemo(() => {
-		const locale$1 = {
-			...defaultLocale,
-			...props.locale
-		};
-		return {
-			dateLib: new DateLib({
-				locale: locale$1,
-				weekStartsOn: props.broadcastCalendar ? 1 : props.weekStartsOn,
-				firstWeekContainsDate: props.firstWeekContainsDate,
-				useAdditionalWeekYearTokens: props.useAdditionalWeekYearTokens,
-				useAdditionalDayOfYearTokens: props.useAdditionalDayOfYearTokens,
-				timeZone: props.timeZone,
-				numerals: props.numerals
-			}, props.dateLib),
-			components: getComponents(props.components),
-			formatters: getFormatters(props.formatters),
-			labels: {
-				...labels_exports,
-				...props.labels
-			},
-			locale: locale$1,
-			classNames: {
-				...getDefaultClassNames(),
-				...props.classNames
-			}
-		};
-	}, [
-		props.locale,
-		props.broadcastCalendar,
-		props.weekStartsOn,
-		props.firstWeekContainsDate,
-		props.useAdditionalWeekYearTokens,
-		props.useAdditionalDayOfYearTokens,
-		props.timeZone,
-		props.numerals,
-		props.dateLib,
-		props.components,
-		props.formatters,
-		props.labels,
-		props.classNames
-	]);
-	if (!props.today) props = {
-		...props,
-		today: dateLib.today()
-	};
-	const { captionLayout, mode, navLayout, numberOfMonths = 1, onDayBlur, onDayClick, onDayFocus, onDayKeyDown, onDayMouseEnter, onDayMouseLeave, onNextClick, onPrevClick, showWeekNumber, styles: styles$1 } = props;
-	const { formatCaption: formatCaption$1, formatDay: formatDay$1, formatMonthDropdown: formatMonthDropdown$1, formatWeekNumber: formatWeekNumber$1, formatWeekNumberHeader: formatWeekNumberHeader$1, formatWeekdayName: formatWeekdayName$1, formatYearDropdown: formatYearDropdown$1 } = formatters;
-	const calendar = useCalendar(props, dateLib);
-	const { days, months, navStart, navEnd, previousMonth: previousMonth$2, nextMonth: nextMonth$2, goToMonth } = calendar;
-	const getModifiers = createGetModifiers(days, props, navStart, navEnd, dateLib);
-	const { isSelected, select, selected: selectedValue } = useSelection(props, dateLib) ?? {};
-	const { blur, focused, isFocusTarget, moveFocus, setFocused } = useFocus(props, calendar, getModifiers, isSelected ?? (() => false), dateLib);
-	const { labelDayButton: labelDayButton$1, labelGridcell: labelGridcell$1, labelGrid: labelGrid$1, labelMonthDropdown: labelMonthDropdown$1, labelNav: labelNav$1, labelPrevious: labelPrevious$1, labelNext: labelNext$1, labelWeekday: labelWeekday$1, labelWeekNumber: labelWeekNumber$1, labelWeekNumberHeader: labelWeekNumberHeader$1, labelYearDropdown: labelYearDropdown$1 } = labels;
-	const weekdays = useMemo(() => getWeekdays(dateLib, props.ISOWeek, props.broadcastCalendar, props.today), [
-		dateLib,
-		props.ISOWeek,
-		props.broadcastCalendar,
-		props.today
-	]);
-	const isInteractive = mode !== void 0 || onDayClick !== void 0;
-	const handlePreviousClick = useCallback(() => {
-		if (!previousMonth$2) return;
-		goToMonth(previousMonth$2);
-		onPrevClick?.(previousMonth$2);
-	}, [
-		previousMonth$2,
-		goToMonth,
-		onPrevClick
-	]);
-	const handleNextClick = useCallback(() => {
-		if (!nextMonth$2) return;
-		goToMonth(nextMonth$2);
-		onNextClick?.(nextMonth$2);
-	}, [
-		goToMonth,
-		nextMonth$2,
-		onNextClick
-	]);
-	const handleDayClick = useCallback((day, m) => (e) => {
-		e.preventDefault();
-		e.stopPropagation();
-		setFocused(day);
-		select?.(day.date, m, e);
-		onDayClick?.(day.date, m, e);
-	}, [
-		select,
-		onDayClick,
-		setFocused
-	]);
-	const handleDayFocus = useCallback((day, m) => (e) => {
-		setFocused(day);
-		onDayFocus?.(day.date, m, e);
-	}, [onDayFocus, setFocused]);
-	const handleDayBlur = useCallback((day, m) => (e) => {
-		blur();
-		onDayBlur?.(day.date, m, e);
-	}, [blur, onDayBlur]);
-	const handleDayKeyDown = useCallback((day, modifiers) => (e) => {
-		const keyMap = {
-			ArrowLeft: [e.shiftKey ? "month" : "day", props.dir === "rtl" ? "after" : "before"],
-			ArrowRight: [e.shiftKey ? "month" : "day", props.dir === "rtl" ? "before" : "after"],
-			ArrowDown: [e.shiftKey ? "year" : "week", "after"],
-			ArrowUp: [e.shiftKey ? "year" : "week", "before"],
-			PageUp: [e.shiftKey ? "year" : "month", "before"],
-			PageDown: [e.shiftKey ? "year" : "month", "after"],
-			Home: ["startOfWeek", "before"],
-			End: ["endOfWeek", "after"]
-		};
-		if (keyMap[e.key]) {
-			e.preventDefault();
-			e.stopPropagation();
-			const [moveBy, moveDir] = keyMap[e.key];
-			moveFocus(moveBy, moveDir);
-		}
-		onDayKeyDown?.(day.date, modifiers, e);
-	}, [
-		moveFocus,
-		onDayKeyDown,
-		props.dir
-	]);
-	const handleDayMouseEnter = useCallback((day, modifiers) => (e) => {
-		onDayMouseEnter?.(day.date, modifiers, e);
-	}, [onDayMouseEnter]);
-	const handleDayMouseLeave = useCallback((day, modifiers) => (e) => {
-		onDayMouseLeave?.(day.date, modifiers, e);
-	}, [onDayMouseLeave]);
-	const handleMonthChange = useCallback((date) => (e) => {
-		const selectedMonth = Number(e.target.value);
-		goToMonth(dateLib.setMonth(dateLib.startOfMonth(date), selectedMonth));
-	}, [dateLib, goToMonth]);
-	const handleYearChange = useCallback((date) => (e) => {
-		const selectedYear = Number(e.target.value);
-		goToMonth(dateLib.setYear(dateLib.startOfMonth(date), selectedYear));
-	}, [dateLib, goToMonth]);
-	const { className, style } = useMemo(() => ({
-		className: [classNames$1[UI.Root], props.className].filter(Boolean).join(" "),
-		style: {
-			...styles$1?.[UI.Root],
-			...props.style
-		}
-	}), [
-		classNames$1,
-		props.className,
-		props.style,
-		styles$1
-	]);
-	const dataAttributes = getDataAttributes(props);
-	const rootElRef = useRef(null);
-	useAnimation(rootElRef, Boolean(props.animate), {
-		classNames: classNames$1,
-		months,
-		focused,
-		dateLib
-	});
-	const contextValue = {
-		dayPickerProps: props,
-		selected: selectedValue,
-		select,
-		isSelected,
-		months,
-		nextMonth: nextMonth$2,
-		previousMonth: previousMonth$2,
-		goToMonth,
-		getModifiers,
-		components,
-		classNames: classNames$1,
-		styles: styles$1,
-		labels,
-		formatters
-	};
-	return React.createElement(dayPickerContext.Provider, { value: contextValue }, React.createElement(components.Root, {
-		rootRef: props.animate ? rootElRef : void 0,
-		className,
-		style,
-		dir: props.dir,
-		id: props.id,
-		lang: props.lang,
-		nonce: props.nonce,
-		title: props.title,
-		role: props.role,
-		"aria-label": props["aria-label"],
-		"aria-labelledby": props["aria-labelledby"],
-		...dataAttributes
-	}, React.createElement(components.Months, {
-		className: classNames$1[UI.Months],
-		style: styles$1?.[UI.Months]
-	}, !props.hideNavigation && !navLayout && React.createElement(components.Nav, {
-		"data-animated-nav": props.animate ? "true" : void 0,
-		className: classNames$1[UI.Nav],
-		style: styles$1?.[UI.Nav],
-		"aria-label": labelNav$1(),
-		onPreviousClick: handlePreviousClick,
-		onNextClick: handleNextClick,
-		previousMonth: previousMonth$2,
-		nextMonth: nextMonth$2
-	}), months.map((calendarMonth, displayIndex) => {
-		return React.createElement(components.Month, {
-			"data-animated-month": props.animate ? "true" : void 0,
-			className: classNames$1[UI.Month],
-			style: styles$1?.[UI.Month],
-			key: displayIndex,
-			displayIndex,
-			calendarMonth
-		}, navLayout === "around" && !props.hideNavigation && displayIndex === 0 && React.createElement(components.PreviousMonthButton, {
-			type: "button",
-			className: classNames$1[UI.PreviousMonthButton],
-			tabIndex: previousMonth$2 ? void 0 : -1,
-			"aria-disabled": previousMonth$2 ? void 0 : true,
-			"aria-label": labelPrevious$1(previousMonth$2),
-			onClick: handlePreviousClick,
-			"data-animated-button": props.animate ? "true" : void 0
-		}, React.createElement(components.Chevron, {
-			disabled: previousMonth$2 ? void 0 : true,
-			className: classNames$1[UI.Chevron],
-			orientation: props.dir === "rtl" ? "right" : "left"
-		})), React.createElement(components.MonthCaption, {
-			"data-animated-caption": props.animate ? "true" : void 0,
-			className: classNames$1[UI.MonthCaption],
-			style: styles$1?.[UI.MonthCaption],
-			calendarMonth,
-			displayIndex
-		}, captionLayout?.startsWith("dropdown") ? React.createElement(components.DropdownNav, {
-			className: classNames$1[UI.Dropdowns],
-			style: styles$1?.[UI.Dropdowns]
-		}, (() => {
-			const monthControl = captionLayout === "dropdown" || captionLayout === "dropdown-months" ? React.createElement(components.MonthsDropdown, {
-				key: "month",
-				className: classNames$1[UI.MonthsDropdown],
-				"aria-label": labelMonthDropdown$1(),
-				classNames: classNames$1,
-				components,
-				disabled: Boolean(props.disableNavigation),
-				onChange: handleMonthChange(calendarMonth.date),
-				options: getMonthOptions(calendarMonth.date, navStart, navEnd, formatters, dateLib),
-				style: styles$1?.[UI.Dropdown],
-				value: dateLib.getMonth(calendarMonth.date)
-			}) : React.createElement("span", { key: "month" }, formatMonthDropdown$1(calendarMonth.date, dateLib));
-			const yearControl = captionLayout === "dropdown" || captionLayout === "dropdown-years" ? React.createElement(components.YearsDropdown, {
-				key: "year",
-				className: classNames$1[UI.YearsDropdown],
-				"aria-label": labelYearDropdown$1(dateLib.options),
-				classNames: classNames$1,
-				components,
-				disabled: Boolean(props.disableNavigation),
-				onChange: handleYearChange(calendarMonth.date),
-				options: getYearOptions(navStart, navEnd, formatters, dateLib, Boolean(props.reverseYears)),
-				style: styles$1?.[UI.Dropdown],
-				value: dateLib.getYear(calendarMonth.date)
-			}) : React.createElement("span", { key: "year" }, formatYearDropdown$1(calendarMonth.date, dateLib));
-			return dateLib.getMonthYearOrder() === "year-first" ? [yearControl, monthControl] : [monthControl, yearControl];
-		})(), React.createElement("span", {
-			role: "status",
-			"aria-live": "polite",
-			style: {
-				border: 0,
-				clip: "rect(0 0 0 0)",
-				height: "1px",
-				margin: "-1px",
-				overflow: "hidden",
-				padding: 0,
-				position: "absolute",
-				width: "1px",
-				whiteSpace: "nowrap",
-				wordWrap: "normal"
-			}
-		}, formatCaption$1(calendarMonth.date, dateLib.options, dateLib))) : React.createElement(components.CaptionLabel, {
-			className: classNames$1[UI.CaptionLabel],
-			role: "status",
-			"aria-live": "polite"
-		}, formatCaption$1(calendarMonth.date, dateLib.options, dateLib))), navLayout === "around" && !props.hideNavigation && displayIndex === numberOfMonths - 1 && React.createElement(components.NextMonthButton, {
-			type: "button",
-			className: classNames$1[UI.NextMonthButton],
-			tabIndex: nextMonth$2 ? void 0 : -1,
-			"aria-disabled": nextMonth$2 ? void 0 : true,
-			"aria-label": labelNext$1(nextMonth$2),
-			onClick: handleNextClick,
-			"data-animated-button": props.animate ? "true" : void 0
-		}, React.createElement(components.Chevron, {
-			disabled: nextMonth$2 ? void 0 : true,
-			className: classNames$1[UI.Chevron],
-			orientation: props.dir === "rtl" ? "left" : "right"
-		})), displayIndex === numberOfMonths - 1 && navLayout === "after" && !props.hideNavigation && React.createElement(components.Nav, {
-			"data-animated-nav": props.animate ? "true" : void 0,
-			className: classNames$1[UI.Nav],
-			style: styles$1?.[UI.Nav],
-			"aria-label": labelNav$1(),
-			onPreviousClick: handlePreviousClick,
-			onNextClick: handleNextClick,
-			previousMonth: previousMonth$2,
-			nextMonth: nextMonth$2
-		}), React.createElement(components.MonthGrid, {
-			role: "grid",
-			"aria-multiselectable": mode === "multiple" || mode === "range",
-			"aria-label": labelGrid$1(calendarMonth.date, dateLib.options, dateLib) || void 0,
-			className: classNames$1[UI.MonthGrid],
-			style: styles$1?.[UI.MonthGrid]
-		}, !props.hideWeekdays && React.createElement(components.Weekdays, {
-			"data-animated-weekdays": props.animate ? "true" : void 0,
-			className: classNames$1[UI.Weekdays],
-			style: styles$1?.[UI.Weekdays]
-		}, showWeekNumber && React.createElement(components.WeekNumberHeader, {
-			"aria-label": labelWeekNumberHeader$1(dateLib.options),
-			className: classNames$1[UI.WeekNumberHeader],
-			style: styles$1?.[UI.WeekNumberHeader],
-			scope: "col"
-		}, formatWeekNumberHeader$1()), weekdays.map((weekday) => React.createElement(components.Weekday, {
-			"aria-label": labelWeekday$1(weekday, dateLib.options, dateLib),
-			className: classNames$1[UI.Weekday],
-			key: String(weekday),
-			style: styles$1?.[UI.Weekday],
-			scope: "col"
-		}, formatWeekdayName$1(weekday, dateLib.options, dateLib)))), React.createElement(components.Weeks, {
-			"data-animated-weeks": props.animate ? "true" : void 0,
-			className: classNames$1[UI.Weeks],
-			style: styles$1?.[UI.Weeks]
-		}, calendarMonth.weeks.map((week) => {
-			return React.createElement(components.Week, {
-				className: classNames$1[UI.Week],
-				key: week.weekNumber,
-				style: styles$1?.[UI.Week],
-				week
-			}, showWeekNumber && React.createElement(components.WeekNumber, {
-				week,
-				style: styles$1?.[UI.WeekNumber],
-				"aria-label": labelWeekNumber$1(week.weekNumber, { locale }),
-				className: classNames$1[UI.WeekNumber],
-				scope: "row",
-				role: "rowheader"
-			}, formatWeekNumber$1(week.weekNumber, dateLib)), week.days.map((day) => {
-				const { date } = day;
-				const modifiers = getModifiers(day);
-				modifiers[DayFlag.focused] = !modifiers.hidden && Boolean(focused?.isEqualTo(day));
-				modifiers[SelectionState.selected] = isSelected?.(date) || modifiers.selected;
-				if (isDateRange(selectedValue)) {
-					const { from, to } = selectedValue;
-					modifiers[SelectionState.range_start] = Boolean(from && to && dateLib.isSameDay(date, from));
-					modifiers[SelectionState.range_end] = Boolean(from && to && dateLib.isSameDay(date, to));
-					modifiers[SelectionState.range_middle] = rangeIncludesDate(selectedValue, date, true, dateLib);
-				}
-				const style$1 = getStyleForModifiers(modifiers, styles$1, props.modifiersStyles);
-				const className$1 = getClassNamesForModifiers(modifiers, classNames$1, props.modifiersClassNames);
-				const ariaLabel = !isInteractive && !modifiers.hidden ? labelGridcell$1(date, modifiers, dateLib.options, dateLib) : void 0;
-				return React.createElement(components.Day, {
-					key: `${day.isoDate}_${day.displayMonthId}`,
-					day,
-					modifiers,
-					className: className$1.join(" "),
-					style: style$1,
-					role: "gridcell",
-					"aria-selected": modifiers.selected || void 0,
-					"aria-label": ariaLabel,
-					"data-day": day.isoDate,
-					"data-month": day.outside ? day.dateMonthId : void 0,
-					"data-selected": modifiers.selected || void 0,
-					"data-disabled": modifiers.disabled || void 0,
-					"data-hidden": modifiers.hidden || void 0,
-					"data-outside": day.outside || void 0,
-					"data-focused": modifiers.focused || void 0,
-					"data-today": modifiers.today || void 0
-				}, !modifiers.hidden && isInteractive ? React.createElement(components.DayButton, {
-					className: classNames$1[UI.DayButton],
-					style: styles$1?.[UI.DayButton],
-					type: "button",
-					day,
-					modifiers,
-					disabled: !modifiers.focused && modifiers.disabled || void 0,
-					"aria-disabled": modifiers.focused && modifiers.disabled || void 0,
-					tabIndex: isFocusTarget(day) ? 0 : -1,
-					"aria-label": labelDayButton$1(date, modifiers, dateLib.options, dateLib),
-					onClick: handleDayClick(day, modifiers),
-					onBlur: handleDayBlur(day, modifiers),
-					onFocus: handleDayFocus(day, modifiers),
-					onKeyDown: handleDayKeyDown(day, modifiers),
-					onMouseEnter: handleDayMouseEnter(day, modifiers),
-					onMouseLeave: handleDayMouseLeave(day, modifiers)
-				}, formatDay$1(date, dateLib.options, dateLib)) : !modifiers.hidden && formatDay$1(day.date, dateLib.options, dateLib));
-			}));
-		}))));
-	})), props.footer && React.createElement(components.Footer, {
-		className: classNames$1[UI.Footer],
-		style: styles$1?.[UI.Footer],
-		role: "status",
-		"aria-live": "polite"
-	}, props.footer)));
-}
 var BUBBLE_WIDTH_PX = 329;
 var WINDOW_MARGIN_PX = 12;
 var BUBBLE_VERTICAL_OFFSET_PX = 26;
@@ -2202,10 +239,7 @@ var HN_Designsystem_DatePicker_en_GB_default = {
 	nextMonth: "Next month",
 	previousMonth: "Previous month",
 	monthDropdown: "Select month",
-	yearDropdown: "Select year",
-	dayFormatPlaceholder: "dd",
-	monthFormatPlaceholder: "mm",
-	yearFormatPlaceholder: "yyyy"
+	yearDropdown: "Select year"
 };
 var HN_Designsystem_DatePicker_nb_NO_default = {
 	dateButtonAriaLabel: "Åpne datovelger",
@@ -2215,12 +249,7 @@ var HN_Designsystem_DatePicker_nb_NO_default = {
 	nextMonth: "Neste måned",
 	previousMonth: "Forrige måned",
 	monthDropdown: "Velg måned",
-	yearDropdown: "Velg år",
-	goToToday: "Gå til i dag",
-	loadingText: "Henter info. Vennligst vent.",
-	dayFormatPlaceholder: "dd",
-	monthFormatPlaceholder: "mm",
-	yearFormatPlaceholder: "åååå"
+	yearDropdown: "Velg år"
 };
 const getResources = (language) => {
 	switch (language) {