ivt 0.7.3 → 0.7.5

package/dist/chunks/{calendar-DtKpXGXO.mjs → calendar-C549VT55.mjs}

@@ -1,232 +1,572 @@
 import * as React from 'react';
 import React__default, { createContext, useContext, useCallback, useRef, useLayoutEffect, useState, useEffect, useMemo } from 'react';
-import { c as cn } from './utils-BqIRZT53.mjs';
-import { t as toDate, c as constructFrom, j as addDays, y as normalizeDates, z as startOfDay, g as getDefaultOptions, A as differenceInCalendarDays, f as format, i as getISOWeek, h as getWeek, B as isDate, e as startOfISOWeek, s as startOfWeek, C as startOfYear, l as enUS } from './format-C24_9AKp.mjs';
-import { C as ChevronLeft } from './chevron-left-DGlHB7Nw.mjs';
-import { C as ChevronRight } from './chevron-right-B6bwFEdI.mjs';
-import { C as ChevronDown } from './chevron-down-gO34wzc7.mjs';
-import { b as buttonVariants, B as Button$1 } from './button-DHQrVlqk.mjs';
+import { c as cn } from './utils-uOfHPBdi.mjs';
+import { t as toDate, c as constructFrom, j as addDays, y as normalizeDates, z as startOfDay, g as getDefaultOptions, l as enUS$1, f as format, A as differenceInCalendarDays, i as getISOWeek, h as getWeek, B as isDate, e as startOfISOWeek, s as startOfWeek, C as startOfYear } from './format-CR4Q6BSq.mjs';
+import { C as ChevronLeft } from './chevron-left-BZ8X7kLy.mjs';
+import { C as ChevronRight } from './chevron-right-jAScR3zY.mjs';
+import { C as ChevronDown } from './chevron-down-o7NUBnJ4.mjs';
+import { b as buttonVariants, B as Button$1 } from './button-BW9I4XWU.mjs';
 
 /**
- * The {@link addMonths} function options.
+ * Time zone name format.
  */ /**
- * @name addMonths
- * @category Month Helpers
- * @summary Add the specified number of months to the given date.
+ * The function returns the time zone name for the given date in the specified
+ * time zone.
  *
- * @description
- * Add the specified number of months to the given date.
+ * It uses the `Intl.DateTimeFormat` API and by default outputs the time zone
+ * name in a long format, e.g. "Pacific Standard Time" or
+ * "Singapore Standard Time".
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ * It is possible to specify the format as the third argument using one of the following options
  *
- * @param date - The date to be changed
- * @param amount - The amount of months to be added.
- * @param options - The options object
+ * - "short": e.g. "EDT" or "GMT+8".
+ * - "long": e.g. "Eastern Daylight Time".
+ * - "shortGeneric": e.g. "ET" or "Singapore Time".
+ * - "longGeneric": e.g. "Eastern Time" or "Singapore Standard Time".
  *
- * @returns The new date with the months added
+ * These options correspond to TR35 tokens `z..zzz`, `zzzz`, `v`, and `vvvv` respectively: https://www.unicode.org/reports/tr35/tr35-dates.html#dfst-zone
  *
- * @example
- * // Add 5 months to 1 September 2014:
- * const result = addMonths(new Date(2014, 8, 1), 5)
- * //=> Sun Feb 01 2015 00:00:00
+ * @param timeZone - Time zone name (IANA or UTC offset)
+ * @param date - Date object to get the time zone name for
+ * @param format - Optional format of the time zone name. Defaults to "long". Can be "short", "long", "shortGeneric", or "longGeneric".
  *
- * // Add one month to 30 January 2023:
- * const result = addMonths(new Date(2023, 0, 30), 1)
- * //=> Tue Feb 28 2023 00:00:00
- */ function addMonths(date, amount, options) {
-    const _date = toDate(date, options?.in);
-    if (isNaN(amount)) return constructFrom(date, NaN);
-    if (!amount) {
-        // If 0 months, no-op to avoid changing times in the hour before end of DST
-        return _date;
-    }
-    const 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.
-    const endOfDesiredMonth = constructFrom(date, _date.getTime());
-    endOfDesiredMonth.setMonth(_date.getMonth() + amount + 1, 0);
-    const 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;
-    }
+ * @returns Time zone name (e.g. "Singapore Standard Time")
+ */ function tzName(timeZone, date, format = "long") {
+    return new Intl.DateTimeFormat("en-US", {
+        // Enforces engine to render the time. Without the option JavaScriptCore omits it.
+        hour: "numeric",
+        timeZone: timeZone,
+        timeZoneName: format
+    }).format(date).split(/\s/g) // Format.JS uses non-breaking spaces
+    .slice(2) // Skip the hour and AM/PM parts
+    .join(" ");
 }
 
+const offsetFormatCache = {};
+const offsetCache = {};
 /**
- * The {@link addWeeks} function options.
- */ /**
- * @name addWeeks
- * @category Week Helpers
- * @summary Add the specified number of weeks to the given date.
- *
- * @description
- * Add the specified number of weeks to the given date.
- *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ * The function extracts UTC offset in minutes from the given date in specified
+ * time zone.
  *
- * @param date - The date to be changed
- * @param amount - The amount of weeks to be added.
- * @param options - An object with options
+ * Unlike `Date.prototype.getTimezoneOffset`, this function returns the value
+ * mirrored to the sign of the offset in the time zone. For Asia/Singapore
+ * (UTC+8), `tzOffset` returns 480, while `getTimezoneOffset` returns -480.
  *
- * @returns The new date with the weeks added
+ * @param timeZone - Time zone name (IANA or UTC offset)
+ * @param date - Date to check the offset for
  *
- * @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(date, amount, options) {
-    return addDays(date, amount * 7, options);
+ * @returns UTC offset in minutes
+ */ function tzOffset(timeZone, date) {
+    try {
+        var _offsetFormatCache, _timeZone;
+        const format = (_offsetFormatCache = offsetFormatCache)[_timeZone = timeZone] || (_offsetFormatCache[_timeZone] = new Intl.DateTimeFormat("en-US", {
+            timeZone,
+            timeZoneName: "longOffset"
+        }).format);
+        const offsetStr = format(date).split("GMT")[1];
+        if (offsetStr in offsetCache) return offsetCache[offsetStr];
+        return calcOffset(offsetStr, offsetStr.split(":"));
+    } catch  {
+        // Fallback to manual parsing if the runtime doesn't support ±HH:MM/±HHMM/±HH
+        // See: https://github.com/nodejs/node/issues/53419
+        if (timeZone in offsetCache) return offsetCache[timeZone];
+        const captures = timeZone?.match(offsetRe);
+        if (captures) return calcOffset(timeZone, captures.slice(1));
+        return NaN;
+    }
+}
+const offsetRe = /([+-]\d\d):?(\d\d)?/;
+function calcOffset(cacheStr, values) {
+    const hours = +(values[0] || 0);
+    const minutes = +(values[1] || 0);
+    // Convert seconds to minutes by dividing by 60 to keep the function return in minutes.
+    const seconds = +(values[2] || 0) / 60;
+    return offsetCache[cacheStr] = hours * 60 + minutes > 0 ? hours * 60 + minutes + seconds : hours * 60 - minutes - seconds;
 }
 
+class TZDateMini extends Date {
+    static tz(tz, ...args) {
+        return args.length ? new TZDateMini(...args, tz) : new TZDateMini(Date.now(), tz);
+    }
+    //#endregion
+    //#region time zone
+    withTimeZone(timeZone) {
+        return new TZDateMini(+this, timeZone);
+    }
+    getTimezoneOffset() {
+        const offset = -tzOffset(this.timeZone, this);
+        // Remove the seconds offset
+        // use Math.floor for negative GMT timezones and Math.ceil for positive GMT timezones.
+        return offset > 0 ? Math.floor(offset) : Math.ceil(offset);
+    }
+    //#endregion
+    //#region time
+    setTime(time) {
+        Date.prototype.setTime.apply(this, arguments);
+        syncToInternal(this);
+        return +this;
+    }
+    //#endregion
+    //#region date-fns integration
+    [Symbol.for("constructDateFrom")](date) {
+        return new TZDateMini(+new Date(date), this.timeZone);
+    }
+    //#region static
+    constructor(...args){
+        super();
+        if (args.length > 1 && typeof args[args.length - 1] === "string") {
+            this.timeZone = args.pop();
+        }
+        this.internal = 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);
+                syncToInternal(this);
+            }
+        }
+    }
+}
+// Assign getters and setters
+const re = /^(get|set)(?!UTC)/;
+Object.getOwnPropertyNames(Date.prototype).forEach((method)=>{
+    if (!re.test(method)) return;
+    const utcMethod = method.replace(re, "$1UTC");
+    // Filter out methods without UTC counterparts
+    if (!TZDateMini.prototype[utcMethod]) return;
+    if (method.startsWith("get")) {
+        // Delegate to internal date's UTC method
+        TZDateMini.prototype[method] = function() {
+            return this.internal[utcMethod]();
+        };
+    } else {
+        // Assign regular setter
+        TZDateMini.prototype[method] = function() {
+            Date.prototype[utcMethod].apply(this.internal, arguments);
+            syncFromInternal(this);
+            return +this;
+        };
+        // Assign UTC setter
+        TZDateMini.prototype[utcMethod] = function() {
+            Date.prototype[utcMethod].apply(this, arguments);
+            syncToInternal(this);
+            return +this;
+        };
+    }
+});
 /**
- * The {@link addYears} function options.
- */ /**
- * @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.
- *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- * @typeParam ResultDate - The result `Date` type.
- *
- * @param date - The date to be changed
- * @param amount - The amount of years to be added.
- * @param options - The options
- *
- * @returns The new date with the years added
+ * Function syncs time to internal date, applying the time zone offset.
  *
- * @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(date, amount, options) {
-    return addMonths(date, amount * 12, options);
+ * @param {Date} date - Date to sync
+ */ function syncToInternal(date) {
+    date.internal.setTime(+date);
+    date.internal.setUTCSeconds(date.internal.getUTCSeconds() - Math.round(-tzOffset(date.timeZone, date) * 60));
 }
