main repo

node_modules/date-fns/parse/_lib/parsers/AMPMMidnightParser.d.mts

@@ -0,0 +1,17 @@
+import type { LocaleDayPeriod, Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class AMPMMidnightParser extends Parser<LocaleDayPeriod> {
+  priority: number;
+  parse(
+    dateString: string,
+    token: string,
+    match: Match,
+  ): ParseResult<LocaleDayPeriod>;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: LocaleDayPeriod,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/AMPMMidnightParser.d.ts

@@ -0,0 +1,17 @@
+import type { LocaleDayPeriod, Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class AMPMMidnightParser extends Parser<LocaleDayPeriod> {
+  priority: number;
+  parse(
+    dateString: string,
+    token: string,
+    match: Match,
+  ): ParseResult<LocaleDayPeriod>;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: LocaleDayPeriod,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/AMPMMidnightParser.js

@@ -0,0 +1,57 @@
+"use strict";
+exports.AMPMMidnightParser = void 0;
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+class AMPMMidnightParser extends _Parser.Parser {
+  priority = 80;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "b":
+      case "bb":
+      case "bbb":
+        return (
+          match.dayPeriod(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "narrow",
+            context: "formatting",
+          })
+        );
+
+      case "bbbbb":
+        return match.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "bbbb":
+      default:
+        return (
+          match.dayPeriod(dateString, {
+            width: "wide",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "narrow",
+            context: "formatting",
+          })
+        );
+    }
+  }
+
+  set(date, _flags, value) {
+    date.setHours((0, _utils.dayPeriodEnumToHours)(value), 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["a", "B", "H", "k", "t", "T"];
+}
+exports.AMPMMidnightParser = AMPMMidnightParser;

node_modules/date-fns/parse/_lib/parsers/AMPMMidnightParser.mjs

@@ -0,0 +1,53 @@
+import { Parser } from "../Parser.mjs";
+import { dayPeriodEnumToHours } from "../utils.mjs";
+
+export class AMPMMidnightParser extends Parser {
+  priority = 80;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "b":
+      case "bb":
+      case "bbb":
+        return (
+          match.dayPeriod(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "narrow",
+            context: "formatting",
+          })
+        );
+
+      case "bbbbb":
+        return match.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "bbbb":
+      default:
+        return (
+          match.dayPeriod(dateString, {
+            width: "wide",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "narrow",
+            context: "formatting",
+          })
+        );
+    }
+  }
+
+  set(date, _flags, value) {
+    date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["a", "B", "H", "k", "t", "T"];
+}

node_modules/date-fns/parse/_lib/parsers/AMPMParser.d.mts

@@ -0,0 +1,17 @@
+import type { LocaleDayPeriod, Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class AMPMParser extends Parser<LocaleDayPeriod> {
+  priority: number;
+  parse(
+    dateString: string,
+    token: string,
+    match: Match,
+  ): ParseResult<LocaleDayPeriod>;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: LocaleDayPeriod,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/AMPMParser.d.ts

@@ -0,0 +1,17 @@
+import type { LocaleDayPeriod, Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class AMPMParser extends Parser<LocaleDayPeriod> {
+  priority: number;
+  parse(
+    dateString: string,
+    token: string,
+    match: Match,
+  ): ParseResult<LocaleDayPeriod>;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: LocaleDayPeriod,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/AMPMParser.js

@@ -0,0 +1,57 @@
+"use strict";
+exports.AMPMParser = void 0;
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+class AMPMParser extends _Parser.Parser {
+  priority = 80;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "a":
+      case "aa":
+      case "aaa":
+        return (
+          match.dayPeriod(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "narrow",
+            context: "formatting",
+          })
+        );
+
+      case "aaaaa":
+        return match.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "aaaa":
+      default:
+        return (
+          match.dayPeriod(dateString, {
+            width: "wide",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "narrow",
+            context: "formatting",
+          })
+        );
+    }
+  }
+
+  set(date, _flags, value) {
+    date.setHours((0, _utils.dayPeriodEnumToHours)(value), 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["b", "B", "H", "k", "t", "T"];
+}
+exports.AMPMParser = AMPMParser;

node_modules/date-fns/parse/_lib/parsers/AMPMParser.mjs

@@ -0,0 +1,53 @@
+import { Parser } from "../Parser.mjs";
+import { dayPeriodEnumToHours } from "../utils.mjs";
+
+export class AMPMParser extends Parser {
+  priority = 80;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "a":
+      case "aa":
+      case "aaa":
+        return (
+          match.dayPeriod(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "narrow",
+            context: "formatting",
+          })
+        );
+
+      case "aaaaa":
+        return match.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "aaaa":
+      default:
+        return (
+          match.dayPeriod(dateString, {
+            width: "wide",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "narrow",
+            context: "formatting",
+          })
+        );
+    }
+  }
+
+  set(date, _flags, value) {
+    date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["b", "B", "H", "k", "t", "T"];
+}

node_modules/date-fns/parse/_lib/parsers/DateParser.d.mts

@@ -0,0 +1,15 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class DateParser extends Parser<number> {
+  priority: number;
+  subPriority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/DateParser.d.ts

@@ -0,0 +1,15 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class DateParser extends Parser<number> {
+  priority: number;
+  subPriority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/DateParser.js

@@ -0,0 +1,64 @@
+"use strict";
+exports.DateParser = void 0;
+var _constants = require("../constants.js");
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+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.Parser {
+  priority = 90;
+  subPriority = 1;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "d":
+        return (0, _utils.parseNumericPattern)(
+          _constants.numericPatterns.date,
+          dateString,
+        );
+      case "do":
+        return match.ordinalNumber(dateString, { unit: "date" });
+      default:
+        return (0, _utils.parseNDigits)(token.length, dateString);
+    }
+  }
+
+  validate(date, value) {
+    const year = date.getFullYear();
+    const isLeapYear = (0, _utils.isLeapYearIndex)(year);
+    const month = date.getMonth();
+    if (isLeapYear) {
+      return value >= 1 && value <= DAYS_IN_MONTH_LEAP_YEAR[month];
+    } else {
+      return value >= 1 && value <= DAYS_IN_MONTH[month];
+    }
+  }
+
+  set(date, _flags, value) {
+    date.setDate(value);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "w",
+    "I",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T",
+  ];
+}
+exports.DateParser = DateParser;

node_modules/date-fns/parse/_lib/parsers/DateParser.mjs

@@ -0,0 +1,61 @@
+import { numericPatterns } from "../constants.mjs";
+import { Parser } from "../Parser.mjs";
+import {
+  isLeapYearIndex,
+  parseNDigits,
+  parseNumericPattern,
+} from "../utils.mjs";
+
+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
+export class DateParser extends Parser {
+  priority = 90;
+  subPriority = 1;
+
+  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(year);
+    const month = date.getMonth();
+    if (isLeapYear) {
+      return value >= 1 && value <= DAYS_IN_MONTH_LEAP_YEAR[month];
+    } else {
+      return value >= 1 && value <= DAYS_IN_MONTH[month];
+    }
+  }
+
+  set(date, _flags, value) {
+    date.setDate(value);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "w",
+    "I",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T",
+  ];
+}

node_modules/date-fns/parse/_lib/parsers/DayOfYearParser.d.mts

@@ -0,0 +1,15 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class DayOfYearParser extends Parser<number> {
+  priority: number;
+  subpriority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/DayOfYearParser.d.ts

@@ -0,0 +1,15 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class DayOfYearParser extends Parser<number> {
+  priority: number;
+  subpriority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/DayOfYearParser.js

@@ -0,0 +1,62 @@
+"use strict";
+exports.DayOfYearParser = void 0;
+var _constants = require("../constants.js");
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+class DayOfYearParser extends _Parser.Parser {
+  priority = 90;
+
+  subpriority = 1;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "D":
+      case "DD":
+        return (0, _utils.parseNumericPattern)(
+          _constants.numericPatterns.dayOfYear,
+          dateString,
+        );
+      case "Do":
+        return match.ordinalNumber(dateString, { unit: "date" });
+      default:
+        return (0, _utils.parseNDigits)(token.length, dateString);
+    }
+  }
+
+  validate(date, value) {
+    const year = date.getFullYear();
+    const isLeapYear = (0, _utils.isLeapYearIndex)(year);
+    if (isLeapYear) {
+      return value >= 1 && value <= 366;
+    } else {
+      return value >= 1 && value <= 365;
+    }
+  }
+
+  set(date, _flags, value) {
+    date.setMonth(0, value);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "I",
+    "d",
+    "E",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T",
+  ];
+}
+exports.DayOfYearParser = DayOfYearParser;

node_modules/date-fns/parse/_lib/parsers/DayOfYearParser.mjs

@@ -0,0 +1,59 @@
+import { numericPatterns } from "../constants.mjs";
+import { Parser } from "../Parser.mjs";
+import {
+  isLeapYearIndex,
+  parseNDigits,
+  parseNumericPattern,
+} from "../utils.mjs";
+
+export class DayOfYearParser extends Parser {
+  priority = 90;
+
+  subpriority = 1;
+
+  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(year);
+    if (isLeapYear) {
+      return value >= 1 && value <= 366;
+    } else {
+      return value >= 1 && value <= 365;
+    }
+  }
+
+  set(date, _flags, value) {
+    date.setMonth(0, value);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "I",
+    "d",
+    "E",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T",
+  ];
+}

