ivt 0.7.4 → 0.7.5

package/dist/chunks/{calendar-Co99lCn4.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-M7D-rn0u.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-BSPAt__h.mjs';
-import { C as ChevronLeft } from './chevron-left-BpfBwM4S.mjs';
-import { C as ChevronRight } from './chevron-right-uq-O8rwC.mjs';
-import { C as ChevronDown } from './chevron-down-CZjN_vyX.mjs';
-import { b as buttonVariants, B as Button$1 } from './button-DsgJkgEz.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
@@ -778,346 +1118,6 @@ function normalizeInterval(context, interval) {
     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
-}
-
-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);
-    }
-}
-
 const FIVE_WEEKS = 5;
 const FOUR_WEEKS = 4;
 /**
@@ -5019,4 +5019,4 @@ function CalendarDayButton({ className, day, modifiers, ...props }) {
 }
 
 export { Calendar as C, CalendarDayButton as a, addMonths as b };
-//# sourceMappingURL=calendar-Co99lCn4.mjs.map
+//# sourceMappingURL=calendar-C549VT55.mjs.map