-
 /**
- * The {@link max} function options.
- */ /**
- * @name max
- * @category Common Helpers
- * @summary Return the latest of the given dates.
- *
- * @description
- * Return the latest of the given dates.
+ * Function syncs the internal date UTC values to the date. It allows to get
+ * accurate timestamp value.
  *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
- *
- * @param dates - The dates to compare
- *
- * @returns The latest of the dates
- *
- * @example
- * // Which of these dates is the latest?
- * const result = max([
- *   new Date(1989, 6, 10),
- *   new Date(1987, 1, 11),
- *   new Date(1995, 6, 2),
- *   new Date(1990, 0, 1)
- * ])
- * //=> Sun Jul 02 1995 00:00:00
- */ function max(dates, options) {
-    let result;
-    let context = options?.in;
-    dates.forEach((date)=>{
-        // Use the first date object as the context function
-        if (!context && typeof date === "object") context = constructFrom.bind(null, date);
-        const date_ = toDate(date, context);
-        if (!result || result < date_ || isNaN(+date_)) result = date_;
-    });
-    return constructFrom(context, result || NaN);
+ * @param {Date} date - The date to sync
+ */ function syncFromInternal(date) {
+    // First we transpose the internal values
+    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());
+    // Now we have to adjust the date to the system time zone
+    adjustToSystemTZ(date);
 }
