@govbr-ds/webcomponents 2.1.0 → 2.1.1

package/dist/esm/isValid-DIUZX1qS.js

@@ -0,0 +1,3684 @@
+/*!
+ * Construído por SERPRO
+ * © https://serpro.gov.br/ - MIT License.
+ */
+import { g as requireNormalizeDates, a as requireConstructFrom, i as requireStartOfDay, e as requireDefaultOptions, c as requireConstants$1, j as requireGetWeekYear, k as requireStartOfWeek, l as requireStartOfISOWeek, b as requireToDate, m as requireGetWeek, n as requireGetISOWeek, o as requireSetDay, p as requireAddDays, q as requireGetTimezoneOffsetInMilliseconds, s as requireLongFormatters, t as requireDefaultLocale, u as requireProtectedTokens, v as requireSetMonth, r as requireIsValid } from './datetime-picker-constants-Bfm58jO6.js';
+
+var eachDayOfInterval = {};
+
+var normalizeInterval = {};
+
+var hasRequiredNormalizeInterval;
+
+function requireNormalizeInterval () {
+	if (hasRequiredNormalizeInterval) return normalizeInterval;
+	hasRequiredNormalizeInterval = 1;
+	normalizeInterval.normalizeInterval = normalizeInterval$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+
+	function normalizeInterval$1(context, interval) {
+	  const [start, end] = (0, _index.normalizeDates)(
+	    context,
+	    interval.start,
+	    interval.end,
+	  );
+	  return { start, end };
+	}
+	return normalizeInterval;
+}
+
+var hasRequiredEachDayOfInterval;
+
+function requireEachDayOfInterval () {
+	if (hasRequiredEachDayOfInterval) return eachDayOfInterval;
+	hasRequiredEachDayOfInterval = 1;
+	eachDayOfInterval.eachDayOfInterval = eachDayOfInterval$1;
+	var _index = /*@__PURE__*/ requireNormalizeInterval();
+	var _index2 = /*@__PURE__*/ requireConstructFrom();
+
+	/**
+	 * The {@link eachDayOfInterval} function options.
+	 */
+
+	/**
+	 * The {@link eachDayOfInterval} function result type. It resolves the proper data type.
+	 * It uses the first argument date object type, starting from the date argument,
+	 * then the start interval date, and finally the end interval date. If
+	 * a context function is passed, it uses the context function return type.
+	 */
+
+	/**
+	 * @name eachDayOfInterval
+	 * @category Interval Helpers
+	 * @summary Return the array of dates within the specified time interval.
+	 *
+	 * @description
+	 * Return the array of dates within the specified time interval.
+	 *
+	 * @typeParam IntervalType - Interval type.
+	 * @typeParam Options - Options type.
+	 *
+	 * @param interval - The interval.
+	 * @param options - An object with options.
+	 *
+	 * @returns The array with starts of days from the day of the interval start to the day of the interval end
+	 *
+	 * @example
+	 * // Each day between 6 October 2014 and 10 October 2014:
+	 * const result = eachDayOfInterval({
+	 *   start: new Date(2014, 9, 6),
+	 *   end: new Date(2014, 9, 10)
+	 * })
+	 * //=> [
+	 * //   Mon Oct 06 2014 00:00:00,
+	 * //   Tue Oct 07 2014 00:00:00,
+	 * //   Wed Oct 08 2014 00:00:00,
+	 * //   Thu Oct 09 2014 00:00:00,
+	 * //   Fri Oct 10 2014 00:00:00
+	 * // ]
+	 */
+	function eachDayOfInterval$1(interval, options) {
+	  const { start, end } = (0, _index.normalizeInterval)(options?.in, interval);
+
+	  let reversed = +start > +end;
+	  const endTime = reversed ? +start : +end;
+	  const date = reversed ? end : start;
+	  date.setHours(0, 0, 0, 0);
+
+	  let step = options?.step ?? 1;
+	  if (!step) return [];
+	  if (step < 0) {
+	    step = -step;
+	    reversed = !reversed;
+	  }
+
+	  const dates = [];
+
+	  while (+date <= endTime) {
+	    dates.push((0, _index2.constructFrom)(start, date));
+	    date.setDate(date.getDate() + step);
+	    date.setHours(0, 0, 0, 0);
+	  }
+
+	  return reversed ? dates.reverse() : dates;
+	}
+	return eachDayOfInterval;
+}
+
+var eachDayOfIntervalExports = /*@__PURE__*/ requireEachDayOfInterval();
+
+var isSameDay = {};
+
+var hasRequiredIsSameDay;
+
+function requireIsSameDay () {
+	if (hasRequiredIsSameDay) return isSameDay;
+	hasRequiredIsSameDay = 1;
+	isSameDay.isSameDay = isSameDay$1;
+	var _index = /*@__PURE__*/ requireNormalizeDates();
+	var _index2 = /*@__PURE__*/ requireStartOfDay();
+
+	/**
+	 * The {@link isSameDay} function options.
+	 */
+
+	/**
+	 * @name isSameDay
+	 * @category Day Helpers
+	 * @summary Are the given dates in the same day (and year and month)?
+	 *
+	 * @description
+	 * Are the given dates in the same day (and year and month)?
+	 *
+	 * @param laterDate - The first date to check
+	 * @param earlierDate - The second date to check
+	 * @param options - An object with options
+	 *
+	 * @returns The dates are in the same day (and year and month)
+	 *
+	 * @example
+	 * // Are 4 September 06:00:00 and 4 September 18:00:00 in the same day?
+	 * const result = isSameDay(new Date(2014, 8, 4, 6, 0), new Date(2014, 8, 4, 18, 0))
+	 * //=> true
+	 *
+	 * @example
+	 * // Are 4 September and 4 October in the same day?
+	 * const result = isSameDay(new Date(2014, 8, 4), new Date(2014, 9, 4))
+	 * //=> false
+	 *
+	 * @example
+	 * // Are 4 September, 2014 and 4 September, 2015 in the same day?
+	 * const result = isSameDay(new Date(2014, 8, 4), new Date(2015, 8, 4))
+	 * //=> false
+	 */
+	function isSameDay$1(laterDate, earlierDate, options) {
+	  const [dateLeft_, dateRight_] = (0, _index.normalizeDates)(
+	    options?.in,
+	    laterDate,
+	    earlierDate,
+	  );
+	  return (
+	    +(0, _index2.startOfDay)(dateLeft_) === +(0, _index2.startOfDay)(dateRight_)
+	  );
+	}
+	return isSameDay;
+}
+
+var isSameDayExports = /*@__PURE__*/ requireIsSameDay();
+
+var parse = {};
+
+var getDefaultOptions = {};
+
+var hasRequiredGetDefaultOptions;
+
+function requireGetDefaultOptions () {
+	if (hasRequiredGetDefaultOptions) return getDefaultOptions;
+	hasRequiredGetDefaultOptions = 1;
+	getDefaultOptions.getDefaultOptions = getDefaultOptions$1;
+	var _index = /*@__PURE__*/ requireDefaultOptions();
+
+	/**
+	 * @name getDefaultOptions
+	 * @category Common Helpers
+	 * @summary Get default options.
+	 * @pure false
+	 *
+	 * @description
+	 * Returns an object that contains defaults for
+	 * `options.locale`, `options.weekStartsOn` and `options.firstWeekContainsDate`
+	 * arguments for all functions.
+	 *
+	 * You can change these with [setDefaultOptions](https://date-fns.org/docs/setDefaultOptions).
+	 *
+	 * @returns The default options
+	 *
+	 * @example
+	 * const result = getDefaultOptions()
+	 * //=> {}
+	 *
+	 * @example
+	 * setDefaultOptions({ weekStarsOn: 1, firstWeekContainsDate: 4 })
+	 * const result = getDefaultOptions()
+	 * //=> { weekStarsOn: 1, firstWeekContainsDate: 4 }
+	 */
+	function getDefaultOptions$1() {
+	  return Object.assign({}, (0, _index.getDefaultOptions)());
+	}
+	return getDefaultOptions;
+}
+
+var Setter = {};
+
+var transpose = {};
+
+var hasRequiredTranspose;
+
+function requireTranspose () {
+	if (hasRequiredTranspose) return transpose;
+	hasRequiredTranspose = 1;
+	transpose.transpose = transpose$1;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+
+	/**
+	 * @name transpose
+	 * @category Generic Helpers
+	 * @summary Transpose the date to the given constructor.
+	 *
+	 * @description
+	 * The function transposes the date to the given constructor. It helps you
+	 * to transpose the date in the system time zone to say `UTCDate` or any other
+	 * date extension.
+	 *
+	 * @typeParam InputDate - The input `Date` type derived from the passed argument.
+	 * @typeParam ResultDate - The result `Date` type derived from the passed constructor.
+	 *
+	 * @param date - The date to use values from
+	 * @param constructor - The date constructor to use
+	 *
+	 * @returns Date transposed to the given constructor
+	 *
+	 * @example
+	 * // Create July 10, 2022 00:00 in locale time zone
+	 * const date = new Date(2022, 6, 10)
+	 * //=> 'Sun Jul 10 2022 00:00:00 GMT+0800 (Singapore Standard Time)'
+	 *
+	 * @example
+	 * // Transpose the date to July 10, 2022 00:00 in UTC
+	 * transpose(date, UTCDate)
+	 * //=> 'Sun Jul 10 2022 00:00:00 GMT+0000 (Coordinated Universal Time)'
+	 */
+	function transpose$1(date, constructor) {
+	  const date_ = isConstructor(constructor)
+	    ? new constructor(0)
+	    : (0, _index.constructFrom)(constructor, 0);
+	  date_.setFullYear(date.getFullYear(), date.getMonth(), date.getDate());
+	  date_.setHours(
+	    date.getHours(),
+	    date.getMinutes(),
+	    date.getSeconds(),
+	    date.getMilliseconds(),
+	  );
+	  return date_;
+	}
+
+	function isConstructor(constructor) {
+	  return (
+	    typeof constructor === "function" &&
+	    constructor.prototype?.constructor === constructor
+	  );
+	}
+	return transpose;
+}
+
+var hasRequiredSetter;
+
+function requireSetter () {
+	if (hasRequiredSetter) return Setter;
+	hasRequiredSetter = 1;
+	Setter.ValueSetter = Setter.Setter = Setter.DateTimezoneSetter = void 0;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+	var _index2 = /*@__PURE__*/ requireTranspose();
+
+	const TIMEZONE_UNIT_PRIORITY = 10;
+
+	let Setter$1 = class Setter {
+	  subPriority = 0;
+
+	  validate(_utcDate, _options) {
+	    return true;
+	  }
+	};
+	Setter.Setter = Setter$1;
+
+	class ValueSetter extends Setter$1 {
+	  constructor(
+	    value,
+	    validateValue,
+
+	    setValue,
+
+	    priority,
+	    subPriority,
+	  ) {
+	    super();
+	    this.value = value;
+	    this.validateValue = validateValue;
+	    this.setValue = setValue;
+	    this.priority = priority;
+	    if (subPriority) {
+	      this.subPriority = subPriority;
+	    }
+	  }
+
+	  validate(date, options) {
+	    return this.validateValue(date, this.value, options);
+	  }
+
+	  set(date, flags, options) {
+	    return this.setValue(date, flags, this.value, options);
+	  }
+	}
+	Setter.ValueSetter = ValueSetter;
+
+	class DateTimezoneSetter extends Setter$1 {
+	  priority = TIMEZONE_UNIT_PRIORITY;
+	  subPriority = -1;
+
+	  constructor(context, reference) {
+	    super();
+	    this.context =
+	      context || ((date) => (0, _index.constructFrom)(reference, date));
+	  }
+
+	  set(date, flags) {
+	    if (flags.timestampIsSet) return date;
+	    return (0, _index.constructFrom)(
+	      date,
+	      (0, _index2.transpose)(date, this.context),
+	    );
+	  }
+	}
+	Setter.DateTimezoneSetter = DateTimezoneSetter;
+	return Setter;
+}
+
+var parsers = {};
+
+var EraParser = {};
+
+var Parser = {};
+
+var hasRequiredParser;
+
+function requireParser () {
+	if (hasRequiredParser) return Parser;
+	hasRequiredParser = 1;
+	Parser.Parser = void 0;
+	var _Setter = /*@__PURE__*/ requireSetter();
+
+	let Parser$1 = class Parser {
+	  run(dateString, token, match, options) {
+	    const result = this.parse(dateString, token, match, options);
+	    if (!result) {
+	      return null;
+	    }
+
+	    return {
+	      setter: new _Setter.ValueSetter(
+	        result.value,
+	        this.validate,
+	        this.set,
+	        this.priority,
+	        this.subPriority,
+	      ),
+	      rest: result.rest,
+	    };
+	  }
+
+	  validate(_utcDate, _value, _options) {
+	    return true;
+	  }
+	};
+	Parser.Parser = Parser$1;
+	return Parser;
+}
+
+var hasRequiredEraParser;
+
+function requireEraParser () {
+	if (hasRequiredEraParser) return EraParser;
+	hasRequiredEraParser = 1;
+	EraParser.EraParser = void 0;
+
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	let EraParser$1 = class EraParser extends _Parser.Parser {
+	  priority = 140;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      // AD, BC
+	      case "G":
+	      case "GG":
+	      case "GGG":
+	        return (
+	          match.era(dateString, { width: "abbreviated" }) ||
+	          match.era(dateString, { width: "narrow" })
+	        );
+
+	      // A, B
+	      case "GGGGG":
+	        return match.era(dateString, { width: "narrow" });
+	      // Anno Domini, Before Christ
+	      case "GGGG":
+	      default:
+	        return (
+	          match.era(dateString, { width: "wide" }) ||
+	          match.era(dateString, { width: "abbreviated" }) ||
+	          match.era(dateString, { width: "narrow" })
+	        );
+	    }
+	  }
+
+	  set(date, flags, value) {
+	    flags.era = value;
+	    date.setFullYear(value, 0, 1);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["R", "u", "t", "T"];
+	};
+	EraParser.EraParser = EraParser$1;
+	return EraParser;
+}
+
+var YearParser = {};
+
+var utils = {};
+
+var constants = {};
+
+var hasRequiredConstants;
+
+function requireConstants () {
+	if (hasRequiredConstants) return constants;
+	hasRequiredConstants = 1;
+	constants.timezonePatterns = constants.numericPatterns = void 0;
+	(constants.numericPatterns = {
+	  month: /^(1[0-2]|0?\d)/, // 0 to 12
+	  date: /^(3[0-1]|[0-2]?\d)/, // 0 to 31
+	  dayOfYear: /^(36[0-6]|3[0-5]\d|[0-2]?\d?\d)/, // 0 to 366
+	  week: /^(5[0-3]|[0-4]?\d)/, // 0 to 53
+	  hour23h: /^(2[0-3]|[0-1]?\d)/, // 0 to 23
+	  hour24h: /^(2[0-4]|[0-1]?\d)/, // 0 to 24
+	  hour11h: /^(1[0-1]|0?\d)/, // 0 to 11
+	  hour12h: /^(1[0-2]|0?\d)/, // 0 to 12
+	  minute: /^[0-5]?\d/, // 0 to 59
+	  second: /^[0-5]?\d/, // 0 to 59
+
+	  singleDigit: /^\d/, // 0 to 9
+	  twoDigits: /^\d{1,2}/, // 0 to 99
+	  threeDigits: /^\d{1,3}/, // 0 to 999
+	  fourDigits: /^\d{1,4}/, // 0 to 9999
+
+	  anyDigitsSigned: /^-?\d+/,
+	  singleDigitSigned: /^-?\d/, // 0 to 9, -0 to -9
+	  twoDigitsSigned: /^-?\d{1,2}/, // 0 to 99, -0 to -99
+	  threeDigitsSigned: /^-?\d{1,3}/, // 0 to 999, -0 to -999
+	  fourDigitsSigned: /^-?\d{1,4}/, // 0 to 9999, -0 to -9999
+	});
+
+	(constants.timezonePatterns = {
+	  basicOptionalMinutes: /^([+-])(\d{2})(\d{2})?|Z/,
+	  basic: /^([+-])(\d{2})(\d{2})|Z/,
+	  basicOptionalSeconds: /^([+-])(\d{2})(\d{2})((\d{2}))?|Z/,
+	  extended: /^([+-])(\d{2}):(\d{2})|Z/,
+	  extendedOptionalSeconds: /^([+-])(\d{2}):(\d{2})(:(\d{2}))?|Z/,
+	});
+	return constants;
+}
+
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	utils.dayPeriodEnumToHours = dayPeriodEnumToHours;
+	utils.isLeapYearIndex = isLeapYearIndex;
+	utils.mapValue = mapValue;
+	utils.normalizeTwoDigitYear = normalizeTwoDigitYear;
+	utils.parseAnyDigitsSigned = parseAnyDigitsSigned;
+	utils.parseNDigits = parseNDigits;
+	utils.parseNDigitsSigned = parseNDigitsSigned;
+	utils.parseNumericPattern = parseNumericPattern;
+	utils.parseTimezonePattern = parseTimezonePattern;
+	var _index = /*@__PURE__*/ requireConstants$1();
+
+	var _constants = /*@__PURE__*/ requireConstants();
+
+	function mapValue(parseFnResult, mapFn) {
+	  if (!parseFnResult) {
+	    return parseFnResult;
+	  }
+
+	  return {
+	    value: mapFn(parseFnResult.value),
+	    rest: parseFnResult.rest,
+	  };
+	}
+
+	function parseNumericPattern(pattern, dateString) {
+	  const matchResult = dateString.match(pattern);
+
+	  if (!matchResult) {
+	    return null;
+	  }
+
+	  return {
+	    value: parseInt(matchResult[0], 10),
+	    rest: dateString.slice(matchResult[0].length),
+	  };
+	}
+
+	function parseTimezonePattern(pattern, dateString) {
+	  const matchResult = dateString.match(pattern);
+
+	  if (!matchResult) {
+	    return null;
+	  }
+
+	  // Input is 'Z'
+	  if (matchResult[0] === "Z") {
+	    return {
+	      value: 0,
+	      rest: dateString.slice(1),
+	    };
+	  }
+
+	  const sign = matchResult[1] === "+" ? 1 : -1;
+	  const hours = matchResult[2] ? parseInt(matchResult[2], 10) : 0;
+	  const minutes = matchResult[3] ? parseInt(matchResult[3], 10) : 0;
+	  const seconds = matchResult[5] ? parseInt(matchResult[5], 10) : 0;
+
+	  return {
+	    value:
+	      sign *
+	      (hours * _index.millisecondsInHour +
+	        minutes * _index.millisecondsInMinute +
+	        seconds * _index.millisecondsInSecond),
+	    rest: dateString.slice(matchResult[0].length),
+	  };
+	}
+
+	function parseAnyDigitsSigned(dateString) {
+	  return parseNumericPattern(
+	    _constants.numericPatterns.anyDigitsSigned,
+	    dateString,
+	  );
+	}
+
+	function parseNDigits(n, dateString) {
+	  switch (n) {
+	    case 1:
+	      return parseNumericPattern(
+	        _constants.numericPatterns.singleDigit,
+	        dateString,
+	      );
+	    case 2:
+	      return parseNumericPattern(
+	        _constants.numericPatterns.twoDigits,
+	        dateString,
+	      );
+	    case 3:
+	      return parseNumericPattern(
+	        _constants.numericPatterns.threeDigits,
+	        dateString,
+	      );
+	    case 4:
+	      return parseNumericPattern(
+	        _constants.numericPatterns.fourDigits,
+	        dateString,
+	      );
+	    default:
+	      return parseNumericPattern(new RegExp("^\\d{1," + n + "}"), dateString);
+	  }
+	}
+
+	function parseNDigitsSigned(n, dateString) {
+	  switch (n) {
+	    case 1:
+	      return parseNumericPattern(
+	        _constants.numericPatterns.singleDigitSigned,
+	        dateString,
+	      );
+	    case 2:
+	      return parseNumericPattern(
+	        _constants.numericPatterns.twoDigitsSigned,
+	        dateString,
+	      );
+	    case 3:
+	      return parseNumericPattern(
+	        _constants.numericPatterns.threeDigitsSigned,
+	        dateString,
+	      );
+	    case 4:
+	      return parseNumericPattern(
+	        _constants.numericPatterns.fourDigitsSigned,
+	        dateString,
+	      );
+	    default:
+	      return parseNumericPattern(new RegExp("^-?\\d{1," + n + "}"), dateString);
+	  }
+	}
+
+	function dayPeriodEnumToHours(dayPeriod) {
+	  switch (dayPeriod) {
+	    case "morning":
+	      return 4;
+	    case "evening":
+	      return 17;
+	    case "pm":
+	    case "noon":
+	    case "afternoon":
+	      return 12;
+	    case "am":
+	    case "midnight":
+	    case "night":
+	    default:
+	      return 0;
+	  }
+	}
+
+	function normalizeTwoDigitYear(twoDigitYear, currentYear) {
+	  const isCommonEra = currentYear > 0;
+	  // Absolute number of the current year:
+	  // 1 -> 1 AC
+	  // 0 -> 1 BC
+	  // -1 -> 2 BC
+	  const absCurrentYear = isCommonEra ? currentYear : 1 - currentYear;
+
+	  let result;
+	  if (absCurrentYear <= 50) {
+	    result = twoDigitYear || 100;
+	  } else {
+	    const rangeEnd = absCurrentYear + 50;
+	    const rangeEndCentury = Math.trunc(rangeEnd / 100) * 100;
+	    const isPreviousCentury = twoDigitYear >= rangeEnd % 100;
+	    result = twoDigitYear + rangeEndCentury - (isPreviousCentury ? 100 : 0);
+	  }
+
+	  return isCommonEra ? result : 1 - result;
+	}
+
+	function isLeapYearIndex(year) {
+	  return year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0);
+	}
+	return utils;
+}
+
+var hasRequiredYearParser;
+
+function requireYearParser () {
+	if (hasRequiredYearParser) return YearParser;
+	hasRequiredYearParser = 1;
+	YearParser.YearParser = void 0;
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	// From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_Patterns
+	// | 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 |
+	let YearParser$1 = class YearParser extends _Parser.Parser {
+	  priority = 130;
+	  incompatibleTokens = ["Y", "R", "u", "w", "I", "i", "e", "c", "t", "T"];
+
+	  parse(dateString, token, match) {
+	    const valueCallback = (year) => ({
+	      year,
+	      isTwoDigitYear: token === "yy",
+	    });
+
+	    switch (token) {
+	      case "y":
+	        return (0, _utils.mapValue)(
+	          (0, _utils.parseNDigits)(4, dateString),
+	          valueCallback,
+	        );
+	      case "yo":
+	        return (0, _utils.mapValue)(
+	          match.ordinalNumber(dateString, {
+	            unit: "year",
+	          }),
+	          valueCallback,
+	        );
+	      default:
+	        return (0, _utils.mapValue)(
+	          (0, _utils.parseNDigits)(token.length, dateString),
+	          valueCallback,
+	        );
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value.isTwoDigitYear || value.year > 0;
+	  }
+
+	  set(date, flags, value) {
+	    const currentYear = date.getFullYear();
+
+	    if (value.isTwoDigitYear) {
+	      const normalizedTwoDigitYear = (0, _utils.normalizeTwoDigitYear)(
+	        value.year,
+	        currentYear,
+	      );
+	      date.setFullYear(normalizedTwoDigitYear, 0, 1);
+	      date.setHours(0, 0, 0, 0);
+	      return date;
+	    }
+
+	    const year =
+	      !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
+	    date.setFullYear(year, 0, 1);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+	};
+	YearParser.YearParser = YearParser$1;
+	return YearParser;
+}
+
+var LocalWeekYearParser = {};
+
+var hasRequiredLocalWeekYearParser;
+
+function requireLocalWeekYearParser () {
+	if (hasRequiredLocalWeekYearParser) return LocalWeekYearParser;
+	hasRequiredLocalWeekYearParser = 1;
+	LocalWeekYearParser.LocalWeekYearParser = void 0;
+	var _index = /*@__PURE__*/ requireGetWeekYear();
+
+	var _index2 = /*@__PURE__*/ requireStartOfWeek();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	// Local week-numbering year
+	let LocalWeekYearParser$1 = class LocalWeekYearParser extends _Parser.Parser {
+	  priority = 130;
+
+	  parse(dateString, token, match) {
+	    const valueCallback = (year) => ({
+	      year,
+	      isTwoDigitYear: token === "YY",
+	    });
+
+	    switch (token) {
+	      case "Y":
+	        return (0, _utils.mapValue)(
+	          (0, _utils.parseNDigits)(4, dateString),
+	          valueCallback,
+	        );
+	      case "Yo":
+	        return (0, _utils.mapValue)(
+	          match.ordinalNumber(dateString, {
+	            unit: "year",
+	          }),
+	          valueCallback,
+	        );
+	      default:
+	        return (0, _utils.mapValue)(
+	          (0, _utils.parseNDigits)(token.length, dateString),
+	          valueCallback,
+	        );
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value.isTwoDigitYear || value.year > 0;
+	  }
+
+	  set(date, flags, value, options) {
+	    const currentYear = (0, _index.getWeekYear)(date, options);
+
+	    if (value.isTwoDigitYear) {
+	      const normalizedTwoDigitYear = (0, _utils.normalizeTwoDigitYear)(
+	        value.year,
+	        currentYear,
+	      );
+	      date.setFullYear(
+	        normalizedTwoDigitYear,
+	        0,
+	        options.firstWeekContainsDate,
+	      );
+	      date.setHours(0, 0, 0, 0);
+	      return (0, _index2.startOfWeek)(date, options);
+	    }
+
+	    const year =
+	      !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
+	    date.setFullYear(year, 0, options.firstWeekContainsDate);
+	    date.setHours(0, 0, 0, 0);
+	    return (0, _index2.startOfWeek)(date, options);
+	  }
+
+	  incompatibleTokens = [
+	    "y",
+	    "R",
+	    "u",
+	    "Q",
+	    "q",
+	    "M",
+	    "L",
+	    "I",
+	    "d",
+	    "D",
+	    "i",
+	    "t",
+	    "T",
+	  ];
+	};
+	LocalWeekYearParser.LocalWeekYearParser = LocalWeekYearParser$1;
+	return LocalWeekYearParser;
+}
+
+var ISOWeekYearParser = {};
+
+var hasRequiredISOWeekYearParser;
+
+function requireISOWeekYearParser () {
+	if (hasRequiredISOWeekYearParser) return ISOWeekYearParser;
+	hasRequiredISOWeekYearParser = 1;
+	ISOWeekYearParser.ISOWeekYearParser = void 0;
+	var _index = /*@__PURE__*/ requireStartOfISOWeek();
+	var _index2 = /*@__PURE__*/ requireConstructFrom();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	// ISO week-numbering year
+	let ISOWeekYearParser$1 = class ISOWeekYearParser extends _Parser.Parser {
+	  priority = 130;
+
+	  parse(dateString, token) {
+	    if (token === "R") {
+	      return (0, _utils.parseNDigitsSigned)(4, dateString);
+	    }
+
+	    return (0, _utils.parseNDigitsSigned)(token.length, dateString);
+	  }
+
+	  set(date, _flags, value) {
+	    const firstWeekOfYear = (0, _index2.constructFrom)(date, 0);
+	    firstWeekOfYear.setFullYear(value, 0, 4);
+	    firstWeekOfYear.setHours(0, 0, 0, 0);
+	    return (0, _index.startOfISOWeek)(firstWeekOfYear);
+	  }
+
+	  incompatibleTokens = [
+	    "G",
+	    "y",
+	    "Y",
+	    "u",
+	    "Q",
+	    "q",
+	    "M",
+	    "L",
+	    "w",
+	    "d",
+	    "D",
+	    "e",
+	    "c",
+	    "t",
+	    "T",
+	  ];
+	};
+	ISOWeekYearParser.ISOWeekYearParser = ISOWeekYearParser$1;
+	return ISOWeekYearParser;
+}
+
+var ExtendedYearParser = {};
+
+var hasRequiredExtendedYearParser;
+
+function requireExtendedYearParser () {
+	if (hasRequiredExtendedYearParser) return ExtendedYearParser;
+	hasRequiredExtendedYearParser = 1;
+	ExtendedYearParser.ExtendedYearParser = void 0;
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let ExtendedYearParser$1 = class ExtendedYearParser extends _Parser.Parser {
+	  priority = 130;
+
+	  parse(dateString, token) {
+	    if (token === "u") {
+	      return (0, _utils.parseNDigitsSigned)(4, dateString);
+	    }
+
+	    return (0, _utils.parseNDigitsSigned)(token.length, dateString);
+	  }
+
+	  set(date, _flags, value) {
+	    date.setFullYear(value, 0, 1);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["G", "y", "Y", "R", "w", "I", "i", "e", "c", "t", "T"];
+	};
+	ExtendedYearParser.ExtendedYearParser = ExtendedYearParser$1;
+	return ExtendedYearParser;
+}
+
+var QuarterParser = {};
+
+var hasRequiredQuarterParser;
+
+function requireQuarterParser () {
+	if (hasRequiredQuarterParser) return QuarterParser;
+	hasRequiredQuarterParser = 1;
+	QuarterParser.QuarterParser = void 0;
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let QuarterParser$1 = class QuarterParser extends _Parser.Parser {
+	  priority = 120;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      // 1, 2, 3, 4
+	      case "Q":
+	      case "QQ": // 01, 02, 03, 04
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	      // 1st, 2nd, 3rd, 4th
+	      case "Qo":
+	        return match.ordinalNumber(dateString, { unit: "quarter" });
+	      // Q1, Q2, Q3, Q4
+	      case "QQQ":
+	        return (
+	          match.quarter(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.quarter(dateString, {
+	            width: "narrow",
+	            context: "formatting",
+	          })
+	        );
+
+	      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+	      case "QQQQQ":
+	        return match.quarter(dateString, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      // 1st quarter, 2nd quarter, ...
+	      case "QQQQ":
+	      default:
+	        return (
+	          match.quarter(dateString, {
+	            width: "wide",
+	            context: "formatting",
+	          }) ||
+	          match.quarter(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.quarter(dateString, {
+	            width: "narrow",
+	            context: "formatting",
+	          })
+	        );
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 1 && value <= 4;
+	  }
+
+	  set(date, _flags, value) {
+	    date.setMonth((value - 1) * 3, 1);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = [
+	    "Y",
+	    "R",
+	    "q",
+	    "M",
+	    "L",
+	    "w",
+	    "I",
+	    "d",
+	    "D",
+	    "i",
+	    "e",
+	    "c",
+	    "t",
+	    "T",
+	  ];
+	};
+	QuarterParser.QuarterParser = QuarterParser$1;
+	return QuarterParser;
+}
+
+var StandAloneQuarterParser = {};
+
+var hasRequiredStandAloneQuarterParser;
+
+function requireStandAloneQuarterParser () {
+	if (hasRequiredStandAloneQuarterParser) return StandAloneQuarterParser;
+	hasRequiredStandAloneQuarterParser = 1;
+	StandAloneQuarterParser.StandAloneQuarterParser = void 0;
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let StandAloneQuarterParser$1 = class StandAloneQuarterParser extends _Parser.Parser {
+	  priority = 120;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      // 1, 2, 3, 4
+	      case "q":
+	      case "qq": // 01, 02, 03, 04
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	      // 1st, 2nd, 3rd, 4th
+	      case "qo":
+	        return match.ordinalNumber(dateString, { unit: "quarter" });
+	      // Q1, Q2, Q3, Q4
+	      case "qqq":
+	        return (
+	          match.quarter(dateString, {
+	            width: "abbreviated",
+	            context: "standalone",
+	          }) ||
+	          match.quarter(dateString, {
+	            width: "narrow",
+	            context: "standalone",
+	          })
+	        );
+
+	      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+	      case "qqqqq":
+	        return match.quarter(dateString, {
+	          width: "narrow",
+	          context: "standalone",
+	        });
+	      // 1st quarter, 2nd quarter, ...
+	      case "qqqq":
+	      default:
+	        return (
+	          match.quarter(dateString, {
+	            width: "wide",
+	            context: "standalone",
+	          }) ||
+	          match.quarter(dateString, {
+	            width: "abbreviated",
+	            context: "standalone",
+	          }) ||
+	          match.quarter(dateString, {
+	            width: "narrow",
+	            context: "standalone",
+	          })
+	        );
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 1 && value <= 4;
+	  }
+
+	  set(date, _flags, value) {
+	    date.setMonth((value - 1) * 3, 1);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = [
+	    "Y",
+	    "R",
+	    "Q",
+	    "M",
+	    "L",
+	    "w",
+	    "I",
+	    "d",
+	    "D",
+	    "i",
+	    "e",
+	    "c",
+	    "t",
+	    "T",
+	  ];
+	};
+	StandAloneQuarterParser.StandAloneQuarterParser = StandAloneQuarterParser$1;
+	return StandAloneQuarterParser;
+}
+
+var MonthParser = {};
+
+var hasRequiredMonthParser;
+
+function requireMonthParser () {
+	if (hasRequiredMonthParser) return MonthParser;
+	hasRequiredMonthParser = 1;
+	MonthParser.MonthParser = void 0;
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let MonthParser$1 = class MonthParser extends _Parser.Parser {
+	  incompatibleTokens = [
+	    "Y",
+	    "R",
+	    "q",
+	    "Q",
+	    "L",
+	    "w",
+	    "I",
+	    "D",
+	    "i",
+	    "e",
+	    "c",
+	    "t",
+	    "T",
+	  ];
+
+	  priority = 110;
+
+	  parse(dateString, token, match) {
+	    const valueCallback = (value) => value - 1;
+
+	    switch (token) {
+	      // 1, 2, ..., 12
+	      case "M":
+	        return (0, _utils.mapValue)(
+	          (0, _utils.parseNumericPattern)(
+	            _constants.numericPatterns.month,
+	            dateString,
+	          ),
+	          valueCallback,
+	        );
+	      // 01, 02, ..., 12
+	      case "MM":
+	        return (0, _utils.mapValue)(
+	          (0, _utils.parseNDigits)(2, dateString),
+	          valueCallback,
+	        );
+	      // 1st, 2nd, ..., 12th
+	      case "Mo":
+	        return (0, _utils.mapValue)(
+	          match.ordinalNumber(dateString, {
+	            unit: "month",
+	          }),
+	          valueCallback,
+	        );
+	      // Jan, Feb, ..., Dec
+	      case "MMM":
+	        return (
+	          match.month(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.month(dateString, { width: "narrow", context: "formatting" })
+	        );
+
+	      // J, F, ..., D
+	      case "MMMMM":
+	        return match.month(dateString, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      // January, February, ..., December
+	      case "MMMM":
+	      default:
+	        return (
+	          match.month(dateString, { width: "wide", context: "formatting" }) ||
+	          match.month(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.month(dateString, { width: "narrow", context: "formatting" })
+	        );
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 0 && value <= 11;
+	  }
+
+	  set(date, _flags, value) {
+	    date.setMonth(value, 1);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+	};
+	MonthParser.MonthParser = MonthParser$1;
+	return MonthParser;
+}
+
+var StandAloneMonthParser = {};
+
+var hasRequiredStandAloneMonthParser;
+
+function requireStandAloneMonthParser () {
+	if (hasRequiredStandAloneMonthParser) return StandAloneMonthParser;
+	hasRequiredStandAloneMonthParser = 1;
+	StandAloneMonthParser.StandAloneMonthParser = void 0;
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let StandAloneMonthParser$1 = class StandAloneMonthParser extends _Parser.Parser {
+	  priority = 110;
+
+	  parse(dateString, token, match) {
+	    const valueCallback = (value) => value - 1;
+
+	    switch (token) {
+	      // 1, 2, ..., 12
+	      case "L":
+	        return (0, _utils.mapValue)(
+	          (0, _utils.parseNumericPattern)(
+	            _constants.numericPatterns.month,
+	            dateString,
+	          ),
+	          valueCallback,
+	        );
+	      // 01, 02, ..., 12
+	      case "LL":
+	        return (0, _utils.mapValue)(
+	          (0, _utils.parseNDigits)(2, dateString),
+	          valueCallback,
+	        );
+	      // 1st, 2nd, ..., 12th
+	      case "Lo":
+	        return (0, _utils.mapValue)(
+	          match.ordinalNumber(dateString, {
+	            unit: "month",
+	          }),
+	          valueCallback,
+	        );
+	      // Jan, Feb, ..., Dec
+	      case "LLL":
+	        return (
+	          match.month(dateString, {
+	            width: "abbreviated",
+	            context: "standalone",
+	          }) ||
+	          match.month(dateString, { width: "narrow", context: "standalone" })
+	        );
+
+	      // J, F, ..., D
+	      case "LLLLL":
+	        return match.month(dateString, {
+	          width: "narrow",
+	          context: "standalone",
+	        });
+	      // January, February, ..., December
+	      case "LLLL":
+	      default:
+	        return (
+	          match.month(dateString, { width: "wide", context: "standalone" }) ||
+	          match.month(dateString, {
+	            width: "abbreviated",
+	            context: "standalone",
+	          }) ||
+	          match.month(dateString, { width: "narrow", context: "standalone" })
+	        );
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 0 && value <= 11;
+	  }
+
+	  set(date, _flags, value) {
+	    date.setMonth(value, 1);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = [
+	    "Y",
+	    "R",
+	    "q",
+	    "Q",
+	    "M",
+	    "w",
+	    "I",
+	    "D",
+	    "i",
+	    "e",
+	    "c",
+	    "t",
+	    "T",
+	  ];
+	};
+	StandAloneMonthParser.StandAloneMonthParser = StandAloneMonthParser$1;
+	return StandAloneMonthParser;
+}
+
+var LocalWeekParser = {};
+
+var setWeek = {};
+
+var hasRequiredSetWeek;
+
+function requireSetWeek () {
+	if (hasRequiredSetWeek) return setWeek;
+	hasRequiredSetWeek = 1;
+	setWeek.setWeek = setWeek$1;
+	var _index = /*@__PURE__*/ requireGetWeek();
+	var _index2 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link setWeek} function options.
+	 */
+
+	/**
+	 * @name setWeek
+	 * @category Week Helpers
+	 * @summary Set the local week to the given date.
+	 *
+	 * @description
+	 * Set the local week to the given date, saving the weekday number.
+	 * 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, 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 week - The week of the new date
+	 * @param options - An object with options
+	 *
+	 * @returns The new date with the local week set
+	 *
+	 * @example
+	 * // Set the 1st week to 2 January 2005 with default options:
+	 * const result = setWeek(new Date(2005, 0, 2), 1)
+	 * //=> Sun Dec 26 2004 00:00:00
+	 *
+	 * @example
+	 * // Set the 1st week to 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 = setWeek(new Date(2005, 0, 2), 1, {
+	 *   weekStartsOn: 1,
+	 *   firstWeekContainsDate: 4
+	 * })
+	 * //=> Sun Jan 4 2004 00:00:00
+	 */
+	function setWeek$1(date, week, options) {
+	  const date_ = (0, _index2.toDate)(date, options?.in);
+	  const diff = (0, _index.getWeek)(date_, options) - week;
+	  date_.setDate(date_.getDate() - diff * 7);
+	  return (0, _index2.toDate)(date_, options?.in);
+	}
+	return setWeek;
+}
+
+var hasRequiredLocalWeekParser;
+
+function requireLocalWeekParser () {
+	if (hasRequiredLocalWeekParser) return LocalWeekParser;
+	hasRequiredLocalWeekParser = 1;
+	LocalWeekParser.LocalWeekParser = void 0;
+	var _index = /*@__PURE__*/ requireSetWeek();
+	var _index2 = /*@__PURE__*/ requireStartOfWeek();
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	// Local week of year
+	let LocalWeekParser$1 = class LocalWeekParser extends _Parser.Parser {
+	  priority = 100;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "w":
+	        return (0, _utils.parseNumericPattern)(
+	          _constants.numericPatterns.week,
+	          dateString,
+	        );
+	      case "wo":
+	        return match.ordinalNumber(dateString, { unit: "week" });
+	      default:
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 1 && value <= 53;
+	  }
+
+	  set(date, _flags, value, options) {
+	    return (0, _index2.startOfWeek)(
+	      (0, _index.setWeek)(date, value, options),
+	      options,
+	    );
+	  }
+
+	  incompatibleTokens = [
+	    "y",
+	    "R",
+	    "u",
+	    "q",
+	    "Q",
+	    "M",
+	    "L",
+	    "I",
+	    "d",
+	    "D",
+	    "i",
+	    "t",
+	    "T",
+	  ];
+	};
+	LocalWeekParser.LocalWeekParser = LocalWeekParser$1;
+	return LocalWeekParser;
+}
+
+var ISOWeekParser = {};
+
+var setISOWeek = {};
+
+var hasRequiredSetISOWeek;
+
+function requireSetISOWeek () {
+	if (hasRequiredSetISOWeek) return setISOWeek;
+	hasRequiredSetISOWeek = 1;
+	setISOWeek.setISOWeek = setISOWeek$1;
+	var _index = /*@__PURE__*/ requireGetISOWeek();
+	var _index2 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link setISOWeek} function options.
+	 */
+
+	/**
+	 * @name setISOWeek
+	 * @category ISO Week Helpers
+	 * @summary Set the ISO week to the given date.
+	 *
+	 * @description
+	 * Set the ISO week to the given date, saving the weekday number.
+	 *
+	 * 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 `Date` type of the context function.
+	 *
+	 * @param date - The date to be changed
+	 * @param week - The ISO week of the new date
+	 * @param options - An object with options
+	 *
+	 * @returns The new date with the ISO week set
+	 *
+	 * @example
+	 * // Set the 53rd ISO week to 7 August 2004:
+	 * const result = setISOWeek(new Date(2004, 7, 7), 53)
+	 * //=> Sat Jan 01 2005 00:00:00
+	 */
+	function setISOWeek$1(date, week, options) {
+	  const _date = (0, _index2.toDate)(date, options?.in);
+	  const diff = (0, _index.getISOWeek)(_date, options) - week;
+	  _date.setDate(_date.getDate() - diff * 7);
+	  return _date;
+	}
+	return setISOWeek;
+}
+
+var hasRequiredISOWeekParser;
+
+function requireISOWeekParser () {
+	if (hasRequiredISOWeekParser) return ISOWeekParser;
+	hasRequiredISOWeekParser = 1;
+	ISOWeekParser.ISOWeekParser = void 0;
+	var _index = /*@__PURE__*/ requireSetISOWeek();
+	var _index2 = /*@__PURE__*/ requireStartOfISOWeek();
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	// ISO week of year
+	let ISOWeekParser$1 = class ISOWeekParser extends _Parser.Parser {
+	  priority = 100;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "I":
+	        return (0, _utils.parseNumericPattern)(
+	          _constants.numericPatterns.week,
+	          dateString,
+	        );
+	      case "Io":
+	        return match.ordinalNumber(dateString, { unit: "week" });
+	      default:
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 1 && value <= 53;
+	  }
+
+	  set(date, _flags, value) {
+	    return (0, _index2.startOfISOWeek)((0, _index.setISOWeek)(date, value));
+	  }
+
+	  incompatibleTokens = [
+	    "y",
+	    "Y",
+	    "u",
+	    "q",
+	    "Q",
+	    "M",
+	    "L",
+	    "w",
+	    "d",
+	    "D",
+	    "e",
+	    "c",
+	    "t",
+	    "T",
+	  ];
+	};
+	ISOWeekParser.ISOWeekParser = ISOWeekParser$1;
+	return ISOWeekParser;
+}
+
+var DateParser = {};
+
+var hasRequiredDateParser;
+
+function requireDateParser () {
+	if (hasRequiredDateParser) return DateParser;
+	hasRequiredDateParser = 1;
+	DateParser.DateParser = void 0;
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+	const DAYS_IN_MONTH_LEAP_YEAR = [
+	  31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
+	];
+
+	// Day of the month
+	let DateParser$1 = class DateParser extends _Parser.Parser {
+	  priority = 90;
+	  subPriority = 1;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "d":
+	        return (0, _utils.parseNumericPattern)(
+	          _constants.numericPatterns.date,
+	          dateString,
+	        );
+	      case "do":
+	        return match.ordinalNumber(dateString, { unit: "date" });
+	      default:
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	    }
+	  }
+
+	  validate(date, value) {
+	    const year = date.getFullYear();
+	    const isLeapYear = (0, _utils.isLeapYearIndex)(year);
+	    const month = date.getMonth();
+	    if (isLeapYear) {
+	      return value >= 1 && value <= DAYS_IN_MONTH_LEAP_YEAR[month];
+	    } else {
+	      return value >= 1 && value <= DAYS_IN_MONTH[month];
+	    }
+	  }
+
+	  set(date, _flags, value) {
+	    date.setDate(value);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = [
+	    "Y",
+	    "R",
+	    "q",
+	    "Q",
+	    "w",
+	    "I",
+	    "D",
+	    "i",
+	    "e",
+	    "c",
+	    "t",
+	    "T",
+	  ];
+	};
+	DateParser.DateParser = DateParser$1;
+	return DateParser;
+}
+
+var DayOfYearParser = {};
+
+var hasRequiredDayOfYearParser;
+
+function requireDayOfYearParser () {
+	if (hasRequiredDayOfYearParser) return DayOfYearParser;
+	hasRequiredDayOfYearParser = 1;
+	DayOfYearParser.DayOfYearParser = void 0;
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let DayOfYearParser$1 = class DayOfYearParser extends _Parser.Parser {
+	  priority = 90;
+
+	  subpriority = 1;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "D":
+	      case "DD":
+	        return (0, _utils.parseNumericPattern)(
+	          _constants.numericPatterns.dayOfYear,
+	          dateString,
+	        );
+	      case "Do":
+	        return match.ordinalNumber(dateString, { unit: "date" });
+	      default:
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	    }
+	  }
+
+	  validate(date, value) {
+	    const year = date.getFullYear();
+	    const isLeapYear = (0, _utils.isLeapYearIndex)(year);
+	    if (isLeapYear) {
+	      return value >= 1 && value <= 366;
+	    } else {
+	      return value >= 1 && value <= 365;
+	    }
+	  }
+
+	  set(date, _flags, value) {
+	    date.setMonth(0, value);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = [
+	    "Y",
+	    "R",
+	    "q",
+	    "Q",
+	    "M",
+	    "L",
+	    "w",
+	    "I",
+	    "d",
+	    "E",
+	    "i",
+	    "e",
+	    "c",
+	    "t",
+	    "T",
+	  ];
+	};
+	DayOfYearParser.DayOfYearParser = DayOfYearParser$1;
+	return DayOfYearParser;
+}
+
+var DayParser = {};
+
+var hasRequiredDayParser;
+
+function requireDayParser () {
+	if (hasRequiredDayParser) return DayParser;
+	hasRequiredDayParser = 1;
+	DayParser.DayParser = void 0;
+	var _index = /*@__PURE__*/ requireSetDay();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	// Day of week
+	let DayParser$1 = class DayParser extends _Parser.Parser {
+	  priority = 90;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      // Tue
+	      case "E":
+	      case "EE":
+	      case "EEE":
+	        return (
+	          match.day(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.day(dateString, { width: "short", context: "formatting" }) ||
+	          match.day(dateString, { width: "narrow", context: "formatting" })
+	        );
+
+	      // T
+	      case "EEEEE":
+	        return match.day(dateString, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      // Tu
+	      case "EEEEEE":
+	        return (
+	          match.day(dateString, { width: "short", context: "formatting" }) ||
+	          match.day(dateString, { width: "narrow", context: "formatting" })
+	        );
+
+	      // Tuesday
+	      case "EEEE":
+	      default:
+	        return (
+	          match.day(dateString, { width: "wide", context: "formatting" }) ||
+	          match.day(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.day(dateString, { width: "short", context: "formatting" }) ||
+	          match.day(dateString, { width: "narrow", context: "formatting" })
+	        );
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 0 && value <= 6;
+	  }
+
+	  set(date, _flags, value, options) {
+	    date = (0, _index.setDay)(date, value, options);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["D", "i", "e", "c", "t", "T"];
+	};
+	DayParser.DayParser = DayParser$1;
+	return DayParser;
+}
+
+var LocalDayParser = {};
+
+var hasRequiredLocalDayParser;
+
+function requireLocalDayParser () {
+	if (hasRequiredLocalDayParser) return LocalDayParser;
+	hasRequiredLocalDayParser = 1;
+	LocalDayParser.LocalDayParser = void 0;
+	var _index = /*@__PURE__*/ requireSetDay();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	// Local day of week
+	let LocalDayParser$1 = class LocalDayParser extends _Parser.Parser {
+	  priority = 90;
+	  parse(dateString, token, match, options) {
+	    const valueCallback = (value) => {
+	      // We want here floor instead of trunc, so we get -7 for value 0 instead of 0
+	      const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
+	      return ((value + options.weekStartsOn + 6) % 7) + wholeWeekDays;
+	    };
+
+	    switch (token) {
+	      // 3
+	      case "e":
+	      case "ee": // 03
+	        return (0, _utils.mapValue)(
+	          (0, _utils.parseNDigits)(token.length, dateString),
+	          valueCallback,
+	        );
+	      // 3rd
+	      case "eo":
+	        return (0, _utils.mapValue)(
+	          match.ordinalNumber(dateString, {
+	            unit: "day",
+	          }),
+	          valueCallback,
+	        );
+	      // Tue
+	      case "eee":
+	        return (
+	          match.day(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.day(dateString, { width: "short", context: "formatting" }) ||
+	          match.day(dateString, { width: "narrow", context: "formatting" })
+	        );
+
+	      // T
+	      case "eeeee":
+	        return match.day(dateString, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      // Tu
+	      case "eeeeee":
+	        return (
+	          match.day(dateString, { width: "short", context: "formatting" }) ||
+	          match.day(dateString, { width: "narrow", context: "formatting" })
+	        );
+
+	      // Tuesday
+	      case "eeee":
+	      default:
+	        return (
+	          match.day(dateString, { width: "wide", context: "formatting" }) ||
+	          match.day(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.day(dateString, { width: "short", context: "formatting" }) ||
+	          match.day(dateString, { width: "narrow", context: "formatting" })
+	        );
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 0 && value <= 6;
+	  }
+
+	  set(date, _flags, value, options) {
+	    date = (0, _index.setDay)(date, value, options);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = [
+	    "y",
+	    "R",
+	    "u",
+	    "q",
+	    "Q",
+	    "M",
+	    "L",
+	    "I",
+	    "d",
+	    "D",
+	    "E",
+	    "i",
+	    "c",
+	    "t",
+	    "T",
+	  ];
+	};
+	LocalDayParser.LocalDayParser = LocalDayParser$1;
+	return LocalDayParser;
+}
+
+var StandAloneLocalDayParser = {};
+
+var hasRequiredStandAloneLocalDayParser;
+
+function requireStandAloneLocalDayParser () {
+	if (hasRequiredStandAloneLocalDayParser) return StandAloneLocalDayParser;
+	hasRequiredStandAloneLocalDayParser = 1;
+	StandAloneLocalDayParser.StandAloneLocalDayParser = void 0;
+	var _index = /*@__PURE__*/ requireSetDay();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	// Stand-alone local day of week
+	let StandAloneLocalDayParser$1 = class StandAloneLocalDayParser extends _Parser.Parser {
+	  priority = 90;
+
+	  parse(dateString, token, match, options) {
+	    const valueCallback = (value) => {
+	      // We want here floor instead of trunc, so we get -7 for value 0 instead of 0
+	      const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
+	      return ((value + options.weekStartsOn + 6) % 7) + wholeWeekDays;
+	    };
+
+	    switch (token) {
+	      // 3
+	      case "c":
+	      case "cc": // 03
+	        return (0, _utils.mapValue)(
+	          (0, _utils.parseNDigits)(token.length, dateString),
+	          valueCallback,
+	        );
+	      // 3rd
+	      case "co":
+	        return (0, _utils.mapValue)(
+	          match.ordinalNumber(dateString, {
+	            unit: "day",
+	          }),
+	          valueCallback,
+	        );
+	      // Tue
+	      case "ccc":
+	        return (
+	          match.day(dateString, {
+	            width: "abbreviated",
+	            context: "standalone",
+	          }) ||
+	          match.day(dateString, { width: "short", context: "standalone" }) ||
+	          match.day(dateString, { width: "narrow", context: "standalone" })
+	        );
+
+	      // T
+	      case "ccccc":
+	        return match.day(dateString, {
+	          width: "narrow",
+	          context: "standalone",
+	        });
+	      // Tu
+	      case "cccccc":
+	        return (
+	          match.day(dateString, { width: "short", context: "standalone" }) ||
+	          match.day(dateString, { width: "narrow", context: "standalone" })
+	        );
+
+	      // Tuesday
+	      case "cccc":
+	      default:
+	        return (
+	          match.day(dateString, { width: "wide", context: "standalone" }) ||
+	          match.day(dateString, {
+	            width: "abbreviated",
+	            context: "standalone",
+	          }) ||
+	          match.day(dateString, { width: "short", context: "standalone" }) ||
+	          match.day(dateString, { width: "narrow", context: "standalone" })
+	        );
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 0 && value <= 6;
+	  }
+
+	  set(date, _flags, value, options) {
+	    date = (0, _index.setDay)(date, value, options);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = [
+	    "y",
+	    "R",
+	    "u",
+	    "q",
+	    "Q",
+	    "M",
+	    "L",
+	    "I",
+	    "d",
+	    "D",
+	    "E",
+	    "i",
+	    "e",
+	    "t",
+	    "T",
+	  ];
+	};
+	StandAloneLocalDayParser.StandAloneLocalDayParser = StandAloneLocalDayParser$1;
+	return StandAloneLocalDayParser;
+}
+
+var ISODayParser = {};
+
+var setISODay = {};
+
+var getISODay = {};
+
+var hasRequiredGetISODay;
+
+function requireGetISODay () {
+	if (hasRequiredGetISODay) return getISODay;
+	hasRequiredGetISODay = 1;
+	getISODay.getISODay = getISODay$1;
+	var _index = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link getISODay} function options.
+	 */
+
+	/**
+	 * @name getISODay
+	 * @category Weekday Helpers
+	 * @summary Get the day of the ISO week of the given date.
+	 *
+	 * @description
+	 * Get the day of the ISO week of the given date,
+	 * which is 7 for Sunday, 1 for Monday etc.
+	 *
+	 * ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
+	 *
+	 * @param date - The given date
+	 * @param options - An object with options
+	 *
+	 * @returns The day of ISO week
+	 *
+	 * @example
+	 * // Which day of the ISO week is 26 February 2012?
+	 * const result = getISODay(new Date(2012, 1, 26))
+	 * //=> 7
+	 */
+	function getISODay$1(date, options) {
+	  const day = (0, _index.toDate)(date, options?.in).getDay();
+	  return day === 0 ? 7 : day;
+	}
+	return getISODay;
+}
+
+var hasRequiredSetISODay;
+
+function requireSetISODay () {
+	if (hasRequiredSetISODay) return setISODay;
+	hasRequiredSetISODay = 1;
+	setISODay.setISODay = setISODay$1;
+	var _index = /*@__PURE__*/ requireAddDays();
+	var _index2 = /*@__PURE__*/ requireGetISODay();
+	var _index3 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link setISODay} function options.
+	 */
+
+	/**
+	 * @name setISODay
+	 * @category Weekday Helpers
+	 * @summary Set the day of the ISO week to the given date.
+	 *
+	 * @description
+	 * Set the day of the ISO week to the given date.
+	 * ISO week starts with Monday.
+	 * 7 is the index of Sunday, 1 is the index of Monday, etc.
+	 *
+	 * @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 ISO week of the new date
+	 * @param options - An object with options
+	 *
+	 * @returns The new date with the day of the ISO week set
+	 *
+	 * @example
+	 * // Set Sunday to 1 September 2014:
+	 * const result = setISODay(new Date(2014, 8, 1), 7)
+	 * //=> Sun Sep 07 2014 00:00:00
+	 */
+	function setISODay$1(date, day, options) {
+	  const date_ = (0, _index3.toDate)(date, options?.in);
+	  const currentDay = (0, _index2.getISODay)(date_, options);
+	  const diff = day - currentDay;
+	  return (0, _index.addDays)(date_, diff, options);
+	}
+	return setISODay;
+}
+
+var hasRequiredISODayParser;
+
+function requireISODayParser () {
+	if (hasRequiredISODayParser) return ISODayParser;
+	hasRequiredISODayParser = 1;
+	ISODayParser.ISODayParser = void 0;
+	var _index = /*@__PURE__*/ requireSetISODay();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	// ISO day of week
+	let ISODayParser$1 = class ISODayParser extends _Parser.Parser {
+	  priority = 90;
+
+	  parse(dateString, token, match) {
+	    const valueCallback = (value) => {
+	      if (value === 0) {
+	        return 7;
+	      }
+	      return value;
+	    };
+
+	    switch (token) {
+	      // 2
+	      case "i":
+	      case "ii": // 02
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	      // 2nd
+	      case "io":
+	        return match.ordinalNumber(dateString, { unit: "day" });
+	      // Tue
+	      case "iii":
+	        return (0, _utils.mapValue)(
+	          match.day(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	            match.day(dateString, {
+	              width: "short",
+	              context: "formatting",
+	            }) ||
+	            match.day(dateString, {
+	              width: "narrow",
+	              context: "formatting",
+	            }),
+	          valueCallback,
+	        );
+	      // T
+	      case "iiiii":
+	        return (0, _utils.mapValue)(
+	          match.day(dateString, {
+	            width: "narrow",
+	            context: "formatting",
+	          }),
+	          valueCallback,
+	        );
+	      // Tu
+	      case "iiiiii":
+	        return (0, _utils.mapValue)(
+	          match.day(dateString, {
+	            width: "short",
+	            context: "formatting",
+	          }) ||
+	            match.day(dateString, {
+	              width: "narrow",
+	              context: "formatting",
+	            }),
+	          valueCallback,
+	        );
+	      // Tuesday
+	      case "iiii":
+	      default:
+	        return (0, _utils.mapValue)(
+	          match.day(dateString, {
+	            width: "wide",
+	            context: "formatting",
+	          }) ||
+	            match.day(dateString, {
+	              width: "abbreviated",
+	              context: "formatting",
+	            }) ||
+	            match.day(dateString, {
+	              width: "short",
+	              context: "formatting",
+	            }) ||
+	            match.day(dateString, {
+	              width: "narrow",
+	              context: "formatting",
+	            }),
+	          valueCallback,
+	        );
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 1 && value <= 7;
+	  }
+
+	  set(date, _flags, value) {
+	    date = (0, _index.setISODay)(date, value);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = [
+	    "y",
+	    "Y",
+	    "u",
+	    "q",
+	    "Q",
+	    "M",
+	    "L",
+	    "w",
+	    "d",
+	    "D",
+	    "E",
+	    "e",
+	    "c",
+	    "t",
+	    "T",
+	  ];
+	};
+	ISODayParser.ISODayParser = ISODayParser$1;
+	return ISODayParser;
+}
+
+var AMPMParser = {};
+
+var hasRequiredAMPMParser;
+
+function requireAMPMParser () {
+	if (hasRequiredAMPMParser) return AMPMParser;
+	hasRequiredAMPMParser = 1;
+	AMPMParser.AMPMParser = void 0;
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let AMPMParser$1 = class AMPMParser extends _Parser.Parser {
+	  priority = 80;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "a":
+	      case "aa":
+	      case "aaa":
+	        return (
+	          match.dayPeriod(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.dayPeriod(dateString, {
+	            width: "narrow",
+	            context: "formatting",
+	          })
+	        );
+
+	      case "aaaaa":
+	        return match.dayPeriod(dateString, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      case "aaaa":
+	      default:
+	        return (
+	          match.dayPeriod(dateString, {
+	            width: "wide",
+	            context: "formatting",
+	          }) ||
+	          match.dayPeriod(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.dayPeriod(dateString, {
+	            width: "narrow",
+	            context: "formatting",
+	          })
+	        );
+	    }
+	  }
+
+	  set(date, _flags, value) {
+	    date.setHours((0, _utils.dayPeriodEnumToHours)(value), 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["b", "B", "H", "k", "t", "T"];
+	};
+	AMPMParser.AMPMParser = AMPMParser$1;
+	return AMPMParser;
+}
+
+var AMPMMidnightParser = {};
+
+var hasRequiredAMPMMidnightParser;
+
+function requireAMPMMidnightParser () {
+	if (hasRequiredAMPMMidnightParser) return AMPMMidnightParser;
+	hasRequiredAMPMMidnightParser = 1;
+	AMPMMidnightParser.AMPMMidnightParser = void 0;
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let AMPMMidnightParser$1 = class AMPMMidnightParser extends _Parser.Parser {
+	  priority = 80;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "b":
+	      case "bb":
+	      case "bbb":
+	        return (
+	          match.dayPeriod(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.dayPeriod(dateString, {
+	            width: "narrow",
+	            context: "formatting",
+	          })
+	        );
+
+	      case "bbbbb":
+	        return match.dayPeriod(dateString, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      case "bbbb":
+	      default:
+	        return (
+	          match.dayPeriod(dateString, {
+	            width: "wide",
+	            context: "formatting",
+	          }) ||
+	          match.dayPeriod(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.dayPeriod(dateString, {
+	            width: "narrow",
+	            context: "formatting",
+	          })
+	        );
+	    }
+	  }
+
+	  set(date, _flags, value) {
+	    date.setHours((0, _utils.dayPeriodEnumToHours)(value), 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["a", "B", "H", "k", "t", "T"];
+	};
+	AMPMMidnightParser.AMPMMidnightParser = AMPMMidnightParser$1;
+	return AMPMMidnightParser;
+}
+
+var DayPeriodParser = {};
+
+var hasRequiredDayPeriodParser;
+
+function requireDayPeriodParser () {
+	if (hasRequiredDayPeriodParser) return DayPeriodParser;
+	hasRequiredDayPeriodParser = 1;
+	DayPeriodParser.DayPeriodParser = void 0;
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	// in the morning, in the afternoon, in the evening, at night
+	let DayPeriodParser$1 = class DayPeriodParser extends _Parser.Parser {
+	  priority = 80;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "B":
+	      case "BB":
+	      case "BBB":
+	        return (
+	          match.dayPeriod(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.dayPeriod(dateString, {
+	            width: "narrow",
+	            context: "formatting",
+	          })
+	        );
+
+	      case "BBBBB":
+	        return match.dayPeriod(dateString, {
+	          width: "narrow",
+	          context: "formatting",
+	        });
+	      case "BBBB":
+	      default:
+	        return (
+	          match.dayPeriod(dateString, {
+	            width: "wide",
+	            context: "formatting",
+	          }) ||
+	          match.dayPeriod(dateString, {
+	            width: "abbreviated",
+	            context: "formatting",
+	          }) ||
+	          match.dayPeriod(dateString, {
+	            width: "narrow",
+	            context: "formatting",
+	          })
+	        );
+	    }
+	  }
+
+	  set(date, _flags, value) {
+	    date.setHours((0, _utils.dayPeriodEnumToHours)(value), 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["a", "b", "t", "T"];
+	};
+	DayPeriodParser.DayPeriodParser = DayPeriodParser$1;
+	return DayPeriodParser;
+}
+
+var Hour1to12Parser = {};
+
+var hasRequiredHour1to12Parser;
+
+function requireHour1to12Parser () {
+	if (hasRequiredHour1to12Parser) return Hour1to12Parser;
+	hasRequiredHour1to12Parser = 1;
+	Hour1to12Parser.Hour1to12Parser = void 0;
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let Hour1to12Parser$1 = class Hour1to12Parser extends _Parser.Parser {
+	  priority = 70;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "h":
+	        return (0, _utils.parseNumericPattern)(
+	          _constants.numericPatterns.hour12h,
+	          dateString,
+	        );
+	      case "ho":
+	        return match.ordinalNumber(dateString, { unit: "hour" });
+	      default:
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 1 && value <= 12;
+	  }
+
+	  set(date, _flags, value) {
+	    const isPM = date.getHours() >= 12;
+	    if (isPM && value < 12) {
+	      date.setHours(value + 12, 0, 0, 0);
+	    } else if (!isPM && value === 12) {
+	      date.setHours(0, 0, 0, 0);
+	    } else {
+	      date.setHours(value, 0, 0, 0);
+	    }
+	    return date;
+	  }
+
+	  incompatibleTokens = ["H", "K", "k", "t", "T"];
+	};
+	Hour1to12Parser.Hour1to12Parser = Hour1to12Parser$1;
+	return Hour1to12Parser;
+}
+
+var Hour0to23Parser = {};
+
+var hasRequiredHour0to23Parser;
+
+function requireHour0to23Parser () {
+	if (hasRequiredHour0to23Parser) return Hour0to23Parser;
+	hasRequiredHour0to23Parser = 1;
+	Hour0to23Parser.Hour0to23Parser = void 0;
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let Hour0to23Parser$1 = class Hour0to23Parser extends _Parser.Parser {
+	  priority = 70;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "H":
+	        return (0, _utils.parseNumericPattern)(
+	          _constants.numericPatterns.hour23h,
+	          dateString,
+	        );
+	      case "Ho":
+	        return match.ordinalNumber(dateString, { unit: "hour" });
+	      default:
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 0 && value <= 23;
+	  }
+
+	  set(date, _flags, value) {
+	    date.setHours(value, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["a", "b", "h", "K", "k", "t", "T"];
+	};
+	Hour0to23Parser.Hour0to23Parser = Hour0to23Parser$1;
+	return Hour0to23Parser;
+}
+
+var Hour0To11Parser = {};
+
+var hasRequiredHour0To11Parser;
+
+function requireHour0To11Parser () {
+	if (hasRequiredHour0To11Parser) return Hour0To11Parser;
+	hasRequiredHour0To11Parser = 1;
+	Hour0To11Parser.Hour0To11Parser = void 0;
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let Hour0To11Parser$1 = class Hour0To11Parser extends _Parser.Parser {
+	  priority = 70;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "K":
+	        return (0, _utils.parseNumericPattern)(
+	          _constants.numericPatterns.hour11h,
+	          dateString,
+	        );
+	      case "Ko":
+	        return match.ordinalNumber(dateString, { unit: "hour" });
+	      default:
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 0 && value <= 11;
+	  }
+
+	  set(date, _flags, value) {
+	    const isPM = date.getHours() >= 12;
+	    if (isPM && value < 12) {
+	      date.setHours(value + 12, 0, 0, 0);
+	    } else {
+	      date.setHours(value, 0, 0, 0);
+	    }
+	    return date;
+	  }
+
+	  incompatibleTokens = ["h", "H", "k", "t", "T"];
+	};
+	Hour0To11Parser.Hour0To11Parser = Hour0To11Parser$1;
+	return Hour0To11Parser;
+}
+
+var Hour1To24Parser = {};
+
+var hasRequiredHour1To24Parser;
+
+function requireHour1To24Parser () {
+	if (hasRequiredHour1To24Parser) return Hour1To24Parser;
+	hasRequiredHour1To24Parser = 1;
+	Hour1To24Parser.Hour1To24Parser = void 0;
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let Hour1To24Parser$1 = class Hour1To24Parser extends _Parser.Parser {
+	  priority = 70;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "k":
+	        return (0, _utils.parseNumericPattern)(
+	          _constants.numericPatterns.hour24h,
+	          dateString,
+	        );
+	      case "ko":
+	        return match.ordinalNumber(dateString, { unit: "hour" });
+	      default:
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 1 && value <= 24;
+	  }
+
+	  set(date, _flags, value) {
+	    const hours = value <= 24 ? value % 24 : value;
+	    date.setHours(hours, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["a", "b", "h", "H", "K", "t", "T"];
+	};
+	Hour1To24Parser.Hour1To24Parser = Hour1To24Parser$1;
+	return Hour1To24Parser;
+}
+
+var MinuteParser = {};
+
+var hasRequiredMinuteParser;
+
+function requireMinuteParser () {
+	if (hasRequiredMinuteParser) return MinuteParser;
+	hasRequiredMinuteParser = 1;
+	MinuteParser.MinuteParser = void 0;
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let MinuteParser$1 = class MinuteParser extends _Parser.Parser {
+	  priority = 60;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "m":
+	        return (0, _utils.parseNumericPattern)(
+	          _constants.numericPatterns.minute,
+	          dateString,
+	        );
+	      case "mo":
+	        return match.ordinalNumber(dateString, { unit: "minute" });
+	      default:
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 0 && value <= 59;
+	  }
+
+	  set(date, _flags, value) {
+	    date.setMinutes(value, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["t", "T"];
+	};
+	MinuteParser.MinuteParser = MinuteParser$1;
+	return MinuteParser;
+}
+
+var SecondParser = {};
+
+var hasRequiredSecondParser;
+
+function requireSecondParser () {
+	if (hasRequiredSecondParser) return SecondParser;
+	hasRequiredSecondParser = 1;
+	SecondParser.SecondParser = void 0;
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let SecondParser$1 = class SecondParser extends _Parser.Parser {
+	  priority = 50;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "s":
+	        return (0, _utils.parseNumericPattern)(
+	          _constants.numericPatterns.second,
+	          dateString,
+	        );
+	      case "so":
+	        return match.ordinalNumber(dateString, { unit: "second" });
+	      default:
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 0 && value <= 59;
+	  }
+
+	  set(date, _flags, value) {
+	    date.setSeconds(value, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["t", "T"];
+	};
+	SecondParser.SecondParser = SecondParser$1;
+	return SecondParser;
+}
+
+var FractionOfSecondParser = {};
+
+var hasRequiredFractionOfSecondParser;
+
+function requireFractionOfSecondParser () {
+	if (hasRequiredFractionOfSecondParser) return FractionOfSecondParser;
+	hasRequiredFractionOfSecondParser = 1;
+	FractionOfSecondParser.FractionOfSecondParser = void 0;
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let FractionOfSecondParser$1 = class FractionOfSecondParser extends _Parser.Parser {
+	  priority = 30;
+
+	  parse(dateString, token) {
+	    const valueCallback = (value) =>
+	      Math.trunc(value * Math.pow(10, -token.length + 3));
+	    return (0, _utils.mapValue)(
+	      (0, _utils.parseNDigits)(token.length, dateString),
+	      valueCallback,
+	    );
+	  }
+
+	  set(date, _flags, value) {
+	    date.setMilliseconds(value);
+	    return date;
+	  }
+
+	  incompatibleTokens = ["t", "T"];
+	};
+	FractionOfSecondParser.FractionOfSecondParser = FractionOfSecondParser$1;
+	return FractionOfSecondParser;
+}
+
+var ISOTimezoneWithZParser = {};
+
+var hasRequiredISOTimezoneWithZParser;
+
+function requireISOTimezoneWithZParser () {
+	if (hasRequiredISOTimezoneWithZParser) return ISOTimezoneWithZParser;
+	hasRequiredISOTimezoneWithZParser = 1;
+	ISOTimezoneWithZParser.ISOTimezoneWithZParser = void 0;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+	var _index2 = /*@__PURE__*/ requireGetTimezoneOffsetInMilliseconds();
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	// Timezone (ISO-8601. +00:00 is `'Z'`)
+	let ISOTimezoneWithZParser$1 = class ISOTimezoneWithZParser extends _Parser.Parser {
+	  priority = 10;
+
+	  parse(dateString, token) {
+	    switch (token) {
+	      case "X":
+	        return (0, _utils.parseTimezonePattern)(
+	          _constants.timezonePatterns.basicOptionalMinutes,
+	          dateString,
+	        );
+	      case "XX":
+	        return (0, _utils.parseTimezonePattern)(
+	          _constants.timezonePatterns.basic,
+	          dateString,
+	        );
+	      case "XXXX":
+	        return (0, _utils.parseTimezonePattern)(
+	          _constants.timezonePatterns.basicOptionalSeconds,
+	          dateString,
+	        );
+	      case "XXXXX":
+	        return (0, _utils.parseTimezonePattern)(
+	          _constants.timezonePatterns.extendedOptionalSeconds,
+	          dateString,
+	        );
+	      case "XXX":
+	      default:
+	        return (0, _utils.parseTimezonePattern)(
+	          _constants.timezonePatterns.extended,
+	          dateString,
+	        );
+	    }
+	  }
+
+	  set(date, flags, value) {
+	    if (flags.timestampIsSet) return date;
+	    return (0, _index.constructFrom)(
+	      date,
+	      date.getTime() -
+	        (0, _index2.getTimezoneOffsetInMilliseconds)(date) -
+	        value,
+	    );
+	  }
+
+	  incompatibleTokens = ["t", "T", "x"];
+	};
+	ISOTimezoneWithZParser.ISOTimezoneWithZParser = ISOTimezoneWithZParser$1;
+	return ISOTimezoneWithZParser;
+}
+
+var ISOTimezoneParser = {};
+
+var hasRequiredISOTimezoneParser;
+
+function requireISOTimezoneParser () {
+	if (hasRequiredISOTimezoneParser) return ISOTimezoneParser;
+	hasRequiredISOTimezoneParser = 1;
+	ISOTimezoneParser.ISOTimezoneParser = void 0;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+	var _index2 = /*@__PURE__*/ requireGetTimezoneOffsetInMilliseconds();
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	// Timezone (ISO-8601)
+	let ISOTimezoneParser$1 = class ISOTimezoneParser extends _Parser.Parser {
+	  priority = 10;
+
+	  parse(dateString, token) {
+	    switch (token) {
+	      case "x":
+	        return (0, _utils.parseTimezonePattern)(
+	          _constants.timezonePatterns.basicOptionalMinutes,
+	          dateString,
+	        );
+	      case "xx":
+	        return (0, _utils.parseTimezonePattern)(
+	          _constants.timezonePatterns.basic,
+	          dateString,
+	        );
+	      case "xxxx":
+	        return (0, _utils.parseTimezonePattern)(
+	          _constants.timezonePatterns.basicOptionalSeconds,
+	          dateString,
+	        );
+	      case "xxxxx":
+	        return (0, _utils.parseTimezonePattern)(
+	          _constants.timezonePatterns.extendedOptionalSeconds,
+	          dateString,
+	        );
+	      case "xxx":
+	      default:
+	        return (0, _utils.parseTimezonePattern)(
+	          _constants.timezonePatterns.extended,
+	          dateString,
+	        );
+	    }
+	  }
+
+	  set(date, flags, value) {
+	    if (flags.timestampIsSet) return date;
+	    return (0, _index.constructFrom)(
+	      date,
+	      date.getTime() -
+	        (0, _index2.getTimezoneOffsetInMilliseconds)(date) -
+	        value,
+	    );
+	  }
+
+	  incompatibleTokens = ["t", "T", "X"];
+	};
+	ISOTimezoneParser.ISOTimezoneParser = ISOTimezoneParser$1;
+	return ISOTimezoneParser;
+}
+
+var TimestampSecondsParser = {};
+
+var hasRequiredTimestampSecondsParser;
+
+function requireTimestampSecondsParser () {
+	if (hasRequiredTimestampSecondsParser) return TimestampSecondsParser;
+	hasRequiredTimestampSecondsParser = 1;
+	TimestampSecondsParser.TimestampSecondsParser = void 0;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let TimestampSecondsParser$1 = class TimestampSecondsParser extends _Parser.Parser {
+	  priority = 40;
+
+	  parse(dateString) {
+	    return (0, _utils.parseAnyDigitsSigned)(dateString);
+	  }
+
+	  set(date, _flags, value) {
+	    return [
+	      (0, _index.constructFrom)(date, value * 1000),
+	      { timestampIsSet: true },
+	    ];
+	  }
+
+	  incompatibleTokens = "*";
+	};
+	TimestampSecondsParser.TimestampSecondsParser = TimestampSecondsParser$1;
+	return TimestampSecondsParser;
+}
+
+var TimestampMillisecondsParser = {};
+
+var hasRequiredTimestampMillisecondsParser;
+
+function requireTimestampMillisecondsParser () {
+	if (hasRequiredTimestampMillisecondsParser) return TimestampMillisecondsParser;
+	hasRequiredTimestampMillisecondsParser = 1;
+	TimestampMillisecondsParser.TimestampMillisecondsParser = void 0;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	let TimestampMillisecondsParser$1 = class TimestampMillisecondsParser extends _Parser.Parser {
+	  priority = 20;
+
+	  parse(dateString) {
+	    return (0, _utils.parseAnyDigitsSigned)(dateString);
+	  }
+
+	  set(date, _flags, value) {
+	    return [(0, _index.constructFrom)(date, value), { timestampIsSet: true }];
+	  }
+
+	  incompatibleTokens = "*";
+	};
+	TimestampMillisecondsParser.TimestampMillisecondsParser = TimestampMillisecondsParser$1;
+	return TimestampMillisecondsParser;
+}
+
+var hasRequiredParsers;
+
+function requireParsers () {
+	if (hasRequiredParsers) return parsers;
+	hasRequiredParsers = 1;
+	parsers.parsers = void 0;
+	var _EraParser = /*@__PURE__*/ requireEraParser();
+	var _YearParser = /*@__PURE__*/ requireYearParser();
+	var _LocalWeekYearParser = /*@__PURE__*/ requireLocalWeekYearParser();
+	var _ISOWeekYearParser = /*@__PURE__*/ requireISOWeekYearParser();
+	var _ExtendedYearParser = /*@__PURE__*/ requireExtendedYearParser();
+	var _QuarterParser = /*@__PURE__*/ requireQuarterParser();
+	var _StandAloneQuarterParser = /*@__PURE__*/ requireStandAloneQuarterParser();
+	var _MonthParser = /*@__PURE__*/ requireMonthParser();
+	var _StandAloneMonthParser = /*@__PURE__*/ requireStandAloneMonthParser();
+	var _LocalWeekParser = /*@__PURE__*/ requireLocalWeekParser();
+	var _ISOWeekParser = /*@__PURE__*/ requireISOWeekParser();
+	var _DateParser = /*@__PURE__*/ requireDateParser();
+	var _DayOfYearParser = /*@__PURE__*/ requireDayOfYearParser();
+	var _DayParser = /*@__PURE__*/ requireDayParser();
+	var _LocalDayParser = /*@__PURE__*/ requireLocalDayParser();
+	var _StandAloneLocalDayParser = /*@__PURE__*/ requireStandAloneLocalDayParser();
+	var _ISODayParser = /*@__PURE__*/ requireISODayParser();
+	var _AMPMParser = /*@__PURE__*/ requireAMPMParser();
+	var _AMPMMidnightParser = /*@__PURE__*/ requireAMPMMidnightParser();
+	var _DayPeriodParser = /*@__PURE__*/ requireDayPeriodParser();
+	var _Hour1to12Parser = /*@__PURE__*/ requireHour1to12Parser();
+	var _Hour0to23Parser = /*@__PURE__*/ requireHour0to23Parser();
+	var _Hour0To11Parser = /*@__PURE__*/ requireHour0To11Parser();
+	var _Hour1To24Parser = /*@__PURE__*/ requireHour1To24Parser();
+	var _MinuteParser = /*@__PURE__*/ requireMinuteParser();
+	var _SecondParser = /*@__PURE__*/ requireSecondParser();
+	var _FractionOfSecondParser = /*@__PURE__*/ requireFractionOfSecondParser();
+	var _ISOTimezoneWithZParser = /*@__PURE__*/ requireISOTimezoneWithZParser();
+	var _ISOTimezoneParser = /*@__PURE__*/ requireISOTimezoneParser();
+	var _TimestampSecondsParser = /*@__PURE__*/ requireTimestampSecondsParser();
+	var _TimestampMillisecondsParser = /*@__PURE__*/ requireTimestampMillisecondsParser();
+
+	/*
+	 * |     | 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  |                                |  P  |                                |
+	 * |  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 `parse` 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.
+	 */
+	(parsers.parsers = {
+	  G: new _EraParser.EraParser(),
+	  y: new _YearParser.YearParser(),
+	  Y: new _LocalWeekYearParser.LocalWeekYearParser(),
+	  R: new _ISOWeekYearParser.ISOWeekYearParser(),
+	  u: new _ExtendedYearParser.ExtendedYearParser(),
+	  Q: new _QuarterParser.QuarterParser(),
+	  q: new _StandAloneQuarterParser.StandAloneQuarterParser(),
+	  M: new _MonthParser.MonthParser(),
+	  L: new _StandAloneMonthParser.StandAloneMonthParser(),
+	  w: new _LocalWeekParser.LocalWeekParser(),
+	  I: new _ISOWeekParser.ISOWeekParser(),
+	  d: new _DateParser.DateParser(),
+	  D: new _DayOfYearParser.DayOfYearParser(),
+	  E: new _DayParser.DayParser(),
+	  e: new _LocalDayParser.LocalDayParser(),
+	  c: new _StandAloneLocalDayParser.StandAloneLocalDayParser(),
+	  i: new _ISODayParser.ISODayParser(),
+	  a: new _AMPMParser.AMPMParser(),
+	  b: new _AMPMMidnightParser.AMPMMidnightParser(),
+	  B: new _DayPeriodParser.DayPeriodParser(),
+	  h: new _Hour1to12Parser.Hour1to12Parser(),
+	  H: new _Hour0to23Parser.Hour0to23Parser(),
+	  K: new _Hour0To11Parser.Hour0To11Parser(),
+	  k: new _Hour1To24Parser.Hour1To24Parser(),
+	  m: new _MinuteParser.MinuteParser(),
+	  s: new _SecondParser.SecondParser(),
+	  S: new _FractionOfSecondParser.FractionOfSecondParser(),
+	  X: new _ISOTimezoneWithZParser.ISOTimezoneWithZParser(),
+	  x: new _ISOTimezoneParser.ISOTimezoneParser(),
+	  t: new _TimestampSecondsParser.TimestampSecondsParser(),
+	  T: new _TimestampMillisecondsParser.TimestampMillisecondsParser(),
+	});
+	return parsers;
+}
+
+var hasRequiredParse;
+
+function requireParse () {
+	if (hasRequiredParse) return parse;
+	hasRequiredParse = 1;
+	(function (exports) {
+		Object.defineProperty(exports, "longFormatters", {
+		  enumerable: true,
+		  get: function () {
+		    return _index2.longFormatters;
+		  },
+		});
+		exports.parse = parse;
+		Object.defineProperty(exports, "parsers", {
+		  enumerable: true,
+		  get: function () {
+		    return _index7.parsers;
+		  },
+		});
+		var _index = /*@__PURE__*/ requireDefaultLocale();
+		var _index2 = /*@__PURE__*/ requireLongFormatters();
+		var _index3 = /*@__PURE__*/ requireProtectedTokens();
+
+		var _index4 = /*@__PURE__*/ requireConstructFrom();
+		var _index5 = /*@__PURE__*/ requireGetDefaultOptions();
+		var _index6 = /*@__PURE__*/ requireToDate();
+
+		var _Setter = /*@__PURE__*/ requireSetter();
+		var _index7 = /*@__PURE__*/ requireParsers();
+
+		// Rexports of internal for libraries to use.
+		// See: https://github.com/date-fns/date-fns/issues/3638#issuecomment-1877082874
+
+		/**
+		 * The {@link parse} function options.
+		 */
+
+		// 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 notWhitespaceRegExp = /\S/;
+		const unescapedLatinCharacterRegExp = /[a-zA-Z]/;
+
+		/**
+		 * @name parse
+		 * @category Common Helpers
+		 * @summary Parse the date.
+		 *
+		 * @description
+		 * Return the date parsed from string using the given format string.
+		 *
+		 * > ⚠️ 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 in the format string 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.
+		 *
+		 * Format of the format 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 5 below the table).
+		 *
+		 * Not all tokens are compatible. Combinations that don't make sense or could lead to bugs are prohibited
+		 * and will throw `RangeError`. For example usage of 24-hour format token with AM/PM token will throw an exception:
+		 *
+		 * ```javascript
+		 * parse('23 AM', 'HH a', new Date())
+		 * //=> RangeError: The format string mustn't contain `HH` and `a` at the same time
+		 * ```
+		 *
+		 * See the compatibility table: https://docs.google.com/spreadsheets/d/e/2PACX-1vQOPU3xUhplll6dyoMmVUXHKl_8CRDs6_ueLmex3SoqwhuolkuN3O05l4rqx5h1dKX8eb46Ul-CCSrq/pubhtml?gid=0&single=true
+		 *
+		 * Accepted format string patterns:
+		 * | Unit                            |Prior| Pattern | Result examples                   | Notes |
+		 * |---------------------------------|-----|---------|-----------------------------------|-------|
+		 * | Era                             | 140 | G..GGG  | AD, BC                            |       |
+		 * |                                 |     | GGGG    | Anno Domini, Before Christ        | 2     |
+		 * |                                 |     | GGGGG   | A, B                              |       |
+		 * | Calendar year                   | 130 | y       | 44, 1, 1900, 2017, 9999           | 4     |
+		 * |                                 |     | yo      | 44th, 1st, 1900th, 9999999th      | 4,5   |
+		 * |                                 |     | yy      | 44, 01, 00, 17                    | 4     |
+		 * |                                 |     | yyy     | 044, 001, 123, 999                | 4     |
+		 * |                                 |     | yyyy    | 0044, 0001, 1900, 2017            | 4     |
+		 * |                                 |     | yyyyy   | ...                               | 2,4   |
+		 * | Local week-numbering year       | 130 | Y       | 44, 1, 1900, 2017, 9000           | 4     |
+		 * |                                 |     | Yo      | 44th, 1st, 1900th, 9999999th      | 4,5   |
+		 * |                                 |     | YY      | 44, 01, 00, 17                    | 4,6   |
+		 * |                                 |     | YYY     | 044, 001, 123, 999                | 4     |
+		 * |                                 |     | YYYY    | 0044, 0001, 1900, 2017            | 4,6   |
+		 * |                                 |     | YYYYY   | ...                               | 2,4   |
+		 * | ISO week-numbering year         | 130 | R       | -43, 1, 1900, 2017, 9999, -9999   | 4,5   |
+		 * |                                 |     | RR      | -43, 01, 00, 17                   | 4,5   |
+		 * |                                 |     | RRR     | -043, 001, 123, 999, -999         | 4,5   |
+		 * |                                 |     | RRRR    | -0043, 0001, 2017, 9999, -9999    | 4,5   |
+		 * |                                 |     | RRRRR   | ...                               | 2,4,5 |
+		 * | Extended year                   | 130 | u       | -43, 1, 1900, 2017, 9999, -999    | 4     |
+		 * |                                 |     | uu      | -43, 01, 99, -99                  | 4     |
+		 * |                                 |     | uuu     | -043, 001, 123, 999, -999         | 4     |
+		 * |                                 |     | uuuu    | -0043, 0001, 2017, 9999, -9999    | 4     |
+		 * |                                 |     | uuuuu   | ...                               | 2,4   |
+		 * | Quarter (formatting)            | 120 | Q       | 1, 2, 3, 4                        |       |
+		 * |                                 |     | Qo      | 1st, 2nd, 3rd, 4th                | 5     |
+		 * |                                 |     | 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)           | 120 | q       | 1, 2, 3, 4                        |       |
+		 * |                                 |     | qo      | 1st, 2nd, 3rd, 4th                | 5     |
+		 * |                                 |     | qq      | 01, 02, 03, 04                    |       |
+		 * |                                 |     | qqq     | Q1, Q2, Q3, Q4                    |       |
+		 * |                                 |     | qqqq    | 1st quarter, 2nd quarter, ...     | 2     |
+		 * |                                 |     | qqqqq   | 1, 2, 3, 4                        | 3     |
+		 * | Month (formatting)              | 110 | M       | 1, 2, ..., 12                     |       |
+		 * |                                 |     | Mo      | 1st, 2nd, ..., 12th               | 5     |
+		 * |                                 |     | MM      | 01, 02, ..., 12                   |       |
+		 * |                                 |     | MMM     | Jan, Feb, ..., Dec                |       |
+		 * |                                 |     | MMMM    | January, February, ..., December  | 2     |
+		 * |                                 |     | MMMMM   | J, F, ..., D                      |       |
+		 * | Month (stand-alone)             | 110 | L       | 1, 2, ..., 12                     |       |
+		 * |                                 |     | Lo      | 1st, 2nd, ..., 12th               | 5     |
+		 * |                                 |     | LL      | 01, 02, ..., 12                   |       |
+		 * |                                 |     | LLL     | Jan, Feb, ..., Dec                |       |
+		 * |                                 |     | LLLL    | January, February, ..., December  | 2     |
+		 * |                                 |     | LLLLL   | J, F, ..., D                      |       |
+		 * | Local week of year              | 100 | w       | 1, 2, ..., 53                     |       |
+		 * |                                 |     | wo      | 1st, 2nd, ..., 53th               | 5     |
+		 * |                                 |     | ww      | 01, 02, ..., 53                   |       |
+		 * | ISO week of year                | 100 | I       | 1, 2, ..., 53                     | 5     |
+		 * |                                 |     | Io      | 1st, 2nd, ..., 53th               | 5     |
+		 * |                                 |     | II      | 01, 02, ..., 53                   | 5     |
+		 * | Day of month                    |  90 | d       | 1, 2, ..., 31                     |       |
+		 * |                                 |     | do      | 1st, 2nd, ..., 31st               | 5     |
+		 * |                                 |     | dd      | 01, 02, ..., 31                   |       |
+		 * | Day of year                     |  90 | D       | 1, 2, ..., 365, 366               | 7     |
+		 * |                                 |     | Do      | 1st, 2nd, ..., 365th, 366th       | 5     |
+		 * |                                 |     | DD      | 01, 02, ..., 365, 366             | 7     |
+		 * |                                 |     | DDD     | 001, 002, ..., 365, 366           |       |
+		 * |                                 |     | DDDD    | ...                               | 2     |
+		 * | Day of week (formatting)        |  90 | 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)    |  90 | i       | 1, 2, 3, ..., 7                   | 5     |
+		 * |                                 |     | io      | 1st, 2nd, ..., 7th                | 5     |
+		 * |                                 |     | ii      | 01, 02, ..., 07                   | 5     |
+		 * |                                 |     | iii     | Mon, Tue, Wed, ..., Sun           | 5     |
+		 * |                                 |     | iiii    | Monday, Tuesday, ..., Sunday      | 2,5   |
+		 * |                                 |     | iiiii   | M, T, W, T, F, S, S               | 5     |
+		 * |                                 |     | iiiiii  | Mo, Tu, We, Th, Fr, Sa, Su        | 5     |
+		 * | Local day of week (formatting)  |  90 | e       | 2, 3, 4, ..., 1                   |       |
+		 * |                                 |     | eo      | 2nd, 3rd, ..., 1st                | 5     |
+		 * |                                 |     | 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) |  90 | c       | 2, 3, 4, ..., 1                   |       |
+		 * |                                 |     | co      | 2nd, 3rd, ..., 1st                | 5     |
+		 * |                                 |     | 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                          |  80 | a..aaa  | AM, PM                            |       |
+		 * |                                 |     | aaaa    | a.m., p.m.                        | 2     |
+		 * |                                 |     | aaaaa   | a, p                              |       |
+		 * | AM, PM, noon, midnight          |  80 | b..bbb  | AM, PM, noon, midnight            |       |
+		 * |                                 |     | bbbb    | a.m., p.m., noon, midnight        | 2     |
+		 * |                                 |     | bbbbb   | a, p, n, mi                       |       |
+		 * | Flexible day period             |  80 | B..BBB  | at night, in the morning, ...     |       |
+		 * |                                 |     | BBBB    | at night, in the morning, ...     | 2     |
+		 * |                                 |     | BBBBB   | at night, in the morning, ...     |       |
+		 * | Hour [1-12]                     |  70 | h       | 1, 2, ..., 11, 12                 |       |
+		 * |                                 |     | ho      | 1st, 2nd, ..., 11th, 12th         | 5     |
+		 * |                                 |     | hh      | 01, 02, ..., 11, 12               |       |
+		 * | Hour [0-23]                     |  70 | H       | 0, 1, 2, ..., 23                  |       |
+		 * |                                 |     | Ho      | 0th, 1st, 2nd, ..., 23rd          | 5     |
+		 * |                                 |     | HH      | 00, 01, 02, ..., 23               |       |
+		 * | Hour [0-11]                     |  70 | K       | 1, 2, ..., 11, 0                  |       |
+		 * |                                 |     | Ko      | 1st, 2nd, ..., 11th, 0th          | 5     |
+		 * |                                 |     | KK      | 01, 02, ..., 11, 00               |       |
+		 * | Hour [1-24]                     |  70 | k       | 24, 1, 2, ..., 23                 |       |
+		 * |                                 |     | ko      | 24th, 1st, 2nd, ..., 23rd         | 5     |
+		 * |                                 |     | kk      | 24, 01, 02, ..., 23               |       |
+		 * | Minute                          |  60 | m       | 0, 1, ..., 59                     |       |
+		 * |                                 |     | mo      | 0th, 1st, ..., 59th               | 5     |
+		 * |                                 |     | mm      | 00, 01, ..., 59                   |       |
+		 * | Second                          |  50 | s       | 0, 1, ..., 59                     |       |
+		 * |                                 |     | so      | 0th, 1st, ..., 59th               | 5     |
+		 * |                                 |     | ss      | 00, 01, ..., 59                   |       |
+		 * | Seconds timestamp               |  40 | t       | 512969520                         |       |
+		 * |                                 |     | tt      | ...                               | 2     |
+		 * | Fraction of second              |  30 | S       | 0, 1, ..., 9                      |       |
+		 * |                                 |     | SS      | 00, 01, ..., 99                   |       |
+		 * |                                 |     | SSS     | 000, 001, ..., 999                |       |
+		 * |                                 |     | SSSS    | ...                               | 2     |
+		 * | Milliseconds timestamp          |  20 | T       | 512969520900                      |       |
+		 * |                                 |     | TT      | ...                               | 2     |
+		 * | Timezone (ISO-8601 w/ Z)        |  10 | 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)       |  10 | 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 |       |
+		 * | Long localized date             |  NA | P       | 05/29/1453                        | 5,8   |
+		 * |                                 |     | PP      | May 29, 1453                      |       |
+		 * |                                 |     | PPP     | May 29th, 1453                    |       |
+		 * |                                 |     | PPPP    | Sunday, May 29th, 1453            | 2,5,8 |
+		 * | Long localized time             |  NA | p       | 12:00 AM                          | 5,8   |
+		 * |                                 |     | pp      | 12:00:00 AM                       |       |
+		 * | Combination of date and time    |  NA | Pp      | 05/29/1453, 12:00 AM              |       |
+		 * |                                 |     | PPpp    | May 29, 1453, 12:00:00 AM         |       |
+		 * |                                 |     | PPPpp   | May 29th, 1453 at ...             |       |
+		 * |                                 |     | PPPPpp  | Sunday, May 29th, 1453 at ...     | 2,5,8 |
+		 * 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.
+		 *    In `format` function, they will produce different result:
+		 *
+		 *    `format(new Date(2017, 10, 6), 'do LLLL', {locale: cs}) //=> '6. listopad'`
+		 *
+		 *    `format(new Date(2017, 10, 6), 'do MMMM', {locale: cs}) //=> '6. listopadu'`
+		 *
+		 *    `parse` will try to match both formatting and stand-alone units interchangeably.
+		 *
+		 * 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:
+		 *    - for numerical units (`yyyyyyyy`) `parse` will try to match a number
+		 *      as wide as the sequence
+		 *    - for text units (`MMMMMMMM`) `parse` will try to match the widest variation of the unit.
+		 *      These variations are marked with "2" in the last column of the table.
+		 *
+		 * 3. `QQQQQ` and `qqqqq` could be not strictly numerical in some locales.
+		 *    These tokens represent the shortest form of the quarter.
+		 *
+		 * 4. 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` will try to guess the century of two digit year by proximity with `referenceDate`:
+		 *
+		 *    `parse('50', 'yy', new Date(2018, 0, 1)) //=> Sat Jan 01 2050 00:00:00`
+		 *
+		 *    `parse('75', 'yy', new Date(2018, 0, 1)) //=> Wed Jan 01 1975 00:00:00`
+		 *
+		 *    while `uu` will just assign the year as is:
+		 *
+		 *    `parse('50', 'uu', new Date(2018, 0, 1)) //=> Sat Jan 01 0050 00:00:00`
+		 *
+		 *    `parse('75', 'uu', new Date(2018, 0, 1)) //=> Tue Jan 01 0075 00:00:00`
+		 *
+		 *    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 [setISOWeekYear](https://date-fns.org/docs/setISOWeekYear)
+		 *    and [setWeekYear](https://date-fns.org/docs/setWeekYear)).
+		 *
+		 * 5. 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
+		 *    - `o`: ordinal number modifier
+		 *    - `P`: long localized date
+		 *    - `p`: long localized time
+		 *
+		 * 6. `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
+		 *
+		 * 7. `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
+		 *
+		 * 8. `P+` tokens do not have a defined priority since they are merely aliases to other tokens based
+		 *    on the given locale.
+		 *
+		 *    using `en-US` locale: `P` => `MM/dd/yyyy`
+		 *    using `en-US` locale: `p` => `hh:mm a`
+		 *    using `pt-BR` locale: `P` => `dd/MM/yyyy`
+		 *    using `pt-BR` locale: `p` => `HH:mm`
+		 *
+		 * Values will be assigned to the date in the descending order of its unit's priority.
+		 * Units of an equal priority overwrite each other in the order of appearance.
+		 *
+		 * If no values of higher priority are parsed (e.g. when parsing string 'January 1st' without a year),
+		 * the values will be taken from 3rd argument `referenceDate` which works as a context of parsing.
+		 *
+		 * `referenceDate` must be passed for correct work of the function.
+		 * If you're not sure which `referenceDate` to supply, create a new instance of Date:
+		 * `parse('02/11/2014', 'MM/dd/yyyy', new Date())`
+		 * In this case parsing will be done in the context of the current date.
+		 * If `referenceDate` is `Invalid Date` or a value not convertible to valid `Date`,
+		 * then `Invalid Date` will be returned.
+		 *
+		 * The result may vary by locale.
+		 *
+		 * If `formatString` matches with `dateString` but does not provides tokens, `referenceDate` will be returned.
+		 *
+		 * If parsing failed, `Invalid Date` will be returned.
+		 * Invalid Date is a Date, whose time value is NaN.
+		 * Time value of Date: http://es5.github.io/#x15.9.1.1
+		 *
+		 * @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 dateStr - The string to parse
+		 * @param formatStr - The string of tokens
+		 * @param referenceDate - defines values missing from the parsed dateString
+		 * @param options - An object with options.
+		 *   see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+		 *   see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
+		 *
+		 * @returns The parsed date
+		 *
+		 * @throws `options.locale` must contain `match` 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
+		 * // Parse 11 February 2014 from middle-endian format:
+		 * var result = parse('02/11/2014', 'MM/dd/yyyy', new Date())
+		 * //=> Tue Feb 11 2014 00:00:00
+		 *
+		 * @example
+		 * // Parse 28th of February in Esperanto locale in the context of 2010 year:
+		 * import eo from 'date-fns/locale/eo'
+		 * var result = parse('28-a de februaro', "do 'de' MMMM", new Date(2010, 0, 1), {
+		 *   locale: eo
+		 * })
+		 * //=> Sun Feb 28 2010 00:00:00
+		 */
+		function parse(dateStr, formatStr, referenceDate, options) {
+		  const invalidDate = () =>
+		    (0, _index4.constructFrom)(options?.in || referenceDate, NaN);
+		  const defaultOptions = (0, _index5.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;
+
+		  if (!formatStr)
+		    return dateStr
+		      ? invalidDate()
+		      : (0, _index6.toDate)(referenceDate, options?.in);
+
+		  const subFnOptions = {
+		    firstWeekContainsDate,
+		    weekStartsOn,
+		    locale,
+		  };
+
+		  // If timezone isn't specified, it will try to use the context or
+		  // the reference date and fallback to the system time zone.
+		  const setters = [new _Setter.DateTimezoneSetter(options?.in, referenceDate)];
+
+		  const tokens = formatStr
+		    .match(longFormattingTokensRegExp)
+		    .map((substring) => {
+		      const firstCharacter = substring[0];
+		      if (firstCharacter in _index2.longFormatters) {
+		        const longFormatter = _index2.longFormatters[firstCharacter];
+		        return longFormatter(substring, locale.formatLong);
+		      }
+		      return substring;
+		    })
+		    .join("")
+		    .match(formattingTokensRegExp);
+
+		  const usedTokens = [];
+
+		  for (let token of tokens) {
+		    if (
+		      !options?.useAdditionalWeekYearTokens &&
+		      (0, _index3.isProtectedWeekYearToken)(token)
+		    ) {
+		      (0, _index3.warnOrThrowProtectedError)(token, formatStr, dateStr);
+		    }
+		    if (
+		      !options?.useAdditionalDayOfYearTokens &&
+		      (0, _index3.isProtectedDayOfYearToken)(token)
+		    ) {
+		      (0, _index3.warnOrThrowProtectedError)(token, formatStr, dateStr);
+		    }
+
+		    const firstCharacter = token[0];
+		    const parser = _index7.parsers[firstCharacter];
+		    if (parser) {
+		      const { incompatibleTokens } = parser;
+		      if (Array.isArray(incompatibleTokens)) {
+		        const incompatibleToken = usedTokens.find(
+		          (usedToken) =>
+		            incompatibleTokens.includes(usedToken.token) ||
+		            usedToken.token === firstCharacter,
+		        );
+		        if (incompatibleToken) {
+		          throw new RangeError(
+		            `The format string mustn't contain \`${incompatibleToken.fullToken}\` and \`${token}\` at the same time`,
+		          );
+		        }
+		      } else if (parser.incompatibleTokens === "*" && usedTokens.length > 0) {
+		        throw new RangeError(
+		          `The format string mustn't contain \`${token}\` and any other token at the same time`,
+		        );
+		      }
+
+		      usedTokens.push({ token: firstCharacter, fullToken: token });
+
+		      const parseResult = parser.run(
+		        dateStr,
+		        token,
+		        locale.match,
+		        subFnOptions,
+		      );
+
+		      if (!parseResult) {
+		        return invalidDate();
+		      }
+
+		      setters.push(parseResult.setter);
+
+		      dateStr = parseResult.rest;
+		    } else {
+		      if (firstCharacter.match(unescapedLatinCharacterRegExp)) {
+		        throw new RangeError(
+		          "Format string contains an unescaped latin alphabet character `" +
+		            firstCharacter +
+		            "`",
+		        );
+		      }
+
+		      // Replace two single quote characters with one single quote character
+		      if (token === "''") {
+		        token = "'";
+		      } else if (firstCharacter === "'") {
+		        token = cleanEscapedString(token);
+		      }
+
+		      // Cut token from string, or, if string doesn't match the token, return Invalid Date
+		      if (dateStr.indexOf(token) === 0) {
+		        dateStr = dateStr.slice(token.length);
+		      } else {
+		        return invalidDate();
+		      }
+		    }
+		  }
+
+		  // Check if the remaining input contains something other than whitespace
+		  if (dateStr.length > 0 && notWhitespaceRegExp.test(dateStr)) {
+		    return invalidDate();
+		  }
+
+		  const uniquePrioritySetters = setters
+		    .map((setter) => setter.priority)
+		    .sort((a, b) => b - a)
+		    .filter((priority, index, array) => array.indexOf(priority) === index)
+		    .map((priority) =>
+		      setters
+		        .filter((setter) => setter.priority === priority)
+		        .sort((a, b) => b.subPriority - a.subPriority),
+		    )
+		    .map((setterArray) => setterArray[0]);
+
+		  let date = (0, _index6.toDate)(referenceDate, options?.in);
+
+		  if (isNaN(+date)) return invalidDate();
+
+		  const flags = {};
+		  for (const setter of uniquePrioritySetters) {
+		    if (!setter.validate(date, subFnOptions)) {
+		      return invalidDate();
+		    }
+
+		    const result = setter.set(date, flags, subFnOptions);
+		    // Result is tuple (date, flags)
+		    if (Array.isArray(result)) {
+		      date = result[0];
+		      Object.assign(flags, result[1]);
+		      // Result is date
+		    } else {
+		      date = result;
+		    }
+		  }
+
+		  return date;
+		}
+
+		function cleanEscapedString(input) {
+		  return input.match(escapedStringRegExp)[1].replace(doubleQuoteRegExp, "'");
+		} 
+	} (parse));
+	return parse;
+}
+
+var parseExports = /*@__PURE__*/ requireParse();
+
+var set = {};
+
+var hasRequiredSet;
+
+function requireSet () {
+	if (hasRequiredSet) return set;
+	hasRequiredSet = 1;
+	set.set = set$1;
+	var _index = /*@__PURE__*/ requireConstructFrom();
+	var _index2 = /*@__PURE__*/ requireSetMonth();
+	var _index3 = /*@__PURE__*/ requireToDate();
+
+	/**
+	 * The {@link set} function options.
+	 */
+
+	/**
+	 * @name set
+	 * @category Common Helpers
+	 * @summary Set date values to a given date.
+	 *
+	 * @description
+	 * Set date values to a given date.
+	 *
+	 * Sets time values to date from object `values`.
+	 * A value is not set if it is undefined or null or doesn't exist in `values`.
+	 *
+	 * Note about bundle size: `set` does not internally use `setX` functions from date-fns but instead opts
+	 * to use native `Date#setX` methods. If you use this function, you may not want to include the
+	 * other `setX` functions that date-fns provides if you are concerned about the bundle size.
+	 *
+	 * @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 values - The date values to be set
+	 * @param options - The options
+	 *
+	 * @returns The new date with options set
+	 *
+	 * @example
+	 * // Transform 1 September 2014 into 20 October 2015 in a single line:
+	 * const result = set(new Date(2014, 8, 20), { year: 2015, month: 9, date: 20 })
+	 * //=> Tue Oct 20 2015 00:00:00
+	 *
+	 * @example
+	 * // Set 12 PM to 1 September 2014 01:23:45 to 1 September 2014 12:00:00:
+	 * const result = set(new Date(2014, 8, 1, 1, 23, 45), { hours: 12 })
+	 * //=> Mon Sep 01 2014 12:23:45
+	 */
+	function set$1(date, values, options) {
+	  let _date = (0, _index3.toDate)(date, options?.in);
+
+	  // Check if date is Invalid Date because Date.prototype.setFullYear ignores the value of Invalid Date
+	  if (isNaN(+_date)) return (0, _index.constructFrom)(options?.in || date, NaN);
+
+	  if (values.year != null) _date.setFullYear(values.year);
+	  if (values.month != null) _date = (0, _index2.setMonth)(_date, values.month);
+	  if (values.date != null) _date.setDate(values.date);
+	  if (values.hours != null) _date.setHours(values.hours);
+	  if (values.minutes != null) _date.setMinutes(values.minutes);
+	  if (values.seconds != null) _date.setSeconds(values.seconds);
+	  if (values.milliseconds != null) _date.setMilliseconds(values.milliseconds);
+
+	  return _date;
+	}
+	return set;
+}
+
+var setExports = /*@__PURE__*/ requireSet();
+
+var toDateExports = /*@__PURE__*/ requireToDate();
+
+const SSR_MOMENT_ATTRIBUTE = 'data-br-ssr-moment';
+function serializeLocalDate(date) {
+    return [
+        date.getFullYear(),
+        date.getMonth(),
+        date.getDate(),
+        date.getHours(),
+        date.getMinutes(),
+        date.getSeconds(),
+        date.getMilliseconds(),
+    ].join('-');
+}
+function parseLocalDate(value) {
+    const parts = value.split('-').map(Number);
+    if (parts.length !== 7 || parts.some((part) => !Number.isFinite(part)))
+        return null;
+    const [year, month, day, hours, minutes, seconds, milliseconds] = parts;
+    const date = new Date(year, month, day, hours, minutes, seconds, milliseconds);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+/** Mantém defaults baseados no relógio idênticos entre SSR e hidratação. */
+function resolveSsrLocalDate(host, fallback) {
+    const hydrated = parseLocalDate(host.getAttribute(SSR_MOMENT_ATTRIBUTE) ?? '');
+    if (hydrated)
+        return hydrated;
+    if (!Number.isNaN(fallback.getTime()))
+        host.setAttribute(SSR_MOMENT_ATTRIBUTE, serializeLocalDate(fallback));
+    return fallback;
+}
+
+function warnInvalidPropValue(componentTag, propName, receivedValue, defaultValue) {
+    console.warn(`[${componentTag}]: valor invalido para "${propName}": "${String(receivedValue)}". Usando valor padrao "${defaultValue}".`);
+}
+
+var isValidExports = /*@__PURE__*/ requireIsValid();
+
+export { resolveSsrLocalDate as a, isSameDayExports as b, eachDayOfIntervalExports as e, isValidExports as i, parseExports as p, requireParse as r, setExports as s, toDateExports as t, warnInvalidPropValue as w };