node_modules/date-fns/parse/_lib/parsers/DayParser.d.mts

@@ -0,0 +1,15 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult, ParserOptions } from "../types.js";
+export declare class DayParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+    options: ParserOptions,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/DayParser.d.ts

@@ -0,0 +1,15 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult, ParserOptions } from "../types.js";
+export declare class DayParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+    options: ParserOptions,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/DayParser.js

@@ -0,0 +1,65 @@
+"use strict";
+exports.DayParser = void 0;
+var _index = require("../../../setDay.js");
+var _Parser = require("../Parser.js");
+
+// Day of week
+class DayParser extends _Parser.Parser {
+  priority = 90;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      // Tue
+      case "E":
+      case "EE":
+      case "EEE":
+        return (
+          match.day(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.day(dateString, { width: "short", context: "formatting" }) ||
+          match.day(dateString, { width: "narrow", context: "formatting" })
+        );
+
+      // T
+      case "EEEEE":
+        return match.day(dateString, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // Tu
+      case "EEEEEE":
+        return (
+          match.day(dateString, { width: "short", context: "formatting" }) ||
+          match.day(dateString, { width: "narrow", context: "formatting" })
+        );
+
+      // Tuesday
+      case "EEEE":
+      default:
+        return (
+          match.day(dateString, { width: "wide", context: "formatting" }) ||
+          match.day(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.day(dateString, { width: "short", context: "formatting" }) ||
+          match.day(dateString, { width: "narrow", context: "formatting" })
+        );
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 6;
+  }
+
+  set(date, _flags, value, options) {
+    date = (0, _index.setDay)(date, value, options);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["D", "i", "e", "c", "t", "T"];
+}
+exports.DayParser = DayParser;

node_modules/date-fns/parse/_lib/parsers/DayParser.mjs

@@ -0,0 +1,62 @@
+import { setDay } from "../../../setDay.mjs";
+import { Parser } from "../Parser.mjs";
+
+// Day of week
+export class DayParser extends Parser {
+  priority = 90;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      // Tue
+      case "E":
+      case "EE":
+      case "EEE":
+        return (
+          match.day(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.day(dateString, { width: "short", context: "formatting" }) ||
+          match.day(dateString, { width: "narrow", context: "formatting" })
+        );
+
+      // T
+      case "EEEEE":
+        return match.day(dateString, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // Tu
+      case "EEEEEE":
+        return (
+          match.day(dateString, { width: "short", context: "formatting" }) ||
+          match.day(dateString, { width: "narrow", context: "formatting" })
+        );
+
+      // Tuesday
+      case "EEEE":
+      default:
+        return (
+          match.day(dateString, { width: "wide", context: "formatting" }) ||
+          match.day(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.day(dateString, { width: "short", context: "formatting" }) ||
+          match.day(dateString, { width: "narrow", context: "formatting" })
+        );
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 6;
+  }
+
+  set(date, _flags, value, options) {
+    date = setDay(date, value, options);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["D", "i", "e", "c", "t", "T"];
+}

node_modules/date-fns/parse/_lib/parsers/DayPeriodParser.d.mts

@@ -0,0 +1,17 @@
+import type { LocaleDayPeriod, Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class DayPeriodParser extends Parser<LocaleDayPeriod> {
+  priority: number;
+  parse(
+    dateString: string,
+    token: string,
+    match: Match,
+  ): ParseResult<LocaleDayPeriod>;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: LocaleDayPeriod,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/DayPeriodParser.d.ts

@@ -0,0 +1,17 @@
+import type { LocaleDayPeriod, Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class DayPeriodParser extends Parser<LocaleDayPeriod> {
+  priority: number;
+  parse(
+    dateString: string,
+    token: string,
+    match: Match,
+  ): ParseResult<LocaleDayPeriod>;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: LocaleDayPeriod,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/DayPeriodParser.js

@@ -0,0 +1,58 @@
+"use strict";
+exports.DayPeriodParser = void 0;
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+// in the morning, in the afternoon, in the evening, at night
+class DayPeriodParser extends _Parser.Parser {
+  priority = 80;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "B":
+      case "BB":
+      case "BBB":
+        return (
+          match.dayPeriod(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "narrow",
+            context: "formatting",
+          })
+        );
+
+      case "BBBBB":
+        return match.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "BBBB":
+      default:
+        return (
+          match.dayPeriod(dateString, {
+            width: "wide",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "narrow",
+            context: "formatting",
+          })
+        );
+    }
+  }
+
+  set(date, _flags, value) {
+    date.setHours((0, _utils.dayPeriodEnumToHours)(value), 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["a", "b", "t", "T"];
+}
+exports.DayPeriodParser = DayPeriodParser;

node_modules/date-fns/parse/_lib/parsers/DayPeriodParser.mjs

@@ -0,0 +1,54 @@
+import { Parser } from "../Parser.mjs";
+import { dayPeriodEnumToHours } from "../utils.mjs";
+
+// in the morning, in the afternoon, in the evening, at night
+export class DayPeriodParser extends Parser {
+  priority = 80;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "B":
+      case "BB":
+      case "BBB":
+        return (
+          match.dayPeriod(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "narrow",
+            context: "formatting",
+          })
+        );
+
+      case "BBBBB":
+        return match.dayPeriod(dateString, {
+          width: "narrow",
+          context: "formatting",
+        });
+      case "BBBB":
+      default:
+        return (
+          match.dayPeriod(dateString, {
+            width: "wide",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.dayPeriod(dateString, {
+            width: "narrow",
+            context: "formatting",
+          })
+        );
+    }
+  }
+
+  set(date, _flags, value) {
+    date.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["a", "b", "t", "T"];
+}

node_modules/date-fns/parse/_lib/parsers/EraParser.d.mts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import type { Era } from "../../../types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class EraParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<Era>;
+  set<DateType extends Date>(
+    date: DateType,
+    flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/EraParser.d.ts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import type { Era } from "../../../types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class EraParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<Era>;
+  set<DateType extends Date>(
+    date: DateType,
+    flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/EraParser.js

@@ -0,0 +1,43 @@
+"use strict";
+exports.EraParser = void 0;
+
+var _Parser = require("../Parser.js");
+
+class EraParser extends _Parser.Parser {
+  priority = 140;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      // AD, BC
+      case "G":
+      case "GG":
+      case "GGG":
+        return (
+          match.era(dateString, { width: "abbreviated" }) ||
+          match.era(dateString, { width: "narrow" })
+        );
+
+      // A, B
+      case "GGGGG":
+        return match.era(dateString, { width: "narrow" });
+      // Anno Domini, Before Christ
+      case "GGGG":
+      default:
+        return (
+          match.era(dateString, { width: "wide" }) ||
+          match.era(dateString, { width: "abbreviated" }) ||
+          match.era(dateString, { width: "narrow" })
+        );
+    }
+  }
+
+  set(date, flags, value) {
+    flags.era = value;
+    date.setFullYear(value, 0, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["R", "u", "t", "T"];
+}
+exports.EraParser = EraParser;

node_modules/date-fns/parse/_lib/parsers/EraParser.mjs

@@ -0,0 +1,39 @@
+import { Parser } from "../Parser.mjs";
+
+export class EraParser extends Parser {
+  priority = 140;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      // AD, BC
+      case "G":
+      case "GG":
+      case "GGG":
+        return (
+          match.era(dateString, { width: "abbreviated" }) ||
+          match.era(dateString, { width: "narrow" })
+        );
+
+      // A, B
+      case "GGGGG":
+        return match.era(dateString, { width: "narrow" });
+      // Anno Domini, Before Christ
+      case "GGGG":
+      default:
+        return (
+          match.era(dateString, { width: "wide" }) ||
+          match.era(dateString, { width: "abbreviated" }) ||
+          match.era(dateString, { width: "narrow" })
+        );
+    }
+  }
+
+  set(date, flags, value) {
+    flags.era = value;
+    date.setFullYear(value, 0, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["R", "u", "t", "T"];
+}

node_modules/date-fns/parse/_lib/parsers/ExtendedYearParser.d.mts

@@ -0,0 +1,12 @@
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class ExtendedYearParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string): ParseResult<number>;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/ExtendedYearParser.d.ts

@@ -0,0 +1,12 @@
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class ExtendedYearParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string): ParseResult<number>;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/ExtendedYearParser.js

@@ -0,0 +1,26 @@
+"use strict";
+exports.ExtendedYearParser = void 0;
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+class ExtendedYearParser extends _Parser.Parser {
+  priority = 130;
+
+  parse(dateString, token) {
+    if (token === "u") {
+      return (0, _utils.parseNDigitsSigned)(4, dateString);
+    }
+
+    return (0, _utils.parseNDigitsSigned)(token.length, dateString);
+  }
+
+  set(date, _flags, value) {
+    date.setFullYear(value, 0, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["G", "y", "Y", "R", "w", "I", "i", "e", "c", "t", "T"];
+}
+exports.ExtendedYearParser = ExtendedYearParser;

node_modules/date-fns/parse/_lib/parsers/ExtendedYearParser.mjs

@@ -0,0 +1,22 @@
+import { Parser } from "../Parser.mjs";
+import { parseNDigitsSigned } from "../utils.mjs";
+
+export class ExtendedYearParser extends Parser {
+  priority = 130;
+
+  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;
+  }
+
+  incompatibleTokens = ["G", "y", "Y", "R", "w", "I", "i", "e", "c", "t", "T"];
+}

node_modules/date-fns/parse/_lib/parsers/FractionOfSecondParser.d.mts

@@ -0,0 +1,12 @@
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class FractionOfSecondParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string): ParseResult<number>;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/FractionOfSecondParser.d.ts

@@ -0,0 +1,12 @@
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class FractionOfSecondParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string): ParseResult<number>;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/FractionOfSecondParser.js

@@ -0,0 +1,26 @@
+"use strict";
+exports.FractionOfSecondParser = void 0;
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+class FractionOfSecondParser extends _Parser.Parser {
+  priority = 30;
+
+  parse(dateString, token) {
+    const valueCallback = (value) =>
+      Math.trunc(value * Math.pow(10, -token.length + 3));
+    return (0, _utils.mapValue)(
+      (0, _utils.parseNDigits)(token.length, dateString),
+      valueCallback,
+    );
+  }
+
+  set(date, _flags, value) {
+    date.setMilliseconds(value);
+    return date;
+  }
+
+  incompatibleTokens = ["t", "T"];
+}
+exports.FractionOfSecondParser = FractionOfSecondParser;

node_modules/date-fns/parse/_lib/parsers/FractionOfSecondParser.mjs

@@ -0,0 +1,19 @@
+import { Parser } from "../Parser.mjs";
+import { mapValue, parseNDigits } from "../utils.mjs";
+
+export class FractionOfSecondParser extends Parser {
+  priority = 30;
+
+  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;
+  }
+
+  incompatibleTokens = ["t", "T"];
+}

node_modules/date-fns/parse/_lib/parsers/Hour0To11Parser.d.mts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class Hour0To11Parser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/Hour0To11Parser.d.ts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class Hour0To11Parser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/Hour0To11Parser.js

@@ -0,0 +1,41 @@
+"use strict";
+exports.Hour0To11Parser = void 0;
+var _constants = require("../constants.js");
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+class Hour0To11Parser extends _Parser.Parser {
+  priority = 70;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "K":
+        return (0, _utils.parseNumericPattern)(
+          _constants.numericPatterns.hour11h,
+          dateString,
+        );
+      case "Ko":
+        return match.ordinalNumber(dateString, { unit: "hour" });
+      default:
+        return (0, _utils.parseNDigits)(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 11;
+  }
+
+  set(date, _flags, value) {
+    const isPM = date.getHours() >= 12;
+    if (isPM && value < 12) {
+      date.setHours(value + 12, 0, 0, 0);
+    } else {
+      date.setHours(value, 0, 0, 0);
+    }
+    return date;
+  }
+
+  incompatibleTokens = ["h", "H", "k", "t", "T"];
+}
+exports.Hour0To11Parser = Hour0To11Parser;

node_modules/date-fns/parse/_lib/parsers/Hour0To11Parser.mjs

@@ -0,0 +1,34 @@
+import { numericPatterns } from "../constants.mjs";
+import { Parser } from "../Parser.mjs";
+import { parseNDigits, parseNumericPattern } from "../utils.mjs";
+
+export class Hour0To11Parser extends Parser {
+  priority = 70;
+
+  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;
+  }
+
+  incompatibleTokens = ["h", "H", "k", "t", "T"];
+}

node_modules/date-fns/parse/_lib/parsers/Hour0to23Parser.d.mts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class Hour0to23Parser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/Hour0to23Parser.d.ts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class Hour0to23Parser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/Hour0to23Parser.js

@@ -0,0 +1,36 @@
+"use strict";
+exports.Hour0to23Parser = void 0;
+var _constants = require("../constants.js");
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+class Hour0to23Parser extends _Parser.Parser {
+  priority = 70;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "H":
+        return (0, _utils.parseNumericPattern)(
+          _constants.numericPatterns.hour23h,
+          dateString,
+        );
+      case "Ho":
+        return match.ordinalNumber(dateString, { unit: "hour" });
+      default:
+        return (0, _utils.parseNDigits)(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 23;
+  }
+
+  set(date, _flags, value) {
+    date.setHours(value, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["a", "b", "h", "K", "k", "t", "T"];
+}
+exports.Hour0to23Parser = Hour0to23Parser;

node_modules/date-fns/parse/_lib/parsers/Hour0to23Parser.mjs

@@ -0,0 +1,29 @@
+import { numericPatterns } from "../constants.mjs";
+import { Parser } from "../Parser.mjs";
+import { parseNDigits, parseNumericPattern } from "../utils.mjs";
+
+export class Hour0to23Parser extends Parser {
+  priority = 70;
+
+  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;
+  }
+
+  incompatibleTokens = ["a", "b", "h", "K", "k", "t", "T"];
+}

node_modules/date-fns/parse/_lib/parsers/Hour1To24Parser.d.mts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class Hour1To24Parser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/Hour1To24Parser.d.ts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class Hour1To24Parser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/Hour1To24Parser.js

@@ -0,0 +1,37 @@
+"use strict";
+exports.Hour1To24Parser = void 0;
+var _constants = require("../constants.js");
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+class Hour1To24Parser extends _Parser.Parser {
+  priority = 70;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "k":
+        return (0, _utils.parseNumericPattern)(
+          _constants.numericPatterns.hour24h,
+          dateString,
+        );
+      case "ko":
+        return match.ordinalNumber(dateString, { unit: "hour" });
+      default:
+        return (0, _utils.parseNDigits)(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 1 && value <= 24;
+  }
+
+  set(date, _flags, value) {
+    const hours = value <= 24 ? value % 24 : value;
+    date.setHours(hours, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["a", "b", "h", "H", "K", "t", "T"];
+}
+exports.Hour1To24Parser = Hour1To24Parser;

node_modules/date-fns/parse/_lib/parsers/Hour1To24Parser.mjs

@@ -0,0 +1,30 @@
+import { numericPatterns } from "../constants.mjs";
+import { Parser } from "../Parser.mjs";
+import { parseNDigits, parseNumericPattern } from "../utils.mjs";
+
+export class Hour1To24Parser extends Parser {
+  priority = 70;
+
+  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;
+  }
+
+  incompatibleTokens = ["a", "b", "h", "H", "K", "t", "T"];
+}

node_modules/date-fns/parse/_lib/parsers/Hour1to12Parser.d.mts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class Hour1to12Parser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/Hour1to12Parser.d.ts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class Hour1to12Parser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/Hour1to12Parser.js

@@ -0,0 +1,43 @@
+"use strict";
+exports.Hour1to12Parser = void 0;
+var _constants = require("../constants.js");
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+class Hour1to12Parser extends _Parser.Parser {
+  priority = 70;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "h":
+        return (0, _utils.parseNumericPattern)(
+          _constants.numericPatterns.hour12h,
+          dateString,
+        );
+      case "ho":
+        return match.ordinalNumber(dateString, { unit: "hour" });
+      default:
+        return (0, _utils.parseNDigits)(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 1 && value <= 12;
+  }
+
+  set(date, _flags, value) {
+    const isPM = date.getHours() >= 12;
+    if (isPM && value < 12) {
+      date.setHours(value + 12, 0, 0, 0);
+    } else if (!isPM && value === 12) {
+      date.setHours(0, 0, 0, 0);
+    } else {
+      date.setHours(value, 0, 0, 0);
+    }
+    return date;
+  }
+
+  incompatibleTokens = ["H", "K", "k", "t", "T"];
+}
+exports.Hour1to12Parser = Hour1to12Parser;

node_modules/date-fns/parse/_lib/parsers/Hour1to12Parser.mjs

@@ -0,0 +1,36 @@
+import { numericPatterns } from "../constants.mjs";
+import { Parser } from "../Parser.mjs";
+import { parseNDigits, parseNumericPattern } from "../utils.mjs";
+
+export class Hour1to12Parser extends Parser {
+  priority = 70;
+
+  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;
+  }
+
+  incompatibleTokens = ["H", "K", "k", "t", "T"];
+}

node_modules/date-fns/parse/_lib/parsers/ISODayParser.d.mts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class ISODayParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/ISODayParser.d.ts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class ISODayParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/ISODayParser.js

@@ -0,0 +1,120 @@
+"use strict";
+exports.ISODayParser = void 0;
+var _index = require("../../../setISODay.js");
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+// ISO day of week
+class ISODayParser extends _Parser.Parser {
+  priority = 90;
+
+  parse(dateString, token, match) {
+    const valueCallback = (value) => {
+      if (value === 0) {
+        return 7;
+      }
+      return value;
+    };
+
+    switch (token) {
+      // 2
+      case "i":
+      case "ii": // 02
+        return (0, _utils.parseNDigits)(token.length, dateString);
+      // 2nd
+      case "io":
+        return match.ordinalNumber(dateString, { unit: "day" });
+      // Tue
+      case "iii":
+        return (0, _utils.mapValue)(
+          match.day(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+            match.day(dateString, {
+              width: "short",
+              context: "formatting",
+            }) ||
+            match.day(dateString, {
+              width: "narrow",
+              context: "formatting",
+            }),
+          valueCallback,
+        );
+      // T
+      case "iiiii":
+        return (0, _utils.mapValue)(
+          match.day(dateString, {
+            width: "narrow",
+            context: "formatting",
+          }),
+          valueCallback,
+        );
+      // Tu
+      case "iiiiii":
+        return (0, _utils.mapValue)(
+          match.day(dateString, {
+            width: "short",
+            context: "formatting",
+          }) ||
+            match.day(dateString, {
+              width: "narrow",
+              context: "formatting",
+            }),
+          valueCallback,
+        );
+      // Tuesday
+      case "iiii":
+      default:
+        return (0, _utils.mapValue)(
+          match.day(dateString, {
+            width: "wide",
+            context: "formatting",
+          }) ||
+            match.day(dateString, {
+              width: "abbreviated",
+              context: "formatting",
+            }) ||
+            match.day(dateString, {
+              width: "short",
+              context: "formatting",
+            }) ||
+            match.day(dateString, {
+              width: "narrow",
+              context: "formatting",
+            }),
+          valueCallback,
+        );
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 1 && value <= 7;
+  }
+
+  set(date, _flags, value) {
+    date = (0, _index.setISODay)(date, value);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = [
+    "y",
+    "Y",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "E",
+    "e",
+    "c",
+    "t",
+    "T",
+  ];
+}
+exports.ISODayParser = ISODayParser;

node_modules/date-fns/parse/_lib/parsers/ISODayParser.mjs

@@ -0,0 +1,116 @@
+import { setISODay } from "../../../setISODay.mjs";
+import { Parser } from "../Parser.mjs";
+import { mapValue, parseNDigits } from "../utils.mjs";
+
+// ISO day of week
+export class ISODayParser extends Parser {
+  priority = 90;
+
+  parse(dateString, token, match) {
+    const valueCallback = (value) => {
+      if (value === 0) {
+        return 7;
+      }
+      return value;
+    };
+
+    switch (token) {
+      // 2
+      case "i":
+      case "ii": // 02
+        return 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;
+  }
+
+  incompatibleTokens = [
+    "y",
+    "Y",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "E",
+    "e",
+    "c",
+    "t",
+    "T",
+  ];
+}

node_modules/date-fns/parse/_lib/parsers/ISOTimezoneParser.d.mts

@@ -0,0 +1,12 @@
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class ISOTimezoneParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string): ParseResult<number>;
+  set<DateType extends Date>(
+    date: DateType,
+    flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/ISOTimezoneParser.d.ts

@@ -0,0 +1,12 @@
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class ISOTimezoneParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string): ParseResult<number>;
+  set<DateType extends Date>(
+    date: DateType,
+    flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/ISOTimezoneParser.js

@@ -0,0 +1,57 @@
+"use strict";
+exports.ISOTimezoneParser = void 0;
+var _index = require("../../../constructFrom.js");
+var _index2 = require("../../../_lib/getTimezoneOffsetInMilliseconds.js");
+var _constants = require("../constants.js");
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+// Timezone (ISO-8601)
+class ISOTimezoneParser extends _Parser.Parser {
+  priority = 10;
+
+  parse(dateString, token) {
+    switch (token) {
+      case "x":
+        return (0, _utils.parseTimezonePattern)(
+          _constants.timezonePatterns.basicOptionalMinutes,
+          dateString,
+        );
+      case "xx":
+        return (0, _utils.parseTimezonePattern)(
+          _constants.timezonePatterns.basic,
+          dateString,
+        );
+      case "xxxx":
+        return (0, _utils.parseTimezonePattern)(
+          _constants.timezonePatterns.basicOptionalSeconds,
+          dateString,
+        );
+      case "xxxxx":
+        return (0, _utils.parseTimezonePattern)(
+          _constants.timezonePatterns.extendedOptionalSeconds,
+          dateString,
+        );
+      case "xxx":
+      default:
+        return (0, _utils.parseTimezonePattern)(
+          _constants.timezonePatterns.extended,
+          dateString,
+        );
+    }
+  }
+
+  set(date, flags, value) {
+    if (flags.timestampIsSet) return date;
+    return (0, _index.constructFrom)(
+      date,
+      date.getTime() -
+        (0, _index2.getTimezoneOffsetInMilliseconds)(date) -
+        value,
+    );
+  }
+
+  incompatibleTokens = ["t", "T", "X"];
+}
+exports.ISOTimezoneParser = ISOTimezoneParser;

node_modules/date-fns/parse/_lib/parsers/ISOTimezoneParser.mjs

@@ -0,0 +1,45 @@
+import { constructFrom } from "../../../constructFrom.mjs";
+import { getTimezoneOffsetInMilliseconds } from "../../../_lib/getTimezoneOffsetInMilliseconds.mjs";
+import { timezonePatterns } from "../constants.mjs";
+import { Parser } from "../Parser.mjs";
+import { parseTimezonePattern } from "../utils.mjs";
+
+// Timezone (ISO-8601)
+export class ISOTimezoneParser extends Parser {
+  priority = 10;
+
+  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,
+    );
+  }
+
+  incompatibleTokens = ["t", "T", "X"];
+}

node_modules/date-fns/parse/_lib/parsers/ISOTimezoneWithZParser.d.mts

@@ -0,0 +1,12 @@
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class ISOTimezoneWithZParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string): ParseResult<number>;
+  set<DateType extends Date>(
+    date: DateType,
+    flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/ISOTimezoneWithZParser.d.ts

@@ -0,0 +1,12 @@
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class ISOTimezoneWithZParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string): ParseResult<number>;
+  set<DateType extends Date>(
+    date: DateType,
+    flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/ISOTimezoneWithZParser.js

@@ -0,0 +1,57 @@
+"use strict";
+exports.ISOTimezoneWithZParser = void 0;
+var _index = require("../../../constructFrom.js");
+var _index2 = require("../../../_lib/getTimezoneOffsetInMilliseconds.js");
+var _constants = require("../constants.js");
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+// Timezone (ISO-8601. +00:00 is `'Z'`)
+class ISOTimezoneWithZParser extends _Parser.Parser {
+  priority = 10;
+
+  parse(dateString, token) {
+    switch (token) {
+      case "X":
+        return (0, _utils.parseTimezonePattern)(
+          _constants.timezonePatterns.basicOptionalMinutes,
+          dateString,
+        );
+      case "XX":
+        return (0, _utils.parseTimezonePattern)(
+          _constants.timezonePatterns.basic,
+          dateString,
+        );
+      case "XXXX":
+        return (0, _utils.parseTimezonePattern)(
+          _constants.timezonePatterns.basicOptionalSeconds,
+          dateString,
+        );
+      case "XXXXX":
+        return (0, _utils.parseTimezonePattern)(
+          _constants.timezonePatterns.extendedOptionalSeconds,
+          dateString,
+        );
+      case "XXX":
+      default:
+        return (0, _utils.parseTimezonePattern)(
+          _constants.timezonePatterns.extended,
+          dateString,
+        );
+    }
+  }
+
+  set(date, flags, value) {
+    if (flags.timestampIsSet) return date;
+    return (0, _index.constructFrom)(
+      date,
+      date.getTime() -
+        (0, _index2.getTimezoneOffsetInMilliseconds)(date) -
+        value,
+    );
+  }
+
+  incompatibleTokens = ["t", "T", "x"];
+}
+exports.ISOTimezoneWithZParser = ISOTimezoneWithZParser;

node_modules/date-fns/parse/_lib/parsers/ISOTimezoneWithZParser.mjs

@@ -0,0 +1,45 @@
+import { constructFrom } from "../../../constructFrom.mjs";
+import { getTimezoneOffsetInMilliseconds } from "../../../_lib/getTimezoneOffsetInMilliseconds.mjs";
+import { timezonePatterns } from "../constants.mjs";
+import { Parser } from "../Parser.mjs";
+import { parseTimezonePattern } from "../utils.mjs";
+
+// Timezone (ISO-8601. +00:00 is `'Z'`)
+export class ISOTimezoneWithZParser extends Parser {
+  priority = 10;
+
+  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,
+    );
+  }
+
+  incompatibleTokens = ["t", "T", "x"];
+}

node_modules/date-fns/parse/_lib/parsers/ISOWeekParser.d.mts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class ISOWeekParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/ISOWeekParser.d.ts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class ISOWeekParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/ISOWeekParser.js

@@ -0,0 +1,53 @@
+"use strict";
+exports.ISOWeekParser = void 0;
+var _index = require("../../../setISOWeek.js");
+var _index2 = require("../../../startOfISOWeek.js");
+var _constants = require("../constants.js");
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+// ISO week of year
+class ISOWeekParser extends _Parser.Parser {
+  priority = 100;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "I":
+        return (0, _utils.parseNumericPattern)(
+          _constants.numericPatterns.week,
+          dateString,
+        );
+      case "Io":
+        return match.ordinalNumber(dateString, { unit: "week" });
+      default:
+        return (0, _utils.parseNDigits)(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 1 && value <= 53;
+  }
+
+  set(date, _flags, value) {
+    return (0, _index2.startOfISOWeek)((0, _index.setISOWeek)(date, value));
+  }
+
+  incompatibleTokens = [
+    "y",
+    "Y",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "e",
+    "c",
+    "t",
+    "T",
+  ];
+}
+exports.ISOWeekParser = ISOWeekParser;

node_modules/date-fns/parse/_lib/parsers/ISOWeekParser.mjs

@@ -0,0 +1,46 @@
+import { setISOWeek } from "../../../setISOWeek.mjs";
+import { startOfISOWeek } from "../../../startOfISOWeek.mjs";
+import { numericPatterns } from "../constants.mjs";
+import { Parser } from "../Parser.mjs";
+import { parseNDigits, parseNumericPattern } from "../utils.mjs";
+
+// ISO week of year
+export class ISOWeekParser extends Parser {
+  priority = 100;
+
+  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));
+  }
+
+  incompatibleTokens = [
+    "y",
+    "Y",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "e",
+    "c",
+    "t",
+    "T",
+  ];
+}

node_modules/date-fns/parse/_lib/parsers/ISOWeekYearParser.d.mts

@@ -0,0 +1,12 @@
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class ISOWeekYearParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string): ParseResult<number>;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/ISOWeekYearParser.d.ts

@@ -0,0 +1,12 @@
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class ISOWeekYearParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string): ParseResult<number>;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/ISOWeekYearParser.js

@@ -0,0 +1,46 @@
+"use strict";
+exports.ISOWeekYearParser = void 0;
+var _index = require("../../../startOfISOWeek.js");
+var _index2 = require("../../../constructFrom.js");
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+// ISO week-numbering year
+class ISOWeekYearParser extends _Parser.Parser {
+  priority = 130;
+
+  parse(dateString, token) {
+    if (token === "R") {
+      return (0, _utils.parseNDigitsSigned)(4, dateString);
+    }
+
+    return (0, _utils.parseNDigitsSigned)(token.length, dateString);
+  }
+
+  set(date, _flags, value) {
+    const firstWeekOfYear = (0, _index2.constructFrom)(date, 0);
+    firstWeekOfYear.setFullYear(value, 0, 4);
+    firstWeekOfYear.setHours(0, 0, 0, 0);
+    return (0, _index.startOfISOWeek)(firstWeekOfYear);
+  }
+
+  incompatibleTokens = [
+    "G",
+    "y",
+    "Y",
+    "u",
+    "Q",
+    "q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "e",
+    "c",
+    "t",
+    "T",
+  ];
+}
+exports.ISOWeekYearParser = ISOWeekYearParser;

node_modules/date-fns/parse/_lib/parsers/ISOWeekYearParser.mjs

@@ -0,0 +1,42 @@
+import { startOfISOWeek } from "../../../startOfISOWeek.mjs";
+import { constructFrom } from "../../../constructFrom.mjs";
+import { Parser } from "../Parser.mjs";
+import { parseNDigitsSigned } from "../utils.mjs";
+
+// ISO week-numbering year
+export class ISOWeekYearParser extends Parser {
+  priority = 130;
+
+  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);
+  }
+
+  incompatibleTokens = [
+    "G",
+    "y",
+    "Y",
+    "u",
+    "Q",
+    "q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "e",
+    "c",
+    "t",
+    "T",
+  ];
+}