-
 /**
- * The {@link min} function options.
- */ /**
- * @name min
- * @category Common Helpers
- * @summary Returns the earliest of the given dates.
- *
- * @description
- * Returns the earliest of the given dates.
- *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
- *
- * @param dates - The dates to compare
- *
- * @returns The earliest of the dates
+ * Function adjusts the date to the system time zone. It uses the time zone
+ * differences to calculate the offset and adjust the date.
  *
- * @example
- * // Which of these dates is the earliest?
- * const result = min([
- *   new Date(1989, 6, 10),
- *   new Date(1987, 1, 11),
- *   new Date(1995, 6, 2),
- *   new Date(1990, 0, 1)
- * ])
- * //=> Wed Feb 11 1987 00:00:00
- */ function min(dates, options) {
-    let result;
-    let context = options?.in;
-    dates.forEach((date)=>{
-        // Use the first date object as the context function
-        if (!context && typeof date === "object") context = constructFrom.bind(null, date);
-        const date_ = toDate(date, context);
-        if (!result || result > date_ || isNaN(+date_)) result = date_;
-    });
-    return constructFrom(context, result || NaN);
+ * @param {Date} date - Date to adjust
+ */ function adjustToSystemTZ(date) {
+    // Save the time zone offset before all the adjustments
+    const baseOffset = tzOffset(date.timeZone, date);
+    // Remove the seconds offset
+    // use Math.floor for negative GMT timezones and Math.ceil for positive GMT timezones.
+    const offset = baseOffset > 0 ? Math.floor(baseOffset) : Math.ceil(baseOffset);
+    //#region System DST adjustment
+    // The biggest problem with using the system time zone is that when we create
+    // a date from internal values stored in UTC, the system time zone might end
+    // up on the DST hour:
+    //
+    //   $ TZ=America/New_York node
+    //   > new Date(2020, 2, 8, 1).toString()
+    //   'Sun Mar 08 2020 01:00:00 GMT-0500 (Eastern Standard Time)'
+    //   > new Date(2020, 2, 8, 2).toString()
+    //   'Sun Mar 08 2020 03:00:00 GMT-0400 (Eastern Daylight Time)'
+    //   > new Date(2020, 2, 8, 3).toString()
+    //   'Sun Mar 08 2020 03:00:00 GMT-0400 (Eastern Daylight Time)'
+    //   > new Date(2020, 2, 8, 4).toString()
+    //   'Sun Mar 08 2020 04:00:00 GMT-0400 (Eastern Daylight Time)'
+    //
+    // Here we get the same hour for both 2 and 3, because the system time zone
+    // has DST beginning at 8 March 2020, 2 a.m. and jumps to 3 a.m. So we have
+    // to adjust the internal date to reflect that.
+    //
+    // However we want to adjust only if that's the DST hour the change happenes,
+    // not the hour where DST moves to.
+    // We calculate the previous hour to see if the time zone offset has changed
+    // and we have landed on the DST hour.
+    const prevHour = new Date(+date);
+    // We use UTC methods here as we don't want to land on the same hour again
+    // in case of DST.
+    prevHour.setUTCHours(prevHour.getUTCHours() - 1);
+    // Calculate if we are on the system DST hour.
+    const systemOffset = -new Date(+date).getTimezoneOffset();
+    const prevHourSystemOffset = -new Date(+prevHour).getTimezoneOffset();
+    const systemDSTChange = systemOffset - prevHourSystemOffset;
+    // Detect the DST shift. System DST change will occur both on
+    const dstShift = Date.prototype.getHours.apply(date) !== date.internal.getUTCHours();
+    // Move the internal date when we are on the system DST hour.
+    if (systemDSTChange && dstShift) date.internal.setUTCMinutes(date.internal.getUTCMinutes() + systemDSTChange);
+    //#endregion
+    //#region System diff adjustment
+    // Now we need to adjust the date, since we just applied internal values.
+    // We need to calculate the difference between the system and date time zones
+    // and apply it to the date.
+    const offsetDiff = systemOffset - offset;
+    if (offsetDiff) Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + offsetDiff);
+    //#endregion
+    //#region Seconds System diff adjustment
+    const systemDate = new Date(+date);
+    // Set the UTC seconds to 0 to isolate the timezone offset in seconds.
+    systemDate.setUTCSeconds(0);
+    // For negative systemOffset, invert the seconds.
+    const systemSecondsOffset = systemOffset > 0 ? systemDate.getSeconds() : (systemDate.getSeconds() - 60) % 60;
+    // Calculate the seconds offset based on the timezone offset.
+    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);
+    }
+    //#endregion
+    //#region Post-adjustment DST fix
+    const postBaseOffset = tzOffset(date.timeZone, date);
+    // Remove the seconds offset
+    // use Math.floor for negative GMT timezones and Math.ceil for positive GMT timezones.
+    const postOffset = postBaseOffset > 0 ? Math.floor(postBaseOffset) : Math.ceil(postBaseOffset);
+    const postSystemOffset = -new Date(+date).getTimezoneOffset();
+    const postOffsetDiff = postSystemOffset - postOffset;
+    const offsetChanged = postOffset !== offset;
+    const postDiff = postOffsetDiff - offsetDiff;
+    if (offsetChanged && postDiff) {
+        Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + postDiff);
+        // Now we need to check if got offset change during the post-adjustment.
+        // If so, we also need both dates to reflect that.
+        const newBaseOffset = tzOffset(date.timeZone, date);
+        // Remove the seconds offset
+        // use Math.floor for negative GMT timezones and Math.ceil for positive GMT timezones.
+        const newOffset = newBaseOffset > 0 ? Math.floor(newBaseOffset) : Math.ceil(newBaseOffset);
+        const offsetChange = postOffset - newOffset;
+        if (offsetChange) {
+            date.internal.setUTCMinutes(date.internal.getUTCMinutes() + offsetChange);
+            Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + offsetChange);
+        }
+    }
+//#endregion
+}
+
+class TZDate extends TZDateMini {
+    //#region static
+    static tz(tz, ...args) {
+        return args.length ? new TZDate(...args, tz) : new TZDate(Date.now(), tz);
+    }
+    //#endregion
+    //#region representation
+    toISOString() {
+        const [sign, hours, minutes] = this.tzComponents();
+        const tz = `${sign}${hours}:${minutes}`;
+        return this.internal.toISOString().slice(0, -1) + tz;
+    }
+    toString() {
+        // "Tue Aug 13 2024 07:50:19 GMT+0800 (Singapore Standard Time)";
+        return `${this.toDateString()} ${this.toTimeString()}`;
+    }
+    toDateString() {
+        // toUTCString returns RFC 7231 ("Mon, 12 Aug 2024 23:36:08 GMT")
+        const [day, date, month, year] = this.internal.toUTCString().split(" ");
+        // "Tue Aug 13 2024"
+        return `${day?.slice(0, -1)} ${month} ${date} ${year}`;
+    }
+    toTimeString() {
+        // toUTCString returns RFC 7231 ("Mon, 12 Aug 2024 23:36:08 GMT")
+        const time = this.internal.toUTCString().split(" ")[4];
+        const [sign, hours, minutes] = this.tzComponents();
+        // "07:42:23 GMT+0800 (Singapore Standard Time)"
+        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
+        });
+    }
+    //#endregion
+    //#region private
+    tzComponents() {
+        const offset = this.getTimezoneOffset();
+        const sign = offset > 0 ? "-" : "+";
+        const hours = String(Math.floor(Math.abs(offset) / 60)).padStart(2, "0");
+        const minutes = String(Math.abs(offset) % 60).padStart(2, "0");
+        return [
+            sign,
+            hours,
+            minutes
+        ];
+    }
+    //#endregion
+    withTimeZone(timeZone) {
+        return new TZDate(+this, timeZone);
+    }
+    //#region date-fns integration
+    [Symbol.for("constructDateFrom")](date) {
+        return new TZDate(+new Date(date), this.timeZone);
+    }
 }
 
 /**
- * The {@link isSameDay} function options.
+ * The {@link addMonths} function options.
  */ /**
- * @name isSameDay
- * @category Day Helpers
- * @summary Are the given dates in the same day (and year and month)?
+ * @name addMonths
+ * @category Month Helpers
+ * @summary Add the specified number of months to the given date.
  *
  * @description
- * Are the given dates in the same day (and year and month)?
+ * Add the specified number of months to the given date.
  *
- * @param laterDate - The first date to check
- * @param earlierDate - The second date to check
- * @param options - An object with options
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
  *
- * @returns The dates are in the same day (and year and month)
+ * @param date - The date to be changed
+ * @param amount - The amount of months to be added.
+ * @param options - The options object
  *
- * @example
- * // Are 4 September 06:00:00 and 4 September 18:00:00 in the same day?
- * const result = isSameDay(new Date(2014, 8, 4, 6, 0), new Date(2014, 8, 4, 18, 0))
- * //=> true
+ * @returns The new date with the months added
  *
  * @example
- * // Are 4 September and 4 October in the same day?
- * const result = isSameDay(new Date(2014, 8, 4), new Date(2014, 9, 4))
- * //=> false
+ * // Add 5 months to 1 September 2014:
+ * const result = addMonths(new Date(2014, 8, 1), 5)
+ * //=> Sun Feb 01 2015 00:00:00
  *
- * @example
+ * // Add one month to 30 January 2023:
+ * const result = addMonths(new Date(2023, 0, 30), 1)
+ * //=> Tue Feb 28 2023 00:00:00
+ */ function addMonths(date, amount, options) {
+    const _date = toDate(date, options?.in);
+    if (isNaN(amount)) return constructFrom(date, NaN);
+    if (!amount) {
+        // If 0 months, no-op to avoid changing times in the hour before end of DST
+        return _date;
+    }
+    const 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.
+    const endOfDesiredMonth = constructFrom(date, _date.getTime());
+    endOfDesiredMonth.setMonth(_date.getMonth() + amount + 1, 0);
+    const 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;
+    }
+}
+
+/**
+ * The {@link addWeeks} function options.
+ */ /**
+ * @name addWeeks
+ * @category Week Helpers
+ * @summary Add the specified number of weeks to the given date.
+ *
+ * @description
+ * Add the specified number of weeks to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of weeks to be added.
+ * @param options - An object with options
+ *
+ * @returns The new date with the weeks added
+ *
+ * @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(date, amount, options) {
+    return addDays(date, amount * 7, options);
+}
+
+/**
+ * The {@link addYears} function options.
+ */ /**
+ * @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.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type.
+ *
+ * @param date - The date to be changed
+ * @param amount - The amount of years to be added.
+ * @param options - The options
+ *
+ * @returns The new date with the years added
+ *
+ * @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(date, amount, options) {
+    return addMonths(date, amount * 12, options);
+}
+
+/**
+ * The {@link max} function options.
+ */ /**
+ * @name max
+ * @category Common Helpers
+ * @summary Return the latest of the given dates.
+ *
+ * @description
+ * Return the latest of the given dates.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param dates - The dates to compare
+ *
+ * @returns The latest of the dates
+ *
+ * @example
+ * // Which of these dates is the latest?
+ * const result = max([
+ *   new Date(1989, 6, 10),
+ *   new Date(1987, 1, 11),
+ *   new Date(1995, 6, 2),
+ *   new Date(1990, 0, 1)
+ * ])
+ * //=> Sun Jul 02 1995 00:00:00
+ */ function max(dates, options) {
+    let result;
+    let context = options?.in;
+    dates.forEach((date)=>{
+        // Use the first date object as the context function
+        if (!context && typeof date === "object") context = constructFrom.bind(null, date);
+        const date_ = toDate(date, context);
+        if (!result || result < date_ || isNaN(+date_)) result = date_;
+    });
+    return constructFrom(context, result || NaN);
+}
+
+/**
+ * The {@link min} function options.
+ */ /**
+ * @name min
+ * @category Common Helpers
+ * @summary Returns the earliest of the given dates.
+ *
+ * @description
+ * Returns the earliest of the given dates.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param dates - The dates to compare
+ *
+ * @returns The earliest of the dates
+ *
+ * @example
+ * // Which of these dates is the earliest?
+ * const result = min([
+ *   new Date(1989, 6, 10),
+ *   new Date(1987, 1, 11),
+ *   new Date(1995, 6, 2),
+ *   new Date(1990, 0, 1)
+ * ])
+ * //=> Wed Feb 11 1987 00:00:00
+ */ function min(dates, options) {
+    let result;
+    let context = options?.in;
+    dates.forEach((date)=>{
+        // Use the first date object as the context function
+        if (!context && typeof date === "object") context = constructFrom.bind(null, date);
+        const date_ = toDate(date, context);
+        if (!result || result > date_ || isNaN(+date_)) result = date_;
+    });
+    return constructFrom(context, result || NaN);
+}
+
+/**
+ * The {@link isSameDay} function options.
+ */ /**
+ * @name isSameDay
+ * @category Day Helpers
+ * @summary Are the given dates in the same day (and year and month)?
+ *
+ * @description
+ * Are the given dates in the same day (and year and month)?
+ *
+ * @param laterDate - The first date to check
+ * @param earlierDate - The second date to check
+ * @param options - An object with options
+ *
+ * @returns The dates are in the same day (and year and month)
+ *
+ * @example
+ * // Are 4 September 06:00:00 and 4 September 18:00:00 in the same day?
+ * const result = isSameDay(new Date(2014, 8, 4, 6, 0), new Date(2014, 8, 4, 18, 0))
+ * //=> true
+ *
+ * @example
+ * // Are 4 September and 4 October in the same day?
+ * const result = isSameDay(new Date(2014, 8, 4), new Date(2014, 9, 4))
+ * //=> false
+ *
+ * @example
  * // Are 4 September, 2014 and 4 September, 2015 in the same day?
  * const result = isSameDay(new Date(2014, 8, 4), new Date(2015, 8, 4))
  * //=> false
@@ -683,439 +1023,99 @@ function normalizeInterval(context, interval) {
  * //=> false
  */ function isSameMonth(laterDate, earlierDate, options) {
     const [laterDate_, earlierDate_] = normalizeDates(options?.in, laterDate, earlierDate);
-    return laterDate_.getFullYear() === earlierDate_.getFullYear() && laterDate_.getMonth() === earlierDate_.getMonth();
-}
-
-/**
- * The {@link isSameYear} function options.
- */ /**
- * @name isSameYear
- * @category Year Helpers
- * @summary Are the given dates in the same year?
- *
- * @description
- * Are the given dates in the same year?
- *
- * @param laterDate - The first date to check
- * @param earlierDate - The second date to check
- * @param options - An object with options
- *
- * @returns The dates are in the same year
- *
- * @example
- * // Are 2 September 2014 and 25 September 2014 in the same year?
- * const result = isSameYear(new Date(2014, 8, 2), new Date(2014, 8, 25))
- * //=> true
- */ function isSameYear(laterDate, earlierDate, options) {
-    const [laterDate_, earlierDate_] = normalizeDates(options?.in, laterDate, earlierDate);
-    return laterDate_.getFullYear() === earlierDate_.getFullYear();
-}
-
-/**
- * The {@link setMonth} function options.
- */ /**
- * @name setMonth
- * @category Month Helpers
- * @summary Set the month to the given date.
- *
- * @description
- * Set the month to the given date.
- *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
- *
- * @param date - The date to be changed
- * @param month - The month index to set (0-11)
- * @param options - The options
- *
- * @returns The new date with the month set
- *
- * @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(date, month, options) {
-    const _date = toDate(date, options?.in);
-    const year = _date.getFullYear();
-    const day = _date.getDate();
-    const midMonth = constructFrom(date, 0);
-    midMonth.setFullYear(year, month, 15);
-    midMonth.setHours(0, 0, 0, 0);
-    const daysInMonth = getDaysInMonth(midMonth);
-    // Set the earlier date, allows to wrap Jan 31 to Feb 28
-    _date.setMonth(month, Math.min(day, daysInMonth));
-    return _date;
-}
-
-/**
- * The {@link setYear} function options.
- */ /**
- * @name setYear
- * @category Year Helpers
- * @summary Set the year to the given date.
- *
- * @description
- * Set the year to the given date.
- *
- * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
- * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
- *
- * @param date - The date to be changed
- * @param year - The year of the new date
- * @param options - An object with options.
- *
- * @returns The new date with the year set
- *
- * @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(date, year, options) {
-    const date_ = toDate(date, options?.in);
-    // Check if date is Invalid Date because Date.prototype.setFullYear ignores the value of Invalid Date
-    if (isNaN(+date_)) return constructFrom(date, NaN);
-    date_.setFullYear(year);
-    return date_;
-}
-
-/**
- * Time zone name format.
- */ /**
- * The function returns the time zone name for the given date in the specified
- * time zone.
- *
- * It uses the `Intl.DateTimeFormat` API and by default outputs the time zone
- * name in a long format, e.g. "Pacific Standard Time" or
- * "Singapore Standard Time".
- *
- * It is possible to specify the format as the third argument using one of the following options
- *
- * - "short": e.g. "EDT" or "GMT+8".
- * - "long": e.g. "Eastern Daylight Time".
- * - "shortGeneric": e.g. "ET" or "Singapore Time".
- * - "longGeneric": e.g. "Eastern Time" or "Singapore Standard Time".
- *
- * These options correspond to TR35 tokens `z..zzz`, `zzzz`, `v`, and `vvvv` respectively: https://www.unicode.org/reports/tr35/tr35-dates.html#dfst-zone
- *
- * @param timeZone - Time zone name (IANA or UTC offset)
- * @param date - Date object to get the time zone name for
- * @param format - Optional format of the time zone name. Defaults to "long". Can be "short", "long", "shortGeneric", or "longGeneric".
- *
- * @returns Time zone name (e.g. "Singapore Standard Time")
- */ function tzName(timeZone, date, format = "long") {
-    return new Intl.DateTimeFormat("en-US", {
-        // Enforces engine to render the time. Without the option JavaScriptCore omits it.
-        hour: "numeric",
-        timeZone: timeZone,
-        timeZoneName: format
-    }).format(date).split(/\s/g) // Format.JS uses non-breaking spaces
-    .slice(2) // Skip the hour and AM/PM parts
-    .join(" ");
-}
-
-const offsetFormatCache = {};
-const offsetCache = {};
-/**
- * The function extracts UTC offset in minutes from the given date in specified
- * time zone.
- *
- * Unlike `Date.prototype.getTimezoneOffset`, this function returns the value
- * mirrored to the sign of the offset in the time zone. For Asia/Singapore
- * (UTC+8), `tzOffset` returns 480, while `getTimezoneOffset` returns -480.
- *
- * @param timeZone - Time zone name (IANA or UTC offset)
- * @param date - Date to check the offset for
- *
- * @returns UTC offset in minutes
- */ function tzOffset(timeZone, date) {
-    try {
-        var _offsetFormatCache, _timeZone;
-        const format = (_offsetFormatCache = offsetFormatCache)[_timeZone = timeZone] || (_offsetFormatCache[_timeZone] = new Intl.DateTimeFormat("en-US", {
-            timeZone,
-            timeZoneName: "longOffset"
-        }).format);
-        const offsetStr = format(date).split("GMT")[1];
-        if (offsetStr in offsetCache) return offsetCache[offsetStr];
-        return calcOffset(offsetStr, offsetStr.split(":"));
-    } catch  {
-        // Fallback to manual parsing if the runtime doesn't support ±HH:MM/±HHMM/±HH
-        // See: https://github.com/nodejs/node/issues/53419
-        if (timeZone in offsetCache) return offsetCache[timeZone];
-        const captures = timeZone?.match(offsetRe);
-        if (captures) return calcOffset(timeZone, captures.slice(1));
-        return NaN;
-    }
-}
-const offsetRe = /([+-]\d\d):?(\d\d)?/;
-function calcOffset(cacheStr, values) {
-    const hours = +(values[0] || 0);
-    const minutes = +(values[1] || 0);
-    // Convert seconds to minutes by dividing by 60 to keep the function return in minutes.
-    const seconds = +(values[2] || 0) / 60;
-    return offsetCache[cacheStr] = hours * 60 + minutes > 0 ? hours * 60 + minutes + seconds : hours * 60 - minutes - seconds;
-}
-
-class TZDateMini extends Date {
-    static tz(tz, ...args) {
-        return args.length ? new TZDateMini(...args, tz) : new TZDateMini(Date.now(), tz);
-    }
-    //#endregion
-    //#region time zone
-    withTimeZone(timeZone) {
-        return new TZDateMini(+this, timeZone);
-    }
-    getTimezoneOffset() {
-        const offset = -tzOffset(this.timeZone, this);
-        // Remove the seconds offset
-        // use Math.floor for negative GMT timezones and Math.ceil for positive GMT timezones.
-        return offset > 0 ? Math.floor(offset) : Math.ceil(offset);
-    }
-    //#endregion
-    //#region time
-    setTime(time) {
-        Date.prototype.setTime.apply(this, arguments);
-        syncToInternal(this);
-        return +this;
-    }
-    //#endregion
-    //#region date-fns integration
-    [Symbol.for("constructDateFrom")](date) {
-        return new TZDateMini(+new Date(date), this.timeZone);
-    }
-    //#region static
-    constructor(...args){
-        super();
-        if (args.length > 1 && typeof args[args.length - 1] === "string") {
-            this.timeZone = args.pop();
-        }
-        this.internal = 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);
-                syncToInternal(this);
-            }
-        }
-    }
-}
-// Assign getters and setters
-const re = /^(get|set)(?!UTC)/;
-Object.getOwnPropertyNames(Date.prototype).forEach((method)=>{
-    if (!re.test(method)) return;
-    const utcMethod = method.replace(re, "$1UTC");
-    // Filter out methods without UTC counterparts
-    if (!TZDateMini.prototype[utcMethod]) return;
-    if (method.startsWith("get")) {
-        // Delegate to internal date's UTC method
-        TZDateMini.prototype[method] = function() {
-            return this.internal[utcMethod]();
-        };
-    } else {
-        // Assign regular setter
-        TZDateMini.prototype[method] = function() {
-            Date.prototype[utcMethod].apply(this.internal, arguments);
-            syncFromInternal(this);
-            return +this;
-        };
-        // Assign UTC setter
-        TZDateMini.prototype[utcMethod] = function() {
-            Date.prototype[utcMethod].apply(this, arguments);
-            syncToInternal(this);
-            return +this;
-        };
-    }
-});
-/**
- * Function syncs time to internal date, applying the time zone offset.
- *
- * @param {Date} date - Date to sync
- */ function syncToInternal(date) {
-    date.internal.setTime(+date);
-    date.internal.setUTCSeconds(date.internal.getUTCSeconds() - Math.round(-tzOffset(date.timeZone, date) * 60));
-}
-/**
- * Function syncs the internal date UTC values to the date. It allows to get
- * accurate timestamp value.
- *
- * @param {Date} date - The date to sync
- */ function syncFromInternal(date) {
-    // First we transpose the internal values
-    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());
-    // Now we have to adjust the date to the system time zone
-    adjustToSystemTZ(date);
-}
-/**
- * Function adjusts the date to the system time zone. It uses the time zone
- * differences to calculate the offset and adjust the date.
- *
- * @param {Date} date - Date to adjust
- */ function adjustToSystemTZ(date) {
-    // Save the time zone offset before all the adjustments
-    const baseOffset = tzOffset(date.timeZone, date);
-    // Remove the seconds offset
-    // use Math.floor for negative GMT timezones and Math.ceil for positive GMT timezones.
-    const offset = baseOffset > 0 ? Math.floor(baseOffset) : Math.ceil(baseOffset);
-    //#region System DST adjustment
-    // The biggest problem with using the system time zone is that when we create
-    // a date from internal values stored in UTC, the system time zone might end
-    // up on the DST hour:
-    //
-    //   $ TZ=America/New_York node
-    //   > new Date(2020, 2, 8, 1).toString()
-    //   'Sun Mar 08 2020 01:00:00 GMT-0500 (Eastern Standard Time)'
-    //   > new Date(2020, 2, 8, 2).toString()
-    //   'Sun Mar 08 2020 03:00:00 GMT-0400 (Eastern Daylight Time)'
-    //   > new Date(2020, 2, 8, 3).toString()
-    //   'Sun Mar 08 2020 03:00:00 GMT-0400 (Eastern Daylight Time)'
-    //   > new Date(2020, 2, 8, 4).toString()
-    //   'Sun Mar 08 2020 04:00:00 GMT-0400 (Eastern Daylight Time)'
-    //
-    // Here we get the same hour for both 2 and 3, because the system time zone
-    // has DST beginning at 8 March 2020, 2 a.m. and jumps to 3 a.m. So we have
-    // to adjust the internal date to reflect that.
-    //
-    // However we want to adjust only if that's the DST hour the change happenes,
-    // not the hour where DST moves to.
-    // We calculate the previous hour to see if the time zone offset has changed
-    // and we have landed on the DST hour.
-    const prevHour = new Date(+date);
-    // We use UTC methods here as we don't want to land on the same hour again
-    // in case of DST.
-    prevHour.setUTCHours(prevHour.getUTCHours() - 1);
-    // Calculate if we are on the system DST hour.
-    const systemOffset = -new Date(+date).getTimezoneOffset();
-    const prevHourSystemOffset = -new Date(+prevHour).getTimezoneOffset();
-    const systemDSTChange = systemOffset - prevHourSystemOffset;
-    // Detect the DST shift. System DST change will occur both on
-    const dstShift = Date.prototype.getHours.apply(date) !== date.internal.getUTCHours();
-    // Move the internal date when we are on the system DST hour.
-    if (systemDSTChange && dstShift) date.internal.setUTCMinutes(date.internal.getUTCMinutes() + systemDSTChange);
-    //#endregion
-    //#region System diff adjustment
-    // Now we need to adjust the date, since we just applied internal values.
-    // We need to calculate the difference between the system and date time zones
-    // and apply it to the date.
-    const offsetDiff = systemOffset - offset;
-    if (offsetDiff) Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + offsetDiff);
-    //#endregion
-    //#region Seconds System diff adjustment
-    const systemDate = new Date(+date);
-    // Set the UTC seconds to 0 to isolate the timezone offset in seconds.
-    systemDate.setUTCSeconds(0);
-    // For negative systemOffset, invert the seconds.
-    const systemSecondsOffset = systemOffset > 0 ? systemDate.getSeconds() : (systemDate.getSeconds() - 60) % 60;
-    // Calculate the seconds offset based on the timezone offset.
-    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);
-    }
-    //#endregion
-    //#region Post-adjustment DST fix
-    const postBaseOffset = tzOffset(date.timeZone, date);
-    // Remove the seconds offset
-    // use Math.floor for negative GMT timezones and Math.ceil for positive GMT timezones.
-    const postOffset = postBaseOffset > 0 ? Math.floor(postBaseOffset) : Math.ceil(postBaseOffset);
-    const postSystemOffset = -new Date(+date).getTimezoneOffset();
-    const postOffsetDiff = postSystemOffset - postOffset;
-    const offsetChanged = postOffset !== offset;
-    const postDiff = postOffsetDiff - offsetDiff;
-    if (offsetChanged && postDiff) {
-        Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + postDiff);
-        // Now we need to check if got offset change during the post-adjustment.
-        // If so, we also need both dates to reflect that.
-        const newBaseOffset = tzOffset(date.timeZone, date);
-        // Remove the seconds offset
-        // use Math.floor for negative GMT timezones and Math.ceil for positive GMT timezones.
-        const newOffset = newBaseOffset > 0 ? Math.floor(newBaseOffset) : Math.ceil(newBaseOffset);
-        const offsetChange = postOffset - newOffset;
-        if (offsetChange) {
-            date.internal.setUTCMinutes(date.internal.getUTCMinutes() + offsetChange);
-            Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + offsetChange);
-        }
-    }
-//#endregion
+    return laterDate_.getFullYear() === earlierDate_.getFullYear() && laterDate_.getMonth() === earlierDate_.getMonth();
 }
 
