ivt 0.4.7 → 0.4.9

package/dist/chunks/pt-BR-on-YW6Ay.mjs

@@ -0,0 +1,3275 @@
+import { c as createLucideIcon } from './createLucideIcon-DwD3HsEs.mjs';
+import { g as getDefaultOptions$1, t as toDate, c as constructFrom, m as millisecondsInHour, b as millisecondsInMinute, d as millisecondsInSecond, e as getWeekYear, s as startOfWeek, h as startOfISOWeek, i as getWeek, j as getISOWeek, k as addDays, l as getTimezoneOffsetInMilliseconds, n as enUS, o as longFormatters, p as isProtectedWeekYearToken, w as warnOrThrowProtectedError, q as isProtectedDayOfYearToken, r as isValid, u as buildFormatLongFn, v as buildLocalizeFn, x as buildMatchFn, y as buildMatchPatternFn } from './calendar-D98dWxWB.mjs';
+
+const __iconNode = [
+    [
+        "path",
+        {
+            d: "M8 2v4",
+            key: "1cmpym"
+        }
+    ],
+    [
+        "path",
+        {
+            d: "M16 2v4",
+            key: "4m81vk"
+        }
+    ],
+    [
+        "rect",
+        {
+            width: "18",
+            height: "18",
+            x: "3",
+            y: "4",
+            rx: "2",
+            key: "1hopcy"
+        }
+    ],
+    [
+        "path",
+        {
+            d: "M3 10h18",
+            key: "8toen8"
+        }
+    ],
+    [
+        "path",
+        {
+            d: "M8 14h.01",
+            key: "6423bh"
+        }
+    ],
+    [
+        "path",
+        {
+            d: "M12 14h.01",
+            key: "1etili"
+        }
+    ],
+    [
+        "path",
+        {
+            d: "M16 14h.01",
+            key: "1gbofw"
+        }
+    ],
+    [
+        "path",
+        {
+            d: "M8 18h.01",
+            key: "lrp35t"
+        }
+    ],
+    [
+        "path",
+        {
+            d: "M12 18h.01",
+            key: "mhygvu"
+        }
+    ],
+    [
+        "path",
+        {
+            d: "M16 18h.01",
+            key: "kzsmim"
+        }
+    ]
+];
+const CalendarDays = createLucideIcon("CalendarDays", __iconNode);
+
+/**
+ * @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() {
+    return Object.assign({}, getDefaultOptions$1());
+}
+
+/**
+ * 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(date, options) {
+    const day = toDate(date, options?.in).getDay();
+    return day === 0 ? 7 : day;
+}
+
+/**
+ * @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(date, constructor) {
+    const date_ = isConstructor(constructor) ? new constructor(0) : 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;
+}
+
+const TIMEZONE_UNIT_PRIORITY = 10;
+class Setter {
+    validate(_utcDate, _options) {
+        return true;
+    }
+    constructor(){
+        this.subPriority = 0;
+    }
+}
+class ValueSetter extends Setter {
+    validate(date, options) {
+        return this.validateValue(date, this.value, options);
+    }
+    set(date, flags, options) {
+        return this.setValue(date, flags, this.value, options);
+    }
+    constructor(value, validateValue, setValue, priority, subPriority){
+        super();
+        this.value = value;
+        this.validateValue = validateValue;
+        this.setValue = setValue;
+        this.priority = priority;
+        if (subPriority) {
+            this.subPriority = subPriority;
+        }
+    }
+}
+class DateTimezoneSetter extends Setter {
+    set(date, flags) {
+        if (flags.timestampIsSet) return date;
+        return constructFrom(date, transpose(date, this.context));
+    }
+    constructor(context, reference){
+        super(), this.priority = TIMEZONE_UNIT_PRIORITY, this.subPriority = -1;
+        this.context = context || ((date)=>constructFrom(reference, date));
+    }
+}
+
+class Parser {
+    run(dateString, token, match, options) {
+        const result = this.parse(dateString, token, match, options);
+        if (!result) {
+            return null;
+        }
+        return {
+            setter: new ValueSetter(result.value, this.validate, this.set, this.priority, this.subPriority),
+            rest: result.rest
+        };
+    }
+    validate(_utcDate, _value, _options) {
+        return true;
+    }
+}
+
+class EraParser extends Parser {
+    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;
+    }
+    constructor(...args){
+        super(...args), this.priority = 140, this.incompatibleTokens = [
+            "R",
+            "u",
+            "t",
+            "T"
+        ];
+    }
+}
+
+const numericPatterns = {
+    month: /^(1[0-2]|0?\d)/,
+    date: /^(3[0-1]|[0-2]?\d)/,
+    dayOfYear: /^(36[0-6]|3[0-5]\d|[0-2]?\d?\d)/,
+    week: /^(5[0-3]|[0-4]?\d)/,
+    hour23h: /^(2[0-3]|[0-1]?\d)/,
+    hour24h: /^(2[0-4]|[0-1]?\d)/,
+    hour11h: /^(1[0-1]|0?\d)/,
+    hour12h: /^(1[0-2]|0?\d)/,
+    minute: /^[0-5]?\d/,
+    second: /^[0-5]?\d/,
+    singleDigit: /^\d/,
+    twoDigits: /^\d{1,2}/,
+    threeDigits: /^\d{1,3}/,
+    fourDigits: /^\d{1,4}/,
+    anyDigitsSigned: /^-?\d+/,
+    singleDigitSigned: /^-?\d/,
+    twoDigitsSigned: /^-?\d{1,2}/,
+    threeDigitsSigned: /^-?\d{1,3}/,
+    fourDigitsSigned: /^-?\d{1,4}/
+};
+const 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/
+};
+
+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 * millisecondsInHour + minutes * millisecondsInMinute + seconds * millisecondsInSecond),
+        rest: dateString.slice(matchResult[0].length)
+    };
+}
+function parseAnyDigitsSigned(dateString) {
+    return parseNumericPattern(numericPatterns.anyDigitsSigned, dateString);
+}
+function parseNDigits(n, dateString) {
+    switch(n){
+        case 1:
+            return parseNumericPattern(numericPatterns.singleDigit, dateString);
+        case 2:
+            return parseNumericPattern(numericPatterns.twoDigits, dateString);
+        case 3:
+            return parseNumericPattern(numericPatterns.threeDigits, dateString);
+        case 4:
+            return parseNumericPattern(numericPatterns.fourDigits, dateString);
+        default:
+            return parseNumericPattern(new RegExp("^\\d{1," + n + "}"), dateString);
+    }
+}
+function parseNDigitsSigned(n, dateString) {
+    switch(n){
+        case 1:
+            return parseNumericPattern(numericPatterns.singleDigitSigned, dateString);
+        case 2:
+            return parseNumericPattern(numericPatterns.twoDigitsSigned, dateString);
+        case 3:
+            return parseNumericPattern(numericPatterns.threeDigitsSigned, dateString);
+        case 4:
+            return parseNumericPattern(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$1(year) {
+    return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
+}
+
+// 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 |
+class YearParser extends Parser {
+    parse(dateString, token, match) {
+        const valueCallback = (year)=>({
+                year,
+                isTwoDigitYear: token === "yy"
+            });
+        switch(token){
+            case "y":
+                return mapValue(parseNDigits(4, dateString), valueCallback);
+            case "yo":
+                return mapValue(match.ordinalNumber(dateString, {
+                    unit: "year"
+                }), valueCallback);
+            default:
+                return mapValue(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 = 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;
+    }
+    constructor(...args){
+        super(...args), this.priority = 130, this.incompatibleTokens = [
+            "Y",
+            "R",
+            "u",
+            "w",
+            "I",
+            "i",
+            "e",
+            "c",
+            "t",
+            "T"
+        ];
+    }
+}
+
+// Local week-numbering year
+class LocalWeekYearParser extends Parser {
+    parse(dateString, token, match) {
+        const valueCallback = (year)=>({
+                year,
+                isTwoDigitYear: token === "YY"
+            });
+        switch(token){
+            case "Y":
+                return mapValue(parseNDigits(4, dateString), valueCallback);
+            case "Yo":
+                return mapValue(match.ordinalNumber(dateString, {
+                    unit: "year"
+                }), valueCallback);
+            default:
+                return mapValue(parseNDigits(token.length, dateString), valueCallback);
+        }
+    }
+    validate(_date, value) {
+        return value.isTwoDigitYear || value.year > 0;
+    }
+    set(date, flags, value, options) {
+        const currentYear = getWeekYear(date, options);
+        if (value.isTwoDigitYear) {
+            const normalizedTwoDigitYear = normalizeTwoDigitYear(value.year, currentYear);
+            date.setFullYear(normalizedTwoDigitYear, 0, options.firstWeekContainsDate);
+            date.setHours(0, 0, 0, 0);
+            return 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 startOfWeek(date, options);
+    }
+    constructor(...args){
+        super(...args), this.priority = 130, this.incompatibleTokens = [
+            "y",
+            "R",
+            "u",
+            "Q",
+            "q",
+            "M",
+            "L",
+            "I",
+            "d",
+            "D",
+            "i",
+            "t",
+            "T"
+        ];
+    }
+}
+
+// ISO week-numbering year
+class ISOWeekYearParser extends Parser {
+    parse(dateString, token) {
+        if (token === "R") {
+            return parseNDigitsSigned(4, dateString);
+        }
+        return parseNDigitsSigned(token.length, dateString);
+    }
+    set(date, _flags, value) {
+        const firstWeekOfYear = constructFrom(date, 0);
+        firstWeekOfYear.setFullYear(value, 0, 4);
+        firstWeekOfYear.setHours(0, 0, 0, 0);
+        return startOfISOWeek(firstWeekOfYear);
+    }
+    constructor(...args){
+        super(...args), this.priority = 130, this.incompatibleTokens = [
+            "G",
+            "y",
+            "Y",
+            "u",
+            "Q",
+            "q",
+            "M",
+            "L",
+            "w",
+            "d",
+            "D",
+            "e",
+            "c",
+            "t",
+            "T"
+        ];
+    }
+}
+
+class ExtendedYearParser extends Parser {
+    parse(dateString, token) {
+        if (token === "u") {
+            return parseNDigitsSigned(4, dateString);
+        }
+        return parseNDigitsSigned(token.length, dateString);
+    }
+    set(date, _flags, value) {
+        date.setFullYear(value, 0, 1);
+        date.setHours(0, 0, 0, 0);
+        return date;
+    }
+    constructor(...args){
+        super(...args), this.priority = 130, this.incompatibleTokens = [
+            "G",
+            "y",
+            "Y",
+            "R",
+            "w",
+            "I",
+            "i",
+            "e",
+            "c",
+            "t",
+            "T"
+        ];
+    }
+}
+
+class QuarterParser extends Parser {
+    parse(dateString, token, match) {
+        switch(token){
+            // 1, 2, 3, 4
+            case "Q":
+            case "QQ":
+                return 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;
+    }
+    constructor(...args){
+        super(...args), this.priority = 120, this.incompatibleTokens = [
+            "Y",
+            "R",
+            "q",
+            "M",
+            "L",
+            "w",
+            "I",
+            "d",
+            "D",
+            "i",
+            "e",
+            "c",
+            "t",
+            "T"
+        ];
+    }
+}
+
+class StandAloneQuarterParser extends Parser {
+    parse(dateString, token, match) {
+        switch(token){
+            // 1, 2, 3, 4
+            case "q":
+            case "qq":
+                return 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;
+    }
+    constructor(...args){
+        super(...args), this.priority = 120, this.incompatibleTokens = [
+            "Y",
+            "R",
+            "Q",
+            "M",
+            "L",
+            "w",
+            "I",
+            "d",
+            "D",
+            "i",
+            "e",
+            "c",
+            "t",
+            "T"
+        ];
+    }
+}
+
+class MonthParser extends Parser {
+    parse(dateString, token, match) {
+        const valueCallback = (value)=>value - 1;
+        switch(token){
+            // 1, 2, ..., 12
+            case "M":
+                return mapValue(parseNumericPattern(numericPatterns.month, dateString), valueCallback);
+            // 01, 02, ..., 12
+            case "MM":
+                return mapValue(parseNDigits(2, dateString), valueCallback);
+            // 1st, 2nd, ..., 12th
+            case "Mo":
+                return 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;
+    }
+    constructor(...args){
+        super(...args), this.incompatibleTokens = [
+            "Y",
+            "R",
+            "q",
+            "Q",
+            "L",
+            "w",
+            "I",
+            "D",
+            "i",
+            "e",
+            "c",
+            "t",
+            "T"
+        ], this.priority = 110;
+    }
+}
+
+class StandAloneMonthParser extends Parser {
+    parse(dateString, token, match) {
+        const valueCallback = (value)=>value - 1;
+        switch(token){
+            // 1, 2, ..., 12
+            case "L":
+                return mapValue(parseNumericPattern(numericPatterns.month, dateString), valueCallback);
+            // 01, 02, ..., 12
+            case "LL":
+                return mapValue(parseNDigits(2, dateString), valueCallback);
+            // 1st, 2nd, ..., 12th
+            case "Lo":
+                return 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;
+    }
+    constructor(...args){
+        super(...args), this.priority = 110, this.incompatibleTokens = [
+            "Y",
+            "R",
+            "q",
+            "Q",
+            "M",
+            "w",
+            "I",
+            "D",
+            "i",
+            "e",
+            "c",
+            "t",
+            "T"
+        ];
+    }
+}
+
+/**
+ * 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(date, week, options) {
+    const date_ = toDate(date, options?.in);
+    const diff = getWeek(date_, options) - week;
+    date_.setDate(date_.getDate() - diff * 7);
+    return toDate(date_, options?.in);
+}
+
+// Local week of year
+class LocalWeekParser extends Parser {
+    parse(dateString, token, match) {
+        switch(token){
+            case "w":
+                return parseNumericPattern(numericPatterns.week, dateString);
+            case "wo":
+                return match.ordinalNumber(dateString, {
+                    unit: "week"
+                });
+            default:
+                return parseNDigits(token.length, dateString);
+        }
+    }
+    validate(_date, value) {
+        return value >= 1 && value <= 53;
+    }
+    set(date, _flags, value, options) {
+        return startOfWeek(setWeek(date, value, options), options);
+    }
+    constructor(...args){
+        super(...args), this.priority = 100, this.incompatibleTokens = [
+            "y",
+            "R",
+            "u",
+            "q",
+            "Q",
+            "M",
+            "L",
+            "I",
+            "d",
+            "D",
+            "i",
+            "t",
+            "T"
+        ];
+    }
+}
+
+/**
+ * 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(date, week, options) {
+    const _date = toDate(date, options?.in);
+    const diff = getISOWeek(_date, options) - week;
+    _date.setDate(_date.getDate() - diff * 7);
+    return _date;
+}
+
+// ISO week of year
+class ISOWeekParser extends Parser {
+    parse(dateString, token, match) {
+        switch(token){
+            case "I":
+                return parseNumericPattern(numericPatterns.week, dateString);
+            case "Io":
+                return match.ordinalNumber(dateString, {
+                    unit: "week"
+                });
+            default:
+                return parseNDigits(token.length, dateString);
+        }
+    }
+    validate(_date, value) {
+        return value >= 1 && value <= 53;
+    }
+    set(date, _flags, value) {
+        return startOfISOWeek(setISOWeek(date, value));
+    }
+    constructor(...args){
+        super(...args), this.priority = 100, this.incompatibleTokens = [
+            "y",
+            "Y",
+            "u",
+            "q",
+            "Q",
+            "M",
+            "L",
+            "w",
+            "d",
+            "D",
+            "e",
+            "c",
+            "t",
+            "T"
+        ];
+    }
+}
+
+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
+class DateParser extends Parser {
+    parse(dateString, token, match) {
+        switch(token){
+            case "d":
+                return parseNumericPattern(numericPatterns.date, dateString);
+            case "do":
+                return match.ordinalNumber(dateString, {
+                    unit: "date"
+                });
+            default:
+                return parseNDigits(token.length, dateString);
+        }
+    }
+    validate(date, value) {
+        const year = date.getFullYear();
+        const isLeapYear = isLeapYearIndex$1(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;
+    }
+    constructor(...args){
+        super(...args), this.priority = 90, this.subPriority = 1, this.incompatibleTokens = [
+            "Y",
+            "R",
+            "q",
+            "Q",
+            "w",
+            "I",
+            "D",
+            "i",
+            "e",
+            "c",
+            "t",
+            "T"
+        ];
+    }
+}
+
+class DayOfYearParser extends Parser {
+    parse(dateString, token, match) {
+        switch(token){
+            case "D":
+            case "DD":
+                return parseNumericPattern(numericPatterns.dayOfYear, dateString);
+            case "Do":
+                return match.ordinalNumber(dateString, {
+                    unit: "date"
+                });
+            default:
+                return parseNDigits(token.length, dateString);
+        }
+    }
+    validate(date, value) {
+        const year = date.getFullYear();
+        const isLeapYear = isLeapYearIndex$1(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;
+    }
+    constructor(...args){
+        super(...args), this.priority = 90, this.subpriority = 1, this.incompatibleTokens = [
+            "Y",
+            "R",
+            "q",
+            "Q",
+            "M",
+            "L",
+            "w",
+            "I",
+            "d",
+            "E",
+            "i",
+            "e",
+            "c",
+            "t",
+            "T"
+        ];
+    }
+}
+
+/**
+ * The {@link setDay} function options.
+ */ /**
+ * @name setDay
+ * @category Weekday Helpers
+ * @summary Set the day of the week to the given date.
+ *
+ * @description
+ * Set the day of the week to the given date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param date - The date to be changed
+ * @param day - The day of the week of the new date
+ * @param options - An object with options.
+ *
+ * @returns The new date with the day of the week set
+ *
+ * @example
+ * // Set week day to Sunday, with the default weekStartsOn of Sunday:
+ * const result = setDay(new Date(2014, 8, 1), 0)
+ * //=> Sun Aug 31 2014 00:00:00
+ *
+ * @example
+ * // Set week day to Sunday, with a weekStartsOn of Monday:
+ * const result = setDay(new Date(2014, 8, 1), 0, { weekStartsOn: 1 })
+ * //=> Sun Sep 07 2014 00:00:00
+ */ function setDay(date, day, options) {
+    const defaultOptions = getDefaultOptions$1();
+    const weekStartsOn = options?.weekStartsOn ?? options?.locale?.options?.weekStartsOn ?? defaultOptions.weekStartsOn ?? defaultOptions.locale?.options?.weekStartsOn ?? 0;
+    const date_ = toDate(date, options?.in);
+    const currentDay = date_.getDay();
+    const remainder = day % 7;
+    const dayIndex = (remainder + 7) % 7;
+    const delta = 7 - weekStartsOn;
+    const diff = day < 0 || day > 6 ? day - (currentDay + delta) % 7 : (dayIndex + delta) % 7 - (currentDay + delta) % 7;
+    return addDays(date_, diff, options);
+}
+
+// Day of week
+class DayParser extends Parser {
+    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 = setDay(date, value, options);
+        date.setHours(0, 0, 0, 0);
+        return date;
+    }
+    constructor(...args){
+        super(...args), this.priority = 90, this.incompatibleTokens = [
+            "D",
+            "i",
+            "e",
+            "c",
+            "t",
+            "T"
+        ];
+    }
+}
+
+// Local day of week
+class LocalDayParser extends Parser {
+    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":
+                return mapValue(parseNDigits(token.length, dateString), valueCallback);
+            // 3rd
+            case "eo":
+                return 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 = setDay(date, value, options);
+        date.setHours(0, 0, 0, 0);
+        return date;
+    }
+    constructor(...args){
+        super(...args), this.priority = 90, this.incompatibleTokens = [
+            "y",
+            "R",
+            "u",
+            "q",
+            "Q",
+            "M",
+            "L",
+            "I",
+            "d",
+            "D",
+            "E",
+            "i",
+            "c",
+            "t",
+            "T"
+        ];
+    }
+}
+
+// Stand-alone local day of week
+class StandAloneLocalDayParser extends Parser {
+    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":
+                return mapValue(parseNDigits(token.length, dateString), valueCallback);
+            // 3rd
+            case "co":
+                return 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 = setDay(date, value, options);
+        date.setHours(0, 0, 0, 0);
+        return date;
+    }
+    constructor(...args){
+        super(...args), this.priority = 90, this.incompatibleTokens = [
+            "y",
+            "R",
+            "u",
+            "q",
+            "Q",
+            "M",
+            "L",
+            "I",
+            "d",
+            "D",
+            "E",
+            "i",
+            "e",
+            "t",
+            "T"
+        ];
+    }
+}
+
+/**
+ * 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(date, day, options) {
+    const date_ = toDate(date, options?.in);
+    const currentDay = getISODay(date_, options);
+    const diff = day - currentDay;
+    return addDays(date_, diff, options);
+}
+
+// ISO day of week
+class ISODayParser extends Parser {
+    parse(dateString, token, match) {
+        const valueCallback = (value)=>{
+            if (value === 0) {
+                return 7;
+            }
+            return value;
+        };
+        switch(token){
+            // 2
+            case "i":
+            case "ii":
+                return parseNDigits(token.length, dateString);
+            // 2nd
+            case "io":
+                return match.ordinalNumber(dateString, {
+                    unit: "day"
+                });
+            // Tue
+            case "iii":
+                return 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 mapValue(match.day(dateString, {
+                    width: "narrow",
+                    context: "formatting"
+                }), valueCallback);
+            // Tu
+            case "iiiiii":
+                return mapValue(match.day(dateString, {
+                    width: "short",
+                    context: "formatting"
+                }) || match.day(dateString, {
+                    width: "narrow",
+                    context: "formatting"
+                }), valueCallback);
+            // Tuesday
+            case "iiii":
+            default:
+                return 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 = setISODay(date, value);
+        date.setHours(0, 0, 0, 0);
+        return date;
+    }
+    constructor(...args){
+        super(...args), this.priority = 90, this.incompatibleTokens = [
+            "y",
+            "Y",
+            "u",
+            "q",
+            "Q",
+            "M",
+            "L",
+            "w",
+            "d",
+            "D",
+            "E",
+            "e",
+            "c",
+            "t",
+            "T"
+        ];
+    }
+}
+
+class AMPMParser extends Parser {
+    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(dayPeriodEnumToHours(value), 0, 0, 0);
+        return date;
+    }
+    constructor(...args){
+        super(...args), this.priority = 80, this.incompatibleTokens = [
+            "b",
+            "B",
+            "H",
+            "k",
+            "t",
+            "T"
+        ];
+    }
+}
+
+class AMPMMidnightParser extends Parser {
+    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(dayPeriodEnumToHours(value), 0, 0, 0);
+        return date;
+    }
+    constructor(...args){
+        super(...args), this.priority = 80, this.incompatibleTokens = [
+            "a",
+            "B",
+            "H",
+            "k",
+            "t",
+            "T"
+        ];
+    }
+}
+
+// in the morning, in the afternoon, in the evening, at night
+class DayPeriodParser extends Parser {
+    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(dayPeriodEnumToHours(value), 0, 0, 0);
+        return date;
+    }
+    constructor(...args){
+        super(...args), this.priority = 80, this.incompatibleTokens = [
+            "a",
+            "b",
+            "t",
+            "T"
+        ];
+    }
+}
+
+class Hour1to12Parser extends Parser {
+    parse(dateString, token, match) {
+        switch(token){
+            case "h":
+                return parseNumericPattern(numericPatterns.hour12h, dateString);
+            case "ho":
+                return match.ordinalNumber(dateString, {
+                    unit: "hour"
+                });
+            default:
+                return 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;
+    }
+    constructor(...args){
+        super(...args), this.priority = 70, this.incompatibleTokens = [
+            "H",
+            "K",
+            "k",
+            "t",
+            "T"
+        ];
+    }
+}
+
+class Hour0to23Parser extends Parser {
+    parse(dateString, token, match) {
+        switch(token){
+            case "H":
+                return parseNumericPattern(numericPatterns.hour23h, dateString);
+            case "Ho":
+                return match.ordinalNumber(dateString, {
+                    unit: "hour"
+                });
+            default:
+                return parseNDigits(token.length, dateString);
+        }
+    }
+    validate(_date, value) {
+        return value >= 0 && value <= 23;
+    }
+    set(date, _flags, value) {
+        date.setHours(value, 0, 0, 0);
+        return date;
+    }
+    constructor(...args){
+        super(...args), this.priority = 70, this.incompatibleTokens = [
+            "a",
+            "b",
+            "h",
+            "K",
+            "k",
+            "t",
+            "T"
+        ];
+    }
+}
+
+class Hour0To11Parser extends Parser {
+    parse(dateString, token, match) {
+        switch(token){
+            case "K":
+                return parseNumericPattern(numericPatterns.hour11h, dateString);
+            case "Ko":
+                return match.ordinalNumber(dateString, {
+                    unit: "hour"
+                });
+            default:
+                return 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;
+    }
+    constructor(...args){
+        super(...args), this.priority = 70, this.incompatibleTokens = [
+            "h",
+            "H",
+            "k",
+            "t",
+            "T"
+        ];
+    }
+}
+
+class Hour1To24Parser extends Parser {
+    parse(dateString, token, match) {
+        switch(token){
+            case "k":
+                return parseNumericPattern(numericPatterns.hour24h, dateString);
+            case "ko":
+                return match.ordinalNumber(dateString, {
+                    unit: "hour"
+                });
+            default:
+                return 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;
+    }
+    constructor(...args){
+        super(...args), this.priority = 70, this.incompatibleTokens = [
+            "a",
+            "b",
+            "h",
+            "H",
+            "K",
+            "t",
+            "T"
+        ];
+    }
+}
+
+class MinuteParser extends Parser {
+    parse(dateString, token, match) {
+        switch(token){
+            case "m":
+                return parseNumericPattern(numericPatterns.minute, dateString);
+            case "mo":
+                return match.ordinalNumber(dateString, {
+                    unit: "minute"
+                });
+            default:
+                return parseNDigits(token.length, dateString);
+        }
+    }
+    validate(_date, value) {
+        return value >= 0 && value <= 59;
+    }
+    set(date, _flags, value) {
+        date.setMinutes(value, 0, 0);
+        return date;
+    }
+    constructor(...args){
+        super(...args), this.priority = 60, this.incompatibleTokens = [
+            "t",
+            "T"
+        ];
+    }
+}
+
+class SecondParser extends Parser {
+    parse(dateString, token, match) {
+        switch(token){
+            case "s":
+                return parseNumericPattern(numericPatterns.second, dateString);
+            case "so":
+                return match.ordinalNumber(dateString, {
+                    unit: "second"
+                });
+            default:
+                return parseNDigits(token.length, dateString);
+        }
+    }
+    validate(_date, value) {
+        return value >= 0 && value <= 59;
+    }
+    set(date, _flags, value) {
+        date.setSeconds(value, 0);
+        return date;
+    }
+    constructor(...args){
+        super(...args), this.priority = 50, this.incompatibleTokens = [
+            "t",
+            "T"
+        ];
+    }
+}
+
+class FractionOfSecondParser extends Parser {
+    parse(dateString, token) {
+        const valueCallback = (value)=>Math.trunc(value * Math.pow(10, -token.length + 3));
+        return mapValue(parseNDigits(token.length, dateString), valueCallback);
+    }
+    set(date, _flags, value) {
+        date.setMilliseconds(value);
+        return date;
+    }
+    constructor(...args){
+        super(...args), this.priority = 30, this.incompatibleTokens = [
+            "t",
+            "T"
+        ];
+    }
+}
+
+// Timezone (ISO-8601. +00:00 is `'Z'`)
+class ISOTimezoneWithZParser extends Parser {
+    parse(dateString, token) {
+        switch(token){
+            case "X":
+                return parseTimezonePattern(timezonePatterns.basicOptionalMinutes, dateString);
+            case "XX":
+                return parseTimezonePattern(timezonePatterns.basic, dateString);
+            case "XXXX":
+                return parseTimezonePattern(timezonePatterns.basicOptionalSeconds, dateString);
+            case "XXXXX":
+                return parseTimezonePattern(timezonePatterns.extendedOptionalSeconds, dateString);
+            case "XXX":
+            default:
+                return parseTimezonePattern(timezonePatterns.extended, dateString);
+        }
+    }
+    set(date, flags, value) {
+        if (flags.timestampIsSet) return date;
+        return constructFrom(date, date.getTime() - getTimezoneOffsetInMilliseconds(date) - value);
+    }
+    constructor(...args){
+        super(...args), this.priority = 10, this.incompatibleTokens = [
+            "t",
+            "T",
+            "x"
+        ];
+    }
+}
+
+// Timezone (ISO-8601)
+class ISOTimezoneParser extends Parser {
+    parse(dateString, token) {
+        switch(token){
+            case "x":
+                return parseTimezonePattern(timezonePatterns.basicOptionalMinutes, dateString);
+            case "xx":
+                return parseTimezonePattern(timezonePatterns.basic, dateString);
+            case "xxxx":
+                return parseTimezonePattern(timezonePatterns.basicOptionalSeconds, dateString);
+            case "xxxxx":
+                return parseTimezonePattern(timezonePatterns.extendedOptionalSeconds, dateString);
+            case "xxx":
+            default:
+                return parseTimezonePattern(timezonePatterns.extended, dateString);
+        }
+    }
+    set(date, flags, value) {
+        if (flags.timestampIsSet) return date;
+        return constructFrom(date, date.getTime() - getTimezoneOffsetInMilliseconds(date) - value);
+    }
+    constructor(...args){
+        super(...args), this.priority = 10, this.incompatibleTokens = [
+            "t",
+            "T",
+            "X"
+        ];
+    }
+}
+
+class TimestampSecondsParser extends Parser {
+    parse(dateString) {
+        return parseAnyDigitsSigned(dateString);
+    }
+    set(date, _flags, value) {
+        return [
+            constructFrom(date, value * 1000),
+            {
+                timestampIsSet: true
+            }
+        ];
+    }
+    constructor(...args){
+        super(...args), this.priority = 40, this.incompatibleTokens = "*";
+    }
+}
+
+class TimestampMillisecondsParser extends Parser {
+    parse(dateString) {
+        return parseAnyDigitsSigned(dateString);
+    }
+    set(date, _flags, value) {
+        return [
+            constructFrom(date, value),
+            {
+                timestampIsSet: true
+            }
+        ];
+    }
+    constructor(...args){
+        super(...args), this.priority = 20, this.incompatibleTokens = "*";
+    }
+}
+
+/*
+ * |     | 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.
+ */ const parsers = {
+    G: new EraParser(),
+    y: new YearParser(),
+    Y: new LocalWeekYearParser(),
+    R: new ISOWeekYearParser(),
+    u: new ExtendedYearParser(),
+    Q: new QuarterParser(),
+    q: new StandAloneQuarterParser(),
+    M: new MonthParser(),
+    L: new StandAloneMonthParser(),
+    w: new LocalWeekParser(),
+    I: new ISOWeekParser(),
+    d: new DateParser(),
+    D: new DayOfYearParser(),
+    E: new DayParser(),
+    e: new LocalDayParser(),
+    c: new StandAloneLocalDayParser(),
+    i: new ISODayParser(),
+    a: new AMPMParser(),
+    b: new AMPMMidnightParser(),
+    B: new DayPeriodParser(),
+    h: new Hour1to12Parser(),
+    H: new Hour0to23Parser(),
+    K: new Hour0To11Parser(),
+    k: new Hour1To24Parser(),
+    m: new MinuteParser(),
+    s: new SecondParser(),
+    S: new FractionOfSecondParser(),
+    X: new ISOTimezoneWithZParser(),
+    x: new ISOTimezoneParser(),
+    t: new TimestampSecondsParser(),
+    T: new TimestampMillisecondsParser()
+};
+
+/**
+ * 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 = ()=>constructFrom(referenceDate, NaN);
+    const defaultOptions = getDefaultOptions();
+    const locale = defaultOptions.locale ?? enUS;
+    const firstWeekContainsDate = defaultOptions.firstWeekContainsDate ?? defaultOptions.locale?.options?.firstWeekContainsDate ?? 1;
+    const weekStartsOn = defaultOptions.weekStartsOn ?? defaultOptions.locale?.options?.weekStartsOn ?? 0;
+    if (!formatStr) return dateStr ? invalidDate() : 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 DateTimezoneSetter(options?.in, referenceDate)
+    ];
+    const tokens = formatStr.match(longFormattingTokensRegExp).map((substring)=>{
+        const firstCharacter = substring[0];
+        if (firstCharacter in longFormatters) {
+            const longFormatter = longFormatters[firstCharacter];
+            return longFormatter(substring, locale.formatLong);
+        }
+        return substring;
+    }).join("").match(formattingTokensRegExp);
+    const usedTokens = [];
+    for (let token of tokens){
+        if (isProtectedWeekYearToken(token)) {
+            warnOrThrowProtectedError(token, formatStr, dateStr);
+        }
+        if (isProtectedDayOfYearToken(token)) {
+            warnOrThrowProtectedError(token, formatStr, dateStr);
+        }
+        const firstCharacter = token[0];
+        const parser = 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 = 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, "'");
+}
+
+/**
+ * The {@link parseISO} function options.
+ */ /**
+ * @name parseISO
+ * @category Common Helpers
+ * @summary Parse ISO string
+ *
+ * @description
+ * Parse the given string in ISO 8601 format and return an instance of Date.
+ *
+ * Function accepts complete ISO 8601 formats as well as partial implementations.
+ * ISO 8601: http://en.wikipedia.org/wiki/ISO_8601
+ *
+ * If the argument isn't a string, the function cannot parse the string or
+ * the values are invalid, it returns Invalid Date.
+ *
+ * @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
+ * @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
+ *
+ * @param argument - The value to convert
+ * @param options - An object with options
+ *
+ * @returns The parsed date in the local time zone
+ *
+ * @example
+ * // Convert string '2014-02-11T11:30:30' to date:
+ * const result = parseISO('2014-02-11T11:30:30')
+ * //=> Tue Feb 11 2014 11:30:30
+ *
+ * @example
+ * // Convert string '+02014101' to date,
+ * // if the additional number of digits in the extended year format is 1:
+ * const result = parseISO('+02014101', { additionalDigits: 1 })
+ * //=> Fri Apr 11 2014 00:00:00
+ */ function parseISO(argument, options) {
+    const invalidDate = ()=>constructFrom(options?.in, NaN);
+    const additionalDigits = 2;
+    const dateStrings = splitDateString(argument);
+    let date;
+    if (dateStrings.date) {
+        const parseYearResult = parseYear(dateStrings.date, additionalDigits);
+        date = parseDate(parseYearResult.restDateString, parseYearResult.year);
+    }
+    if (!date || isNaN(+date)) return invalidDate();
+    const timestamp = +date;
+    let time = 0;
+    let offset;
+    if (dateStrings.time) {
+        time = parseTime(dateStrings.time);
+        if (isNaN(time)) return invalidDate();
+    }
+    if (dateStrings.timezone) {
+        offset = parseTimezone(dateStrings.timezone);
+        if (isNaN(offset)) return invalidDate();
+    } else {
+        const tmpDate = new Date(timestamp + time);
+        const result = toDate(0, options?.in);
+        result.setFullYear(tmpDate.getUTCFullYear(), tmpDate.getUTCMonth(), tmpDate.getUTCDate());
+        result.setHours(tmpDate.getUTCHours(), tmpDate.getUTCMinutes(), tmpDate.getUTCSeconds(), tmpDate.getUTCMilliseconds());
+        return result;
+    }
+    return toDate(timestamp + time + offset, options?.in);
+}
+const patterns = {
+    dateTimeDelimiter: /[T ]/,
+    timeZoneDelimiter: /[Z ]/i,
+    timezone: /([Z+-].*)$/
+};
+const dateRegex = /^-?(?:(\d{3})|(\d{2})(?:-?(\d{2}))?|W(\d{2})(?:-?(\d{1}))?|)$/;
+const timeRegex = /^(\d{2}(?:[.,]\d*)?)(?::?(\d{2}(?:[.,]\d*)?))?(?::?(\d{2}(?:[.,]\d*)?))?$/;
+const timezoneRegex = /^([+-])(\d{2})(?::?(\d{2}))?$/;
+function splitDateString(dateString) {
+    const dateStrings = {};
+    const array = dateString.split(patterns.dateTimeDelimiter);
+    let timeString;
+    // The regex match should only return at maximum two array elements.
+    // [date], [time], or [date, time].
+    if (array.length > 2) {
+        return dateStrings;
+    }
+    if (/:/.test(array[0])) {
+        timeString = array[0];
+    } else {
+        dateStrings.date = array[0];
+        timeString = array[1];
+        if (patterns.timeZoneDelimiter.test(dateStrings.date)) {
+            dateStrings.date = dateString.split(patterns.timeZoneDelimiter)[0];
+            timeString = dateString.substr(dateStrings.date.length, dateString.length);
+        }
+    }
+    if (timeString) {
+        const token = patterns.timezone.exec(timeString);
+        if (token) {
+            dateStrings.time = timeString.replace(token[1], "");
+            dateStrings.timezone = token[1];
+        } else {
+            dateStrings.time = timeString;
+        }
+    }
+    return dateStrings;
+}
+function parseYear(dateString, additionalDigits) {
+    const regex = new RegExp("^(?:(\\d{4}|[+-]\\d{" + (4 + additionalDigits) + "})|(\\d{2}|[+-]\\d{" + (2 + additionalDigits) + "})$)");
+    const captures = dateString.match(regex);
+    // Invalid ISO-formatted year
+    if (!captures) return {
+        year: NaN,
+        restDateString: ""
+    };
+    const year = captures[1] ? parseInt(captures[1]) : null;
+    const century = captures[2] ? parseInt(captures[2]) : null;
+    // either year or century is null, not both
+    return {
+        year: century === null ? year : century * 100,
+        restDateString: dateString.slice((captures[1] || captures[2]).length)
+    };
+}
+function parseDate(dateString, year) {
+    // Invalid ISO-formatted year
+    if (year === null) return new Date(NaN);
+    const captures = dateString.match(dateRegex);
+    // Invalid ISO-formatted string
+    if (!captures) return new Date(NaN);
+    const isWeekDate = !!captures[4];
+    const dayOfYear = parseDateUnit(captures[1]);
+    const month = parseDateUnit(captures[2]) - 1;
+    const day = parseDateUnit(captures[3]);
+    const week = parseDateUnit(captures[4]);
+    const dayOfWeek = parseDateUnit(captures[5]) - 1;
+    if (isWeekDate) {
+        if (!validateWeekDate(year, week, dayOfWeek)) {
+            return new Date(NaN);
+        }
+        return dayOfISOWeekYear(year, week, dayOfWeek);
+    } else {
+        const date = new Date(0);
+        if (!validateDate(year, month, day) || !validateDayOfYearDate(year, dayOfYear)) {
+            return new Date(NaN);
+        }
+        date.setUTCFullYear(year, month, Math.max(dayOfYear, day));
+        return date;
+    }
+}
+function parseDateUnit(value) {
+    return value ? parseInt(value) : 1;
+}
+function parseTime(timeString) {
+    const captures = timeString.match(timeRegex);
+    if (!captures) return NaN; // Invalid ISO-formatted time
+    const hours = parseTimeUnit(captures[1]);
+    const minutes = parseTimeUnit(captures[2]);
+    const seconds = parseTimeUnit(captures[3]);
+    if (!validateTime(hours, minutes, seconds)) {
+        return NaN;
+    }
+    return hours * millisecondsInHour + minutes * millisecondsInMinute + seconds * 1000;
+}
+function parseTimeUnit(value) {
+    return value && parseFloat(value.replace(",", ".")) || 0;
+}
+function parseTimezone(timezoneString) {
+    if (timezoneString === "Z") return 0;
+    const captures = timezoneString.match(timezoneRegex);
+    if (!captures) return 0;
+    const sign = captures[1] === "+" ? -1 : 1;
+    const hours = parseInt(captures[2]);
+    const minutes = captures[3] && parseInt(captures[3]) || 0;
+    if (!validateTimezone(hours, minutes)) {
+        return NaN;
+    }
+    return sign * (hours * millisecondsInHour + minutes * millisecondsInMinute);
+}
+function dayOfISOWeekYear(isoWeekYear, week, day) {
+    const date = new Date(0);
+    date.setUTCFullYear(isoWeekYear, 0, 4);
+    const fourthOfJanuaryDay = date.getUTCDay() || 7;
+    const diff = (week - 1) * 7 + day + 1 - fourthOfJanuaryDay;
+    date.setUTCDate(date.getUTCDate() + diff);
+    return date;
+}
+// Validation functions
+// February is null to handle the leap year (using ||)
+const daysInMonths = [
+    31,
+    null,
+    31,
+    30,
+    31,
+    30,
+    31,
+    31,
+    30,
+    31,
+    30,
+    31
+];
+function isLeapYearIndex(year) {
+    return year % 400 === 0 || year % 4 === 0 && year % 100 !== 0;
+}
+function validateDate(year, month, date) {
+    return month >= 0 && month <= 11 && date >= 1 && date <= (daysInMonths[month] || (isLeapYearIndex(year) ? 29 : 28));
+}
+function validateDayOfYearDate(year, dayOfYear) {
+    return dayOfYear >= 1 && dayOfYear <= (isLeapYearIndex(year) ? 366 : 365);
+}
+function validateWeekDate(_year, week, day) {
+    return week >= 1 && week <= 53 && day >= 0 && day <= 6;
+}
+function validateTime(hours, minutes, seconds) {
+    if (hours === 24) {
+        return minutes === 0 && seconds === 0;
+    }
+    return seconds >= 0 && seconds < 60 && minutes >= 0 && minutes < 60 && hours >= 0 && hours < 25;
+}
+function validateTimezone(_hours, minutes) {
+    return minutes >= 0 && minutes <= 59;
+}
+
+function tryParseDate(value) {
+    if (!value) return undefined;
+    if (value instanceof Date) return isValid(value) ? value : undefined;
+    // 1) tenta ISO
+    const iso = parseISO(value);
+    if (isValid(iso)) return iso;
+    // 2) tenta dd/MM/yyyy
+    const dmy = parse(value, "dd/MM/yyyy", new Date());
+    if (isValid(dmy)) return dmy;
+    // 3) tenta d/M/yyyy (por segurança, cobre 4/9/2025 sem zero à esquerda)
+    const dmyLoose = parse(value, "d/M/yyyy", new Date());
+    if (isValid(dmyLoose)) return dmyLoose;
+    return undefined;
+}
+
+const formatDistanceLocale = {
+    lessThanXSeconds: {
+        one: "menos de um segundo",
+        other: "menos de {{count}} segundos"
+    },
+    xSeconds: {
+        one: "1 segundo",
+        other: "{{count}} segundos"
+    },
+    halfAMinute: "meio minuto",
+    lessThanXMinutes: {
+        one: "menos de um minuto",
+        other: "menos de {{count}} minutos"
+    },
+    xMinutes: {
+        one: "1 minuto",
+        other: "{{count}} minutos"
+    },
+    aboutXHours: {
+        one: "cerca de 1 hora",
+        other: "cerca de {{count}} horas"
+    },
+    xHours: {
+        one: "1 hora",
+        other: "{{count}} horas"
+    },
+    xDays: {
+        one: "1 dia",
+        other: "{{count}} dias"
+    },
+    aboutXWeeks: {
+        one: "cerca de 1 semana",
+        other: "cerca de {{count}} semanas"
+    },
+    xWeeks: {
+        one: "1 semana",
+        other: "{{count}} semanas"
+    },
+    aboutXMonths: {
+        one: "cerca de 1 mês",
+        other: "cerca de {{count}} meses"
+    },
+    xMonths: {
+        one: "1 mês",
+        other: "{{count}} meses"
+    },
+    aboutXYears: {
+        one: "cerca de 1 ano",
+        other: "cerca de {{count}} anos"
+    },
+    xYears: {
+        one: "1 ano",
+        other: "{{count}} anos"
+    },
+    overXYears: {
+        one: "mais de 1 ano",
+        other: "mais de {{count}} anos"
+    },
+    almostXYears: {
+        one: "quase 1 ano",
+        other: "quase {{count}} anos"
+    }
+};
+const formatDistance = (token, count, options)=>{
+    let result;
+    const tokenValue = formatDistanceLocale[token];
+    if (typeof tokenValue === "string") {
+        result = tokenValue;
+    } else if (count === 1) {
+        result = tokenValue.one;
+    } else {
+        result = tokenValue.other.replace("{{count}}", String(count));
+    }
+    if (options?.addSuffix) {
+        if (options.comparison && options.comparison > 0) {
+            return "em " + result;
+        } else {
+            return "há " + result;
+        }
+    }
+    return result;
+};
+
+const dateFormats = {
+    full: "EEEE, d 'de' MMMM 'de' y",
+    long: "d 'de' MMMM 'de' y",
+    medium: "d MMM y",
+    short: "dd/MM/yyyy"
+};
+const timeFormats = {
+    full: "HH:mm:ss zzzz",
+    long: "HH:mm:ss z",
+    medium: "HH:mm:ss",
+    short: "HH:mm"
+};
+const dateTimeFormats = {
+    full: "{{date}} 'às' {{time}}",
+    long: "{{date}} 'às' {{time}}",
+    medium: "{{date}}, {{time}}",
+    short: "{{date}}, {{time}}"
+};
+const formatLong = {
+    date: buildFormatLongFn({
+        formats: dateFormats,
+        defaultWidth: "full"
+    }),
+    time: buildFormatLongFn({
+        formats: timeFormats,
+        defaultWidth: "full"
+    }),
+    dateTime: buildFormatLongFn({
+        formats: dateTimeFormats,
+        defaultWidth: "full"
+    })
+};
+
+const formatRelativeLocale = {
+    lastWeek: (date)=>{
+        const weekday = date.getDay();
+        const last = weekday === 0 || weekday === 6 ? "último" : "última";
+        return "'" + last + "' eeee 'às' p";
+    },
+    yesterday: "'ontem às' p",
+    today: "'hoje às' p",
+    tomorrow: "'amanhã às' p",
+    nextWeek: "eeee 'às' p",
+    other: "P"
+};
+const formatRelative = (token, date, _baseDate, _options)=>{
+    const format = formatRelativeLocale[token];
+    if (typeof format === "function") {
+        return format(date);
+    }
+    return format;
+};
+
+const eraValues = {
+    narrow: [
+        "AC",
+        "DC"
+    ],
+    abbreviated: [
+        "AC",
+        "DC"
+    ],
+    wide: [
+        "antes de cristo",
+        "depois de cristo"
+    ]
+};
+const quarterValues = {
+    narrow: [
+        "1",
+        "2",
+        "3",
+        "4"
+    ],
+    abbreviated: [
+        "T1",
+        "T2",
+        "T3",
+        "T4"
+    ],
+    wide: [
+        "1º trimestre",
+        "2º trimestre",
+        "3º trimestre",
+        "4º trimestre"
+    ]
+};
+const monthValues = {
+    narrow: [
+        "j",
+        "f",
+        "m",
+        "a",
+        "m",
+        "j",
+        "j",
+        "a",
+        "s",
+        "o",
+        "n",
+        "d"
+    ],
+    abbreviated: [
+        "jan",
+        "fev",
+        "mar",
+        "abr",
+        "mai",
+        "jun",
+        "jul",
+        "ago",
+        "set",
+        "out",
+        "nov",
+        "dez"
+    ],
+    wide: [
+        "janeiro",
+        "fevereiro",
+        "março",
+        "abril",
+        "maio",
+        "junho",
+        "julho",
+        "agosto",
+        "setembro",
+        "outubro",
+        "novembro",
+        "dezembro"
+    ]
+};
+const dayValues = {
+    narrow: [
+        "D",
+        "S",
+        "T",
+        "Q",
+        "Q",
+        "S",
+        "S"
+    ],
+    short: [
+        "dom",
+        "seg",
+        "ter",
+        "qua",
+        "qui",
+        "sex",
+        "sab"
+    ],
+    abbreviated: [
+        "domingo",
+        "segunda",
+        "terça",
+        "quarta",
+        "quinta",
+        "sexta",
+        "sábado"
+    ],
+    wide: [
+        "domingo",
+        "segunda-feira",
+        "terça-feira",
+        "quarta-feira",
+        "quinta-feira",
+        "sexta-feira",
+        "sábado"
+    ]
+};
+const dayPeriodValues = {
+    narrow: {
+        am: "a",
+        pm: "p",
+        midnight: "mn",
+        noon: "md",
+        morning: "manhã",
+        afternoon: "tarde",
+        evening: "tarde",
+        night: "noite"
+    },
+    abbreviated: {
+        am: "AM",
+        pm: "PM",
+        midnight: "meia-noite",
+        noon: "meio-dia",
+        morning: "manhã",
+        afternoon: "tarde",
+        evening: "tarde",
+        night: "noite"
+    },
+    wide: {
+        am: "a.m.",
+        pm: "p.m.",
+        midnight: "meia-noite",
+        noon: "meio-dia",
+        morning: "manhã",
+        afternoon: "tarde",
+        evening: "tarde",
+        night: "noite"
+    }
+};
+const formattingDayPeriodValues = {
+    narrow: {
+        am: "a",
+        pm: "p",
+        midnight: "mn",
+        noon: "md",
+        morning: "da manhã",
+        afternoon: "da tarde",
+        evening: "da tarde",
+        night: "da noite"
+    },
+    abbreviated: {
+        am: "AM",
+        pm: "PM",
+        midnight: "meia-noite",
+        noon: "meio-dia",
+        morning: "da manhã",
+        afternoon: "da tarde",
+        evening: "da tarde",
+        night: "da noite"
+    },
+    wide: {
+        am: "a.m.",
+        pm: "p.m.",
+        midnight: "meia-noite",
+        noon: "meio-dia",
+        morning: "da manhã",
+        afternoon: "da tarde",
+        evening: "da tarde",
+        night: "da noite"
+    }
+};
+const ordinalNumber = (dirtyNumber, options)=>{
+    const number = Number(dirtyNumber);
+    if (options?.unit === "week") {
+        return number + "ª";
+    }
+    return number + "º";
+};
+const localize = {
+    ordinalNumber,
+    era: buildLocalizeFn({
+        values: eraValues,
+        defaultWidth: "wide"
+    }),
+    quarter: buildLocalizeFn({
+        values: quarterValues,
+        defaultWidth: "wide",
+        argumentCallback: (quarter)=>quarter - 1
+    }),
+    month: buildLocalizeFn({
+        values: monthValues,
+        defaultWidth: "wide"
+    }),
+    day: buildLocalizeFn({
+        values: dayValues,
+        defaultWidth: "wide"
+    }),
+    dayPeriod: buildLocalizeFn({
+        values: dayPeriodValues,
+        defaultWidth: "wide",
+        formattingValues: formattingDayPeriodValues,
+        defaultFormattingWidth: "wide"
+    })
+};
+
+const matchOrdinalNumberPattern = /^(\d+)[ºªo]?/i;
+const parseOrdinalNumberPattern = /\d+/i;
+const matchEraPatterns = {
+    narrow: /^(ac|dc|a|d)/i,
+    abbreviated: /^(a\.?\s?c\.?|d\.?\s?c\.?)/i,
+    wide: /^(antes de cristo|depois de cristo)/i
+};
+const parseEraPatterns = {
+    any: [
+        /^ac/i,
+        /^dc/i
+    ],
+    wide: [
+        /^antes de cristo/i,
+        /^depois de cristo/i
+    ]
+};
+const matchQuarterPatterns = {
+    narrow: /^[1234]/i,
+    abbreviated: /^T[1234]/i,
+    wide: /^[1234](º)? trimestre/i
+};
+const parseQuarterPatterns = {
+    any: [
+        /1/i,
+        /2/i,
+        /3/i,
+        /4/i
+    ]
+};
+const matchMonthPatterns = {
+    narrow: /^[jfmajsond]/i,
+    abbreviated: /^(jan|fev|mar|abr|mai|jun|jul|ago|set|out|nov|dez)/i,
+    wide: /^(janeiro|fevereiro|março|abril|maio|junho|julho|agosto|setembro|outubro|novembro|dezembro)/i
+};
+const parseMonthPatterns = {
+    narrow: [
+        /^j/i,
+        /^f/i,
+        /^m/i,
+        /^a/i,
+        /^m/i,
+        /^j/i,
+        /^j/i,
+        /^a/i,
+        /^s/i,
+        /^o/i,
+        /^n/i,
+        /^d/i
+    ],
+    any: [
+        /^ja/i,
+        /^fev/i,
+        /^mar/i,
+        /^abr/i,
+        /^mai/i,
+        /^jun/i,
+        /^jul/i,
+        /^ago/i,
+        /^set/i,
+        /^out/i,
+        /^nov/i,
+        /^dez/i
+    ]
+};
+const matchDayPatterns = {
+    narrow: /^(dom|[23456]ª?|s[aá]b)/i,
+    short: /^(dom|[23456]ª?|s[aá]b)/i,
+    abbreviated: /^(dom|seg|ter|qua|qui|sex|s[aá]b)/i,
+    wide: /^(domingo|(segunda|ter[cç]a|quarta|quinta|sexta)([- ]feira)?|s[aá]bado)/i
+};
+const parseDayPatterns = {
+    short: [
+        /^d/i,
+        /^2/i,
+        /^3/i,
+        /^4/i,
+        /^5/i,
+        /^6/i,
+        /^s[aá]/i
+    ],
+    narrow: [
+        /^d/i,
+        /^2/i,
+        /^3/i,
+        /^4/i,
+        /^5/i,
+        /^6/i,
+        /^s[aá]/i
+    ],
+    any: [
+        /^d/i,
+        /^seg/i,
+        /^t/i,
+        /^qua/i,
+        /^qui/i,
+        /^sex/i,
+        /^s[aá]b/i
+    ]
+};
+const matchDayPeriodPatterns = {
+    narrow: /^(a|p|mn|md|(da) (manhã|tarde|noite))/i,
+    any: /^([ap]\.?\s?m\.?|meia[-\s]noite|meio[-\s]dia|(da) (manhã|tarde|noite))/i
+};
+const parseDayPeriodPatterns = {
+    any: {
+        am: /^a/i,
+        pm: /^p/i,
+        midnight: /^mn|^meia[-\s]noite/i,
+        noon: /^md|^meio[-\s]dia/i,
+        morning: /manhã/i,
+        afternoon: /tarde/i,
+        evening: /tarde/i,
+        night: /noite/i
+    }
+};
+const match = {
+    ordinalNumber: buildMatchPatternFn({
+        matchPattern: matchOrdinalNumberPattern,
+        parsePattern: parseOrdinalNumberPattern,
+        valueCallback: (value)=>parseInt(value, 10)
+    }),
+    era: buildMatchFn({
+        matchPatterns: matchEraPatterns,
+        defaultMatchWidth: "wide",
+        parsePatterns: parseEraPatterns,
+        defaultParseWidth: "any"
+    }),
+    quarter: buildMatchFn({
+        matchPatterns: matchQuarterPatterns,
+        defaultMatchWidth: "wide",
+        parsePatterns: parseQuarterPatterns,
+        defaultParseWidth: "any",
+        valueCallback: (index)=>index + 1
+    }),
+    month: buildMatchFn({
+        matchPatterns: matchMonthPatterns,
+        defaultMatchWidth: "wide",
+        parsePatterns: parseMonthPatterns,
+        defaultParseWidth: "any"
+    }),
+    day: buildMatchFn({
+        matchPatterns: matchDayPatterns,
+        defaultMatchWidth: "wide",
+        parsePatterns: parseDayPatterns,
+        defaultParseWidth: "any"
+    }),
+    dayPeriod: buildMatchFn({
+        matchPatterns: matchDayPeriodPatterns,
+        defaultMatchWidth: "any",
+        parsePatterns: parseDayPeriodPatterns,
+        defaultParseWidth: "any"
+    })
+};
+
+/**
+ * @category Locales
+ * @summary Portuguese locale (Brazil).
+ * @language Portuguese
+ * @iso-639-2 por
+ * @author Lucas Duailibe [@duailibe](https://github.com/duailibe)
+ * @author Yago Carballo [@yagocarballo](https://github.com/YagoCarballo)
+ */ const ptBR = {
+    code: "pt-BR",
+    formatDistance: formatDistance,
+    formatLong: formatLong,
+    formatRelative: formatRelative,
+    localize: localize,
+    match: match,
+    options: {
+        weekStartsOn: 0 /* Sunday */ ,
+        firstWeekContainsDate: 1
+    }
+};
+
+export { CalendarDays as C, ptBR as p, tryParseDate as t };
+//# sourceMappingURL=pt-BR-on-YW6Ay.mjs.map