node_modules/date-fns/parse/_lib/parsers/LocalDayParser.d.mts

@@ -0,0 +1,20 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult, ParserOptions } from "../types.js";
+export declare class LocalDayParser extends Parser<number> {
+  priority: number;
+  parse(
+    dateString: string,
+    token: string,
+    match: Match,
+    options: ParserOptions,
+  ): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+    options: ParserOptions,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/LocalDayParser.d.ts

@@ -0,0 +1,20 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult, ParserOptions } from "../types.js";
+export declare class LocalDayParser extends Parser<number> {
+  priority: number;
+  parse(
+    dateString: string,
+    token: string,
+    match: Match,
+    options: ParserOptions,
+  ): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+    options: ParserOptions,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/LocalDayParser.js

@@ -0,0 +1,101 @@
+"use strict";
+exports.LocalDayParser = void 0;
+var _index = require("../../../setDay.js");
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+// Local day of week
+class LocalDayParser extends _Parser.Parser {
+  priority = 90;
+  parse(dateString, token, match, options) {
+    const valueCallback = (value) => {
+      // We want here floor instead of trunc, so we get -7 for value 0 instead of 0
+      const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
+      return ((value + options.weekStartsOn + 6) % 7) + wholeWeekDays;
+    };
+
+    switch (token) {
+      // 3
+      case "e":
+      case "ee": // 03
+        return (0, _utils.mapValue)(
+          (0, _utils.parseNDigits)(token.length, dateString),
+          valueCallback,
+        );
+      // 3rd
+      case "eo":
+        return (0, _utils.mapValue)(
+          match.ordinalNumber(dateString, {
+            unit: "day",
+          }),
+          valueCallback,
+        );
+      // Tue
+      case "eee":
+        return (
+          match.day(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.day(dateString, { width: "short", context: "formatting" }) ||
+          match.day(dateString, { width: "narrow", context: "formatting" })
+        );
+
+      // T
+      case "eeeee":
+        return match.day(dateString, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // Tu
+      case "eeeeee":
+        return (
+          match.day(dateString, { width: "short", context: "formatting" }) ||
+          match.day(dateString, { width: "narrow", context: "formatting" })
+        );
+
+      // Tuesday
+      case "eeee":
+      default:
+        return (
+          match.day(dateString, { width: "wide", context: "formatting" }) ||
+          match.day(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.day(dateString, { width: "short", context: "formatting" }) ||
+          match.day(dateString, { width: "narrow", context: "formatting" })
+        );
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 6;
+  }
+
+  set(date, _flags, value, options) {
+    date = (0, _index.setDay)(date, value, options);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "E",
+    "i",
+    "c",
+    "t",
+    "T",
+  ];
+}
+exports.LocalDayParser = LocalDayParser;

node_modules/date-fns/parse/_lib/parsers/LocalDayParser.mjs

@@ -0,0 +1,94 @@
+import { setDay } from "../../../setDay.mjs";
+import { Parser } from "../Parser.mjs";
+import { mapValue, parseNDigits } from "../utils.mjs";
+
+// Local day of week
+export class LocalDayParser extends Parser {
+  priority = 90;
+  parse(dateString, token, match, options) {
+    const valueCallback = (value) => {
+      // We want here floor instead of trunc, so we get -7 for value 0 instead of 0
+      const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
+      return ((value + options.weekStartsOn + 6) % 7) + wholeWeekDays;
+    };
+
+    switch (token) {
+      // 3
+      case "e":
+      case "ee": // 03
+        return 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;
+  }
+
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "E",
+    "i",
+    "c",
+    "t",
+    "T",
+  ];
+}

node_modules/date-fns/parse/_lib/parsers/LocalWeekParser.d.mts

@@ -0,0 +1,15 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult, ParserOptions } from "../types.js";
+export declare class LocalWeekParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+    options: ParserOptions,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/LocalWeekParser.d.ts

@@ -0,0 +1,15 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult, ParserOptions } from "../types.js";
+export declare class LocalWeekParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+    options: ParserOptions,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/LocalWeekParser.js

@@ -0,0 +1,55 @@
+"use strict";
+exports.LocalWeekParser = void 0;
+var _index = require("../../../setWeek.js");
+var _index2 = require("../../../startOfWeek.js");
+var _constants = require("../constants.js");
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+// Local week of year
+class LocalWeekParser extends _Parser.Parser {
+  priority = 100;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "w":
+        return (0, _utils.parseNumericPattern)(
+          _constants.numericPatterns.week,
+          dateString,
+        );
+      case "wo":
+        return match.ordinalNumber(dateString, { unit: "week" });
+      default:
+        return (0, _utils.parseNDigits)(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 1 && value <= 53;
+  }
+
+  set(date, _flags, value, options) {
+    return (0, _index2.startOfWeek)(
+      (0, _index.setWeek)(date, value, options),
+      options,
+    );
+  }
+
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "i",
+    "t",
+    "T",
+  ];
+}
+exports.LocalWeekParser = LocalWeekParser;

node_modules/date-fns/parse/_lib/parsers/LocalWeekParser.mjs

@@ -0,0 +1,45 @@
+import { setWeek } from "../../../setWeek.mjs";
+import { startOfWeek } from "../../../startOfWeek.mjs";
+import { numericPatterns } from "../constants.mjs";
+import { Parser } from "../Parser.mjs";
+import { parseNDigits, parseNumericPattern } from "../utils.mjs";
+
+// Local week of year
+export class LocalWeekParser extends Parser {
+  priority = 100;
+
+  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);
+  }
+
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "i",
+    "t",
+    "T",
+  ];
+}