-class TZDate extends TZDateMini {
-    //#region static
-    static tz(tz, ...args) {
-        return args.length ? new TZDate(...args, tz) : new TZDate(Date.now(), tz);
-    }
-    //#endregion
-    //#region representation
-    toISOString() {
-        const [sign, hours, minutes] = this.tzComponents();
-        const tz = `${sign}${hours}:${minutes}`;
-        return this.internal.toISOString().slice(0, -1) + tz;
-    }
-    toString() {
-        // "Tue Aug 13 2024 07:50:19 GMT+0800 (Singapore Standard Time)";
-        return `${this.toDateString()} ${this.toTimeString()}`;
-    }
-    toDateString() {
-        // toUTCString returns RFC 7231 ("Mon, 12 Aug 2024 23:36:08 GMT")
-        const [day, date, month, year] = this.internal.toUTCString().split(" ");
-        // "Tue Aug 13 2024"
-        return `${day?.slice(0, -1)} ${month} ${date} ${year}`;
-    }
-    toTimeString() {
-        // toUTCString returns RFC 7231 ("Mon, 12 Aug 2024 23:36:08 GMT")
-        const time = this.internal.toUTCString().split(" ")[4];
-        const [sign, hours, minutes] = this.tzComponents();
-        // "07:42:23 GMT+0800 (Singapore Standard Time)"
-        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
-        });
-    }
-    //#endregion
-    //#region private
-    tzComponents() {
-        const offset = this.getTimezoneOffset();
-        const sign = offset > 0 ? "-" : "+";
-        const hours = String(Math.floor(Math.abs(offset) / 60)).padStart(2, "0");
-        const minutes = String(Math.abs(offset) % 60).padStart(2, "0");
-        return [
-            sign,
-            hours,
-            minutes
-        ];
-    }
-    //#endregion
-    withTimeZone(timeZone) {
-        return new TZDate(+this, timeZone);
-    }
-    //#region date-fns integration
-    [Symbol.for("constructDateFrom")](date) {
-        return new TZDate(+new Date(date), this.timeZone);
-    }
+/**
+ * The {@link isSameYear} function options.
+ */ /**
+ * @name isSameYear
+ * @category Year Helpers
+ * @summary Are the given dates in the same year?
+ *
+ * @description
+ * Are the given dates in the same year?
+ *
+ * @param laterDate - The first date to check
+ * @param earlierDate - The second date to check
+ * @param options - An object with options
+ *
+ * @returns The dates are in the same year
+ *
+ * @example
+ * // Are 2 September 2014 and 25 September 2014 in the same year?
+ * const result = isSameYear(new Date(2014, 8, 2), new Date(2014, 8, 25))
+ * //=> true
+ */ function isSameYear(laterDate, earlierDate, options) {
+    const [laterDate_, earlierDate_] = normalizeDates(options?.in, laterDate, earlierDate);
+    return laterDate_.getFullYear() === earlierDate_.getFullYear();
+}
+
+/**
+ * The {@link setMonth} function options.
+ */ /**
+ * @name setMonth
+ * @category Month Helpers
+ * @summary Set the month to the given date.
+ *
+ * @description
+ * Set the month to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param month - The month index to set (0-11)
+ * @param options - The options
+ *
+ * @returns The new date with the month set
+ *
+ * @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(date, month, options) {
+    const _date = toDate(date, options?.in);
+    const year = _date.getFullYear();
+    const day = _date.getDate();
+    const midMonth = constructFrom(date, 0);
+    midMonth.setFullYear(year, month, 15);
+    midMonth.setHours(0, 0, 0, 0);
+    const daysInMonth = getDaysInMonth(midMonth);
+    // Set the earlier date, allows to wrap Jan 31 to Feb 28
+    _date.setMonth(month, Math.min(day, daysInMonth));
+    return _date;
+}
+
+/**
+ * The {@link setYear} function options.
+ */ /**
+ * @name setYear
+ * @category Year Helpers
+ * @summary Set the year to the given date.
+ *
+ * @description
+ * Set the year to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param year - The year of the new date
+ * @param options - An object with options.
+ *
+ * @returns The new date with the year set
+ *
+ * @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(date, year, options) {
+    const date_ = toDate(date, options?.in);
+    // Check if date is Invalid Date because Date.prototype.setFullYear ignores the value of Invalid Date
+    if (isNaN(+date_)) return constructFrom(date, NaN);
+    date_.setFullYear(year);
+    return date_;
 }
 
 const FIVE_WEEKS = 5;
@@ -1182,6 +1182,74 @@ const FOUR_WEEKS = 4;
     return endDate;
 }
 
+/** English (United States) locale extended with DayPicker-specific translations. */ const enUS = {
+    ...enUS$1,
+    labels: {
+        labelDayButton: (date, modifiers, options, dateLib)=>{
+            let formatDate;
+            if (dateLib && typeof dateLib.format === "function") {
+                formatDate = dateLib.format.bind(dateLib);
+            } else {
+                formatDate = (d, pattern)=>format(d, pattern, {
+                        locale: enUS$1,
+                        ...options
+                    });
+            }
+            let label = formatDate(date, "PPPP");
+            if (modifiers.today) label = `Today, ${label}`;
+            if (modifiers.selected) label = `${label}, selected`;
+            return label;
+        },
+        labelMonthDropdown: "Choose the Month",
+        labelNext: "Go to the Next Month",
+        labelPrevious: "Go to the Previous Month",
+        labelWeekNumber: (weekNumber)=>`Week ${weekNumber}`,
+        labelYearDropdown: "Choose the Year",
+        labelGrid: (date, options, dateLib)=>{
+            let formatDate;
+            if (dateLib && typeof dateLib.format === "function") {
+                formatDate = dateLib.format.bind(dateLib);
+            } else {
+                formatDate = (d, pattern)=>format(d, pattern, {
+                        locale: enUS$1,
+                        ...options
+                    });
+            }
+            return formatDate(date, "LLLL yyyy");
+        },
+        labelGridcell: (date, modifiers, options, dateLib)=>{
+            let formatDate;
+            if (dateLib && typeof dateLib.format === "function") {
+                formatDate = dateLib.format.bind(dateLib);
+            } else {
+                formatDate = (d, pattern)=>format(d, pattern, {
+                        locale: enUS$1,
+                        ...options
+                    });
+            }
+            let label = formatDate(date, "PPPP");
+            if (modifiers?.today) {
+                label = `Today, ${label}`;
+            }
+            return label;
+        },
+        labelNav: "Navigation bar",
+        labelWeekNumberHeader: "Week Number",
+        labelWeekday: (date, options, dateLib)=>{
+            let formatDate;
+            if (dateLib && typeof dateLib.format === "function") {
+                formatDate = dateLib.format.bind(dateLib);
+            } else {
+                formatDate = (d, pattern)=>format(d, pattern, {
+                        locale: enUS$1,
+                        ...options
+                    });
+            }
+            return formatDate(date, "cccc");
+        }
+    }
+};
+
 /**
  * A wrapper class around [date-fns](http://date-fns.org) that provides utility
  * methods for date manipulation and formatting.
@@ -1661,6 +1729,9 @@ DateLib.yearFirstLocales = new Set([
         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");
     }
 }
 
@@ -2309,7 +2380,7 @@ var components = /*#__PURE__*/Object.freeze({
             return isSameDay(date, matcher);
         }
         if (isDatesArray(matcher, dateLib)) {
-            return matcher.includes(date);
+            return matcher.some((matcherDate)=>isSameDay(date, matcherDate));
         }
         if (isDateRange(matcher)) {
             return rangeIncludesDate(matcher, date, false, dateLib);
@@ -2358,7 +2429,7 @@ var components = /*#__PURE__*/Object.freeze({
  * @param dateLib The date library to use for date manipulation.
  * @returns A function that retrieves the modifiers for a given `CalendarDay`.
  */ function createGetModifiers(days, props, navStart, navEnd, dateLib) {
-    const { disabled, hidden, modifiers, showOutsideDays, broadcastCalendar, today } = props;
+    const { disabled, hidden, modifiers, showOutsideDays, broadcastCalendar, today = dateLib.today() } = props;
     const { isSameDay, isSameMonth, startOfMonth, isBefore, endOfMonth, isAfter } = dateLib;
     const computedNavStart = navStart && startOfMonth(navStart);
     const computedNavEnd = navEnd && endOfMonth(navEnd);
@@ -2378,7 +2449,7 @@ var components = /*#__PURE__*/Object.freeze({
         const isDisabled = Boolean(disabled && dateMatchModifiers(date, disabled, dateLib));
         const isHidden = Boolean(hidden && dateMatchModifiers(date, hidden, dateLib)) || isBeforeNavStart || isAfterNavEnd || // Broadcast calendar will show outside days as default
         !broadcastCalendar && !showOutsideDays && isOutside || broadcastCalendar && showOutsideDays === false && isOutside;
-        const isToday = isSameDay(date, today ?? dateLib.today());
+        const isToday = isSameDay(date, today);
         if (isOutside) internalModifiersMap.outside.push(day);
         if (isDisabled) internalModifiersMap.disabled.push(day);
         if (isHidden) internalModifiersMap.hidden.push(day);
@@ -2639,136 +2710,26 @@ var defaultFormatters = /*#__PURE__*/Object.freeze({
   formatWeekNumberHeader: formatWeekNumberHeader,
   formatWeekdayName: formatWeekdayName,
   formatYearCaption: formatYearCaption,
-  formatYearDropdown: formatYearDropdown
-});
-
-/**
- * Merges custom formatters from the props with the default formatters.
- *
- * @param customFormatters The custom formatters provided in the DayPicker
- *   props.
- * @returns The merged formatters object.
- */ function getFormatters(customFormatters) {
-    if (customFormatters?.formatMonthCaption && !customFormatters.formatCaption) {
-        customFormatters.formatCaption = customFormatters.formatMonthCaption;
-    }
-    if (customFormatters?.formatYearCaption && !customFormatters.formatYearDropdown) {
-        customFormatters.formatYearDropdown = customFormatters.formatYearCaption;
-    }
-    return {
-        ...defaultFormatters,
-        ...customFormatters
-    };
-}
-
-/**
- * Returns the months to show in the dropdown.
- *
- * This function generates a list of months for the current year, formatted
- * using the provided formatter, and determines whether each month should be
- * disabled based on the navigation range.
- *
- * @param displayMonth The currently displayed month.
- * @param navStart The start date for navigation.
- * @param navEnd The end date for navigation.
- * @param formatters The formatters to use for formatting the month labels.
- * @param dateLib The date library to use for date manipulation.
- * @returns An array of dropdown options representing the months, or `undefined`
- *   if no months are available.
- */ function getMonthOptions(displayMonth, navStart, navEnd, formatters, dateLib) {
-    const { startOfMonth, startOfYear, endOfYear, eachMonthOfInterval, getMonth } = dateLib;
-    const months = eachMonthOfInterval({
-        start: startOfYear(displayMonth),
-        end: endOfYear(displayMonth)
-    });
-    const options = months.map((month)=>{
-        const label = formatters.formatMonthDropdown(month, dateLib);
-        const value = getMonth(month);
-        const disabled = navStart && month < startOfMonth(navStart) || navEnd && month > startOfMonth(navEnd) || false;
-        return {
-            value,
-            label,
-            disabled
-        };
-    });
-    return options;
-}
-
-/**
- * Returns the computed style for a day based on its modifiers.
- *
- * This function merges the base styles for the day with any styles associated
- * with active modifiers.
- *
- * @param dayModifiers The modifiers applied to the day.
- * @param styles The base styles for the calendar elements.
- * @param modifiersStyles The styles associated with specific modifiers.
- * @returns The computed style for the day.
- */ function getStyleForModifiers(dayModifiers, styles = {}, modifiersStyles = {}) {
-    let style = {
-        ...styles?.[UI.Day]
-    };
-    Object.entries(dayModifiers).filter(([, active])=>active === true).forEach(([modifier])=>{
-        style = {
-            ...style,
-            ...modifiersStyles?.[modifier]
-        };
-    });
-    return style;
-}
+  formatYearDropdown: formatYearDropdown
+});
 
 /**
- * Generates a series of 7 days, starting from the beginning of the week, to use
- * for formatting weekday names (e.g., Monday, Tuesday, etc.).
+ * Merges custom formatters from the props with the default formatters.
  *
- * @param dateLib The date library to use for date manipulation.
- * @param ISOWeek Whether to use ISO week numbering (weeks start on Monday).
- * @param broadcastCalendar Whether to use the broadcast calendar (weeks start
- *   on Monday, but may include adjustments for broadcast-specific rules).
- * @returns An array of 7 dates representing the weekdays.
- */ function getWeekdays(dateLib, ISOWeek, broadcastCalendar) {
-    const today = dateLib.today();
-    const start = ISOWeek ? dateLib.startOfISOWeek(today) : dateLib.startOfWeek(today);
-    const days = [];
-    for(let i = 0; i < 7; i++){
-        const day = dateLib.addDays(start, i);
-        days.push(day);
+ * @param customFormatters The custom formatters provided in the DayPicker
+ *   props.
+ * @returns The merged formatters object.
+ */ function getFormatters(customFormatters) {
+    if (customFormatters?.formatMonthCaption && !customFormatters.formatCaption) {
+        customFormatters.formatCaption = customFormatters.formatMonthCaption;
     }
-    return days;
-}
-
-/**
- * Returns the years to display in the dropdown.
- *
- * This function generates a list of years between the navigation start and end
- * dates, formatted using the provided formatter.
- *
- * @param navStart The start date for navigation.
- * @param navEnd The end date for navigation.
- * @param formatters The formatters to use for formatting the year labels.
- * @param dateLib The date library to use for date manipulation.
- * @param reverse If true, reverses the order of the years (descending).
- * @returns An array of dropdown options representing the years, or `undefined`
- *   if `navStart` or `navEnd` is not provided.
- */ function getYearOptions(navStart, navEnd, formatters, dateLib, reverse = false) {
-    if (!navStart) return undefined;
-    if (!navEnd) return undefined;
-    const { startOfYear, endOfYear, eachYearOfInterval, getYear } = dateLib;
-    const firstNavYear = startOfYear(navStart);
-    const lastNavYear = endOfYear(navEnd);
-    const years = eachYearOfInterval({
-        start: firstNavYear,
-        end: lastNavYear
-    });
-    if (reverse) years.reverse();
-    return years.map((year)=>{
-        const label = formatters.formatYearDropdown(year, dateLib);
-        return {
-            value: getYear(year),
-            label,
-            disabled: false
-        };
-    });
+    if (customFormatters?.formatYearCaption && !customFormatters.formatYearDropdown) {
+        customFormatters.formatYearDropdown = customFormatters.formatYearCaption;
+    }
+    return {
+        ...defaultFormatters,
+        ...customFormatters
+    };
 }
 
 /**
@@ -2857,6 +2818,7 @@ var defaultFormatters = /*#__PURE__*/Object.freeze({
     return "";
 }
 
+const defaultLabel = "Go to the Next Month";
 /**
  * Generates the ARIA label for the "next month" button.
  *
@@ -2866,8 +2828,8 @@ var defaultFormatters = /*#__PURE__*/Object.freeze({
  * @returns The ARIA label for the "next month" button.
  * @group Labels
  * @see https://daypicker.dev/docs/translation#aria-labels
- */ function labelNext(_month) {
-    return "Go to the Next Month";
+ */ function labelNext(_month, _options) {
+    return defaultLabel;
 }
 
 /**
@@ -2951,6 +2913,297 @@ var defaultLabels = /*#__PURE__*/Object.freeze({
   labelYearDropdown: labelYearDropdown
 });
 
+const resolveLabel = (defaultLabel, customLabel, localeLabel)=>{
+    if (customLabel) return customLabel;
+    if (localeLabel) {
+        return typeof localeLabel === "function" ? localeLabel : (..._args)=>localeLabel;
+    }
+    return defaultLabel;
+};
+/**
+ * Merges custom labels from the props with the default labels.
+ *
+ * When available, uses the locale-provided translation for `labelNext`.
+ *
+ * @param customLabels The custom labels provided in the DayPicker props.
+ * @param options Options from the date library, used to resolve locale
+ *   translations.
+ * @returns The merged labels object with locale-aware defaults.
+ */ function getLabels(customLabels, options) {
+    const localeLabels = options.locale?.labels ?? {};
+    return {
+        ...defaultLabels,
+        ...customLabels ?? {},
+        labelDayButton: resolveLabel(labelDayButton, customLabels?.labelDayButton, localeLabels.labelDayButton),
+        labelMonthDropdown: resolveLabel(labelMonthDropdown, customLabels?.labelMonthDropdown, localeLabels.labelMonthDropdown),
+        labelNext: resolveLabel(labelNext, customLabels?.labelNext, localeLabels.labelNext),
+        labelPrevious: resolveLabel(labelPrevious, customLabels?.labelPrevious, localeLabels.labelPrevious),
+        labelWeekNumber: resolveLabel(labelWeekNumber, customLabels?.labelWeekNumber, localeLabels.labelWeekNumber),
+        labelYearDropdown: resolveLabel(labelYearDropdown, customLabels?.labelYearDropdown, localeLabels.labelYearDropdown),
+        labelGrid: resolveLabel(labelGrid, customLabels?.labelGrid, localeLabels.labelGrid),
+        labelGridcell: resolveLabel(labelGridcell, customLabels?.labelGridcell, localeLabels.labelGridcell),
+        labelNav: resolveLabel(labelNav, customLabels?.labelNav, localeLabels.labelNav),
+        labelWeekNumberHeader: resolveLabel(labelWeekNumberHeader, customLabels?.labelWeekNumberHeader, localeLabels.labelWeekNumberHeader),
+        labelWeekday: resolveLabel(labelWeekday, customLabels?.labelWeekday, localeLabels.labelWeekday)
+    };
+}
+
+/**
+ * Returns the months to show in the dropdown.
+ *
+ * This function generates a list of months for the current year, formatted
+ * using the provided formatter, and determines whether each month should be
+ * disabled based on the navigation range.
+ *
+ * @param displayMonth The currently displayed month.
+ * @param navStart The start date for navigation.
+ * @param navEnd The end date for navigation.
+ * @param formatters The formatters to use for formatting the month labels.
+ * @param dateLib The date library to use for date manipulation.
+ * @returns An array of dropdown options representing the months, or `undefined`
+ *   if no months are available.
+ */ function getMonthOptions(displayMonth, navStart, navEnd, formatters, dateLib) {
+    const { startOfMonth, startOfYear, endOfYear, eachMonthOfInterval, getMonth } = dateLib;
+    const months = eachMonthOfInterval({
+        start: startOfYear(displayMonth),
+        end: endOfYear(displayMonth)
+    });
+    const options = months.map((month)=>{
+        const label = formatters.formatMonthDropdown(month, dateLib);
+        const value = getMonth(month);
+        const disabled = navStart && month < startOfMonth(navStart) || navEnd && month > startOfMonth(navEnd) || false;
+        return {
+            value,
+            label,
+            disabled
+        };
+    });
+    return options;
+}
+
+/**
+ * Returns the computed style for a day based on its modifiers.
+ *
+ * This function merges the base styles for the day with any styles associated
+ * with active modifiers.
+ *
+ * @param dayModifiers The modifiers applied to the day.
+ * @param styles The base styles for the calendar elements.
+ * @param modifiersStyles The styles associated with specific modifiers.
+ * @returns The computed style for the day.
+ */ function getStyleForModifiers(dayModifiers, styles = {}, modifiersStyles = {}) {
+    let style = {
+        ...styles?.[UI.Day]
+    };
+    Object.entries(dayModifiers).filter(([, active])=>active === true).forEach(([modifier])=>{
+        style = {
+            ...style,
+            ...modifiersStyles?.[modifier]
+        };
+    });
+    return style;
+}
+
+/**
+ * Generates a series of 7 days, starting from the beginning of the week, to use
+ * for formatting weekday names (e.g., Monday, Tuesday, etc.).
+ *
+ * @param dateLib The date library to use for date manipulation.
+ * @param ISOWeek Whether to use ISO week numbering (weeks start on Monday).
+ * @param broadcastCalendar Whether to use the broadcast calendar (weeks start
+ *   on Monday, but may include adjustments for broadcast-specific rules).
+ * @returns An array of 7 dates representing the weekdays.
+ */ 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;
+}
+
+/**
+ * Returns the years to display in the dropdown.
+ *
+ * This function generates a list of years between the navigation start and end
+ * dates, formatted using the provided formatter.
+ *
+ * @param navStart The start date for navigation.
+ * @param navEnd The end date for navigation.
+ * @param formatters The formatters to use for formatting the year labels.
+ * @param dateLib The date library to use for date manipulation.
+ * @param reverse If true, reverses the order of the years (descending).
+ * @returns An array of dropdown options representing the years, or `undefined`
+ *   if `navStart` or `navEnd` is not provided.
+ */ function getYearOptions(navStart, navEnd, formatters, dateLib, reverse = false) {
+    if (!navStart) return undefined;
+    if (!navEnd) return undefined;
+    const { startOfYear, endOfYear, eachYearOfInterval, getYear } = dateLib;
+    const firstNavYear = startOfYear(navStart);
+    const lastNavYear = endOfYear(navEnd);
+    const years = eachYearOfInterval({
+        start: firstNavYear,
+        end: lastNavYear
+    });
+    if (reverse) years.reverse();
+    return years.map((year)=>{
+        const label = formatters.formatYearDropdown(year, dateLib);
+        return {
+            value: getYear(year),
+            label,
+            disabled: false
+        };
+    });
+}
+
+/**
+ * Creates `dateLib` overrides that keep all calendar math at noon in the target
+ * time zone. This avoids second-level offset changes (e.g., historical zones
+ * with +03:41:12) from pushing dates backward across midnight.
+ */ function createNoonOverrides(timeZone, options = {}) {
+    const { weekStartsOn, locale } = options;
+    const fallbackWeekStartsOn = weekStartsOn ?? locale?.options?.weekStartsOn ?? 0;
+    // Keep all internal math anchored at noon in the target zone to avoid
+    // historical second-level offsets from crossing midnight.
+    const toNoonTZDate = (date)=>{
+        const normalizedDate = typeof date === "number" || typeof date === "string" ? new Date(date) : date;
+        return new TZDate(normalizedDate.getFullYear(), normalizedDate.getMonth(), normalizedDate.getDate(), 12, 0, 0, timeZone);
+    };
+    // Convert a value into a host `Date` that represents the same calendar day
+    // as the target-zone noon. This is useful for helpers (e.g., date-fns week
+    // utilities) that expect local `Date` instances rather than `TZDate`s.
+    const toCalendarDate = (date)=>{
+        const zoned = toNoonTZDate(date);
+        return new Date(zoned.getFullYear(), zoned.getMonth(), zoned.getDate(), 0, 0, 0, 0);
+    };
+    return {
+        today: ()=>{
+            return toNoonTZDate(TZDate.tz(timeZone));
+        },
+        newDate: (year, monthIndex, date)=>{
+            return new TZDate(year, monthIndex, date, 12, 0, 0, timeZone);
+        },
+        startOfDay: (date)=>{
+            return toNoonTZDate(date);
+        },
+        startOfWeek: (date, options)=>{
+            const base = toNoonTZDate(date);
+            const weekStartsOnValue = options?.weekStartsOn ?? fallbackWeekStartsOn;
+            const diff = (base.getDay() - weekStartsOnValue + 7) % 7;
+            base.setDate(base.getDate() - diff);
+            return base;
+        },
+        startOfISOWeek: (date)=>{
+            const base = toNoonTZDate(date);
+            const diff = (base.getDay() - 1 + 7) % 7;
+            base.setDate(base.getDate() - diff);
+            return base;
+        },
+        startOfMonth: (date)=>{
+            const base = toNoonTZDate(date);
+            base.setDate(1);
+            return base;
+        },
+        startOfYear: (date)=>{
+            const base = toNoonTZDate(date);
+            base.setMonth(0, 1);
+            return base;
+        },
+        endOfWeek: (date, options)=>{
+            const base = toNoonTZDate(date);
+            const weekStartsOnValue = options?.weekStartsOn ?? fallbackWeekStartsOn;
+            const endDow = (weekStartsOnValue + 6) % 7;
+            const diff = (endDow - base.getDay() + 7) % 7;
+            base.setDate(base.getDate() + diff);
+            return base;
+        },
+        endOfISOWeek: (date)=>{
+            const base = toNoonTZDate(date);
+            const diff = (7 - base.getDay()) % 7;
+            base.setDate(base.getDate() + diff);
+            return base;
+        },
+        endOfMonth: (date)=>{
+            const base = toNoonTZDate(date);
+            base.setMonth(base.getMonth() + 1, 0);
+            return base;
+        },
+        endOfYear: (date)=>{
+            const base = toNoonTZDate(date);
+            base.setMonth(11, 31);
+            return base;
+        },
+        eachMonthOfInterval: (interval)=>{
+            const start = toNoonTZDate(interval.start);
+            const end = toNoonTZDate(interval.end);
+            const result = [];
+            const cursor = new TZDate(start.getFullYear(), start.getMonth(), 1, 12, 0, 0, timeZone);
+            const endKey = end.getFullYear() * 12 + end.getMonth();
+            while(cursor.getFullYear() * 12 + cursor.getMonth() <= endKey){
+                result.push(new TZDate(cursor, timeZone));
+                cursor.setMonth(cursor.getMonth() + 1, 1);
+            }
+            return result;
+        },
+        // Normalize to noon once before arithmetic (avoid DST/midnight edge cases),
+        // mutate the same TZDate, and return it.
+        addDays: (date, amount)=>{
+            const base = toNoonTZDate(date);
+            base.setDate(base.getDate() + amount);
+            return base;
+        },
+        addWeeks: (date, amount)=>{
+            const base = toNoonTZDate(date);
+            base.setDate(base.getDate() + amount * 7);
+            return base;
+        },
+        addMonths: (date, amount)=>{
+            const base = toNoonTZDate(date);
+            base.setMonth(base.getMonth() + amount);
+            return base;
+        },
+        addYears: (date, amount)=>{
+            const base = toNoonTZDate(date);
+            base.setFullYear(base.getFullYear() + amount);
+            return base;
+        },
+        eachYearOfInterval: (interval)=>{
+            const start = toNoonTZDate(interval.start);
+            const end = toNoonTZDate(interval.end);
+            const years = [];
+            const cursor = new TZDate(start.getFullYear(), 0, 1, 12, 0, 0, timeZone);
+            while(cursor.getFullYear() <= end.getFullYear()){
+                years.push(new TZDate(cursor, timeZone));
+                cursor.setFullYear(cursor.getFullYear() + 1, 0, 1);
+            }
+            return years;
+        },
+        getWeek: (date, options)=>{
+            const base = toCalendarDate(date);
+            return getWeek(base, {
+                weekStartsOn: options?.weekStartsOn ?? fallbackWeekStartsOn,
+                firstWeekContainsDate: options?.firstWeekContainsDate ?? locale?.options?.firstWeekContainsDate ?? 1
+            });
+        },
+        getISOWeek: (date)=>{
+            const base = toCalendarDate(date);
+            return getISOWeek(base);
+        },
+        differenceInCalendarDays: (dateLeft, dateRight)=>{
+            const left = toCalendarDate(dateLeft);
+            const right = toCalendarDate(dateRight);
+            return differenceInCalendarDays(left, right);
+        },
+        differenceInCalendarMonths: (dateLeft, dateRight)=>{
+            const left = toCalendarDate(dateLeft);
+            const right = toCalendarDate(dateRight);
+            return differenceInCalendarMonths(left, right);
+        }
+    };
+}
+
 const asHtmlElement = (element)=>{
     if (element instanceof HTMLElement) return element;
     return null;
@@ -3114,15 +3367,16 @@ const queryWeekdaysEl = (element)=>asHtmlElement(element.querySelector("[data-an
     const { ISOWeek, fixedWeeks, broadcastCalendar } = props ?? {};
     const { addDays, differenceInCalendarDays, differenceInCalendarMonths, endOfBroadcastWeek, endOfISOWeek, endOfMonth, endOfWeek, isAfter, startOfBroadcastWeek, startOfISOWeek, startOfWeek } = dateLib;
     const startWeekFirstDate = broadcastCalendar ? startOfBroadcastWeek(firstMonth, dateLib) : ISOWeek ? startOfISOWeek(firstMonth) : startOfWeek(firstMonth);
-    const endWeekLastDate = broadcastCalendar ? endOfBroadcastWeek(lastMonth) : ISOWeek ? endOfISOWeek(endOfMonth(lastMonth)) : endOfWeek(endOfMonth(lastMonth));
-    const nOfDays = differenceInCalendarDays(endWeekLastDate, startWeekFirstDate);
+    const displayMonthsWeekEnd = broadcastCalendar ? endOfBroadcastWeek(lastMonth) : ISOWeek ? endOfISOWeek(endOfMonth(lastMonth)) : endOfWeek(endOfMonth(lastMonth));
+    // If maxDate is set, clamp the grid to the end of that week.
+    const constraintWeekEnd = maxDate && (broadcastCalendar ? endOfBroadcastWeek(maxDate) : ISOWeek ? endOfISOWeek(maxDate) : endOfWeek(maxDate));
+    // Pick the earliest week end between the displayed months and the constraint.
+    const gridEndDate = constraintWeekEnd && isAfter(displayMonthsWeekEnd, constraintWeekEnd) ? constraintWeekEnd : displayMonthsWeekEnd;
+    const nOfDays = differenceInCalendarDays(gridEndDate, startWeekFirstDate);
     const nOfMonths = differenceInCalendarMonths(lastMonth, firstMonth) + 1;
     const dates = [];
     for(let i = 0; i <= nOfDays; i++){
         const date = addDays(startWeekFirstDate, i);
-        if (maxDate && isAfter(date, maxDate)) {
-            break;
-        }
         dates.push(date);
     }
     // If fixed weeks is enabled, add the extra dates to the array
@@ -3430,13 +3684,47 @@ const queryWeekdaysEl = (element)=>asHtmlElement(element.querySelector("[data-an
     }, [
         props.timeZone
     ]);
-    /** The months displayed in the calendar. */ const displayMonths = getDisplayMonths(firstMonth, navEnd, props, dateLib);
-    /** The dates displayed in the calendar. */ const dates = getDates(displayMonths, props.endMonth ? endOfMonth(props.endMonth) : undefined, props, dateLib);
-    /** The Months displayed in the calendar. */ const months = getMonths(displayMonths, dates, props, dateLib);
-    /** The Weeks displayed in the calendar. */ const weeks = getWeeks(months);
-    /** The Days displayed in the calendar. */ const days = getDays(months);
-    const previousMonth = getPreviousMonth(firstMonth, navStart, props, dateLib);
-    const nextMonth = getNextMonth(firstMonth, navEnd, props, dateLib);
+    /** The months displayed in the calendar. */ // biome-ignore lint/correctness/useExhaustiveDependencies: We want to recompute only when specific props change.
+    const { months, weeks, days, previousMonth, nextMonth } = useMemo(()=>{
+        const displayMonths = getDisplayMonths(firstMonth, navEnd, {
+            numberOfMonths: props.numberOfMonths
+        }, dateLib);
+        const dates = getDates(displayMonths, props.endMonth ? endOfMonth(props.endMonth) : undefined, {
+            ISOWeek: props.ISOWeek,
+            fixedWeeks: props.fixedWeeks,
+            broadcastCalendar: props.broadcastCalendar
+        }, dateLib);
+        const months = getMonths(displayMonths, dates, {
+            broadcastCalendar: props.broadcastCalendar,
+            fixedWeeks: props.fixedWeeks,
+            ISOWeek: props.ISOWeek,
+            reverseMonths: props.reverseMonths
+        }, dateLib);
+        const weeks = getWeeks(months);
+        const days = getDays(months);
+        const previousMonth = getPreviousMonth(firstMonth, navStart, props, dateLib);
+        const nextMonth = getNextMonth(firstMonth, navEnd, props, dateLib);
+        return {
+            months,
+            weeks,
+            days,
+            previousMonth,
+            nextMonth
+        };
+    }, [
+        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)=>{
@@ -4042,6 +4330,72 @@ var FocusTargetPriority;
     }
 }
 
+/**
+ * Convert a {@link Date} or {@link TZDate} instance to the given time zone.
+ * Reuses the same instance when it is already a {@link TZDate} using the target
+ * time zone to avoid extra allocations.
+ */ function toTimeZone(date, timeZone) {
+    if (date instanceof TZDate && date.timeZone === timeZone) {
+        return date;
+    }
+    return new TZDate(date, timeZone);
+}
+
+function toZoneNoon(date, timeZone, noonSafe) {
+    return toTimeZone(date, timeZone);
+}
+function convertMatcher(matcher, timeZone, noonSafe) {
+    if (typeof matcher === "boolean" || typeof matcher === "function") {
+        return matcher;
+    }
+    if (matcher instanceof Date) {
+        return toZoneNoon(matcher, timeZone);
+    }
+    if (Array.isArray(matcher)) {
+        return matcher.map((value)=>value instanceof Date ? toZoneNoon(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: toZoneNoon(matcher.before, timeZone),
+            after: toZoneNoon(matcher.after, timeZone)
+        };
+    }
+    if (isDateAfterType(matcher)) {
+        return {
+            after: toZoneNoon(matcher.after, timeZone)
+        };
+    }
+    if (isDateBeforeType(matcher)) {
+        return {
+            before: toZoneNoon(matcher.before, timeZone)
+        };
+    }
+    return matcher;
+}
+/**
+ * Convert any {@link Matcher} or array of matchers to the specified time zone.
+ *
+ * @param matchers - The matcher or matchers to convert.
+ * @param timeZone - The target IANA time zone.
+ * @returns The converted matcher(s).
+ * @group Utilities
+ */ function convertMatchersToTimeZone(matchers, timeZone, noonSafe) {
+    if (!matchers) {
+        return matchers;
+    }
+    if (Array.isArray(matchers)) {
+        return matchers.map((matcher)=>convertMatcher(matcher, timeZone));
+    }
+    return convertMatcher(matchers, timeZone);
+}
+
 /**
  * Renders the DayPicker calendar component.
  *
@@ -4051,58 +4405,79 @@ var FocusTargetPriority;
  * @see https://daypicker.dev
  */ function DayPicker(initialProps) {
     let props = initialProps;
-    if (props.timeZone) {
+    const timeZone = props.timeZone;
+    if (timeZone) {
         props = {
-            ...initialProps
+            ...initialProps,
+            timeZone
         };
         if (props.today) {
-            props.today = new TZDate(props.today, props.timeZone);
+            props.today = toTimeZone(props.today, timeZone);
         }
         if (props.month) {
-            props.month = new TZDate(props.month, props.timeZone);
+            props.month = toTimeZone(props.month, timeZone);
         }
         if (props.defaultMonth) {
-            props.defaultMonth = new TZDate(props.defaultMonth, props.timeZone);
+            props.defaultMonth = toTimeZone(props.defaultMonth, timeZone);
         }
         if (props.startMonth) {
-            props.startMonth = new TZDate(props.startMonth, props.timeZone);
+            props.startMonth = toTimeZone(props.startMonth, timeZone);
         }
         if (props.endMonth) {
-            props.endMonth = new TZDate(props.endMonth, props.timeZone);
+            props.endMonth = toTimeZone(props.endMonth, timeZone);
         }
         if (props.mode === "single" && props.selected) {
-            props.selected = new TZDate(props.selected, props.timeZone);
+            props.selected = toTimeZone(props.selected, timeZone);
         } else if (props.mode === "multiple" && props.selected) {
-            props.selected = props.selected?.map((date)=>new TZDate(date, props.timeZone));
+            props.selected = props.selected?.map((date)=>toTimeZone(date, timeZone));
         } else if (props.mode === "range" && props.selected) {
             props.selected = {
-                from: props.selected.from ? new TZDate(props.selected.from, props.timeZone) : undefined,
-                to: props.selected.to ? new TZDate(props.selected.to, props.timeZone) : undefined
+                from: props.selected.from ? toTimeZone(props.selected.from, timeZone) : props.selected.from,
+                to: props.selected.to ? toTimeZone(props.selected.to, timeZone) : props.selected.to
             };
         }
+        if (props.disabled !== undefined) {
+            props.disabled = convertMatchersToTimeZone(props.disabled, timeZone);
+        }
+        if (props.hidden !== undefined) {
+            props.hidden = convertMatchersToTimeZone(props.hidden, timeZone);
+        }
+        if (props.modifiers) {
+            const nextModifiers = {};
+            Object.keys(props.modifiers).forEach((key)=>{
+                nextModifiers[key] = convertMatchersToTimeZone(props.modifiers?.[key], timeZone);
+            });
+            props.modifiers = nextModifiers;
+        }
     }
     const { components, formatters, labels, dateLib, locale, classNames } = useMemo(()=>{
         const locale = {
             ...enUS,
             ...props.locale
         };
+        const weekStartsOn = props.broadcastCalendar ? 1 : props.weekStartsOn;
+        const noonOverrides = props.noonSafe && props.timeZone ? createNoonOverrides(props.timeZone, {
+            weekStartsOn,
+            locale
+        }) : undefined;
+        const overrides = props.dateLib && noonOverrides ? {
+            ...noonOverrides,
+            ...props.dateLib
+        } : props.dateLib ?? noonOverrides;
         const dateLib = new DateLib({
             locale,
-            weekStartsOn: props.broadcastCalendar ? 1 : props.weekStartsOn,
+            weekStartsOn,
             firstWeekContainsDate: props.firstWeekContainsDate,
             useAdditionalWeekYearTokens: props.useAdditionalWeekYearTokens,
             useAdditionalDayOfYearTokens: props.useAdditionalDayOfYearTokens,
             timeZone: props.timeZone,
             numerals: props.numerals
-        }, props.dateLib);
+        }, overrides);
         return {
             dateLib,
             components: getComponents(props.components),
             formatters: getFormatters(props.formatters),
-            labels: {
-                ...defaultLabels,
-                ...props.labels
-            },
+            labels: getLabels(props.labels, dateLib.options),
             locale,
             classNames: {
                 ...getDefaultClassNames(),
@@ -4119,11 +4494,18 @@ var FocusTargetPriority;
         props.timeZone,
         props.numerals,
         props.dateLib,
+        props.noonSafe,
         props.components,
         props.formatters,
         props.labels,
         props.classNames
     ]);
+    if (!props.today) {
+        props = {
+            ...props,
+            today: dateLib.today()
+        };
+    }
     const { captionLayout, mode, navLayout, numberOfMonths = 1, onDayBlur, onDayClick, onDayFocus, onDayKeyDown, onDayMouseEnter, onDayMouseLeave, onNextClick, onPrevClick, showWeekNumber, styles } = props;
     const { formatCaption, formatDay, formatMonthDropdown, formatWeekNumber, formatWeekNumberHeader, formatWeekdayName, formatYearDropdown } = formatters;
     const calendar = useCalendar(props, dateLib);
@@ -4132,9 +4514,11 @@ var FocusTargetPriority;
     const { isSelected, select, selected: selectedValue } = useSelection(props, dateLib) ?? {};
     const { blur, focused, isFocusTarget, moveFocus, setFocused } = useFocus(props, calendar, getModifiers, isSelected ?? (()=>false), dateLib);
     const { labelDayButton, labelGridcell, labelGrid, labelMonthDropdown, labelNav, labelPrevious, labelNext, labelWeekday, labelWeekNumber, labelWeekNumberHeader, labelYearDropdown } = labels;
-    const weekdays = useMemo(()=>getWeekdays(dateLib, props.ISOWeek), [
+    const weekdays = useMemo(()=>getWeekdays(dateLib, props.ISOWeek, props.broadcastCalendar, props.today), [
         dateLib,
-        props.ISOWeek
+        props.ISOWeek,
+        props.broadcastCalendar,
+        props.today
     ]);
     const isInteractive = mode !== undefined || onDayClick !== undefined;
     const handlePreviousClick = useCallback(()=>{
@@ -4159,6 +4543,9 @@ var FocusTargetPriority;
             e.preventDefault();
             e.stopPropagation();
             setFocused(day);
+            if (m.disabled) {
+                return;
+            }
             select?.(day.date, m, e);
             onDayClick?.(day.date, m, e);
         }, [
@@ -4401,8 +4788,7 @@ var FocusTargetPriority;
                 whiteSpace: "nowrap",
                 wordWrap: "normal"
             }
-        }, formatCaption(calendarMonth.date, dateLib.options, dateLib))) : // biome-ignore lint/a11y/useSemanticElements: breaking change
-        React__default.createElement(components.CaptionLabel, {
+        }, formatCaption(calendarMonth.date, dateLib.options, dateLib))) : React__default.createElement(components.CaptionLabel, {
             className: classNames[UI.CaptionLabel],
             role: "status",
             "aria-live": "polite"
@@ -4458,8 +4844,7 @@ var FocusTargetPriority;
                 key: week.weekNumber,
                 style: styles?.[UI.Week],
                 week: week
-            }, showWeekNumber && // biome-ignore lint/a11y/useSemanticElements: react component
-            React__default.createElement(components.WeekNumber, {
+            }, showWeekNumber && React__default.createElement(components.WeekNumber, {
                 week: week,
                 style: styles?.[UI.WeekNumber],
                 "aria-label": labelWeekNumber(week.weekNumber, {
@@ -4483,9 +4868,8 @@ var FocusTargetPriority;
                 const style = getStyleForModifiers(modifiers, styles, props.modifiersStyles);
                 const className = getClassNamesForModifiers(modifiers, classNames, props.modifiersClassNames);
                 const ariaLabel = !isInteractive && !modifiers.hidden ? labelGridcell(date, modifiers, dateLib.options, dateLib) : undefined;
-                return(// biome-ignore lint/a11y/useSemanticElements: react component
-                React__default.createElement(components.Day, {
-                    key: `${dateLib.format(date, "yyyy-MM-dd")}_${dateLib.format(day.displayMonth, "yyyy-MM")}`,
+                return React__default.createElement(components.Day, {
+                    key: `${day.isoDate}_${day.displayMonthId}`,
                     day: day,
                     modifiers: modifiers,
                     className: className.join(" "),
@@ -4493,8 +4877,8 @@ var FocusTargetPriority;
                     role: "gridcell",
                     "aria-selected": modifiers.selected || undefined,
                     "aria-label": ariaLabel,
-                    "data-day": dateLib.format(date, "yyyy-MM-dd"),
-                    "data-month": day.outside ? dateLib.format(date, "yyyy-MM") : undefined,
+                    "data-day": day.isoDate,
+                    "data-month": day.outside ? day.dateMonthId : undefined,
                     "data-selected": modifiers.selected || undefined,
                     "data-disabled": modifiers.disabled || undefined,
                     "data-hidden": modifiers.hidden || undefined,
@@ -4507,7 +4891,8 @@ var FocusTargetPriority;
                     type: "button",
                     day: day,
                     modifiers: modifiers,
-                    disabled: modifiers.disabled || undefined,
+                    disabled: !modifiers.focused && modifiers.disabled || undefined,
+                    "aria-disabled": modifiers.focused && modifiers.disabled || undefined,
                     tabIndex: isFocusTarget(day) ? 0 : -1,
                     "aria-label": labelDayButton(date, modifiers, dateLib.options, dateLib),
                     onClick: handleDayClick(day, modifiers),
@@ -4516,11 +4901,10 @@ var FocusTargetPriority;
                     onKeyDown: handleDayKeyDown(day, modifiers),
                     onMouseEnter: handleDayMouseEnter(day, modifiers),
                     onMouseLeave: handleDayMouseLeave(day, modifiers)
-                }, formatDay(date, dateLib.options, dateLib)) : !modifiers.hidden && formatDay(day.date, dateLib.options, dateLib)));
+                }, formatDay(date, dateLib.options, dateLib)) : !modifiers.hidden && formatDay(day.date, dateLib.options, dateLib));
             }));
         }))));
-    })), props.footer && // biome-ignore lint/a11y/useSemanticElements: react component
-    React__default.createElement(components.Footer, {
+    })), props.footer && React__default.createElement(components.Footer, {
         className: classNames[UI.Footer],
         style: styles?.[UI.Footer],
         role: "status",
@@ -4635,4 +5019,4 @@ function CalendarDayButton({ className, day, modifiers, ...props }) {
 }
 
 export { Calendar as C, CalendarDayButton as a, addMonths as b };
-//# sourceMappingURL=calendar-DtKpXGXO.mjs.map
+//# sourceMappingURL=calendar-C549VT55.mjs.map