@govbr-ds/webcomponents 2.1.0 → 2.1.1

package/dist/cjs/datetime-picker-constants-B5pWeOn1.js

@@ -0,0 +1,3827 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+'use strict';
+
+var addDays = {};
+
+var constructFrom = {};
+
+var constants = {};
+
+var hasRequiredConstants;
+
+function requireConstants () {
+	if (hasRequiredConstants) return constants;
+	hasRequiredConstants = 1;
+	constants.secondsInYear =
+	  constants.secondsInWeek =
+	  constants.secondsInQuarter =
+	  constants.secondsInMonth =
+	  constants.secondsInMinute =
+	  constants.secondsInHour =
+	  constants.secondsInDay =
+	  constants.quartersInYear =
+	  constants.monthsInYear =
+	  constants.monthsInQuarter =
+	  constants.minutesInYear =
+	  constants.minutesInMonth =
+	  constants.minutesInHour =
+	  constants.minutesInDay =
+	  constants.minTime =
+	  constants.millisecondsInWeek =
+	  constants.millisecondsInSecond =
+	  constants.millisecondsInMinute =
+	  constants.millisecondsInHour =
+	  constants.millisecondsInDay =
+	  constants.maxTime =
+	  constants.daysInYear =
+	  constants.daysInWeek =
+	  constants.constructFromSymbol =
+	    void 0; /**
+	 * @module constants
+	 * @summary Useful constants
+	 * @description
+	 * Collection of useful date constants.
+	 *
+	 * The constants could be imported from `date-fns/constants`:
+	 *
+	 * ```ts
+	 * import { maxTime, minTime } from "date-fns/constants";
+	 *
+	 * function isAllowedTime(time) {
+	 *   return time <= maxTime && time >= minTime;
+	 * }
+	 * ```
+	 */
+
+	/**
+	 * @constant
+	 * @name daysInWeek
+	 * @summary Days in 1 week.
+	 */
+	(constants.daysInWeek = 7);
+
+	/**
+	 * @constant
+	 * @name daysInYear
+	 * @summary Days in 1 year.
+	 *
+	 * @description
+	 * How many days in a year.
+	 *
+	 * One years equals 365.2425 days according to the formula:
+	 *
+	 * > Leap year occurs every 4 years, except for years that are divisible by 100 and not divisible by 400.
+	 * > 1 mean year = (365+1/4-1/100+1/400) days = 365.2425 days
+	 */
+	const daysInYear = (constants.daysInYear = 365.2425);
+
+	/**
+	 * @constant
+	 * @name maxTime
+	 * @summary Maximum allowed time.
+	 *
+	 * @example
+	 * import { maxTime } from "date-fns/constants";
+	 *
+	 * const isValid = 8640000000000001 <= maxTime;
+	 * //=> false
+	 *
+	 * new Date(8640000000000001);
+	 * //=> Invalid Date
+	 */
+	const maxTime = (constants.maxTime = Math.pow(10, 8) * 24 * 60 * 60 * 1000);
+
+	/**
+	 * @constant
+	 * @name minTime
+	 * @summary Minimum allowed time.
+	 *
+	 * @example
+	 * import { minTime } from "date-fns/constants";
+	 *
+	 * const isValid = -8640000000000001 >= minTime;
+	 * //=> false
+	 *
+	 * new Date(-8640000000000001)
+	 * //=> Invalid Date
+	 */
+	(constants.minTime = -maxTime);
+
+	/**
+	 * @constant
+	 * @name millisecondsInWeek
+	 * @summary Milliseconds in 1 week.
+	 */
+	(constants.millisecondsInWeek = 604800000);
+
+	/**
+	 * @constant
+	 * @name millisecondsInDay
+	 * @summary Milliseconds in 1 day.
+	 */
+	(constants.millisecondsInDay = 86400000);
+
+	/**
+	 * @constant
+	 * @name millisecondsInMinute
+	 * @summary Milliseconds in 1 minute
+	 */
+	(constants.millisecondsInMinute = 60000);
+
+	/**
+	 * @constant
+	 * @name millisecondsInHour
+	 * @summary Milliseconds in 1 hour
+	 */
+	(constants.millisecondsInHour = 3600000);
+
+	/**
+	 * @constant
+	 * @name millisecondsInSecond
+	 * @summary Milliseconds in 1 second
+	 */
+	(constants.millisecondsInSecond = 1000);
+
+	/**
+	 * @constant
+	 * @name minutesInYear
+	 * @summary Minutes in 1 year.
+	 */
+	(constants.minutesInYear = 525600);
+
+	/**
+	 * @constant
+	 * @name minutesInMonth
+	 * @summary Minutes in 1 month.
+	 */
+	(constants.minutesInMonth = 43200);
+
+	/**
+	 * @constant
+	 * @name minutesInDay
+	 * @summary Minutes in 1 day.
+	 */
+	(constants.minutesInDay = 1440);
+
+	/**
+	 * @constant
+	 * @name minutesInHour
+	 * @summary Minutes in 1 hour.
+	 */
+	(constants.minutesInHour = 60);
+
+	/**
+	 * @constant
+	 * @name monthsInQuarter
+	 * @summary Months in 1 quarter.
+	 */
+	(constants.monthsInQuarter = 3);
+
+	/**
+	 * @constant
+	 * @name monthsInYear
+	 * @summary Months in 1 year.
+	 */
+	(constants.monthsInYear = 12);
+
+	/**
+	 * @constant
+	 * @name quartersInYear
+	 * @summary Quarters in 1 year
+	 */
+	(constants.quartersInYear = 4);
+
+	/**
+	 * @constant
+	 * @name secondsInHour
+	 * @summary Seconds in 1 hour.
+	 */
+	const secondsInHour = (constants.secondsInHour = 3600);
+
+	/**
+	 * @constant
+	 * @name secondsInMinute
+	 * @summary Seconds in 1 minute.
+	 */
+	(constants.secondsInMinute = 60);
+
+	/**
+	 * @constant
+	 * @name secondsInDay
+	 * @summary Seconds in 1 day.
+	 */
+	const secondsInDay = (constants.secondsInDay = secondsInHour * 24);
+
+	/**
+	 * @constant
+	 * @name secondsInWeek
+	 * @summary Seconds in 1 week.
+	 */
+	(constants.secondsInWeek = secondsInDay * 7);
+
+	/**
+	 * @constant
+	 * @name secondsInYear
+	 * @summary Seconds in 1 year.
+	 */
+	const secondsInYear = (constants.secondsInYear = secondsInDay * daysInYear);
+
+	/**
+	 * @constant
+	 * @name secondsInMonth
+	 * @summary Seconds in 1 month
+	 */
+	const secondsInMonth = (constants.secondsInMonth = secondsInYear / 12);
+
+	/**
+	 * @constant
+	 * @name secondsInQuarter
+	 * @summary Seconds in 1 quarter.
+	 */
+	(constants.secondsInQuarter = secondsInMonth * 3);
+
+	/**
+	 * @constant
+	 * @name constructFromSymbol
+	 * @summary Symbol enabling Date extensions to inherit properties from the reference date.
+	 *
+	 * The symbol is used to enable the `constructFrom` function to construct a date
+	 * using a reference date and a value. It allows to transfer extra properties
+	 * from the reference date to the new date. It's useful for extensions like
+	 * [`TZDate`](https://github.com/date-fns/tz) that accept a time zone as
+	 * a constructor argument.
+	 */
+	(constants.constructFromSymbol =
+	  Symbol.for("constructDateFrom"));
+	return constants;
+}
+
+var hasRequiredConstructFrom;
+
+function requireConstructFrom () {
+	if (hasRequiredConstructFrom) return constructFrom;
+	hasRequiredConstructFrom = 1;
+	constructFrom.constructFrom = constructFrom$1;
+	var _index = /*@__PURE__*/ requireConstants();
+
+	/**
+	 * @name constructFrom
+	 * @category Generic Helpers
+	 * @summary Constructs a date using the reference date and the value
+	 *
+	 * @description
+	 * The function constructs a new date using the constructor from the reference
+	 * date and the given value. It helps to build generic functions that accept
+	 * date extensions.
+	 *
+	 * It defaults to `Date` if the passed reference date is a number or a string.
+	 *
+	 * Starting from v3.7.0, it allows to construct a date using `[Symbol.for("constructDateFrom")]`
+	 * enabling to transfer extra properties from the reference date to the new date.
+	 * It's useful for extensions like [`TZDate`](https://github.com/date-fns/tz)
+	 * that accept a time zone as a constructor argument.
+	 *
+	 * @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).
+	 *
+	 * @param date - The reference date to take constructor from
+	 * @param value - The value to create the date
+	 *
+	 * @returns Date initialized using the given date and value
+	 *
+	 * @example
+	 * import { constructFrom } from "date-fns";
+	 *
+	 * // A function that clones a date preserving the original type
+	 * function cloneDate<DateType extends Date>(date: DateType): DateType {
+	 *   return constructFrom(
+	 *     date, // Use constructor from the given date
+	 *     date.getTime() // Use the date value to create a new date
+	 *   );
+	 * }
+	 */
+	function constructFrom$1(date, value) {
+	  if (typeof date === "function") return date(value);
+
+	  if (date && typeof date === "object" && _index.constructFromSymbol in date)
+	    return date[_index.constructFromSymbol](value);
+
+	  if (date instanceof Date) return new date.constructor(value);
+
+	  return new Date(value);
+	}
+	return constructFrom;
+}
+
+var toDate = {};
+
+var hasRequiredToDate;
+
+function requireToDate () {
+	if (hasRequiredToDate) return toDate;
+	hasRequiredToDate = 1;
+	toDate.toDate = toDate$1;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+
+	/**
+	 * @name toDate
+	 * @category Common Helpers
+	 * @summary Convert the given argument to an instance of Date.
+	 *
+	 * @description
+	 * Convert the given argument to an instance of Date.
+	 *
+	 * If the argument is an instance of Date, the function returns its clone.
+	 *
+	 * If the argument is a number, it is treated as a timestamp.
+	 *
+	 * If the argument is none of the above, the function returns Invalid Date.
+	 *
+	 * Starting from v3.7.0, it clones a date using `[Symbol.for("constructDateFrom")]`
+	 * enabling to transfer extra properties from the reference date to the new date.
+	 * It's useful for extensions like [`TZDate`](https://github.com/date-fns/tz)
+	 * that accept a time zone as a constructor argument.
+	 *
+	 * **Note**: *all* Date arguments passed to any *date-fns* function is processed by `toDate`.
+	 *
+	 * @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 argument - The value to convert
+	 *
+	 * @returns The parsed date in the local time zone
+	 *
+	 * @example
+	 * // Clone the date:
+	 * const result = toDate(new Date(2014, 1, 11, 11, 30, 30))
+	 * //=> Tue Feb 11 2014 11:30:30
+	 *
+	 * @example
+	 * // Convert the timestamp to date:
+	 * const result = toDate(1392098430000)
+	 * //=> Tue Feb 11 2014 11:30:30
+	 */
+	function toDate$1(argument, context) {
+	  // [TODO] Get rid of `toDate` or `constructFrom`?
+	  return (0, _index.constructFrom)(context || argument, argument);
+	}
+	return toDate;
+}
+
+var hasRequiredAddDays;
+
+function requireAddDays () {
+	if (hasRequiredAddDays) return addDays;
+	hasRequiredAddDays = 1;
+	addDays.addDays = addDays$1;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+	var _index2 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link addDays} function options.
+	 */
+
+	/**
+	 * @name addDays
+	 * @category Day Helpers
+	 * @summary Add the specified number of days to the given date.
+	 *
+	 * @description
+	 * Add the specified number of days to the given date.
+	 *
+	 * **You don't need date-fns\***:
+	 *
+	 * Temporal has a built-in `add` method on all its classes:
+	 *
+	 * - [`Temporal.Instant.prototype.add()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal/Instant/add)
+	 * - [`Temporal.PlainDate.prototype.add()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal/PlainDate/add)
+	 * - [`Temporal.PlainDateTime.prototype.add()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal/PlainDateTime/add)
+	 * - [`Temporal.PlainTime.prototype.add()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal/PlainTime/add)
+	 * - [`Temporal.PlainYearMonth.prototype.add()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal/PlainYearMonth/add)
+	 * - [`Temporal.ZonedDateTime.prototype.add()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal/ZonedDateTime/add)
+	 *
+	 * \* **Not really**, see: https://date-fns.org/you-dont-need-date-fns
+	 *
+	 * @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 days to be added.
+	 * @param options - An object with options
+	 *
+	 * @returns The new date with the days added
+	 *
+	 * @example
+	 * // Add 10 days to 1 September 2014:
+	 * const result = addDays(new Date(2014, 8, 1), 10)
+	 * //=> Thu Sep 11 2014 00:00:00
+	 *
+	 * @example
+	 * // Using Temporal:
+	 * // Add 10 days to 1 September 2014:
+	 * Temporal.PlainDate.from("2014-09-01").add({ days: 10 }).toString();
+	 * //=> "2014-09-11"
+	 */
+	function addDays$1(date, amount, options) {
+	  const _date = (0, _index2.toDate)(date, options?.in);
+	  if (isNaN(amount)) return (0, _index.constructFrom)(options?.in || date, NaN);
+
+	  // If 0 days, no-op to avoid changing times in the hour before end of DST
+	  if (!amount) return _date;
+
+	  _date.setDate(_date.getDate() + amount);
+	  return _date;
+	}
+	return addDays;
+}
+
+var format = {};
+
+var defaultLocale = {};
+
+var enUS = {};
+
+var formatDistance = {};
+
+var hasRequiredFormatDistance;
+
+function requireFormatDistance () {
+	if (hasRequiredFormatDistance) return formatDistance;
+	hasRequiredFormatDistance = 1;
+	formatDistance.formatDistance = void 0;
+
+	const formatDistanceLocale = {
+	  lessThanXSeconds: {
+	    one: "less than a second",
+	    other: "less than {{count}} seconds",
+	  },
+
+	  xSeconds: {
+	    one: "1 second",
+	    other: "{{count}} seconds",
+	  },
+
+	  halfAMinute: "half a minute",
+
+	  lessThanXMinutes: {
+	    one: "less than a minute",
+	    other: "less than {{count}} minutes",
+	  },
+
+	  xMinutes: {
+	    one: "1 minute",
+	    other: "{{count}} minutes",
+	  },
+
+	  aboutXHours: {
+	    one: "about 1 hour",
+	    other: "about {{count}} hours",
+	  },
+
+	  xHours: {
+	    one: "1 hour",
+	    other: "{{count}} hours",
+	  },
+
+	  xDays: {
+	    one: "1 day",
+	    other: "{{count}} days",
+	  },
+
+	  aboutXWeeks: {
+	    one: "about 1 week",
+	    other: "about {{count}} weeks",
+	  },
+
+	  xWeeks: {
+	    one: "1 week",
+	    other: "{{count}} weeks",
+	  },
+
+	  aboutXMonths: {
+	    one: "about 1 month",
+	    other: "about {{count}} months",
+	  },
+
+	  xMonths: {
+	    one: "1 month",
+	    other: "{{count}} months",
+	  },
+
+	  aboutXYears: {
+	    one: "about 1 year",
+	    other: "about {{count}} years",
+	  },
+
+	  xYears: {
+	    one: "1 year",
+	    other: "{{count}} years",
+	  },
+
+	  overXYears: {
+	    one: "over 1 year",
+	    other: "over {{count}} years",
+	  },
+
+	  almostXYears: {
+	    one: "almost 1 year",
+	    other: "almost {{count}} years",
+	  },
+	};
+
+	const formatDistance$1 = (token, count, options) => {
+	  let result;
+
+	  const tokenValue = formatDistanceLocale[token];
+	  if (typeof tokenValue === "string") {
+	    result = tokenValue;
+	  } else if (count === 1) {
+	    result = tokenValue.one;
+	  } else {
+	    result = tokenValue.other.replace("{{count}}", count.toString());
+	  }
+
+	  if (options?.addSuffix) {
+	    if (options.comparison && options.comparison > 0) {
+	      return "in " + result;
+	    } else {
+	      return result + " ago";
+	    }
+	  }
+
+	  return result;
+	};
+	formatDistance.formatDistance = formatDistance$1;
+	return formatDistance;
+}
+
+var formatLong = {};
+
+var buildFormatLongFn = {};
+
+var hasRequiredBuildFormatLongFn;
+
+function requireBuildFormatLongFn () {
+	if (hasRequiredBuildFormatLongFn) return buildFormatLongFn;
+	hasRequiredBuildFormatLongFn = 1;
+	buildFormatLongFn.buildFormatLongFn = buildFormatLongFn$1;
+
+	function buildFormatLongFn$1(args) {
+	  return (options = {}) => {
+	    // TODO: Remove String()
+	    const width = options.width ? String(options.width) : args.defaultWidth;
+	    const format = args.formats[width] || args.formats[args.defaultWidth];
+	    return format;
+	  };
+	}
+	return buildFormatLongFn;
+}
+
+var hasRequiredFormatLong;
+
+function requireFormatLong () {
+	if (hasRequiredFormatLong) return formatLong;
+	hasRequiredFormatLong = 1;
+	formatLong.formatLong = void 0;
+	var _index = /*@__PURE__*/ requireBuildFormatLongFn();
+
+	const dateFormats = {
+	  full: "EEEE, MMMM do, y",
+	  long: "MMMM do, y",
+	  medium: "MMM d, y",
+	  short: "MM/dd/yyyy",
+	};
+
+	const timeFormats = {
+	  full: "h:mm:ss a zzzz",
+	  long: "h:mm:ss a z",
+	  medium: "h:mm:ss a",
+	  short: "h:mm a",
+	};
+
+	const dateTimeFormats = {
+	  full: "{{date}} 'at' {{time}}",
+	  long: "{{date}} 'at' {{time}}",
+	  medium: "{{date}}, {{time}}",
+	  short: "{{date}}, {{time}}",
+	};
+
+	(formatLong.formatLong = {
+	  date: (0, _index.buildFormatLongFn)({
+	    formats: dateFormats,
+	    defaultWidth: "full",
+	  }),
+
+	  time: (0, _index.buildFormatLongFn)({
+	    formats: timeFormats,
+	    defaultWidth: "full",
+	  }),
+
+	  dateTime: (0, _index.buildFormatLongFn)({
+	    formats: dateTimeFormats,
+	    defaultWidth: "full",
+	  }),
+	});
+	return formatLong;
+}
+
+var formatRelative = {};
+
+var hasRequiredFormatRelative;
+
+function requireFormatRelative () {
+	if (hasRequiredFormatRelative) return formatRelative;
+	hasRequiredFormatRelative = 1;
+	formatRelative.formatRelative = void 0;
+
+	const formatRelativeLocale = {
+	  lastWeek: "'last' eeee 'at' p",
+	  yesterday: "'yesterday at' p",
+	  today: "'today at' p",
+	  tomorrow: "'tomorrow at' p",
+	  nextWeek: "eeee 'at' p",
+	  other: "P",
+	};
+
+	const formatRelative$1 = (token, _date, _baseDate, _options) =>
+	  formatRelativeLocale[token];
+	formatRelative.formatRelative = formatRelative$1;
+	return formatRelative;
+}
+
+var localize = {};
+
+var buildLocalizeFn = {};
+
+var hasRequiredBuildLocalizeFn;
+
+function requireBuildLocalizeFn () {
+	if (hasRequiredBuildLocalizeFn) return buildLocalizeFn;
+	hasRequiredBuildLocalizeFn = 1;
+	buildLocalizeFn.buildLocalizeFn = buildLocalizeFn$1;
+
+	/**
+	 * The localize function argument callback which allows to convert raw value to
+	 * the actual type.
+	 *
+	 * @param value - The value to convert
+	 *
+	 * @returns The converted value
+	 */
+
+	/**
+	 * The map of localized values for each width.
+	 */
+
+	/**
+	 * The index type of the locale unit value. It types conversion of units of
+	 * values that don't start at 0 (i.e. quarters).
+	 */
+
+	/**
+	 * Converts the unit value to the tuple of values.
+	 */
+
+	/**
+	 * The tuple of localized era values. The first element represents BC,
+	 * the second element represents AD.
+	 */
+
+	/**
+	 * The tuple of localized quarter values. The first element represents Q1.
+	 */
+
+	/**
+	 * The tuple of localized day values. The first element represents Sunday.
+	 */
+
+	/**
+	 * The tuple of localized month values. The first element represents January.
+	 */
+
+	function buildLocalizeFn$1(args) {
+	  return (value, options) => {
+	    const context = options?.context ? String(options.context) : "standalone";
+
+	    let valuesArray;
+	    if (context === "formatting" && args.formattingValues) {
+	      const defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
+	      const width = options?.width ? String(options.width) : defaultWidth;
+
+	      valuesArray =
+	        args.formattingValues[width] || args.formattingValues[defaultWidth];
+	    } else {
+	      const defaultWidth = args.defaultWidth;
+	      const width = options?.width ? String(options.width) : args.defaultWidth;
+
+	      valuesArray = args.values[width] || args.values[defaultWidth];
+	    }
+	    const index = args.argumentCallback ? args.argumentCallback(value) : value;
+
+	    // @ts-expect-error - For some reason TypeScript just don't want to match it, no matter how hard we try. I challenge you to try to remove it!
+	    return valuesArray[index];
+	  };
+	}
+	return buildLocalizeFn;
+}
+
+var hasRequiredLocalize;
+
+function requireLocalize () {
+	if (hasRequiredLocalize) return localize;
+	hasRequiredLocalize = 1;
+	localize.localize = void 0;
+	var _index = /*@__PURE__*/ requireBuildLocalizeFn();
+
+	const eraValues = {
+	  narrow: ["B", "A"],
+	  abbreviated: ["BC", "AD"],
+	  wide: ["Before Christ", "Anno Domini"],
+	};
+
+	const quarterValues = {
+	  narrow: ["1", "2", "3", "4"],
+	  abbreviated: ["Q1", "Q2", "Q3", "Q4"],
+	  wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"],
+	};
+
+	// Note: in English, the names of days of the week and months are capitalized.
+	// If you are making a new locale based on this one, check if the same is true for the language you're working on.
+	// Generally, formatted dates should look like they are in the middle of a sentence,
+	// e.g. in Spanish language the weekdays and months should be in the lowercase.
+	const monthValues = {
+	  narrow: ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"],
+	  abbreviated: [
+	    "Jan",
+	    "Feb",
+	    "Mar",
+	    "Apr",
+	    "May",
+	    "Jun",
+	    "Jul",
+	    "Aug",
+	    "Sep",
+	    "Oct",
+	    "Nov",
+	    "Dec",
+	  ],
+
+	  wide: [
+	    "January",
+	    "February",
+	    "March",
+	    "April",
+	    "May",
+	    "June",
+	    "July",
+	    "August",
+	    "September",
+	    "October",
+	    "November",
+	    "December",
+	  ],
+	};
+
+	const dayValues = {
+	  narrow: ["S", "M", "T", "W", "T", "F", "S"],
+	  short: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
+	  abbreviated: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+	  wide: [
+	    "Sunday",
+	    "Monday",
+	    "Tuesday",
+	    "Wednesday",
+	    "Thursday",
+	    "Friday",
+	    "Saturday",
+	  ],
+	};
+
+	const dayPeriodValues = {
+	  narrow: {
+	    am: "a",
+	    pm: "p",
+	    midnight: "mi",
+	    noon: "n",
+	    morning: "morning",
+	    afternoon: "afternoon",
+	    evening: "evening",
+	    night: "night",
+	  },
+	  abbreviated: {
+	    am: "AM",
+	    pm: "PM",
+	    midnight: "midnight",
+	    noon: "noon",
+	    morning: "morning",
+	    afternoon: "afternoon",
+	    evening: "evening",
+	    night: "night",
+	  },
+	  wide: {
+	    am: "a.m.",
+	    pm: "p.m.",
+	    midnight: "midnight",
+	    noon: "noon",
+	    morning: "morning",
+	    afternoon: "afternoon",
+	    evening: "evening",
+	    night: "night",
+	  },
+	};
+
+	const formattingDayPeriodValues = {
+	  narrow: {
+	    am: "a",
+	    pm: "p",
+	    midnight: "mi",
+	    noon: "n",
+	    morning: "in the morning",
+	    afternoon: "in the afternoon",
+	    evening: "in the evening",
+	    night: "at night",
+	  },
+	  abbreviated: {
+	    am: "AM",
+	    pm: "PM",
+	    midnight: "midnight",
+	    noon: "noon",
+	    morning: "in the morning",
+	    afternoon: "in the afternoon",
+	    evening: "in the evening",
+	    night: "at night",
+	  },
+	  wide: {
+	    am: "a.m.",
+	    pm: "p.m.",
+	    midnight: "midnight",
+	    noon: "noon",
+	    morning: "in the morning",
+	    afternoon: "in the afternoon",
+	    evening: "in the evening",
+	    night: "at night",
+	  },
+	};
+
+	const ordinalNumber = (dirtyNumber, _options) => {
+	  const number = Number(dirtyNumber);
+
+	  // If ordinal numbers depend on context, for example,
+	  // if they are different for different grammatical genders,
+	  // use `options.unit`.
+	  //
+	  // `unit` can be 'year', 'quarter', 'month', 'week', 'date', 'dayOfYear',
+	  // 'day', 'hour', 'minute', 'second'.
+
+	  const rem100 = number % 100;
+	  if (rem100 > 20 || rem100 < 10) {
+	    switch (rem100 % 10) {
+	      case 1:
+	        return number + "st";
+	      case 2:
+	        return number + "nd";
+	      case 3:
+	        return number + "rd";
+	    }
+	  }
+	  return number + "th";
+	};
+
+	(localize.localize = {
+	  ordinalNumber,
+
+	  era: (0, _index.buildLocalizeFn)({
+	    values: eraValues,
+	    defaultWidth: "wide",
+	  }),
+
+	  quarter: (0, _index.buildLocalizeFn)({
+	    values: quarterValues,
+	    defaultWidth: "wide",
+	    argumentCallback: (quarter) => quarter - 1,
+	  }),
+
+	  month: (0, _index.buildLocalizeFn)({
+	    values: monthValues,
+	    defaultWidth: "wide",
+	  }),
+
+	  day: (0, _index.buildLocalizeFn)({
+	    values: dayValues,
+	    defaultWidth: "wide",
+	  }),
+
+	  dayPeriod: (0, _index.buildLocalizeFn)({
+	    values: dayPeriodValues,
+	    defaultWidth: "wide",
+	    formattingValues: formattingDayPeriodValues,
+	    defaultFormattingWidth: "wide",
+	  }),
+	});
+	return localize;
+}
+
+var match = {};
+
+var buildMatchFn = {};
+
+var hasRequiredBuildMatchFn;
+
+function requireBuildMatchFn () {
+	if (hasRequiredBuildMatchFn) return buildMatchFn;
+	hasRequiredBuildMatchFn = 1;
+	buildMatchFn.buildMatchFn = buildMatchFn$1;
+
+	function buildMatchFn$1(args) {
+	  return (string, options = {}) => {
+	    const width = options.width;
+
+	    const matchPattern =
+	      (width && args.matchPatterns[width]) ||
+	      args.matchPatterns[args.defaultMatchWidth];
+	    const matchResult = string.match(matchPattern);
+
+	    if (!matchResult) {
+	      return null;
+	    }
+	    const matchedString = matchResult[0];
+
+	    const parsePatterns =
+	      (width && args.parsePatterns[width]) ||
+	      args.parsePatterns[args.defaultParseWidth];
+
+	    const key = Array.isArray(parsePatterns)
+	      ? findIndex(parsePatterns, (pattern) => pattern.test(matchedString))
+	      : // [TODO] -- I challenge you to fix the type
+	        findKey(parsePatterns, (pattern) => pattern.test(matchedString));
+
+	    let value;
+
+	    value = args.valueCallback ? args.valueCallback(key) : key;
+	    value = options.valueCallback
+	      ? // [TODO] -- I challenge you to fix the type
+	        options.valueCallback(value)
+	      : value;
+
+	    const rest = string.slice(matchedString.length);
+
+	    return { value, rest };
+	  };
+	}
+
+	function findKey(object, predicate) {
+	  for (const key in object) {
+	    if (
+	      Object.prototype.hasOwnProperty.call(object, key) &&
+	      predicate(object[key])
+	    ) {
+	      return key;
+	    }
+	  }
+	  return undefined;
+	}
+
+	function findIndex(array, predicate) {
+	  for (let key = 0; key < array.length; key++) {
+	    if (predicate(array[key])) {
+	      return key;
+	    }
+	  }
+	  return undefined;
+	}
+	return buildMatchFn;
+}
+
+var buildMatchPatternFn = {};
+
+var hasRequiredBuildMatchPatternFn;
+
+function requireBuildMatchPatternFn () {
+	if (hasRequiredBuildMatchPatternFn) return buildMatchPatternFn;
+	hasRequiredBuildMatchPatternFn = 1;
+	buildMatchPatternFn.buildMatchPatternFn = buildMatchPatternFn$1;
+
+	function buildMatchPatternFn$1(args) {
+	  return (string, options = {}) => {
+	    const matchResult = string.match(args.matchPattern);
+	    if (!matchResult) return null;
+	    const matchedString = matchResult[0];
+
+	    const parseResult = string.match(args.parsePattern);
+	    if (!parseResult) return null;
+	    let value = args.valueCallback
+	      ? args.valueCallback(parseResult[0])
+	      : parseResult[0];
+
+	    // [TODO] I challenge you to fix the type
+	    value = options.valueCallback ? options.valueCallback(value) : value;
+
+	    const rest = string.slice(matchedString.length);
+
+	    return { value, rest };
+	  };
+	}
+	return buildMatchPatternFn;
+}
+
+var hasRequiredMatch;
+
+function requireMatch () {
+	if (hasRequiredMatch) return match;
+	hasRequiredMatch = 1;
+	match.match = void 0;
+
+	var _index = /*@__PURE__*/ requireBuildMatchFn();
+	var _index2 = /*@__PURE__*/ requireBuildMatchPatternFn();
+
+	const matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i;
+	const parseOrdinalNumberPattern = /\d+/i;
+
+	const matchEraPatterns = {
+	  narrow: /^(b|a)/i,
+	  abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
+	  wide: /^(before christ|before common era|anno domini|common era)/i,
+	};
+	const parseEraPatterns = {
+	  any: [/^b/i, /^(a|c)/i],
+	};
+
+	const matchQuarterPatterns = {
+	  narrow: /^[1234]/i,
+	  abbreviated: /^q[1234]/i,
+	  wide: /^[1234](th|st|nd|rd)? quarter/i,
+	};
+	const parseQuarterPatterns = {
+	  any: [/1/i, /2/i, /3/i, /4/i],
+	};
+
+	const matchMonthPatterns = {
+	  narrow: /^[jfmasond]/i,
+	  abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
+	  wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i,
+	};
+	const parseMonthPatterns = {
+	  narrow: [
+	    /^j/i,
+	    /^f/i,
+	    /^m/i,
+	    /^a/i,
+	    /^m/i,
+	    /^j/i,
+	    /^j/i,
+	    /^a/i,
+	    /^s/i,
+	    /^o/i,
+	    /^n/i,
+	    /^d/i,
+	  ],
+
+	  any: [
+	    /^ja/i,
+	    /^f/i,
+	    /^mar/i,
+	    /^ap/i,
+	    /^may/i,
+	    /^jun/i,
+	    /^jul/i,
+	    /^au/i,
+	    /^s/i,
+	    /^o/i,
+	    /^n/i,
+	    /^d/i,
+	  ],
+	};
+
+	const matchDayPatterns = {
+	  narrow: /^[smtwf]/i,
+	  short: /^(su|mo|tu|we|th|fr|sa)/i,
+	  abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
+	  wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i,
+	};
+	const parseDayPatterns = {
+	  narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
+	  any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i],
+	};
+
+	const matchDayPeriodPatterns = {
+	  narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
+	  any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i,
+	};
+	const parseDayPeriodPatterns = {
+	  any: {
+	    am: /^a/i,
+	    pm: /^p/i,
+	    midnight: /^mi/i,
+	    noon: /^no/i,
+	    morning: /morning/i,
+	    afternoon: /afternoon/i,
+	    evening: /evening/i,
+	    night: /night/i,
+	  },
+	};
+
+	(match.match = {
+	  ordinalNumber: (0, _index2.buildMatchPatternFn)({
+	    matchPattern: matchOrdinalNumberPattern,
+	    parsePattern: parseOrdinalNumberPattern,
+	    valueCallback: (value) => parseInt(value, 10),
+	  }),
+
+	  era: (0, _index.buildMatchFn)({
+	    matchPatterns: matchEraPatterns,
+	    defaultMatchWidth: "wide",
+	    parsePatterns: parseEraPatterns,
+	    defaultParseWidth: "any",
+	  }),
+
+	  quarter: (0, _index.buildMatchFn)({
+	    matchPatterns: matchQuarterPatterns,
+	    defaultMatchWidth: "wide",
+	    parsePatterns: parseQuarterPatterns,
+	    defaultParseWidth: "any",
+	    valueCallback: (index) => index + 1,
+	  }),
+
+	  month: (0, _index.buildMatchFn)({
+	    matchPatterns: matchMonthPatterns,
+	    defaultMatchWidth: "wide",
+	    parsePatterns: parseMonthPatterns,
+	    defaultParseWidth: "any",
+	  }),
+
+	  day: (0, _index.buildMatchFn)({
+	    matchPatterns: matchDayPatterns,
+	    defaultMatchWidth: "wide",
+	    parsePatterns: parseDayPatterns,
+	    defaultParseWidth: "any",
+	  }),
+
+	  dayPeriod: (0, _index.buildMatchFn)({
+	    matchPatterns: matchDayPeriodPatterns,
+	    defaultMatchWidth: "any",
+	    parsePatterns: parseDayPeriodPatterns,
+	    defaultParseWidth: "any",
+	  }),
+	});
+	return match;
+}
+
+var hasRequiredEnUS;
+
+function requireEnUS () {
+	if (hasRequiredEnUS) return enUS;
+	hasRequiredEnUS = 1;
+	enUS.enUS = void 0;
+	var _index = /*@__PURE__*/ requireFormatDistance();
+	var _index2 = /*@__PURE__*/ requireFormatLong();
+	var _index3 = /*@__PURE__*/ requireFormatRelative();
+	var _index4 = /*@__PURE__*/ requireLocalize();
+	var _index5 = /*@__PURE__*/ requireMatch();
+
+	/**
+	 * @category Locales
+	 * @summary English locale (United States).
+	 * @language English
+	 * @iso-639-2 eng
+	 * @author Sasha Koss [@kossnocorp](https://github.com/kossnocorp)
+	 * @author Lesha Koss [@leshakoss](https://github.com/leshakoss)
+	 */
+	(enUS.enUS = {
+	  code: "en-US",
+	  formatDistance: _index.formatDistance,
+	  formatLong: _index2.formatLong,
+	  formatRelative: _index3.formatRelative,
+	  localize: _index4.localize,
+	  match: _index5.match,
+	  options: {
+	    weekStartsOn: 0 /* Sunday */,
+	    firstWeekContainsDate: 1,
+	  },
+	});
+	return enUS;
+}
+
+var hasRequiredDefaultLocale;
+
+function requireDefaultLocale () {
+	if (hasRequiredDefaultLocale) return defaultLocale;
+	hasRequiredDefaultLocale = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "defaultLocale", {
+		  enumerable: true,
+		  get: function () {
+		    return _index.enUS;
+		  },
+		});
+		var _index = /*@__PURE__*/ requireEnUS(); 
+	} (defaultLocale));
+	return defaultLocale;
+}
+
+var defaultOptions = {};
+
+var hasRequiredDefaultOptions;
+
+function requireDefaultOptions () {
+	if (hasRequiredDefaultOptions) return defaultOptions;
+	hasRequiredDefaultOptions = 1;
+	defaultOptions.getDefaultOptions = getDefaultOptions;
+	defaultOptions.setDefaultOptions = setDefaultOptions;
+
+	let defaultOptions$1 = {};
+
+	function getDefaultOptions() {
+	  return defaultOptions$1;
+	}
+
+	function setDefaultOptions(newOptions) {
+	  defaultOptions$1 = newOptions;
+	}
+	return defaultOptions;
+}
+
+var formatters = {};
+
+var getDayOfYear = {};
+
+var differenceInCalendarDays = {};
+
+var getTimezoneOffsetInMilliseconds = {};
+
+var hasRequiredGetTimezoneOffsetInMilliseconds;
+
+function requireGetTimezoneOffsetInMilliseconds () {
+	if (hasRequiredGetTimezoneOffsetInMilliseconds) return getTimezoneOffsetInMilliseconds;
+	hasRequiredGetTimezoneOffsetInMilliseconds = 1;
+	getTimezoneOffsetInMilliseconds.getTimezoneOffsetInMilliseconds = getTimezoneOffsetInMilliseconds$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
+	 * They usually appear for dates that denote time before the timezones were introduced
+	 * (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891
+	 * and GMT+01:00:00 after that date)
+	 *
+	 * Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,
+	 * which would lead to incorrect calculations.
+	 *
+	 * This function returns the timezone offset in milliseconds that takes seconds in account.
+	 */
+	function getTimezoneOffsetInMilliseconds$1(date) {
+	  const _date = (0, _index.toDate)(date);
+	  const utcDate = new Date(
+	    Date.UTC(
+	      _date.getFullYear(),
+	      _date.getMonth(),
+	      _date.getDate(),
+	      _date.getHours(),
+	      _date.getMinutes(),
+	      _date.getSeconds(),
+	      _date.getMilliseconds(),
+	    ),
+	  );
+	  utcDate.setUTCFullYear(_date.getFullYear());
+	  return +date - +utcDate;
+	}
+	return getTimezoneOffsetInMilliseconds;
+}
+
+var normalizeDates = {};
+
+var hasRequiredNormalizeDates;
+
+function requireNormalizeDates () {
+	if (hasRequiredNormalizeDates) return normalizeDates;
+	hasRequiredNormalizeDates = 1;
+	normalizeDates.normalizeDates = normalizeDates$1;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+
+	function normalizeDates$1(context, ...dates) {
+	  const normalize = _index.constructFrom.bind(
+	    null,
+	    context || dates.find((date) => typeof date === "object"),
+	  );
+	  return dates.map(normalize);
+	}
+	return normalizeDates;
+}
+
+var startOfDay = {};
+
+var hasRequiredStartOfDay;
+
+function requireStartOfDay () {
+	if (hasRequiredStartOfDay) return startOfDay;
+	hasRequiredStartOfDay = 1;
+	startOfDay.startOfDay = startOfDay$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link startOfDay} function options.
+	 */
+
+	/**
+	 * @name startOfDay
+	 * @category Day Helpers
+	 * @summary Return the start of a day for the given date.
+	 *
+	 * @description
+	 * Return the start of a day for the given date.
+	 * The result will be in the local timezone.
+	 *
+	 * @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 original date
+	 * @param options - The options
+	 *
+	 * @returns The start of a day
+	 *
+	 * @example
+	 * // The start of a day for 2 September 2014 11:55:00:
+	 * const result = startOfDay(new Date(2014, 8, 2, 11, 55, 0))
+	 * //=> Tue Sep 02 2014 00:00:00
+	 */
+	function startOfDay$1(date, options) {
+	  const _date = (0, _index.toDate)(date, options?.in);
+	  _date.setHours(0, 0, 0, 0);
+	  return _date;
+	}
+	return startOfDay;
+}
+
+var hasRequiredDifferenceInCalendarDays;
+
+function requireDifferenceInCalendarDays () {
+	if (hasRequiredDifferenceInCalendarDays) return differenceInCalendarDays;
+	hasRequiredDifferenceInCalendarDays = 1;
+	differenceInCalendarDays.differenceInCalendarDays = differenceInCalendarDays$1;
+	var _index = /*@__PURE__*/ requireGetTimezoneOffsetInMilliseconds();
+	var _index2 = /*@__PURE__*/ requireNormalizeDates();
+	var _index3 = /*@__PURE__*/ requireConstants();
+	var _index4 = /*@__PURE__*/ requireStartOfDay();
+
+	/**
+	 * The {@link differenceInCalendarDays} function options.
+	 */
+
+	/**
+	 * @name differenceInCalendarDays
+	 * @category Day Helpers
+	 * @summary Get the number of calendar days between the given dates.
+	 *
+	 * @description
+	 * Get the number of calendar days between the given dates. This means that the times are removed
+	 * from the dates and then the difference in days is calculated.
+	 *
+	 * @param laterDate - The later date
+	 * @param earlierDate - The earlier date
+	 * @param options - The options object
+	 *
+	 * @returns The number of calendar days
+	 *
+	 * @example
+	 * // How many calendar days are between
+	 * // 2 July 2011 23:00:00 and 2 July 2012 00:00:00?
+	 * const result = differenceInCalendarDays(
+	 *   new Date(2012, 6, 2, 0, 0),
+	 *   new Date(2011, 6, 2, 23, 0)
+	 * )
+	 * //=> 366
+	 * // How many calendar days are between
+	 * // 2 July 2011 23:59:00 and 3 July 2011 00:01:00?
+	 * const result = differenceInCalendarDays(
+	 *   new Date(2011, 6, 3, 0, 1),
+	 *   new Date(2011, 6, 2, 23, 59)
+	 * )
+	 * //=> 1
+	 */
+	function differenceInCalendarDays$1(laterDate, earlierDate, options) {
+	  const [laterDate_, earlierDate_] = (0, _index2.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+
+	  const laterStartOfDay = (0, _index4.startOfDay)(laterDate_);
+	  const earlierStartOfDay = (0, _index4.startOfDay)(earlierDate_);
+
+	  const laterTimestamp =
+	    +laterStartOfDay -
+	    (0, _index.getTimezoneOffsetInMilliseconds)(laterStartOfDay);
+	  const earlierTimestamp =
+	    +earlierStartOfDay -
+	    (0, _index.getTimezoneOffsetInMilliseconds)(earlierStartOfDay);
+
+	  // Round the number of days to the nearest integer because the number of
+	  // milliseconds in a day is not constant (e.g. it's different in the week of
+	  // the daylight saving time clock shift).
+	  return Math.round(
+	    (laterTimestamp - earlierTimestamp) / _index3.millisecondsInDay,
+	  );
+	}
+	return differenceInCalendarDays;
+}
+
+var startOfYear = {};
+
+var hasRequiredStartOfYear;
+
+function requireStartOfYear () {
+	if (hasRequiredStartOfYear) return startOfYear;
+	hasRequiredStartOfYear = 1;
+	startOfYear.startOfYear = startOfYear$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link startOfYear} function options.
+	 */
+
+	/**
+	 * @name startOfYear
+	 * @category Year Helpers
+	 * @summary Return the start of a year for the given date.
+	 *
+	 * @description
+	 * Return the start of a year for the given date.
+	 * The result will be in the local timezone.
+	 *
+	 * @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 original date
+	 * @param options - The options
+	 *
+	 * @returns The start of a year
+	 *
+	 * @example
+	 * // The start of a year for 2 September 2014 11:55:00:
+	 * const result = startOfYear(new Date(2014, 8, 2, 11, 55, 00))
+	 * //=> Wed Jan 01 2014 00:00:00
+	 */
+	function startOfYear$1(date, options) {
+	  const date_ = (0, _index.toDate)(date, options?.in);
+	  date_.setFullYear(date_.getFullYear(), 0, 1);
+	  date_.setHours(0, 0, 0, 0);
+	  return date_;
+	}
+	return startOfYear;
+}
+
+var hasRequiredGetDayOfYear;
+
+function requireGetDayOfYear () {
+	if (hasRequiredGetDayOfYear) return getDayOfYear;
+	hasRequiredGetDayOfYear = 1;
+	getDayOfYear.getDayOfYear = getDayOfYear$1;
+	var _index = /*@__PURE__*/ requireDifferenceInCalendarDays();
+	var _index2 = /*@__PURE__*/ requireStartOfYear();
+	var _index3 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link getDayOfYear} function options.
+	 */
+
+	/**
+	 * @name getDayOfYear
+	 * @category Day Helpers
+	 * @summary Get the day of the year of the given date.
+	 *
+	 * @description
+	 * Get the day of the year of the given date.
+	 *
+	 * @param date - The given date
+	 * @param options - The options
+	 *
+	 * @returns The day of year
+	 *
+	 * @example
+	 * // Which day of the year is 2 July 2014?
+	 * const result = getDayOfYear(new Date(2014, 6, 2))
+	 * //=> 183
+	 */
+	function getDayOfYear$1(date, options) {
+	  const _date = (0, _index3.toDate)(date, options?.in);
+	  const diff = (0, _index.differenceInCalendarDays)(
+	    _date,
+	    (0, _index2.startOfYear)(_date),
+	  );
+	  const dayOfYear = diff + 1;
+	  return dayOfYear;
+	}
+	return getDayOfYear;
+}
+
+var getISOWeek = {};
+
+var startOfISOWeek = {};
+
+var startOfWeek = {};
+
+var hasRequiredStartOfWeek;
+
+function requireStartOfWeek () {
+	if (hasRequiredStartOfWeek) return startOfWeek;
+	hasRequiredStartOfWeek = 1;
+	startOfWeek.startOfWeek = startOfWeek$1;
+	var _index = /*@__PURE__*/ requireDefaultOptions();
+	var _index2 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link startOfWeek} function options.
+	 */
+
+	/**
+	 * @name startOfWeek
+	 * @category Week Helpers
+	 * @summary Return the start of a week for the given date.
+	 *
+	 * @description
+	 * Return the start of a week for the given date.
+	 * The result will be in the local timezone.
+	 *
+	 * @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 original date
+	 * @param options - An object with options
+	 *
+	 * @returns The start of a week
+	 *
+	 * @example
+	 * // The start of a week for 2 September 2014 11:55:00:
+	 * const result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0))
+	 * //=> Sun Aug 31 2014 00:00:00
+	 *
+	 * @example
+	 * // If the week starts on Monday, the start of the week for 2 September 2014 11:55:00:
+	 * const result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0), { weekStartsOn: 1 })
+	 * //=> Mon Sep 01 2014 00:00:00
+	 */
+	function startOfWeek$1(date, options) {
+	  const defaultOptions = (0, _index.getDefaultOptions)();
+	  const weekStartsOn =
+	    options?.weekStartsOn ??
+	    options?.locale?.options?.weekStartsOn ??
+	    defaultOptions.weekStartsOn ??
+	    defaultOptions.locale?.options?.weekStartsOn ??
+	    0;
+
+	  const _date = (0, _index2.toDate)(date, options?.in);
+	  const day = _date.getDay();
+	  const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
+
+	  _date.setDate(_date.getDate() - diff);
+	  _date.setHours(0, 0, 0, 0);
+	  return _date;
+	}
+	return startOfWeek;
+}
+
+var hasRequiredStartOfISOWeek;
+
+function requireStartOfISOWeek () {
+	if (hasRequiredStartOfISOWeek) return startOfISOWeek;
+	hasRequiredStartOfISOWeek = 1;
+	startOfISOWeek.startOfISOWeek = startOfISOWeek$1;
+	var _index = /*@__PURE__*/ requireStartOfWeek();
+
+	/**
+	 * The {@link startOfISOWeek} function options.
+	 */
+
+	/**
+	 * @name startOfISOWeek
+	 * @category ISO Week Helpers
+	 * @summary Return the start of an ISO week for the given date.
+	 *
+	 * @description
+	 * Return the start of an ISO week for the given date.
+	 * The result will be in the local timezone.
+	 *
+	 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_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 original date
+	 * @param options - An object with options
+	 *
+	 * @returns The start of an ISO week
+	 *
+	 * @example
+	 * // The start of an ISO week for 2 September 2014 11:55:00:
+	 * const result = startOfISOWeek(new Date(2014, 8, 2, 11, 55, 0))
+	 * //=> Mon Sep 01 2014 00:00:00
+	 */
+	function startOfISOWeek$1(date, options) {
+	  return (0, _index.startOfWeek)(date, { ...options, weekStartsOn: 1 });
+	}
+	return startOfISOWeek;
+}
+
+var startOfISOWeekYear = {};
+
+var getISOWeekYear = {};
+
+var hasRequiredGetISOWeekYear;
+
+function requireGetISOWeekYear () {
+	if (hasRequiredGetISOWeekYear) return getISOWeekYear;
+	hasRequiredGetISOWeekYear = 1;
+	getISOWeekYear.getISOWeekYear = getISOWeekYear$1;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+	var _index2 = /*@__PURE__*/ requireStartOfISOWeek();
+	var _index3 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link getISOWeekYear} function options.
+	 */
+
+	/**
+	 * @name getISOWeekYear
+	 * @category ISO Week-Numbering Year Helpers
+	 * @summary Get the ISO week-numbering year of the given date.
+	 *
+	 * @description
+	 * Get the ISO week-numbering year of the given date,
+	 * which always starts 3 days before the year's first Thursday.
+	 *
+	 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
+	 *
+	 * @param date - The given date
+	 *
+	 * @returns The ISO week-numbering year
+	 *
+	 * @example
+	 * // Which ISO-week numbering year is 2 January 2005?
+	 * const result = getISOWeekYear(new Date(2005, 0, 2))
+	 * //=> 2004
+	 */
+	function getISOWeekYear$1(date, options) {
+	  const _date = (0, _index3.toDate)(date, options?.in);
+	  const year = _date.getFullYear();
+
+	  const fourthOfJanuaryOfNextYear = (0, _index.constructFrom)(_date, 0);
+	  fourthOfJanuaryOfNextYear.setFullYear(year + 1, 0, 4);
+	  fourthOfJanuaryOfNextYear.setHours(0, 0, 0, 0);
+	  const startOfNextYear = (0, _index2.startOfISOWeek)(
+	    fourthOfJanuaryOfNextYear,
+	  );
+
+	  const fourthOfJanuaryOfThisYear = (0, _index.constructFrom)(_date, 0);
+	  fourthOfJanuaryOfThisYear.setFullYear(year, 0, 4);
+	  fourthOfJanuaryOfThisYear.setHours(0, 0, 0, 0);
+	  const startOfThisYear = (0, _index2.startOfISOWeek)(
+	    fourthOfJanuaryOfThisYear,
+	  );
+
+	  if (_date.getTime() >= startOfNextYear.getTime()) {
+	    return year + 1;
+	  } else if (_date.getTime() >= startOfThisYear.getTime()) {
+	    return year;
+	  } else {
+	    return year - 1;
+	  }
+	}
+	return getISOWeekYear;
+}
+
+var hasRequiredStartOfISOWeekYear;
+
+function requireStartOfISOWeekYear () {
+	if (hasRequiredStartOfISOWeekYear) return startOfISOWeekYear;
+	hasRequiredStartOfISOWeekYear = 1;
+	startOfISOWeekYear.startOfISOWeekYear = startOfISOWeekYear$1;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+	var _index2 = /*@__PURE__*/ requireGetISOWeekYear();
+	var _index3 = /*@__PURE__*/ requireStartOfISOWeek();
+
+	/**
+	 * The {@link startOfISOWeekYear} function options.
+	 */
+
+	/**
+	 * @name startOfISOWeekYear
+	 * @category ISO Week-Numbering Year Helpers
+	 * @summary Return the start of an ISO week-numbering year for the given date.
+	 *
+	 * @description
+	 * Return the start of an ISO week-numbering year,
+	 * which always starts 3 days before the year's first Thursday.
+	 * The result will be in the local timezone.
+	 *
+	 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_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 original date
+	 * @param options - An object with options
+	 *
+	 * @returns The start of an ISO week-numbering year
+	 *
+	 * @example
+	 * // The start of an ISO week-numbering year for 2 July 2005:
+	 * const result = startOfISOWeekYear(new Date(2005, 6, 2))
+	 * //=> Mon Jan 03 2005 00:00:00
+	 */
+	function startOfISOWeekYear$1(date, options) {
+	  const year = (0, _index2.getISOWeekYear)(date, options);
+	  const fourthOfJanuary = (0, _index.constructFrom)(options?.in || date, 0);
+	  fourthOfJanuary.setFullYear(year, 0, 4);
+	  fourthOfJanuary.setHours(0, 0, 0, 0);
+	  return (0, _index3.startOfISOWeek)(fourthOfJanuary);
+	}
+	return startOfISOWeekYear;
+}
+
+var hasRequiredGetISOWeek;
+
+function requireGetISOWeek () {
+	if (hasRequiredGetISOWeek) return getISOWeek;
+	hasRequiredGetISOWeek = 1;
+	getISOWeek.getISOWeek = getISOWeek$1;
+	var _index = /*@__PURE__*/ requireConstants();
+	var _index2 = /*@__PURE__*/ requireStartOfISOWeek();
+	var _index3 = /*@__PURE__*/ requireStartOfISOWeekYear();
+	var _index4 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link getISOWeek} function options.
+	 */
+
+	/**
+	 * @name getISOWeek
+	 * @category ISO Week Helpers
+	 * @summary Get the ISO week of the given date.
+	 *
+	 * @description
+	 * Get the ISO week of the given date.
+	 *
+	 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
+	 *
+	 * @param date - The given date
+	 * @param options - The options
+	 *
+	 * @returns The ISO week
+	 *
+	 * @example
+	 * // Which week of the ISO-week numbering year is 2 January 2005?
+	 * const result = getISOWeek(new Date(2005, 0, 2))
+	 * //=> 53
+	 */
+	function getISOWeek$1(date, options) {
+	  const _date = (0, _index4.toDate)(date, options?.in);
+	  const diff =
+	    +(0, _index2.startOfISOWeek)(_date) -
+	    +(0, _index3.startOfISOWeekYear)(_date);
+
+	  // Round the number of weeks to the nearest integer because the number of
+	  // milliseconds in a week is not constant (e.g. it's different in the week of
+	  // the daylight saving time clock shift).
+	  return Math.round(diff / _index.millisecondsInWeek) + 1;
+	}
+	return getISOWeek;
+}
+
+var getWeek = {};
+
+var startOfWeekYear = {};
+
+var getWeekYear = {};
+
+var hasRequiredGetWeekYear;
+
+function requireGetWeekYear () {
+	if (hasRequiredGetWeekYear) return getWeekYear;
+	hasRequiredGetWeekYear = 1;
+	getWeekYear.getWeekYear = getWeekYear$1;
+	var _index = /*@__PURE__*/ requireDefaultOptions();
+	var _index2 = /*@__PURE__*/ requireConstructFrom();
+	var _index3 = /*@__PURE__*/ requireStartOfWeek();
+	var _index4 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link getWeekYear} function options.
+	 */
+
+	/**
+	 * @name getWeekYear
+	 * @category Week-Numbering Year Helpers
+	 * @summary Get the local week-numbering year of the given date.
+	 *
+	 * @description
+	 * Get the local week-numbering year of the given date.
+	 * The exact calculation depends on the values of
+	 * `options.weekStartsOn` (which is the index of the first day of the week)
+	 * and `options.firstWeekContainsDate` (which is the day of January, which is always in
+	 * the first week of the week-numbering year)
+	 *
+	 * Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system
+	 *
+	 * @param date - The given date
+	 * @param options - An object with options.
+	 *
+	 * @returns The local week-numbering year
+	 *
+	 * @example
+	 * // Which week numbering year is 26 December 2004 with the default settings?
+	 * const result = getWeekYear(new Date(2004, 11, 26))
+	 * //=> 2005
+	 *
+	 * @example
+	 * // Which week numbering year is 26 December 2004 if week starts on Saturday?
+	 * const result = getWeekYear(new Date(2004, 11, 26), { weekStartsOn: 6 })
+	 * //=> 2004
+	 *
+	 * @example
+	 * // Which week numbering year is 26 December 2004 if the first week contains 4 January?
+	 * const result = getWeekYear(new Date(2004, 11, 26), { firstWeekContainsDate: 4 })
+	 * //=> 2004
+	 */
+	function getWeekYear$1(date, options) {
+	  const _date = (0, _index4.toDate)(date, options?.in);
+	  const year = _date.getFullYear();
+
+	  const defaultOptions = (0, _index.getDefaultOptions)();
+	  const firstWeekContainsDate =
+	    options?.firstWeekContainsDate ??
+	    options?.locale?.options?.firstWeekContainsDate ??
+	    defaultOptions.firstWeekContainsDate ??
+	    defaultOptions.locale?.options?.firstWeekContainsDate ??
+	    1;
+
+	  const firstWeekOfNextYear = (0, _index2.constructFrom)(
+	    options?.in || date,
+	    0,
+	  );
+	  firstWeekOfNextYear.setFullYear(year + 1, 0, firstWeekContainsDate);
+	  firstWeekOfNextYear.setHours(0, 0, 0, 0);
+	  const startOfNextYear = (0, _index3.startOfWeek)(
+	    firstWeekOfNextYear,
+	    options,
+	  );
+
+	  const firstWeekOfThisYear = (0, _index2.constructFrom)(
+	    options?.in || date,
+	    0,
+	  );
+	  firstWeekOfThisYear.setFullYear(year, 0, firstWeekContainsDate);
+	  firstWeekOfThisYear.setHours(0, 0, 0, 0);
+	  const startOfThisYear = (0, _index3.startOfWeek)(
+	    firstWeekOfThisYear,
+	    options,
+	  );
+
+	  if (+_date >= +startOfNextYear) {
+	    return year + 1;
+	  } else if (+_date >= +startOfThisYear) {
+	    return year;
+	  } else {
+	    return year - 1;
+	  }
+	}
+	return getWeekYear;
+}
+
+var hasRequiredStartOfWeekYear;
+
+function requireStartOfWeekYear () {
+	if (hasRequiredStartOfWeekYear) return startOfWeekYear;
+	hasRequiredStartOfWeekYear = 1;
+	startOfWeekYear.startOfWeekYear = startOfWeekYear$1;
+	var _index = /*@__PURE__*/ requireDefaultOptions();
+	var _index2 = /*@__PURE__*/ requireConstructFrom();
+	var _index3 = /*@__PURE__*/ requireGetWeekYear();
+	var _index4 = /*@__PURE__*/ requireStartOfWeek();
+
+	/**
+	 * The {@link startOfWeekYear} function options.
+	 */
+
+	/**
+	 * @name startOfWeekYear
+	 * @category Week-Numbering Year Helpers
+	 * @summary Return the start of a local week-numbering year for the given date.
+	 *
+	 * @description
+	 * Return the start of a local week-numbering year.
+	 * The exact calculation depends on the values of
+	 * `options.weekStartsOn` (which is the index of the first day of the week)
+	 * and `options.firstWeekContainsDate` (which is the day of January, which is always in
+	 * the first week of the week-numbering year)
+	 *
+	 * Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system
+	 *
+	 * @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 original date
+	 * @param options - An object with options
+	 *
+	 * @returns The start of a week-numbering year
+	 *
+	 * @example
+	 * // The start of an a week-numbering year for 2 July 2005 with default settings:
+	 * const result = startOfWeekYear(new Date(2005, 6, 2))
+	 * //=> Sun Dec 26 2004 00:00:00
+	 *
+	 * @example
+	 * // The start of a week-numbering year for 2 July 2005
+	 * // if Monday is the first day of week
+	 * // and 4 January is always in the first week of the year:
+	 * const result = startOfWeekYear(new Date(2005, 6, 2), {
+	 *   weekStartsOn: 1,
+	 *   firstWeekContainsDate: 4
+	 * })
+	 * //=> Mon Jan 03 2005 00:00:00
+	 */
+	function startOfWeekYear$1(date, options) {
+	  const defaultOptions = (0, _index.getDefaultOptions)();
+	  const firstWeekContainsDate =
+	    options?.firstWeekContainsDate ??
+	    options?.locale?.options?.firstWeekContainsDate ??
+	    defaultOptions.firstWeekContainsDate ??
+	    defaultOptions.locale?.options?.firstWeekContainsDate ??
+	    1;
+
+	  const year = (0, _index3.getWeekYear)(date, options);
+	  const firstWeek = (0, _index2.constructFrom)(options?.in || date, 0);
+	  firstWeek.setFullYear(year, 0, firstWeekContainsDate);
+	  firstWeek.setHours(0, 0, 0, 0);
+	  const _date = (0, _index4.startOfWeek)(firstWeek, options);
+	  return _date;
+	}
+	return startOfWeekYear;
+}
+
+var hasRequiredGetWeek;
+
+function requireGetWeek () {
+	if (hasRequiredGetWeek) return getWeek;
+	hasRequiredGetWeek = 1;
+	getWeek.getWeek = getWeek$1;
+	var _index = /*@__PURE__*/ requireConstants();
+	var _index2 = /*@__PURE__*/ requireStartOfWeek();
+	var _index3 = /*@__PURE__*/ requireStartOfWeekYear();
+	var _index4 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link getWeek} function options.
+	 */
+
+	/**
+	 * @name getWeek
+	 * @category Week Helpers
+	 * @summary Get the local week index of the given date.
+	 *
+	 * @description
+	 * Get the local week index of the given date.
+	 * The exact calculation depends on the values of
+	 * `options.weekStartsOn` (which is the index of the first day of the week)
+	 * and `options.firstWeekContainsDate` (which is the day of January, which is always in
+	 * the first week of the week-numbering year)
+	 *
+	 * Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system
+	 *
+	 * @param date - The given date
+	 * @param options - An object with options
+	 *
+	 * @returns The week
+	 *
+	 * @example
+	 * // Which week of the local week numbering year is 2 January 2005 with default options?
+	 * const result = getWeek(new Date(2005, 0, 2))
+	 * //=> 2
+	 *
+	 * @example
+	 * // Which week of the local week numbering year is 2 January 2005,
+	 * // if Monday is the first day of the week,
+	 * // and the first week of the year always contains 4 January?
+	 * const result = getWeek(new Date(2005, 0, 2), {
+	 *   weekStartsOn: 1,
+	 *   firstWeekContainsDate: 4
+	 * })
+	 * //=> 53
+	 */
+	function getWeek$1(date, options) {
+	  const _date = (0, _index4.toDate)(date, options?.in);
+	  const diff =
+	    +(0, _index2.startOfWeek)(_date, options) -
+	    +(0, _index3.startOfWeekYear)(_date, options);
+
+	  // Round the number of weeks to the nearest integer because the number of
+	  // milliseconds in a week is not constant (e.g. it's different in the week of
+	  // the daylight saving time clock shift).
+	  return Math.round(diff / _index.millisecondsInWeek) + 1;
+	}
+	return getWeek;
+}
+
+var addLeadingZeros = {};
+
+var hasRequiredAddLeadingZeros;
+
+function requireAddLeadingZeros () {
+	if (hasRequiredAddLeadingZeros) return addLeadingZeros;
+	hasRequiredAddLeadingZeros = 1;
+	addLeadingZeros.addLeadingZeros = addLeadingZeros$1;
+	function addLeadingZeros$1(number, targetLength) {
+	  const sign = number < 0 ? "-" : "";
+	  const output = Math.abs(number).toString().padStart(targetLength, "0");
+	  return sign + output;
+	}
+	return addLeadingZeros;
+}
+
+var lightFormatters = {};
+
+var hasRequiredLightFormatters;
+
+function requireLightFormatters () {
+	if (hasRequiredLightFormatters) return lightFormatters;
+	hasRequiredLightFormatters = 1;
+	lightFormatters.lightFormatters = void 0;
+	var _index = /*@__PURE__*/ requireAddLeadingZeros();
+
+	/*
+	 * |     | Unit                           |     | Unit                           |
+	 * |-----|--------------------------------|-----|--------------------------------|
+	 * |  a  | AM, PM                         |  A* |                                |
+	 * |  d  | Day of month                   |  D  |                                |
+	 * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
+	 * |  m  | Minute                         |  M  | Month                          |
+	 * |  s  | Second                         |  S  | Fraction of second             |
+	 * |  y  | Year (abs)                     |  Y  |                                |
+	 *
+	 * Letters marked by * are not implemented but reserved by Unicode standard.
+	 */
+
+	(lightFormatters.lightFormatters = {
+	  // Year
+	  y(date, token) {
+	    // From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_tokens
+	    // | Year     |     y | yy |   yyy |  yyyy | yyyyy |
+	    // |----------|-------|----|-------|-------|-------|
+	    // | AD 1     |     1 | 01 |   001 |  0001 | 00001 |
+	    // | AD 12    |    12 | 12 |   012 |  0012 | 00012 |
+	    // | AD 123   |   123 | 23 |   123 |  0123 | 00123 |
+	    // | AD 1234  |  1234 | 34 |  1234 |  1234 | 01234 |
+	    // | AD 12345 | 12345 | 45 | 12345 | 12345 | 12345 |
+
+	    const signedYear = date.getFullYear();
+	    // Returns 1 for 1 BC (which is year 0 in JavaScript)
+	    const year = signedYear > 0 ? signedYear : 1 - signedYear;
+	    return (0, _index.addLeadingZeros)(
+	      token === "yy" ? year % 100 : year,
+	      token.length,
+	    );
+	  },
+
+	  // Month
+	  M(date, token) {
+	    const month = date.getMonth();
+	    return token === "M"
+	      ? String(month + 1)
+	      : (0, _index.addLeadingZeros)(month + 1, 2);
+	  },
+
+	  // Day of the month
+	  d(date, token) {
+	    return (0, _index.addLeadingZeros)(date.getDate(), token.length);
+	  },
+
+	  // AM or PM
+	  a(date, token) {
+	    const dayPeriodEnumValue = date.getHours() / 12 >= 1 ? "pm" : "am";
+
+	    switch (token) {
+	      case "a":
+	      case "aa":
+	        return dayPeriodEnumValue.toUpperCase();
+	      case "aaa":
+	        return dayPeriodEnumValue;
+	      case "aaaaa":
+	        return dayPeriodEnumValue[0];
+	      case "aaaa":
+	      default:
+	        return dayPeriodEnumValue === "am" ? "a.m." : "p.m.";
+	    }
+	  },
+
+	  // Hour [1-12]
+	  h(date, token) {
+	    return (0, _index.addLeadingZeros)(
+	      date.getHours() % 12 || 12,
+	      token.length,
+	    );
+	  },
+
+	  // Hour [0-23]
+	  H(date, token) {
+	    return (0, _index.addLeadingZeros)(date.getHours(), token.length);
+	  },
+
+	  // Minute
+	  m(date, token) {
+	    return (0, _index.addLeadingZeros)(date.getMinutes(), token.length);
+	  },
+
+	  // Second
+	  s(date, token) {
+	    return (0, _index.addLeadingZeros)(date.getSeconds(), token.length);
+	  },
+
+	  // Fraction of second
+	  S(date, token) {
+	    const numberOfDigits = token.length;
+	    const milliseconds = date.getMilliseconds();
+	    const fractionalSeconds = Math.trunc(
+	      milliseconds * Math.pow(10, numberOfDigits - 3),
+	    );
+	    return (0, _index.addLeadingZeros)(fractionalSeconds, token.length);
+	  },
+	});
+	return lightFormatters;
+}
+
+var hasRequiredFormatters;
+
+function requireFormatters () {
+	if (hasRequiredFormatters) return formatters;
+	hasRequiredFormatters = 1;
+	formatters.formatters = void 0;
+	var _index = /*@__PURE__*/ requireGetDayOfYear();
+	var _index2 = /*@__PURE__*/ requireGetISOWeek();
+	var _index3 = /*@__PURE__*/ requireGetISOWeekYear();
+	var _index4 = /*@__PURE__*/ requireGetWeek();
+	var _index5 = /*@__PURE__*/ requireGetWeekYear();
+
+	var _index6 = /*@__PURE__*/ requireAddLeadingZeros();
+	var _index7 = /*@__PURE__*/ requireLightFormatters();
+
+	const dayPeriodEnum = {
+	  midnight: "midnight",
+	  noon: "noon",
+	  morning: "morning",
+	  afternoon: "afternoon",
+	  evening: "evening",
+	  night: "night",
+	};
+
+	/*
+	 * |     | Unit                           |     | Unit                           |
+	 * |-----|--------------------------------|-----|--------------------------------|
+	 * |  a  | AM, PM                         |  A* | Milliseconds in day            |
+	 * |  b  | AM, PM, noon, midnight         |  B  | Flexible day period            |
+	 * |  c  | Stand-alone local day of week  |  C* | Localized hour w/ day period   |
+	 * |  d  | Day of month                   |  D  | Day of year                    |
+	 * |  e  | Local day of week              |  E  | Day of week                    |
+	 * |  f  |                                |  F* | Day of week in month           |
+	 * |  g* | Modified Julian day            |  G  | Era                            |
+	 * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
+	 * |  i! | ISO day of week                |  I! | ISO week of year               |
+	 * |  j* | Localized hour w/ day period   |  J* | Localized hour w/o day period  |
+	 * |  k  | Hour [1-24]                    |  K  | Hour [0-11]                    |
+	 * |  l* | (deprecated)                   |  L  | Stand-alone month              |
+	 * |  m  | Minute                         |  M  | Month                          |
+	 * |  n  |                                |  N  |                                |
+	 * |  o! | Ordinal number modifier        |  O  | Timezone (GMT)                 |
+	 * |  p! | Long localized time            |  P! | Long localized date            |
+	 * |  q  | Stand-alone quarter            |  Q  | Quarter                        |
+	 * |  r* | Related Gregorian year         |  R! | ISO week-numbering year        |
+	 * |  s  | Second                         |  S  | Fraction of second             |
+	 * |  t! | Seconds timestamp              |  T! | Milliseconds timestamp         |
+	 * |  u  | Extended year                  |  U* | Cyclic year                    |
+	 * |  v* | Timezone (generic non-locat.)  |  V* | Timezone (location)            |
+	 * |  w  | Local week of year             |  W* | Week of month                  |
+	 * |  x  | Timezone (ISO-8601 w/o Z)      |  X  | Timezone (ISO-8601)            |
+	 * |  y  | Year (abs)                     |  Y  | Local week-numbering year      |
+	 * |  z  | Timezone (specific non-locat.) |  Z* | Timezone (aliases)             |
+	 *
+	 * Letters marked by * are not implemented but reserved by Unicode standard.
+	 *
+	 * Letters marked by ! are non-standard, but implemented by date-fns:
+	 * - `o` modifies the previous token to turn it into an ordinal (see `format` docs)
+	 * - `i` is ISO day of week. For `i` and `ii` is returns numeric ISO week days,
+	 *   i.e. 7 for Sunday, 1 for Monday, etc.
+	 * - `I` is ISO week of year, as opposed to `w` which is local week of year.
+	 * - `R` is ISO week-numbering year, as opposed to `Y` which is local week-numbering year.
+	 *   `R` is supposed to be used in conjunction with `I` and `i`
+	 *   for universal ISO week-numbering date, whereas
+	 *   `Y` is supposed to be used in conjunction with `w` and `e`
+	 *   for week-numbering date specific to the locale.
+	 * - `P` is long localized date format
+	 * - `p` is long localized time format
+	 */
+
+	(formatters.formatters = {
+	  // Era
+	  G: function (date, token, localize) {
+	    const era = date.getFullYear() > 0 ? 1 : 0;
+	    switch (token) {
+	      // AD, BC
+	      case "G":
+	      case "GG":
+	      case "GGG":
+	        return localize.era(era, { width: "abbreviated" });
+	      // A, B
+	      case "GGGGG":
+	        return localize.era(era, { width: "narrow" });
+	      // Anno Domini, Before Christ
+	      case "GGGG":
+	      default:
+	        return localize.era(era, { width: "wide" });
+	    }
+	  },
+
+	  // Year
+	  y: function (date, token, localize) {
+	    // Ordinal number
+	    if (token === "yo") {
+	      const signedYear = date.getFullYear();
+	      // Returns 1 for 1 BC (which is year 0 in JavaScript)
+	      const year = signedYear > 0 ? signedYear : 1 - signedYear;
+	      return localize.ordinalNumber(year, { unit: "year" });
+	    }
+
+	    return _index7.lightFormatters.y(date, token);
+	  },
+
+	  // Local week-numbering year
+	  Y: function (date, token, localize, options) {
+	    const signedWeekYear = (0, _index5.getWeekYear)(date, options);
+	    // Returns 1 for 1 BC (which is year 0 in JavaScript)
+	    const weekYear = signedWeekYear > 0 ? signedWeekYear : 1 - signedWeekYear;
+
+	    // Two digit year
+	    if (token === "YY") {
+	      const twoDigitYear = weekYear % 100;
+	      return (0, _index6.addLeadingZeros)(twoDigitYear, 2);
+	    }
+
+	    // Ordinal number
+	    if (token === "Yo") {
+	      return localize.ordinalNumber(weekYear, { unit: "year" });
+	    }
+
+	    // Padding
+	    return (0, _index6.addLeadingZeros)(weekYear, token.length);
+	  },
+
+	  // ISO week-numbering year
+	  R: function (date, token) {
+	    const isoWeekYear = (0, _index3.getISOWeekYear)(date);
+
+	    // Padding
+	    return (0, _index6.addLeadingZeros)(isoWeekYear, token.length);
+	  },
+
+	  // Extended year. This is a single number designating the year of this calendar system.
+	  // The main difference between `y` and `u` localizers are B.C. years:
+	  // | Year | `y` | `u` |
+	  // |------|-----|-----|
+	  // | AC 1 |   1 |   1 |
+	  // | BC 1 |   1 |   0 |
+	  // | BC 2 |   2 |  -1 |
+	  // Also `yy` always returns the last two digits of a year,
+	  // while `uu` pads single digit years to 2 characters and returns other years unchanged.
+	  u: function (date, token) {
+	    const year = date.getFullYear();
+	    return (0, _index6.addLeadingZeros)(year, token.length);
+	  },
+
+	  // Quarter
+	  Q: function (date, token, localize) {
+	    const quarter = Math.ceil((date.getMonth() + 1) / 3);
+	    switch (token) {
+	      // 1, 2, 3, 4
+	      case "Q":
+	        return String(quarter);
+	      // 01, 02, 03, 04
+	      case "QQ":
+	        return (0, _index6.addLeadingZeros)(quarter, 2);
+	      // 1st, 2nd, 3rd, 4th
+	      case "Qo":
+	        return localize.ordinalNumber(quarter, { unit: "quarter" });
+	      // Q1, Q2, Q3, Q4
+	      case "QQQ":
+	        return localize.quarter(quarter, {
+	          width: "abbreviated",
+	          context: "formatting",
+	        });
+	      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+	      case "QQQQQ":
+	        return localize.quarter(quarter, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      // 1st quarter, 2nd quarter, ...
+	      case "QQQQ":
+	      default:
+	        return localize.quarter(quarter, {
+	          width: "wide",
+	          context: "formatting",
+	        });
+	    }
+	  },
+
+	  // Stand-alone quarter
+	  q: function (date, token, localize) {
+	    const quarter = Math.ceil((date.getMonth() + 1) / 3);
+	    switch (token) {
+	      // 1, 2, 3, 4
+	      case "q":
+	        return String(quarter);
+	      // 01, 02, 03, 04
+	      case "qq":
+	        return (0, _index6.addLeadingZeros)(quarter, 2);
+	      // 1st, 2nd, 3rd, 4th
+	      case "qo":
+	        return localize.ordinalNumber(quarter, { unit: "quarter" });
+	      // Q1, Q2, Q3, Q4
+	      case "qqq":
+	        return localize.quarter(quarter, {
+	          width: "abbreviated",
+	          context: "standalone",
+	        });
+	      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+	      case "qqqqq":
+	        return localize.quarter(quarter, {
+	          width: "narrow",
+	          context: "standalone",
+	        });
+	      // 1st quarter, 2nd quarter, ...
+	      case "qqqq":
+	      default:
+	        return localize.quarter(quarter, {
+	          width: "wide",
+	          context: "standalone",
+	        });
+	    }
+	  },
+
+	  // Month
+	  M: function (date, token, localize) {
+	    const month = date.getMonth();
+	    switch (token) {
+	      case "M":
+	      case "MM":
+	        return _index7.lightFormatters.M(date, token);
+	      // 1st, 2nd, ..., 12th
+	      case "Mo":
+	        return localize.ordinalNumber(month + 1, { unit: "month" });
+	      // Jan, Feb, ..., Dec
+	      case "MMM":
+	        return localize.month(month, {
+	          width: "abbreviated",
+	          context: "formatting",
+	        });
+	      // J, F, ..., D
+	      case "MMMMM":
+	        return localize.month(month, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      // January, February, ..., December
+	      case "MMMM":
+	      default:
+	        return localize.month(month, { width: "wide", context: "formatting" });
+	    }
+	  },
+
+	  // Stand-alone month
+	  L: function (date, token, localize) {
+	    const month = date.getMonth();
+	    switch (token) {
+	      // 1, 2, ..., 12
+	      case "L":
+	        return String(month + 1);
+	      // 01, 02, ..., 12
+	      case "LL":
+	        return (0, _index6.addLeadingZeros)(month + 1, 2);
+	      // 1st, 2nd, ..., 12th
+	      case "Lo":
+	        return localize.ordinalNumber(month + 1, { unit: "month" });
+	      // Jan, Feb, ..., Dec
+	      case "LLL":
+	        return localize.month(month, {
+	          width: "abbreviated",
+	          context: "standalone",
+	        });
+	      // J, F, ..., D
+	      case "LLLLL":
+	        return localize.month(month, {
+	          width: "narrow",
+	          context: "standalone",
+	        });
+	      // January, February, ..., December
+	      case "LLLL":
+	      default:
+	        return localize.month(month, { width: "wide", context: "standalone" });
+	    }
+	  },
+
+	  // Local week of year
+	  w: function (date, token, localize, options) {
+	    const week = (0, _index4.getWeek)(date, options);
+
+	    if (token === "wo") {
+	      return localize.ordinalNumber(week, { unit: "week" });
+	    }
+
+	    return (0, _index6.addLeadingZeros)(week, token.length);
+	  },
+
+	  // ISO week of year
+	  I: function (date, token, localize) {
+	    const isoWeek = (0, _index2.getISOWeek)(date);
+
+	    if (token === "Io") {
+	      return localize.ordinalNumber(isoWeek, { unit: "week" });
+	    }
+
+	    return (0, _index6.addLeadingZeros)(isoWeek, token.length);
+	  },
+
+	  // Day of the month
+	  d: function (date, token, localize) {
+	    if (token === "do") {
+	      return localize.ordinalNumber(date.getDate(), { unit: "date" });
+	    }
+
+	    return _index7.lightFormatters.d(date, token);
+	  },
+
+	  // Day of year
+	  D: function (date, token, localize) {
+	    const dayOfYear = (0, _index.getDayOfYear)(date);
+
+	    if (token === "Do") {
+	      return localize.ordinalNumber(dayOfYear, { unit: "dayOfYear" });
+	    }
+
+	    return (0, _index6.addLeadingZeros)(dayOfYear, token.length);
+	  },
+
+	  // Day of week
+	  E: function (date, token, localize) {
+	    const dayOfWeek = date.getDay();
+	    switch (token) {
+	      // Tue
+	      case "E":
+	      case "EE":
+	      case "EEE":
+	        return localize.day(dayOfWeek, {
+	          width: "abbreviated",
+	          context: "formatting",
+	        });
+	      // T
+	      case "EEEEE":
+	        return localize.day(dayOfWeek, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      // Tu
+	      case "EEEEEE":
+	        return localize.day(dayOfWeek, {
+	          width: "short",
+	          context: "formatting",
+	        });
+	      // Tuesday
+	      case "EEEE":
+	      default:
+	        return localize.day(dayOfWeek, {
+	          width: "wide",
+	          context: "formatting",
+	        });
+	    }
+	  },
+
+	  // Local day of week
+	  e: function (date, token, localize, options) {
+	    const dayOfWeek = date.getDay();
+	    const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
+	    switch (token) {
+	      // Numerical value (Nth day of week with current locale or weekStartsOn)
+	      case "e":
+	        return String(localDayOfWeek);
+	      // Padded numerical value
+	      case "ee":
+	        return (0, _index6.addLeadingZeros)(localDayOfWeek, 2);
+	      // 1st, 2nd, ..., 7th
+	      case "eo":
+	        return localize.ordinalNumber(localDayOfWeek, { unit: "day" });
+	      case "eee":
+	        return localize.day(dayOfWeek, {
+	          width: "abbreviated",
+	          context: "formatting",
+	        });
+	      // T
+	      case "eeeee":
+	        return localize.day(dayOfWeek, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      // Tu
+	      case "eeeeee":
+	        return localize.day(dayOfWeek, {
+	          width: "short",
+	          context: "formatting",
+	        });
+	      // Tuesday
+	      case "eeee":
+	      default:
+	        return localize.day(dayOfWeek, {
+	          width: "wide",
+	          context: "formatting",
+	        });
+	    }
+	  },
+
+	  // Stand-alone local day of week
+	  c: function (date, token, localize, options) {
+	    const dayOfWeek = date.getDay();
+	    const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
+	    switch (token) {
+	      // Numerical value (same as in `e`)
+	      case "c":
+	        return String(localDayOfWeek);
+	      // Padded numerical value
+	      case "cc":
+	        return (0, _index6.addLeadingZeros)(localDayOfWeek, token.length);
+	      // 1st, 2nd, ..., 7th
+	      case "co":
+	        return localize.ordinalNumber(localDayOfWeek, { unit: "day" });
+	      case "ccc":
+	        return localize.day(dayOfWeek, {
+	          width: "abbreviated",
+	          context: "standalone",
+	        });
+	      // T
+	      case "ccccc":
+	        return localize.day(dayOfWeek, {
+	          width: "narrow",
+	          context: "standalone",
+	        });
+	      // Tu
+	      case "cccccc":
+	        return localize.day(dayOfWeek, {
+	          width: "short",
+	          context: "standalone",
+	        });
+	      // Tuesday
+	      case "cccc":
+	      default:
+	        return localize.day(dayOfWeek, {
+	          width: "wide",
+	          context: "standalone",
+	        });
+	    }
+	  },
+
+	  // ISO day of week
+	  i: function (date, token, localize) {
+	    const dayOfWeek = date.getDay();
+	    const isoDayOfWeek = dayOfWeek === 0 ? 7 : dayOfWeek;
+	    switch (token) {
+	      // 2
+	      case "i":
+	        return String(isoDayOfWeek);
+	      // 02
+	      case "ii":
+	        return (0, _index6.addLeadingZeros)(isoDayOfWeek, token.length);
+	      // 2nd
+	      case "io":
+	        return localize.ordinalNumber(isoDayOfWeek, { unit: "day" });
+	      // Tue
+	      case "iii":
+	        return localize.day(dayOfWeek, {
+	          width: "abbreviated",
+	          context: "formatting",
+	        });
+	      // T
+	      case "iiiii":
+	        return localize.day(dayOfWeek, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      // Tu
+	      case "iiiiii":
+	        return localize.day(dayOfWeek, {
+	          width: "short",
+	          context: "formatting",
+	        });
+	      // Tuesday
+	      case "iiii":
+	      default:
+	        return localize.day(dayOfWeek, {
+	          width: "wide",
+	          context: "formatting",
+	        });
+	    }
+	  },
+
+	  // AM or PM
+	  a: function (date, token, localize) {
+	    const hours = date.getHours();
+	    const dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
+
+	    switch (token) {
+	      case "a":
+	      case "aa":
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: "abbreviated",
+	          context: "formatting",
+	        });
+	      case "aaa":
+	        return localize
+	          .dayPeriod(dayPeriodEnumValue, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          })
+	          .toLowerCase();
+	      case "aaaaa":
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      case "aaaa":
+	      default:
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: "wide",
+	          context: "formatting",
+	        });
+	    }
+	  },
+
+	  // AM, PM, midnight, noon
+	  b: function (date, token, localize) {
+	    const hours = date.getHours();
+	    let dayPeriodEnumValue;
+	    if (hours === 12) {
+	      dayPeriodEnumValue = dayPeriodEnum.noon;
+	    } else if (hours === 0) {
+	      dayPeriodEnumValue = dayPeriodEnum.midnight;
+	    } else {
+	      dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
+	    }
+
+	    switch (token) {
+	      case "b":
+	      case "bb":
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: "abbreviated",
+	          context: "formatting",
+	        });
+	      case "bbb":
+	        return localize
+	          .dayPeriod(dayPeriodEnumValue, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          })
+	          .toLowerCase();
+	      case "bbbbb":
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      case "bbbb":
+	      default:
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: "wide",
+	          context: "formatting",
+	        });
+	    }
+	  },
+
+	  // in the morning, in the afternoon, in the evening, at night
+	  B: function (date, token, localize) {
+	    const hours = date.getHours();
+	    let dayPeriodEnumValue;
+	    if (hours >= 17) {
+	      dayPeriodEnumValue = dayPeriodEnum.evening;
+	    } else if (hours >= 12) {
+	      dayPeriodEnumValue = dayPeriodEnum.afternoon;
+	    } else if (hours >= 4) {
+	      dayPeriodEnumValue = dayPeriodEnum.morning;
+	    } else {
+	      dayPeriodEnumValue = dayPeriodEnum.night;
+	    }
+
+	    switch (token) {
+	      case "B":
+	      case "BB":
+	      case "BBB":
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: "abbreviated",
+	          context: "formatting",
+	        });
+	      case "BBBBB":
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      case "BBBB":
+	      default:
+	        return localize.dayPeriod(dayPeriodEnumValue, {
+	          width: "wide",
+	          context: "formatting",
+	        });
+	    }
+	  },
+
+	  // Hour [1-12]
+	  h: function (date, token, localize) {
+	    if (token === "ho") {
+	      let hours = date.getHours() % 12;
+	      if (hours === 0) hours = 12;
+	      return localize.ordinalNumber(hours, { unit: "hour" });
+	    }
+
+	    return _index7.lightFormatters.h(date, token);
+	  },
+
+	  // Hour [0-23]
+	  H: function (date, token, localize) {
+	    if (token === "Ho") {
+	      return localize.ordinalNumber(date.getHours(), { unit: "hour" });
+	    }
+
+	    return _index7.lightFormatters.H(date, token);
+	  },
+
+	  // Hour [0-11]
+	  K: function (date, token, localize) {
+	    const hours = date.getHours() % 12;
+
+	    if (token === "Ko") {
+	      return localize.ordinalNumber(hours, { unit: "hour" });
+	    }
+
+	    return (0, _index6.addLeadingZeros)(hours, token.length);
+	  },
+
+	  // Hour [1-24]
+	  k: function (date, token, localize) {
+	    let hours = date.getHours();
+	    if (hours === 0) hours = 24;
+
+	    if (token === "ko") {
+	      return localize.ordinalNumber(hours, { unit: "hour" });
+	    }
+
+	    return (0, _index6.addLeadingZeros)(hours, token.length);
+	  },
+
+	  // Minute
+	  m: function (date, token, localize) {
+	    if (token === "mo") {
+	      return localize.ordinalNumber(date.getMinutes(), { unit: "minute" });
+	    }
+
+	    return _index7.lightFormatters.m(date, token);
+	  },
+
+	  // Second
+	  s: function (date, token, localize) {
+	    if (token === "so") {
+	      return localize.ordinalNumber(date.getSeconds(), { unit: "second" });
+	    }
+
+	    return _index7.lightFormatters.s(date, token);
+	  },
+
+	  // Fraction of second
+	  S: function (date, token) {
+	    return _index7.lightFormatters.S(date, token);
+	  },
+
+	  // Timezone (ISO-8601. If offset is 0, output is always `'Z'`)
+	  X: function (date, token, _localize) {
+	    const timezoneOffset = date.getTimezoneOffset();
+
+	    if (timezoneOffset === 0) {
+	      return "Z";
+	    }
+
+	    switch (token) {
+	      // Hours and optional minutes
+	      case "X":
+	        return formatTimezoneWithOptionalMinutes(timezoneOffset);
+
+	      // Hours, minutes and optional seconds without `:` delimiter
+	      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+	      // so this token always has the same output as `XX`
+	      case "XXXX":
+	      case "XX": // Hours and minutes without `:` delimiter
+	        return formatTimezone(timezoneOffset);
+
+	      // Hours, minutes and optional seconds with `:` delimiter
+	      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+	      // so this token always has the same output as `XXX`
+	      case "XXXXX":
+	      case "XXX": // Hours and minutes with `:` delimiter
+	      default:
+	        return formatTimezone(timezoneOffset, ":");
+	    }
+	  },
+
+	  // Timezone (ISO-8601. If offset is 0, output is `'+00:00'` or equivalent)
+	  x: function (date, token, _localize) {
+	    const timezoneOffset = date.getTimezoneOffset();
+
+	    switch (token) {
+	      // Hours and optional minutes
+	      case "x":
+	        return formatTimezoneWithOptionalMinutes(timezoneOffset);
+
+	      // Hours, minutes and optional seconds without `:` delimiter
+	      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+	      // so this token always has the same output as `xx`
+	      case "xxxx":
+	      case "xx": // Hours and minutes without `:` delimiter
+	        return formatTimezone(timezoneOffset);
+
+	      // Hours, minutes and optional seconds with `:` delimiter
+	      // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
+	      // so this token always has the same output as `xxx`
+	      case "xxxxx":
+	      case "xxx": // Hours and minutes with `:` delimiter
+	      default:
+	        return formatTimezone(timezoneOffset, ":");
+	    }
+	  },
+
+	  // Timezone (GMT)
+	  O: function (date, token, _localize) {
+	    const timezoneOffset = date.getTimezoneOffset();
+
+	    switch (token) {
+	      // Short
+	      case "O":
+	      case "OO":
+	      case "OOO":
+	        return "GMT" + formatTimezoneShort(timezoneOffset, ":");
+	      // Long
+	      case "OOOO":
+	      default:
+	        return "GMT" + formatTimezone(timezoneOffset, ":");
+	    }
+	  },
+
+	  // Timezone (specific non-location)
+	  z: function (date, token, _localize) {
+	    const timezoneOffset = date.getTimezoneOffset();
+
+	    switch (token) {
+	      // Short
+	      case "z":
+	      case "zz":
+	      case "zzz":
+	        return "GMT" + formatTimezoneShort(timezoneOffset, ":");
+	      // Long
+	      case "zzzz":
+	      default:
+	        return "GMT" + formatTimezone(timezoneOffset, ":");
+	    }
+	  },
+
+	  // Seconds timestamp
+	  t: function (date, token, _localize) {
+	    const timestamp = Math.trunc(+date / 1000);
+	    return (0, _index6.addLeadingZeros)(timestamp, token.length);
+	  },
+
+	  // Milliseconds timestamp
+	  T: function (date, token, _localize) {
+	    return (0, _index6.addLeadingZeros)(+date, token.length);
+	  },
+	});
+
+	function formatTimezoneShort(offset, delimiter = "") {
+	  const sign = offset > 0 ? "-" : "+";
+	  const absOffset = Math.abs(offset);
+	  const hours = Math.trunc(absOffset / 60);
+	  const minutes = absOffset % 60;
+	  if (minutes === 0) {
+	    return sign + String(hours);
+	  }
+	  return (
+	    sign + String(hours) + delimiter + (0, _index6.addLeadingZeros)(minutes, 2)
+	  );
+	}
+
+	function formatTimezoneWithOptionalMinutes(offset, delimiter) {
+	  if (offset % 60 === 0) {
+	    const sign = offset > 0 ? "-" : "+";
+	    return sign + (0, _index6.addLeadingZeros)(Math.abs(offset) / 60, 2);
+	  }
+	  return formatTimezone(offset, delimiter);
+	}
+
+	function formatTimezone(offset, delimiter = "") {
+	  const sign = offset > 0 ? "-" : "+";
+	  const absOffset = Math.abs(offset);
+	  const hours = (0, _index6.addLeadingZeros)(Math.trunc(absOffset / 60), 2);
+	  const minutes = (0, _index6.addLeadingZeros)(absOffset % 60, 2);
+	  return sign + hours + delimiter + minutes;
+	}
+	return formatters;
+}
+
+var longFormatters = {};
+
+var hasRequiredLongFormatters;
+
+function requireLongFormatters () {
+	if (hasRequiredLongFormatters) return longFormatters;
+	hasRequiredLongFormatters = 1;
+	longFormatters.longFormatters = void 0;
+
+	const dateLongFormatter = (pattern, formatLong) => {
+	  switch (pattern) {
+	    case "P":
+	      return formatLong.date({ width: "short" });
+	    case "PP":
+	      return formatLong.date({ width: "medium" });
+	    case "PPP":
+	      return formatLong.date({ width: "long" });
+	    case "PPPP":
+	    default:
+	      return formatLong.date({ width: "full" });
+	  }
+	};
+
+	const timeLongFormatter = (pattern, formatLong) => {
+	  switch (pattern) {
+	    case "p":
+	      return formatLong.time({ width: "short" });
+	    case "pp":
+	      return formatLong.time({ width: "medium" });
+	    case "ppp":
+	      return formatLong.time({ width: "long" });
+	    case "pppp":
+	    default:
+	      return formatLong.time({ width: "full" });
+	  }
+	};
+
+	const dateTimeLongFormatter = (pattern, formatLong) => {
+	  const matchResult = pattern.match(/(P+)(p+)?/) || [];
+	  const datePattern = matchResult[1];
+	  const timePattern = matchResult[2];
+
+	  if (!timePattern) {
+	    return dateLongFormatter(pattern, formatLong);
+	  }
+
+	  let dateTimeFormat;
+
+	  switch (datePattern) {
+	    case "P":
+	      dateTimeFormat = formatLong.dateTime({ width: "short" });
+	      break;
+	    case "PP":
+	      dateTimeFormat = formatLong.dateTime({ width: "medium" });
+	      break;
+	    case "PPP":
+	      dateTimeFormat = formatLong.dateTime({ width: "long" });
+	      break;
+	    case "PPPP":
+	    default:
+	      dateTimeFormat = formatLong.dateTime({ width: "full" });
+	      break;
+	  }
+
+	  return dateTimeFormat
+	    .replace("{{date}}", dateLongFormatter(datePattern, formatLong))
+	    .replace("{{time}}", timeLongFormatter(timePattern, formatLong));
+	};
+
+	(longFormatters.longFormatters = {
+	  p: timeLongFormatter,
+	  P: dateTimeLongFormatter,
+	});
+	return longFormatters;
+}
+
+var protectedTokens = {};
+
+var hasRequiredProtectedTokens;
+
+function requireProtectedTokens () {
+	if (hasRequiredProtectedTokens) return protectedTokens;
+	hasRequiredProtectedTokens = 1;
+	protectedTokens.isProtectedDayOfYearToken = isProtectedDayOfYearToken;
+	protectedTokens.isProtectedWeekYearToken = isProtectedWeekYearToken;
+	protectedTokens.warnOrThrowProtectedError = warnOrThrowProtectedError;
+	const dayOfYearTokenRE = /^D+$/;
+	const weekYearTokenRE = /^Y+$/;
+
+	const throwTokens = ["D", "DD", "YY", "YYYY"];
+
+	function isProtectedDayOfYearToken(token) {
+	  return dayOfYearTokenRE.test(token);
+	}
+
+	function isProtectedWeekYearToken(token) {
+	  return weekYearTokenRE.test(token);
+	}
+
+	function warnOrThrowProtectedError(token, format, input) {
+	  const _message = message(token, format, input);
+	  console.warn(_message);
+	  if (throwTokens.includes(token)) throw new RangeError(_message);
+	}
+
+	function message(token, format, input) {
+	  const subject = token[0] === "Y" ? "years" : "days of the month";
+	  return `Use \`${token.toLowerCase()}\` instead of \`${token}\` (in \`${format}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
+	}
+	return protectedTokens;
+}
+
+var isValid = {};
+
+var isDate = {};
+
+var hasRequiredIsDate;
+
+function requireIsDate () {
+	if (hasRequiredIsDate) return isDate;
+	hasRequiredIsDate = 1;
+	isDate.isDate = isDate$1; /**
+	 * @name isDate
+	 * @category Common Helpers
+	 * @summary Is the given value a date?
+	 *
+	 * @description
+	 * Returns true if the given value is an instance of Date. The function works for dates transferred across iframes.
+	 *
+	 * @param value - The value to check
+	 *
+	 * @returns True if the given value is a date
+	 *
+	 * @example
+	 * // For a valid date:
+	 * const result = isDate(new Date())
+	 * //=> true
+	 *
+	 * @example
+	 * // For an invalid date:
+	 * const result = isDate(new Date(NaN))
+	 * //=> true
+	 *
+	 * @example
+	 * // For some value:
+	 * const result = isDate('2014-02-31')
+	 * //=> false
+	 *
+	 * @example
+	 * // For an object:
+	 * const result = isDate({})
+	 * //=> false
+	 */
+	function isDate$1(value) {
+	  return (
+	    value instanceof Date ||
+	    (typeof value === "object" &&
+	      Object.prototype.toString.call(value) === "[object Date]")
+	  );
+	}
+	return isDate;
+}
+
+var hasRequiredIsValid;
+
+function requireIsValid () {
+	if (hasRequiredIsValid) return isValid;
+	hasRequiredIsValid = 1;
+	isValid.isValid = isValid$1;
+	var _index = /*@__PURE__*/ requireIsDate();
+	var _index2 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * @name isValid
+	 * @category Common Helpers
+	 * @summary Is the given date valid?
+	 *
+	 * @description
+	 * Returns false if argument is Invalid Date and true otherwise.
+	 * Argument is converted to Date using `toDate`. See [toDate](https://date-fns.org/docs/toDate)
+	 * Invalid Date is a Date, whose time value is NaN.
+	 *
+	 * Time value of Date: http://es5.github.io/#x15.9.1.1
+	 *
+	 * @param date - The date to check
+	 *
+	 * @returns The date is valid
+	 *
+	 * @example
+	 * // For the valid date:
+	 * const result = isValid(new Date(2014, 1, 31))
+	 * //=> true
+	 *
+	 * @example
+	 * // For the value, convertible into a date:
+	 * const result = isValid(1393804800000)
+	 * //=> true
+	 *
+	 * @example
+	 * // For the invalid date:
+	 * const result = isValid(new Date(''))
+	 * //=> false
+	 */
+	function isValid$1(date) {
+	  return !(
+	    (!(0, _index.isDate)(date) && typeof date !== "number") ||
+	    isNaN(+(0, _index2.toDate)(date))
+	  );
+	}
+	return isValid;
+}
+
+var hasRequiredFormat;
+
+function requireFormat () {
+	if (hasRequiredFormat) return format;
+	hasRequiredFormat = 1;
+	(function (exports) {
+		exports.format = exports.formatDate = format;
+		Object.defineProperty(exports, "formatters", {
+		  enumerable: true,
+		  get: function () {
+		    return _index3.formatters;
+		  },
+		});
+		Object.defineProperty(exports, "longFormatters", {
+		  enumerable: true,
+		  get: function () {
+		    return _index4.longFormatters;
+		  },
+		});
+		var _index = /*@__PURE__*/ requireDefaultLocale();
+		var _index2 = /*@__PURE__*/ requireDefaultOptions();
+		var _index3 = /*@__PURE__*/ requireFormatters();
+		var _index4 = /*@__PURE__*/ requireLongFormatters();
+		var _index5 = /*@__PURE__*/ requireProtectedTokens();
+
+		var _index6 = /*@__PURE__*/ requireIsValid();
+		var _index7 = /*@__PURE__*/ requireToDate();
+
+		// Rexports of internal for libraries to use.
+		// See: https://github.com/date-fns/date-fns/issues/3638#issuecomment-1877082874
+
+		// This RegExp consists of three parts separated by `|`:
+		// - [yYQqMLwIdDecihHKkms]o matches any available ordinal number token
+		//   (one of the certain letters followed by `o`)
+		// - (\w)\1* matches any sequences of the same letter
+		// - '' matches two quote characters in a row
+		// - '(''|[^'])+('|$) matches anything surrounded by two quote characters ('),
+		//   except a single quote symbol, which ends the sequence.
+		//   Two quote characters do not end the sequence.
+		//   If there is no matching single quote
+		//   then the sequence will continue until the end of the string.
+		// - . matches any single character unmatched by previous parts of the RegExps
+		const formattingTokensRegExp =
+		  /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g;
+
+		// This RegExp catches symbols escaped by quotes, and also
+		// sequences of symbols P, p, and the combinations like `PPPPPPPppppp`
+		const longFormattingTokensRegExp = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g;
+
+		const escapedStringRegExp = /^'([^]*?)'?$/;
+		const doubleQuoteRegExp = /''/g;
+		const unescapedLatinCharacterRegExp = /[a-zA-Z]/;
+
+		/**
+		 * The {@link format} function options.
+		 */
+
+		/**
+		 * @name format
+		 * @alias formatDate
+		 * @category Common Helpers
+		 * @summary Format the date.
+		 *
+		 * @description
+		 * Return the formatted date string in the given format. The result may vary by locale.
+		 *
+		 * > ⚠️ Please note that the `format` tokens differ from Moment.js and other libraries.
+		 * > See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+		 *
+		 * The characters wrapped between two single quotes characters (') are escaped.
+		 * Two single quotes in a row, whether inside or outside a quoted sequence, represent a 'real' single quote.
+		 * (see the last example)
+		 *
+		 * Format of the string is based on Unicode Technical Standard #35:
+		 * https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
+		 * with a few additions (see note 7 below the table).
+		 *
+		 * Accepted patterns:
+		 * | Unit                            | Pattern | Result examples                   | Notes |
+		 * |---------------------------------|---------|-----------------------------------|-------|
+		 * | Era                             | G..GGG  | AD, BC                            |       |
+		 * |                                 | GGGG    | Anno Domini, Before Christ        | 2     |
+		 * |                                 | GGGGG   | A, B                              |       |
+		 * | Calendar year                   | y       | 44, 1, 1900, 2017                 | 5     |
+		 * |                                 | yo      | 44th, 1st, 0th, 17th              | 5,7   |
+		 * |                                 | yy      | 44, 01, 00, 17                    | 5     |
+		 * |                                 | yyy     | 044, 001, 1900, 2017              | 5     |
+		 * |                                 | yyyy    | 0044, 0001, 1900, 2017            | 5     |
+		 * |                                 | yyyyy   | ...                               | 3,5   |
+		 * | Local week-numbering year       | Y       | 44, 1, 1900, 2017                 | 5     |
+		 * |                                 | Yo      | 44th, 1st, 1900th, 2017th         | 5,7   |
+		 * |                                 | YY      | 44, 01, 00, 17                    | 5,8   |
+		 * |                                 | YYY     | 044, 001, 1900, 2017              | 5     |
+		 * |                                 | YYYY    | 0044, 0001, 1900, 2017            | 5,8   |
+		 * |                                 | YYYYY   | ...                               | 3,5   |
+		 * | ISO week-numbering year         | R       | -43, 0, 1, 1900, 2017             | 5,7   |
+		 * |                                 | RR      | -43, 00, 01, 1900, 2017           | 5,7   |
+		 * |                                 | RRR     | -043, 000, 001, 1900, 2017        | 5,7   |
+		 * |                                 | RRRR    | -0043, 0000, 0001, 1900, 2017     | 5,7   |
+		 * |                                 | RRRRR   | ...                               | 3,5,7 |
+		 * | Extended year                   | u       | -43, 0, 1, 1900, 2017             | 5     |
+		 * |                                 | uu      | -43, 01, 1900, 2017               | 5     |
+		 * |                                 | uuu     | -043, 001, 1900, 2017             | 5     |
+		 * |                                 | uuuu    | -0043, 0001, 1900, 2017           | 5     |
+		 * |                                 | uuuuu   | ...                               | 3,5   |
+		 * | Quarter (formatting)            | Q       | 1, 2, 3, 4                        |       |
+		 * |                                 | Qo      | 1st, 2nd, 3rd, 4th                | 7     |
+		 * |                                 | QQ      | 01, 02, 03, 04                    |       |
+		 * |                                 | QQQ     | Q1, Q2, Q3, Q4                    |       |
+		 * |                                 | QQQQ    | 1st quarter, 2nd quarter, ...     | 2     |
+		 * |                                 | QQQQQ   | 1, 2, 3, 4                        | 4     |
+		 * | Quarter (stand-alone)           | q       | 1, 2, 3, 4                        |       |
+		 * |                                 | qo      | 1st, 2nd, 3rd, 4th                | 7     |
+		 * |                                 | qq      | 01, 02, 03, 04                    |       |
+		 * |                                 | qqq     | Q1, Q2, Q3, Q4                    |       |
+		 * |                                 | qqqq    | 1st quarter, 2nd quarter, ...     | 2     |
+		 * |                                 | qqqqq   | 1, 2, 3, 4                        | 4     |
+		 * | Month (formatting)              | M       | 1, 2, ..., 12                     |       |
+		 * |                                 | Mo      | 1st, 2nd, ..., 12th               | 7     |
+		 * |                                 | MM      | 01, 02, ..., 12                   |       |
+		 * |                                 | MMM     | Jan, Feb, ..., Dec                |       |
+		 * |                                 | MMMM    | January, February, ..., December  | 2     |
+		 * |                                 | MMMMM   | J, F, ..., D                      |       |
+		 * | Month (stand-alone)             | L       | 1, 2, ..., 12                     |       |
+		 * |                                 | Lo      | 1st, 2nd, ..., 12th               | 7     |
+		 * |                                 | LL      | 01, 02, ..., 12                   |       |
+		 * |                                 | LLL     | Jan, Feb, ..., Dec                |       |
+		 * |                                 | LLLL    | January, February, ..., December  | 2     |
+		 * |                                 | LLLLL   | J, F, ..., D                      |       |
+		 * | Local week of year              | w       | 1, 2, ..., 53                     |       |
+		 * |                                 | wo      | 1st, 2nd, ..., 53th               | 7     |
+		 * |                                 | ww      | 01, 02, ..., 53                   |       |
+		 * | ISO week of year                | I       | 1, 2, ..., 53                     | 7     |
+		 * |                                 | Io      | 1st, 2nd, ..., 53th               | 7     |
+		 * |                                 | II      | 01, 02, ..., 53                   | 7     |
+		 * | Day of month                    | d       | 1, 2, ..., 31                     |       |
+		 * |                                 | do      | 1st, 2nd, ..., 31st               | 7     |
+		 * |                                 | dd      | 01, 02, ..., 31                   |       |
+		 * | Day of year                     | D       | 1, 2, ..., 365, 366               | 9     |
+		 * |                                 | Do      | 1st, 2nd, ..., 365th, 366th       | 7     |
+		 * |                                 | DD      | 01, 02, ..., 365, 366             | 9     |
+		 * |                                 | DDD     | 001, 002, ..., 365, 366           |       |
+		 * |                                 | DDDD    | ...                               | 3     |
+		 * | Day of week (formatting)        | E..EEE  | Mon, Tue, Wed, ..., Sun           |       |
+		 * |                                 | EEEE    | Monday, Tuesday, ..., Sunday      | 2     |
+		 * |                                 | EEEEE   | M, T, W, T, F, S, S               |       |
+		 * |                                 | EEEEEE  | Mo, Tu, We, Th, Fr, Sa, Su        |       |
+		 * | ISO day of week (formatting)    | i       | 1, 2, 3, ..., 7                   | 7     |
+		 * |                                 | io      | 1st, 2nd, ..., 7th                | 7     |
+		 * |                                 | ii      | 01, 02, ..., 07                   | 7     |
+		 * |                                 | iii     | Mon, Tue, Wed, ..., Sun           | 7     |
+		 * |                                 | iiii    | Monday, Tuesday, ..., Sunday      | 2,7   |
+		 * |                                 | iiiii   | M, T, W, T, F, S, S               | 7     |
+		 * |                                 | iiiiii  | Mo, Tu, We, Th, Fr, Sa, Su        | 7     |
+		 * | Local day of week (formatting)  | e       | 2, 3, 4, ..., 1                   |       |
+		 * |                                 | eo      | 2nd, 3rd, ..., 1st                | 7     |
+		 * |                                 | ee      | 02, 03, ..., 01                   |       |
+		 * |                                 | eee     | Mon, Tue, Wed, ..., Sun           |       |
+		 * |                                 | eeee    | Monday, Tuesday, ..., Sunday      | 2     |
+		 * |                                 | eeeee   | M, T, W, T, F, S, S               |       |
+		 * |                                 | eeeeee  | Mo, Tu, We, Th, Fr, Sa, Su        |       |
+		 * | Local day of week (stand-alone) | c       | 2, 3, 4, ..., 1                   |       |
+		 * |                                 | co      | 2nd, 3rd, ..., 1st                | 7     |
+		 * |                                 | cc      | 02, 03, ..., 01                   |       |
+		 * |                                 | ccc     | Mon, Tue, Wed, ..., Sun           |       |
+		 * |                                 | cccc    | Monday, Tuesday, ..., Sunday      | 2     |
+		 * |                                 | ccccc   | M, T, W, T, F, S, S               |       |
+		 * |                                 | cccccc  | Mo, Tu, We, Th, Fr, Sa, Su        |       |
+		 * | AM, PM                          | a..aa   | AM, PM                            |       |
+		 * |                                 | aaa     | am, pm                            |       |
+		 * |                                 | aaaa    | a.m., p.m.                        | 2     |
+		 * |                                 | aaaaa   | a, p                              |       |
+		 * | AM, PM, noon, midnight          | b..bb   | AM, PM, noon, midnight            |       |
+		 * |                                 | bbb     | am, pm, noon, midnight            |       |
+		 * |                                 | bbbb    | a.m., p.m., noon, midnight        | 2     |
+		 * |                                 | bbbbb   | a, p, n, mi                       |       |
+		 * | Flexible day period             | B..BBB  | at night, in the morning, ...     |       |
+		 * |                                 | BBBB    | at night, in the morning, ...     | 2     |
+		 * |                                 | BBBBB   | at night, in the morning, ...     |       |
+		 * | Hour [1-12]                     | h       | 1, 2, ..., 11, 12                 |       |
+		 * |                                 | ho      | 1st, 2nd, ..., 11th, 12th         | 7     |
+		 * |                                 | hh      | 01, 02, ..., 11, 12               |       |
+		 * | Hour [0-23]                     | H       | 0, 1, 2, ..., 23                  |       |
+		 * |                                 | Ho      | 0th, 1st, 2nd, ..., 23rd          | 7     |
+		 * |                                 | HH      | 00, 01, 02, ..., 23               |       |
+		 * | Hour [0-11]                     | K       | 1, 2, ..., 11, 0                  |       |
+		 * |                                 | Ko      | 1st, 2nd, ..., 11th, 0th          | 7     |
+		 * |                                 | KK      | 01, 02, ..., 11, 00               |       |
+		 * | Hour [1-24]                     | k       | 24, 1, 2, ..., 23                 |       |
+		 * |                                 | ko      | 24th, 1st, 2nd, ..., 23rd         | 7     |
+		 * |                                 | kk      | 24, 01, 02, ..., 23               |       |
+		 * | Minute                          | m       | 0, 1, ..., 59                     |       |
+		 * |                                 | mo      | 0th, 1st, ..., 59th               | 7     |
+		 * |                                 | mm      | 00, 01, ..., 59                   |       |
+		 * | Second                          | s       | 0, 1, ..., 59                     |       |
+		 * |                                 | so      | 0th, 1st, ..., 59th               | 7     |
+		 * |                                 | ss      | 00, 01, ..., 59                   |       |
+		 * | Fraction of second              | S       | 0, 1, ..., 9                      |       |
+		 * |                                 | SS      | 00, 01, ..., 99                   |       |
+		 * |                                 | SSS     | 000, 001, ..., 999                |       |
+		 * |                                 | SSSS    | ...                               | 3     |
+		 * | Timezone (ISO-8601 w/ Z)        | X       | -08, +0530, Z                     |       |
+		 * |                                 | XX      | -0800, +0530, Z                   |       |
+		 * |                                 | XXX     | -08:00, +05:30, Z                 |       |
+		 * |                                 | XXXX    | -0800, +0530, Z, +123456          | 2     |
+		 * |                                 | XXXXX   | -08:00, +05:30, Z, +12:34:56      |       |
+		 * | Timezone (ISO-8601 w/o Z)       | x       | -08, +0530, +00                   |       |
+		 * |                                 | xx      | -0800, +0530, +0000               |       |
+		 * |                                 | xxx     | -08:00, +05:30, +00:00            | 2     |
+		 * |                                 | xxxx    | -0800, +0530, +0000, +123456      |       |
+		 * |                                 | xxxxx   | -08:00, +05:30, +00:00, +12:34:56 |       |
+		 * | Timezone (GMT)                  | O...OOO | GMT-8, GMT+5:30, GMT+0            |       |
+		 * |                                 | OOOO    | GMT-08:00, GMT+05:30, GMT+00:00   | 2     |
+		 * | Timezone (specific non-locat.)  | z...zzz | GMT-8, GMT+5:30, GMT+0            | 6     |
+		 * |                                 | zzzz    | GMT-08:00, GMT+05:30, GMT+00:00   | 2,6   |
+		 * | Seconds timestamp               | t       | 512969520                         | 7     |
+		 * |                                 | tt      | ...                               | 3,7   |
+		 * | Milliseconds timestamp          | T       | 512969520900                      | 7     |
+		 * |                                 | TT      | ...                               | 3,7   |
+		 * | Long localized date             | P       | 04/29/1453                        | 7     |
+		 * |                                 | PP      | Apr 29, 1453                      | 7     |
+		 * |                                 | PPP     | April 29th, 1453                  | 7     |
+		 * |                                 | PPPP    | Friday, April 29th, 1453          | 2,7   |
+		 * | Long localized time             | p       | 12:00 AM                          | 7     |
+		 * |                                 | pp      | 12:00:00 AM                       | 7     |
+		 * |                                 | ppp     | 12:00:00 AM GMT+2                 | 7     |
+		 * |                                 | pppp    | 12:00:00 AM GMT+02:00             | 2,7   |
+		 * | Combination of date and time    | Pp      | 04/29/1453, 12:00 AM              | 7     |
+		 * |                                 | PPpp    | Apr 29, 1453, 12:00:00 AM         | 7     |
+		 * |                                 | PPPppp  | April 29th, 1453 at ...           | 7     |
+		 * |                                 | PPPPpppp| Friday, April 29th, 1453 at ...   | 2,7   |
+		 * Notes:
+		 * 1. "Formatting" units (e.g. formatting quarter) in the default en-US locale
+		 *    are the same as "stand-alone" units, but are different in some languages.
+		 *    "Formatting" units are declined according to the rules of the language
+		 *    in the context of a date. "Stand-alone" units are always nominative singular:
+		 *
+		 *    `format(new Date(2017, 10, 6), 'do LLLL', {locale: cs}) //=> '6. listopad'`
+		 *
+		 *    `format(new Date(2017, 10, 6), 'do MMMM', {locale: cs}) //=> '6. listopadu'`
+		 *
+		 * 2. Any sequence of the identical letters is a pattern, unless it is escaped by
+		 *    the single quote characters (see below).
+		 *    If the sequence is longer than listed in table (e.g. `EEEEEEEEEEE`)
+		 *    the output will be the same as default pattern for this unit, usually
+		 *    the longest one (in case of ISO weekdays, `EEEE`). Default patterns for units
+		 *    are marked with "2" in the last column of the table.
+		 *
+		 *    `format(new Date(2017, 10, 6), 'MMM') //=> 'Nov'`
+		 *
+		 *    `format(new Date(2017, 10, 6), 'MMMM') //=> 'November'`
+		 *
+		 *    `format(new Date(2017, 10, 6), 'MMMMM') //=> 'N'`
+		 *
+		 *    `format(new Date(2017, 10, 6), 'MMMMMM') //=> 'November'`
+		 *
+		 *    `format(new Date(2017, 10, 6), 'MMMMMMM') //=> 'November'`
+		 *
+		 * 3. Some patterns could be unlimited length (such as `yyyyyyyy`).
+		 *    The output will be padded with zeros to match the length of the pattern.
+		 *
+		 *    `format(new Date(2017, 10, 6), 'yyyyyyyy') //=> '00002017'`
+		 *
+		 * 4. `QQQQQ` and `qqqqq` could be not strictly numerical in some locales.
+		 *    These tokens represent the shortest form of the quarter.
+		 *
+		 * 5. The main difference between `y` and `u` patterns are B.C. years:
+		 *
+		 *    | Year | `y` | `u` |
+		 *    |------|-----|-----|
+		 *    | AC 1 |   1 |   1 |
+		 *    | BC 1 |   1 |   0 |
+		 *    | BC 2 |   2 |  -1 |
+		 *
+		 *    Also `yy` always returns the last two digits of a year,
+		 *    while `uu` pads single digit years to 2 characters and returns other years unchanged:
+		 *
+		 *    | Year | `yy` | `uu` |
+		 *    |------|------|------|
+		 *    | 1    |   01 |   01 |
+		 *    | 14   |   14 |   14 |
+		 *    | 376  |   76 |  376 |
+		 *    | 1453 |   53 | 1453 |
+		 *
+		 *    The same difference is true for local and ISO week-numbering years (`Y` and `R`),
+		 *    except local week-numbering years are dependent on `options.weekStartsOn`
+		 *    and `options.firstWeekContainsDate` (compare [getISOWeekYear](https://date-fns.org/docs/getISOWeekYear)
+		 *    and [getWeekYear](https://date-fns.org/docs/getWeekYear)).
+		 *
+		 * 6. Specific non-location timezones are currently unavailable in `date-fns`,
+		 *    so right now these tokens fall back to GMT timezones.
+		 *
+		 * 7. These patterns are not in the Unicode Technical Standard #35:
+		 *    - `i`: ISO day of week
+		 *    - `I`: ISO week of year
+		 *    - `R`: ISO week-numbering year
+		 *    - `t`: seconds timestamp
+		 *    - `T`: milliseconds timestamp
+		 *    - `o`: ordinal number modifier
+		 *    - `P`: long localized date
+		 *    - `p`: long localized time
+		 *
+		 * 8. `YY` and `YYYY` tokens represent week-numbering years but they are often confused with years.
+		 *    You should enable `options.useAdditionalWeekYearTokens` to use them. See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+		 *
+		 * 9. `D` and `DD` tokens represent days of the year but they are often confused with days of the month.
+		 *    You should enable `options.useAdditionalDayOfYearTokens` to use them. See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+		 *
+		 * @param date - The original date
+		 * @param format - The string of tokens
+		 * @param options - An object with options
+		 *
+		 * @returns The formatted date string
+		 *
+		 * @throws `date` must not be Invalid Date
+		 * @throws `options.locale` must contain `localize` property
+		 * @throws `options.locale` must contain `formatLong` property
+		 * @throws use `yyyy` instead of `YYYY` for formatting years using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+		 * @throws use `yy` instead of `YY` for formatting years using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+		 * @throws use `d` instead of `D` for formatting days of the month using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+		 * @throws use `dd` instead of `DD` for formatting days of the month using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+		 * @throws format string contains an unescaped latin alphabet character
+		 *
+		 * @example
+		 * // Represent 11 February 2014 in middle-endian format:
+		 * const result = format(new Date(2014, 1, 11), 'MM/dd/yyyy')
+		 * //=> '02/11/2014'
+		 *
+		 * @example
+		 * // Represent 2 July 2014 in Esperanto:
+		 * import { eoLocale } from 'date-fns/locale/eo'
+		 * const result = format(new Date(2014, 6, 2), "do 'de' MMMM yyyy", {
+		 *   locale: eoLocale
+		 * })
+		 * //=> '2-a de julio 2014'
+		 *
+		 * @example
+		 * // Escape string by single quote characters:
+		 * const result = format(new Date(2014, 6, 2, 15), "h 'o''clock'")
+		 * //=> "3 o'clock"
+		 */
+		function format(date, formatStr, options) {
+		  const defaultOptions = (0, _index2.getDefaultOptions)();
+		  const locale =
+		    options?.locale ?? defaultOptions.locale ?? _index.defaultLocale;
+
+		  const firstWeekContainsDate =
+		    options?.firstWeekContainsDate ??
+		    options?.locale?.options?.firstWeekContainsDate ??
+		    defaultOptions.firstWeekContainsDate ??
+		    defaultOptions.locale?.options?.firstWeekContainsDate ??
+		    1;
+
+		  const weekStartsOn =
+		    options?.weekStartsOn ??
+		    options?.locale?.options?.weekStartsOn ??
+		    defaultOptions.weekStartsOn ??
+		    defaultOptions.locale?.options?.weekStartsOn ??
+		    0;
+
+		  const originalDate = (0, _index7.toDate)(date, options?.in);
+
+		  if (!(0, _index6.isValid)(originalDate)) {
+		    throw new RangeError("Invalid time value");
+		  }
+
+		  let parts = formatStr
+		    .match(longFormattingTokensRegExp)
+		    .map((substring) => {
+		      const firstCharacter = substring[0];
+		      if (firstCharacter === "p" || firstCharacter === "P") {
+		        const longFormatter = _index4.longFormatters[firstCharacter];
+		        return longFormatter(substring, locale.formatLong);
+		      }
+		      return substring;
+		    })
+		    .join("")
+		    .match(formattingTokensRegExp)
+		    .map((substring) => {
+		      // Replace two single quote characters with one single quote character
+		      if (substring === "''") {
+		        return { isToken: false, value: "'" };
+		      }
+
+		      const firstCharacter = substring[0];
+		      if (firstCharacter === "'") {
+		        return { isToken: false, value: cleanEscapedString(substring) };
+		      }
+
+		      if (_index3.formatters[firstCharacter]) {
+		        return { isToken: true, value: substring };
+		      }
+
+		      if (firstCharacter.match(unescapedLatinCharacterRegExp)) {
+		        throw new RangeError(
+		          "Format string contains an unescaped latin alphabet character `" +
+		            firstCharacter +
+		            "`",
+		        );
+		      }
+
+		      return { isToken: false, value: substring };
+		    });
+
+		  // invoke localize preprocessor (only for french locales at the moment)
+		  if (locale.localize.preprocessor) {
+		    parts = locale.localize.preprocessor(originalDate, parts);
+		  }
+
+		  const formatterOptions = {
+		    firstWeekContainsDate,
+		    weekStartsOn,
+		    locale,
+		  };
+
+		  return parts
+		    .map((part) => {
+		      if (!part.isToken) return part.value;
+
+		      const token = part.value;
+
+		      if (
+		        (!options?.useAdditionalWeekYearTokens &&
+		          (0, _index5.isProtectedWeekYearToken)(token)) ||
+		        (!options?.useAdditionalDayOfYearTokens &&
+		          (0, _index5.isProtectedDayOfYearToken)(token))
+		      ) {
+		        (0, _index5.warnOrThrowProtectedError)(token, formatStr, String(date));
+		      }
+
+		      const formatter = _index3.formatters[token[0]];
+		      return formatter(originalDate, token, locale.localize, formatterOptions);
+		    })
+		    .join("");
+		}
+
+		function cleanEscapedString(input) {
+		  const matched = input.match(escapedStringRegExp);
+
+		  if (!matched) {
+		    return input;
+		  }
+
+		  return matched[1].replace(doubleQuoteRegExp, "'");
+		} 
+	} (format));
+	return format;
+}
+
+var formatExports = /*@__PURE__*/ requireFormat();
+
+var setDay = {};
+
+var hasRequiredSetDay;
+
+function requireSetDay () {
+	if (hasRequiredSetDay) return setDay;
+	hasRequiredSetDay = 1;
+	setDay.setDay = setDay$1;
+	var _index = /*@__PURE__*/ requireDefaultOptions();
+	var _index2 = /*@__PURE__*/ requireAddDays();
+	var _index3 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link setDay} function options.
+	 */
+
+	/**
+	 * @name setDay
+	 * @category Weekday Helpers
+	 * @summary Set the day of the week to the given date.
+	 *
+	 * @description
+	 * Set the day of the week 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 day - The day of the week of the new date
+	 * @param options - An object with options.
+	 *
+	 * @returns The new date with the day of the week set
+	 *
+	 * @example
+	 * // Set week day to Sunday, with the default weekStartsOn of Sunday:
+	 * const result = setDay(new Date(2014, 8, 1), 0)
+	 * //=> Sun Aug 31 2014 00:00:00
+	 *
+	 * @example
+	 * // Set week day to Sunday, with a weekStartsOn of Monday:
+	 * const result = setDay(new Date(2014, 8, 1), 0, { weekStartsOn: 1 })
+	 * //=> Sun Sep 07 2014 00:00:00
+	 */
+	function setDay$1(date, day, options) {
+	  const defaultOptions = (0, _index.getDefaultOptions)();
+	  const weekStartsOn =
+	    options?.weekStartsOn ??
+	    options?.locale?.options?.weekStartsOn ??
+	    defaultOptions.weekStartsOn ??
+	    defaultOptions.locale?.options?.weekStartsOn ??
+	    0;
+
+	  const date_ = (0, _index3.toDate)(date, options?.in);
+	  const currentDay = date_.getDay();
+
+	  const remainder = day % 7;
+	  const dayIndex = (remainder + 7) % 7;
+
+	  const delta = 7 - weekStartsOn;
+	  const diff =
+	    day < 0 || day > 6
+	      ? day - ((currentDay + delta) % 7)
+	      : ((dayIndex + delta) % 7) - ((currentDay + delta) % 7);
+	  return (0, _index2.addDays)(date_, diff, options);
+	}
+	return setDay;
+}
+
+var setMonth = {};
+
+var getDaysInMonth = {};
+
+var hasRequiredGetDaysInMonth;
+
+function requireGetDaysInMonth () {
+	if (hasRequiredGetDaysInMonth) return getDaysInMonth;
+	hasRequiredGetDaysInMonth = 1;
+	getDaysInMonth.getDaysInMonth = getDaysInMonth$1;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+	var _index2 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link getDaysInMonth} function options.
+	 */
+
+	/**
+	 * @name getDaysInMonth
+	 * @category Month Helpers
+	 * @summary Get the number of days in a month of the given date.
+	 *
+	 * @description
+	 * Get the number of days in a month of the given date, considering the context if provided.
+	 *
+	 * @param date - The given date
+	 * @param options - An object with options
+	 *
+	 * @returns The number of days in a month
+	 *
+	 * @example
+	 * // How many days are in February 2000?
+	 * const result = getDaysInMonth(new Date(2000, 1))
+	 * //=> 29
+	 */
+	function getDaysInMonth$1(date, options) {
+	  const _date = (0, _index2.toDate)(date, options?.in);
+	  const year = _date.getFullYear();
+	  const monthIndex = _date.getMonth();
+	  const lastDayOfMonth = (0, _index.constructFrom)(_date, 0);
+	  lastDayOfMonth.setFullYear(year, monthIndex + 1, 0);
+	  lastDayOfMonth.setHours(0, 0, 0, 0);
+	  return lastDayOfMonth.getDate();
+	}
+	return getDaysInMonth;
+}
+
+var hasRequiredSetMonth;
+
+function requireSetMonth () {
+	if (hasRequiredSetMonth) return setMonth;
+	hasRequiredSetMonth = 1;
+	setMonth.setMonth = setMonth$1;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+	var _index2 = /*@__PURE__*/ requireGetDaysInMonth();
+	var _index3 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * 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$1(date, month, options) {
+	  const _date = (0, _index3.toDate)(date, options?.in);
+	  const year = _date.getFullYear();
+	  const day = _date.getDate();
+
+	  const midMonth = (0, _index.constructFrom)(options?.in || date, 0);
+	  midMonth.setFullYear(year, month, 15);
+	  midMonth.setHours(0, 0, 0, 0);
+	  const daysInMonth = (0, _index2.getDaysInMonth)(midMonth);
+
+	  // Set the earlier date, allows to wrap Jan 31 to Feb 28
+	  _date.setMonth(month, Math.min(day, daysInMonth));
+	  return _date;
+	}
+	return setMonth;
+}
+
+/**
+ * Conjunto de modos suportados pelo datetime picker.
+ *
+ * `DEFAULT` define o modo aplicado quando o consumidor não informa um valor válido.
+ */
+const DATETIME_PICKER_MODE = {
+    DATE: 'date',
+    TIME: 'time',
+    DATETIME: 'datetime',
+    DEFAULT: 'datetime',
+};
+/**
+ * Valores de locale aceitos pelo componente.
+ *
+ * `DEFAULT` representa o locale padrão do design system.
+ */
+const DATETIME_PICKER_LOCALE = {
+    DEFAULT: 'pt-BR',
+};
+/**
+ * Ações de navegação emitidas pelos controles do calendário e do relógio.
+ *
+ * Os nomes são usados como contrato entre os componentes que compartilham a navegação.
+ */
+const NAVIGATION_ACTION = {
+    PREVIOUS_HOUR: 'previous-hour',
+    PREVIOUS_MINUTE: 'previous-minute',
+    PREVIOUS_MONTH: 'previous-month',
+    NEXT_HOUR: 'next-hour',
+    NEXT_MINUTE: 'next-minute',
+    NEXT_MONTH: 'next-month',
+};
+
+exports.DATETIME_PICKER_LOCALE = DATETIME_PICKER_LOCALE;
+exports.DATETIME_PICKER_MODE = DATETIME_PICKER_MODE;
+exports.NAVIGATION_ACTION = NAVIGATION_ACTION;
+exports.formatExports = formatExports;
+exports.requireAddDays = requireAddDays;
+exports.requireAddLeadingZeros = requireAddLeadingZeros;
+exports.requireBuildFormatLongFn = requireBuildFormatLongFn;
+exports.requireBuildLocalizeFn = requireBuildLocalizeFn;
+exports.requireBuildMatchFn = requireBuildMatchFn;
+exports.requireBuildMatchPatternFn = requireBuildMatchPatternFn;
+exports.requireConstants = requireConstants;
+exports.requireConstructFrom = requireConstructFrom;
+exports.requireDefaultLocale = requireDefaultLocale;
+exports.requireDefaultOptions = requireDefaultOptions;
+exports.requireGetISOWeek = requireGetISOWeek;
+exports.requireGetTimezoneOffsetInMilliseconds = requireGetTimezoneOffsetInMilliseconds;
+exports.requireGetWeek = requireGetWeek;
+exports.requireGetWeekYear = requireGetWeekYear;
+exports.requireIsValid = requireIsValid;
+exports.requireLongFormatters = requireLongFormatters;
+exports.requireNormalizeDates = requireNormalizeDates;
+exports.requireProtectedTokens = requireProtectedTokens;
+exports.requireSetDay = requireSetDay;
+exports.requireSetMonth = requireSetMonth;
+exports.requireStartOfDay = requireStartOfDay;
+exports.requireStartOfISOWeek = requireStartOfISOWeek;
+exports.requireStartOfWeek = requireStartOfWeek;
+exports.requireToDate = requireToDate;