node_modules/date-fns/parse/_lib/parsers/LocalWeekYearParser.d.mts

@@ -0,0 +1,23 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult, ParserOptions } from "../types.js";
+import type { YearParserValue } from "./YearParser.js";
+export declare class LocalWeekYearParser extends Parser<YearParserValue> {
+  priority: number;
+  parse(
+    dateString: string,
+    token: string,
+    match: Match,
+  ): ParseResult<YearParserValue>;
+  validate<DateType extends Date>(
+    _date: DateType,
+    value: YearParserValue,
+  ): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    flags: ParseFlags,
+    value: YearParserValue,
+    options: ParserOptions,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/LocalWeekYearParser.d.ts

@@ -0,0 +1,23 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult, ParserOptions } from "../types.js";
+import type { YearParserValue } from "./YearParser.js";
+export declare class LocalWeekYearParser extends Parser<YearParserValue> {
+  priority: number;
+  parse(
+    dateString: string,
+    token: string,
+    match: Match,
+  ): ParseResult<YearParserValue>;
+  validate<DateType extends Date>(
+    _date: DateType,
+    value: YearParserValue,
+  ): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    flags: ParseFlags,
+    value: YearParserValue,
+    options: ParserOptions,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/LocalWeekYearParser.js

@@ -0,0 +1,85 @@
+"use strict";
+exports.LocalWeekYearParser = void 0;
+var _index = require("../../../getWeekYear.js");
+
+var _index2 = require("../../../startOfWeek.js");
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+// Local week-numbering year
+class LocalWeekYearParser extends _Parser.Parser {
+  priority = 130;
+
+  parse(dateString, token, match) {
+    const valueCallback = (year) => ({
+      year,
+      isTwoDigitYear: token === "YY",
+    });
+
+    switch (token) {
+      case "Y":
+        return (0, _utils.mapValue)(
+          (0, _utils.parseNDigits)(4, dateString),
+          valueCallback,
+        );
+      case "Yo":
+        return (0, _utils.mapValue)(
+          match.ordinalNumber(dateString, {
+            unit: "year",
+          }),
+          valueCallback,
+        );
+      default:
+        return (0, _utils.mapValue)(
+          (0, _utils.parseNDigits)(token.length, dateString),
+          valueCallback,
+        );
+    }
+  }
+
+  validate(_date, value) {
+    return value.isTwoDigitYear || value.year > 0;
+  }
+
+  set(date, flags, value, options) {
+    const currentYear = (0, _index.getWeekYear)(date, options);
+
+    if (value.isTwoDigitYear) {
+      const normalizedTwoDigitYear = (0, _utils.normalizeTwoDigitYear)(
+        value.year,
+        currentYear,
+      );
+      date.setFullYear(
+        normalizedTwoDigitYear,
+        0,
+        options.firstWeekContainsDate,
+      );
+      date.setHours(0, 0, 0, 0);
+      return (0, _index2.startOfWeek)(date, options);
+    }
+
+    const year =
+      !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
+    date.setFullYear(year, 0, options.firstWeekContainsDate);
+    date.setHours(0, 0, 0, 0);
+    return (0, _index2.startOfWeek)(date, options);
+  }
+
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "Q",
+    "q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "i",
+    "t",
+    "T",
+  ];
+}
+exports.LocalWeekYearParser = LocalWeekYearParser;

node_modules/date-fns/parse/_lib/parsers/LocalWeekYearParser.mjs

@@ -0,0 +1,74 @@
+import { getWeekYear } from "../../../getWeekYear.mjs";
+import { startOfWeek } from "../../../startOfWeek.mjs";
+import { Parser } from "../Parser.mjs";
+import { mapValue, normalizeTwoDigitYear, parseNDigits } from "../utils.mjs";
+
+// Local week-numbering year
+export class LocalWeekYearParser extends Parser {
+  priority = 130;
+
+  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);
+  }
+
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "Q",
+    "q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "i",
+    "t",
+    "T",
+  ];
+}

node_modules/date-fns/parse/_lib/parsers/MinuteParser.d.mts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class MinuteParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/MinuteParser.d.ts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class MinuteParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/MinuteParser.js

@@ -0,0 +1,36 @@
+"use strict";
+exports.MinuteParser = void 0;
+var _constants = require("../constants.js");
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+class MinuteParser extends _Parser.Parser {
+  priority = 60;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "m":
+        return (0, _utils.parseNumericPattern)(
+          _constants.numericPatterns.minute,
+          dateString,
+        );
+      case "mo":
+        return match.ordinalNumber(dateString, { unit: "minute" });
+      default:
+        return (0, _utils.parseNDigits)(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 59;
+  }
+
+  set(date, _flags, value) {
+    date.setMinutes(value, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["t", "T"];
+}
+exports.MinuteParser = MinuteParser;

node_modules/date-fns/parse/_lib/parsers/MinuteParser.mjs

@@ -0,0 +1,29 @@
+import { numericPatterns } from "../constants.mjs";
+import { Parser } from "../Parser.mjs";
+import { parseNDigits, parseNumericPattern } from "../utils.mjs";
+
+export class MinuteParser extends Parser {
+  priority = 60;
+
+  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;
+  }
+
+  incompatibleTokens = ["t", "T"];
+}

node_modules/date-fns/parse/_lib/parsers/MonthParser.d.mts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class MonthParser extends Parser<number> {
+  incompatibleTokens: string[];
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+}

node_modules/date-fns/parse/_lib/parsers/MonthParser.d.ts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class MonthParser extends Parser<number> {
+  incompatibleTokens: string[];
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+}

node_modules/date-fns/parse/_lib/parsers/MonthParser.js

@@ -0,0 +1,94 @@
+"use strict";
+exports.MonthParser = void 0;
+var _constants = require("../constants.js");
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+class MonthParser extends _Parser.Parser {
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "L",
+    "w",
+    "I",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T",
+  ];
+
+  priority = 110;
+
+  parse(dateString, token, match) {
+    const valueCallback = (value) => value - 1;
+
+    switch (token) {
+      // 1, 2, ..., 12
+      case "M":
+        return (0, _utils.mapValue)(
+          (0, _utils.parseNumericPattern)(
+            _constants.numericPatterns.month,
+            dateString,
+          ),
+          valueCallback,
+        );
+      // 01, 02, ..., 12
+      case "MM":
+        return (0, _utils.mapValue)(
+          (0, _utils.parseNDigits)(2, dateString),
+          valueCallback,
+        );
+      // 1st, 2nd, ..., 12th
+      case "Mo":
+        return (0, _utils.mapValue)(
+          match.ordinalNumber(dateString, {
+            unit: "month",
+          }),
+          valueCallback,
+        );
+      // Jan, Feb, ..., Dec
+      case "MMM":
+        return (
+          match.month(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.month(dateString, { width: "narrow", context: "formatting" })
+        );
+
+      // J, F, ..., D
+      case "MMMMM":
+        return match.month(dateString, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // January, February, ..., December
+      case "MMMM":
+      default:
+        return (
+          match.month(dateString, { width: "wide", context: "formatting" }) ||
+          match.month(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.month(dateString, { width: "narrow", context: "formatting" })
+        );
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 11;
+  }
+
+  set(date, _flags, value) {
+    date.setMonth(value, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+}
+exports.MonthParser = MonthParser;

node_modules/date-fns/parse/_lib/parsers/MonthParser.mjs

@@ -0,0 +1,84 @@
+import { numericPatterns } from "../constants.mjs";
+import { Parser } from "../Parser.mjs";
+import { mapValue, parseNDigits, parseNumericPattern } from "../utils.mjs";
+
+export class MonthParser extends Parser {
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "L",
+    "w",
+    "I",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T",
+  ];
+
+  priority = 110;
+
+  parse(dateString, token, match) {
+    const valueCallback = (value) => value - 1;
+
+    switch (token) {
+      // 1, 2, ..., 12
+      case "M":
+        return 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;
+  }
+}

node_modules/date-fns/parse/_lib/parsers/QuarterParser.d.mts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class QuarterParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/QuarterParser.d.ts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class QuarterParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/QuarterParser.js

@@ -0,0 +1,85 @@
+"use strict";
+exports.QuarterParser = void 0;
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+class QuarterParser extends _Parser.Parser {
+  priority = 120;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      // 1, 2, 3, 4
+      case "Q":
+      case "QQ": // 01, 02, 03, 04
+        return (0, _utils.parseNDigits)(token.length, dateString);
+      // 1st, 2nd, 3rd, 4th
+      case "Qo":
+        return match.ordinalNumber(dateString, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "QQQ":
+        return (
+          match.quarter(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.quarter(dateString, {
+            width: "narrow",
+            context: "formatting",
+          })
+        );
+
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "QQQQQ":
+        return match.quarter(dateString, {
+          width: "narrow",
+          context: "formatting",
+        });
+      // 1st quarter, 2nd quarter, ...
+      case "QQQQ":
+      default:
+        return (
+          match.quarter(dateString, {
+            width: "wide",
+            context: "formatting",
+          }) ||
+          match.quarter(dateString, {
+            width: "abbreviated",
+            context: "formatting",
+          }) ||
+          match.quarter(dateString, {
+            width: "narrow",
+            context: "formatting",
+          })
+        );
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 1 && value <= 4;
+  }
+
+  set(date, _flags, value) {
+    date.setMonth((value - 1) * 3, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "M",
+    "L",
+    "w",
+    "I",
+    "d",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T",
+  ];
+}
+exports.QuarterParser = QuarterParser;

node_modules/date-fns/parse/_lib/parsers/QuarterParser.mjs

@@ -0,0 +1,81 @@
+import { Parser } from "../Parser.mjs";
+import { parseNDigits } from "../utils.mjs";
+
+export class QuarterParser extends Parser {
+  priority = 120;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      // 1, 2, 3, 4
+      case "Q":
+      case "QQ": // 01, 02, 03, 04
+        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;
+  }
+
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "M",
+    "L",
+    "w",
+    "I",
+    "d",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T",
+  ];
+}

node_modules/date-fns/parse/_lib/parsers/SecondParser.d.mts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class SecondParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/SecondParser.d.ts

@@ -0,0 +1,14 @@
+import type { Match } from "../../../locale/types.js";
+import { Parser } from "../Parser.js";
+import type { ParseFlags, ParseResult } from "../types.js";
+export declare class SecondParser extends Parser<number> {
+  priority: number;
+  parse(dateString: string, token: string, match: Match): ParseResult<number>;
+  validate<DateType extends Date>(_date: DateType, value: number): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    _flags: ParseFlags,
+    value: number,
+  ): DateType;
+  incompatibleTokens: string[];
+}

node_modules/date-fns/parse/_lib/parsers/SecondParser.js

@@ -0,0 +1,36 @@
+"use strict";
+exports.SecondParser = void 0;
+var _constants = require("../constants.js");
+var _Parser = require("../Parser.js");
+
+var _utils = require("../utils.js");
+
+class SecondParser extends _Parser.Parser {
+  priority = 50;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "s":
+        return (0, _utils.parseNumericPattern)(
+          _constants.numericPatterns.second,
+          dateString,
+        );
+      case "so":
+        return match.ordinalNumber(dateString, { unit: "second" });
+      default:
+        return (0, _utils.parseNDigits)(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 59;
+  }
+
+  set(date, _flags, value) {
+    date.setSeconds(value, 0);
+    return date;
+  }
+
+  incompatibleTokens = ["t", "T"];
+}
+exports.SecondParser = SecondParser;

node_modules/date-fns/parse/_lib/parsers/SecondParser.mjs

@@ -0,0 +1,29 @@
+import { numericPatterns } from "../constants.mjs";
+import { Parser } from "../Parser.mjs";
+import { parseNDigits, parseNumericPattern } from "../utils.mjs";
+
+export class SecondParser extends Parser {
+  priority = 50;
+
+  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;
+  }
+
+  incompatibleTokens = ["t", "T"];
+}