📝 Commit Details:

backend/node_modules/date-fns/parse/_lib/Parser.cjs

@@ -0,0 +1,28 @@
+"use strict";
+exports.Parser = void 0;
+var _Setter = require("./Setter.cjs");
+
+class Parser {
+  run(dateString, token, match, options) {
+    const result = this.parse(dateString, token, match, options);
+    if (!result) {
+      return null;
+    }
+
+    return {
+      setter: new _Setter.ValueSetter(
+        result.value,
+        this.validate,
+        this.set,
+        this.priority,
+        this.subPriority,
+      ),
+      rest: result.rest,
+    };
+  }
+
+  validate(_utcDate, _value, _options) {
+    return true;
+  }
+}
+exports.Parser = Parser;

backend/node_modules/date-fns/parse/_lib/Parser.d.cts

@@ -0,0 +1,34 @@
+import type { Match } from "../../locale/types.js";
+import { ValueSetter } from "./Setter.js";
+import type { ParseFlags, ParseResult, ParserOptions } from "./types.js";
+export declare abstract class Parser<Value> {
+  abstract incompatibleTokens: string[] | "*";
+  abstract priority: number;
+  subPriority?: number;
+  run(
+    dateString: string,
+    token: string,
+    match: Match,
+    options: ParserOptions,
+  ): {
+    setter: ValueSetter<Value>;
+    rest: string;
+  } | null;
+  protected abstract parse(
+    dateString: string,
+    token: string,
+    match: Match,
+    options: ParserOptions,
+  ): ParseResult<Value>;
+  protected validate<DateType extends Date>(
+    _utcDate: DateType,
+    _value: Value,
+    _options: ParserOptions,
+  ): boolean;
+  protected abstract set<DateType extends Date>(
+    date: DateType,
+    flags: ParseFlags,
+    value: Value,
+    options: ParserOptions,
+  ): DateType | [DateType, ParseFlags];
+}

backend/node_modules/date-fns/parse/_lib/Parser.d.ts

@@ -0,0 +1,34 @@
+import type { Match } from "../../locale/types.js";
+import { ValueSetter } from "./Setter.js";
+import type { ParseFlags, ParseResult, ParserOptions } from "./types.js";
+export declare abstract class Parser<Value> {
+  abstract incompatibleTokens: string[] | "*";
+  abstract priority: number;
+  subPriority?: number;
+  run(
+    dateString: string,
+    token: string,
+    match: Match,
+    options: ParserOptions,
+  ): {
+    setter: ValueSetter<Value>;
+    rest: string;
+  } | null;
+  protected abstract parse(
+    dateString: string,
+    token: string,
+    match: Match,
+    options: ParserOptions,
+  ): ParseResult<Value>;
+  protected validate<DateType extends Date>(
+    _utcDate: DateType,
+    _value: Value,
+    _options: ParserOptions,
+  ): boolean;
+  protected abstract set<DateType extends Date>(
+    date: DateType,
+    flags: ParseFlags,
+    value: Value,
+    options: ParserOptions,
+  ): DateType | [DateType, ParseFlags];
+}

backend/node_modules/date-fns/parse/_lib/Parser.js

@@ -0,0 +1,25 @@
+import { ValueSetter } from "./Setter.js";
+
+export class Parser {
+  run(dateString, token, match, options) {
+    const result = this.parse(dateString, token, match, options);
+    if (!result) {
+      return null;
+    }
+
+    return {
+      setter: new ValueSetter(
+        result.value,
+        this.validate,
+        this.set,
+        this.priority,
+        this.subPriority,
+      ),
+      rest: result.rest,
+    };
+  }
+
+  validate(_utcDate, _value, _options) {
+    return true;
+  }
+}

backend/node_modules/date-fns/parse/_lib/Setter.cjs

@@ -0,0 +1,66 @@
+"use strict";
+exports.ValueSetter = exports.Setter = exports.DateTimezoneSetter = void 0;
+var _index = require("../../constructFrom.cjs");
+var _index2 = require("../../transpose.cjs");
+
+const TIMEZONE_UNIT_PRIORITY = 10;
+
+class Setter {
+  subPriority = 0;
+
+  validate(_utcDate, _options) {
+    return true;
+  }
+}
+exports.Setter = Setter;
+
+class ValueSetter extends Setter {
+  constructor(
+    value,
+
+    validateValue,
+
+    setValue,
+
+    priority,
+    subPriority,
+  ) {
+    super();
+    this.value = value;
+    this.validateValue = validateValue;
+    this.setValue = setValue;
+    this.priority = priority;
+    if (subPriority) {
+      this.subPriority = subPriority;
+    }
+  }
+
+  validate(date, options) {
+    return this.validateValue(date, this.value, options);
+  }
+
+  set(date, flags, options) {
+    return this.setValue(date, flags, this.value, options);
+  }
+}
+exports.ValueSetter = ValueSetter;
+
+class DateTimezoneSetter extends Setter {
+  priority = TIMEZONE_UNIT_PRIORITY;
+  subPriority = -1;
+
+  constructor(context, reference) {
+    super();
+    this.context =
+      context || ((date) => (0, _index.constructFrom)(reference, date));
+  }
+
+  set(date, flags) {
+    if (flags.timestampIsSet) return date;
+    return (0, _index.constructFrom)(
+      date,
+      (0, _index2.transpose)(date, this.context),
+    );
+  }
+}
+exports.DateTimezoneSetter = DateTimezoneSetter;

backend/node_modules/date-fns/parse/_lib/Setter.d.cts

@@ -0,0 +1,56 @@
+import type { ContextFn, DateArg } from "../../types.js";
+import type { ParseFlags, ParserOptions } from "./types.js";
+export declare abstract class Setter {
+  abstract priority: number;
+  subPriority: number;
+  validate<DateType extends Date>(
+    _utcDate: DateType,
+    _options?: ParserOptions,
+  ): boolean;
+  abstract set<DateType extends Date>(
+    date: DateType,
+    flags: ParseFlags,
+    options: ParserOptions,
+  ): DateType | [DateType, ParseFlags];
+}
+export declare class ValueSetter<Value> extends Setter {
+  private value;
+  private validateValue;
+  private setValue;
+  priority: number;
+  constructor(
+    value: Value,
+    validateValue: <DateType extends Date>(
+      date: DateType,
+      value: Value,
+      options: ParserOptions,
+    ) => boolean,
+    setValue: <DateType extends Date>(
+      date: DateType,
+      flags: ParseFlags,
+      value: Value,
+      options: ParserOptions,
+    ) => DateType | [DateType, ParseFlags],
+    priority: number,
+    subPriority?: number,
+  );
+  validate<DateType extends Date>(
+    date: DateType,
+    options: ParserOptions,
+  ): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    flags: ParseFlags,
+    options: ParserOptions,
+  ): DateType | [DateType, ParseFlags];
+}
+export declare class DateTimezoneSetter extends Setter {
+  priority: number;
+  subPriority: number;
+  context: ContextFn<Date>;
+  constructor(
+    context: ContextFn<Date> | undefined,
+    reference: DateArg<Date> & {},
+  );
+  set<DateType extends Date>(date: DateType, flags: ParseFlags): DateType;
+}

backend/node_modules/date-fns/parse/_lib/Setter.d.ts

@@ -0,0 +1,56 @@
+import type { ContextFn, DateArg } from "../../types.js";
+import type { ParseFlags, ParserOptions } from "./types.js";
+export declare abstract class Setter {
+  abstract priority: number;
+  subPriority: number;
+  validate<DateType extends Date>(
+    _utcDate: DateType,
+    _options?: ParserOptions,
+  ): boolean;
+  abstract set<DateType extends Date>(
+    date: DateType,
+    flags: ParseFlags,
+    options: ParserOptions,
+  ): DateType | [DateType, ParseFlags];
+}
+export declare class ValueSetter<Value> extends Setter {
+  private value;
+  private validateValue;
+  private setValue;
+  priority: number;
+  constructor(
+    value: Value,
+    validateValue: <DateType extends Date>(
+      date: DateType,
+      value: Value,
+      options: ParserOptions,
+    ) => boolean,
+    setValue: <DateType extends Date>(
+      date: DateType,
+      flags: ParseFlags,
+      value: Value,
+      options: ParserOptions,
+    ) => DateType | [DateType, ParseFlags],
+    priority: number,
+    subPriority?: number,
+  );
+  validate<DateType extends Date>(
+    date: DateType,
+    options: ParserOptions,
+  ): boolean;
+  set<DateType extends Date>(
+    date: DateType,
+    flags: ParseFlags,
+    options: ParserOptions,
+  ): DateType | [DateType, ParseFlags];
+}
+export declare class DateTimezoneSetter extends Setter {
+  priority: number;
+  subPriority: number;
+  context: ContextFn<Date>;
+  constructor(
+    context: ContextFn<Date> | undefined,
+    reference: DateArg<Date> & {},
+  );
+  set<DateType extends Date>(date: DateType, flags: ParseFlags): DateType;
+}

backend/node_modules/date-fns/parse/_lib/Setter.js

@@ -0,0 +1,57 @@
+import { constructFrom } from "../../constructFrom.js";
+import { transpose } from "../../transpose.js";
+
+const TIMEZONE_UNIT_PRIORITY = 10;
+
+export class Setter {
+  subPriority = 0;
+
+  validate(_utcDate, _options) {
+    return true;
+  }
+}
+
+export class ValueSetter extends Setter {
+  constructor(
+    value,
+
+    validateValue,
+
+    setValue,
+
+    priority,
+    subPriority,
+  ) {
+    super();
+    this.value = value;
+    this.validateValue = validateValue;
+    this.setValue = setValue;
+    this.priority = priority;
+    if (subPriority) {
+      this.subPriority = subPriority;
+    }
+  }
+
+  validate(date, options) {
+    return this.validateValue(date, this.value, options);
+  }
+
+  set(date, flags, options) {
+    return this.setValue(date, flags, this.value, options);
+  }
+}
+
+export class DateTimezoneSetter extends Setter {
+  priority = TIMEZONE_UNIT_PRIORITY;
+  subPriority = -1;
+
+  constructor(context, reference) {
+    super();
+    this.context = context || ((date) => constructFrom(reference, date));
+  }
+
+  set(date, flags) {
+    if (flags.timestampIsSet) return date;
+    return constructFrom(date, transpose(date, this.context));
+  }
+}

backend/node_modules/date-fns/parse/_lib/constants.cjs

@@ -0,0 +1,33 @@
+"use strict";
+exports.timezonePatterns = exports.numericPatterns = void 0;
+const numericPatterns = (exports.numericPatterns = {
+  month: /^(1[0-2]|0?\d)/, // 0 to 12
+  date: /^(3[0-1]|[0-2]?\d)/, // 0 to 31
+  dayOfYear: /^(36[0-6]|3[0-5]\d|[0-2]?\d?\d)/, // 0 to 366
+  week: /^(5[0-3]|[0-4]?\d)/, // 0 to 53
+  hour23h: /^(2[0-3]|[0-1]?\d)/, // 0 to 23
+  hour24h: /^(2[0-4]|[0-1]?\d)/, // 0 to 24
+  hour11h: /^(1[0-1]|0?\d)/, // 0 to 11
+  hour12h: /^(1[0-2]|0?\d)/, // 0 to 12
+  minute: /^[0-5]?\d/, // 0 to 59
+  second: /^[0-5]?\d/, // 0 to 59
+
+  singleDigit: /^\d/, // 0 to 9
+  twoDigits: /^\d{1,2}/, // 0 to 99
+  threeDigits: /^\d{1,3}/, // 0 to 999
+  fourDigits: /^\d{1,4}/, // 0 to 9999
+
+  anyDigitsSigned: /^-?\d+/,
+  singleDigitSigned: /^-?\d/, // 0 to 9, -0 to -9
+  twoDigitsSigned: /^-?\d{1,2}/, // 0 to 99, -0 to -99
+  threeDigitsSigned: /^-?\d{1,3}/, // 0 to 999, -0 to -999
+  fourDigitsSigned: /^-?\d{1,4}/, // 0 to 9999, -0 to -9999
+});
+
+const timezonePatterns = (exports.timezonePatterns = {
+  basicOptionalMinutes: /^([+-])(\d{2})(\d{2})?|Z/,
+  basic: /^([+-])(\d{2})(\d{2})|Z/,
+  basicOptionalSeconds: /^([+-])(\d{2})(\d{2})((\d{2}))?|Z/,
+  extended: /^([+-])(\d{2}):(\d{2})|Z/,
+  extendedOptionalSeconds: /^([+-])(\d{2}):(\d{2})(:(\d{2}))?|Z/,
+});

backend/node_modules/date-fns/parse/_lib/constants.d.cts

@@ -0,0 +1,28 @@
+export declare const numericPatterns: {
+  month: RegExp;
+  date: RegExp;
+  dayOfYear: RegExp;
+  week: RegExp;
+  hour23h: RegExp;
+  hour24h: RegExp;
+  hour11h: RegExp;
+  hour12h: RegExp;
+  minute: RegExp;
+  second: RegExp;
+  singleDigit: RegExp;
+  twoDigits: RegExp;
+  threeDigits: RegExp;
+  fourDigits: RegExp;
+  anyDigitsSigned: RegExp;
+  singleDigitSigned: RegExp;
+  twoDigitsSigned: RegExp;
+  threeDigitsSigned: RegExp;
+  fourDigitsSigned: RegExp;
+};
+export declare const timezonePatterns: {
+  basicOptionalMinutes: RegExp;
+  basic: RegExp;
+  basicOptionalSeconds: RegExp;
+  extended: RegExp;
+  extendedOptionalSeconds: RegExp;
+};

backend/node_modules/date-fns/parse/_lib/constants.d.ts

@@ -0,0 +1,28 @@
+export declare const numericPatterns: {
+  month: RegExp;
+  date: RegExp;
+  dayOfYear: RegExp;
+  week: RegExp;
+  hour23h: RegExp;
+  hour24h: RegExp;
+  hour11h: RegExp;
+  hour12h: RegExp;
+  minute: RegExp;
+  second: RegExp;
+  singleDigit: RegExp;
+  twoDigits: RegExp;
+  threeDigits: RegExp;
+  fourDigits: RegExp;
+  anyDigitsSigned: RegExp;
+  singleDigitSigned: RegExp;
+  twoDigitsSigned: RegExp;
+  threeDigitsSigned: RegExp;
+  fourDigitsSigned: RegExp;
+};
+export declare const timezonePatterns: {
+  basicOptionalMinutes: RegExp;
+  basic: RegExp;
+  basicOptionalSeconds: RegExp;
+  extended: RegExp;
+  extendedOptionalSeconds: RegExp;
+};

backend/node_modules/date-fns/parse/_lib/constants.js

@@ -0,0 +1,31 @@
+export const numericPatterns = {
+  month: /^(1[0-2]|0?\d)/, // 0 to 12
+  date: /^(3[0-1]|[0-2]?\d)/, // 0 to 31
+  dayOfYear: /^(36[0-6]|3[0-5]\d|[0-2]?\d?\d)/, // 0 to 366
+  week: /^(5[0-3]|[0-4]?\d)/, // 0 to 53
+  hour23h: /^(2[0-3]|[0-1]?\d)/, // 0 to 23
+  hour24h: /^(2[0-4]|[0-1]?\d)/, // 0 to 24
+  hour11h: /^(1[0-1]|0?\d)/, // 0 to 11
+  hour12h: /^(1[0-2]|0?\d)/, // 0 to 12
+  minute: /^[0-5]?\d/, // 0 to 59
+  second: /^[0-5]?\d/, // 0 to 59
+
+  singleDigit: /^\d/, // 0 to 9
+  twoDigits: /^\d{1,2}/, // 0 to 99
+  threeDigits: /^\d{1,3}/, // 0 to 999
+  fourDigits: /^\d{1,4}/, // 0 to 9999
+
+  anyDigitsSigned: /^-?\d+/,
+  singleDigitSigned: /^-?\d/, // 0 to 9, -0 to -9
+  twoDigitsSigned: /^-?\d{1,2}/, // 0 to 99, -0 to -99
+  threeDigitsSigned: /^-?\d{1,3}/, // 0 to 999, -0 to -999
+  fourDigitsSigned: /^-?\d{1,4}/, // 0 to 9999, -0 to -9999
+};
+
+export const timezonePatterns = {
+  basicOptionalMinutes: /^([+-])(\d{2})(\d{2})?|Z/,
+  basic: /^([+-])(\d{2})(\d{2})|Z/,
+  basicOptionalSeconds: /^([+-])(\d{2})(\d{2})((\d{2}))?|Z/,
+  extended: /^([+-])(\d{2}):(\d{2})|Z/,
+  extendedOptionalSeconds: /^([+-])(\d{2}):(\d{2})(:(\d{2}))?|Z/,
+};

backend/node_modules/date-fns/parse/_lib/parsers.cjs

@@ -0,0 +1,110 @@
+"use strict";
+exports.parsers = void 0;
+var _EraParser = require("./parsers/EraParser.cjs");
+var _YearParser = require("./parsers/YearParser.cjs");
+var _LocalWeekYearParser = require("./parsers/LocalWeekYearParser.cjs");
+var _ISOWeekYearParser = require("./parsers/ISOWeekYearParser.cjs");
+var _ExtendedYearParser = require("./parsers/ExtendedYearParser.cjs");
+var _QuarterParser = require("./parsers/QuarterParser.cjs");
+var _StandAloneQuarterParser = require("./parsers/StandAloneQuarterParser.cjs");
+var _MonthParser = require("./parsers/MonthParser.cjs");
+var _StandAloneMonthParser = require("./parsers/StandAloneMonthParser.cjs");
+var _LocalWeekParser = require("./parsers/LocalWeekParser.cjs");
+var _ISOWeekParser = require("./parsers/ISOWeekParser.cjs");
+var _DateParser = require("./parsers/DateParser.cjs");
+var _DayOfYearParser = require("./parsers/DayOfYearParser.cjs");
+var _DayParser = require("./parsers/DayParser.cjs");
+var _LocalDayParser = require("./parsers/LocalDayParser.cjs");
+var _StandAloneLocalDayParser = require("./parsers/StandAloneLocalDayParser.cjs");
+var _ISODayParser = require("./parsers/ISODayParser.cjs");
+var _AMPMParser = require("./parsers/AMPMParser.cjs");
+var _AMPMMidnightParser = require("./parsers/AMPMMidnightParser.cjs");
+var _DayPeriodParser = require("./parsers/DayPeriodParser.cjs");
+var _Hour1to12Parser = require("./parsers/Hour1to12Parser.cjs");
+var _Hour0to23Parser = require("./parsers/Hour0to23Parser.cjs");
+var _Hour0To11Parser = require("./parsers/Hour0To11Parser.cjs");
+var _Hour1To24Parser = require("./parsers/Hour1To24Parser.cjs");
+var _MinuteParser = require("./parsers/MinuteParser.cjs");
+var _SecondParser = require("./parsers/SecondParser.cjs");
+var _FractionOfSecondParser = require("./parsers/FractionOfSecondParser.cjs");
+var _ISOTimezoneWithZParser = require("./parsers/ISOTimezoneWithZParser.cjs");
+var _ISOTimezoneParser = require("./parsers/ISOTimezoneParser.cjs");
+var _TimestampSecondsParser = require("./parsers/TimestampSecondsParser.cjs");
+var _TimestampMillisecondsParser = require("./parsers/TimestampMillisecondsParser.cjs");
+
+/*
+ * |     | Unit                           |     | Unit                           |
+ * |-----|--------------------------------|-----|--------------------------------|
+ * |  a  | AM, PM                         |  A* | Milliseconds in day            |
+ * |  b  | AM, PM, noon, midnight         |  B  | Flexible day period            |
+ * |  c  | Stand-alone local day of week  |  C* | Localized hour w/ day period   |
+ * |  d  | Day of month                   |  D  | Day of year                    |
+ * |  e  | Local day of week              |  E  | Day of week                    |
+ * |  f  |                                |  F* | Day of week in month           |
+ * |  g* | Modified Julian day            |  G  | Era                            |
+ * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
+ * |  i! | ISO day of week                |  I! | ISO week of year               |
+ * |  j* | Localized hour w/ day period   |  J* | Localized hour w/o day period  |
+ * |  k  | Hour [1-24]                    |  K  | Hour [0-11]                    |
+ * |  l* | (deprecated)                   |  L  | Stand-alone month              |
+ * |  m  | Minute                         |  M  | Month                          |
+ * |  n  |                                |  N  |                                |
+ * |  o! | Ordinal number modifier        |  O* | Timezone (GMT)                 |
+ * |  p  |                                |  P  |                                |
+ * |  q  | Stand-alone quarter            |  Q  | Quarter                        |
+ * |  r* | Related Gregorian year         |  R! | ISO week-numbering year        |
+ * |  s  | Second                         |  S  | Fraction of second             |
+ * |  t! | Seconds timestamp              |  T! | Milliseconds timestamp         |
+ * |  u  | Extended year                  |  U* | Cyclic year                    |
+ * |  v* | Timezone (generic non-locat.)  |  V* | Timezone (location)            |
+ * |  w  | Local week of year             |  W* | Week of month                  |
+ * |  x  | Timezone (ISO-8601 w/o Z)      |  X  | Timezone (ISO-8601)            |
+ * |  y  | Year (abs)                     |  Y  | Local week-numbering year      |
+ * |  z* | Timezone (specific non-locat.) |  Z* | Timezone (aliases)             |
+ *
+ * Letters marked by * are not implemented but reserved by Unicode standard.
+ *
+ * Letters marked by ! are non-standard, but implemented by date-fns:
+ * - `o` modifies the previous token to turn it into an ordinal (see `parse` docs)
+ * - `i` is ISO day of week. For `i` and `ii` is returns numeric ISO week days,
+ *   i.e. 7 for Sunday, 1 for Monday, etc.
+ * - `I` is ISO week of year, as opposed to `w` which is local week of year.
+ * - `R` is ISO week-numbering year, as opposed to `Y` which is local week-numbering year.
+ *   `R` is supposed to be used in conjunction with `I` and `i`
+ *   for universal ISO week-numbering date, whereas
+ *   `Y` is supposed to be used in conjunction with `w` and `e`
+ *   for week-numbering date specific to the locale.
+ */
+const parsers = (exports.parsers = {
+  G: new _EraParser.EraParser(),
+  y: new _YearParser.YearParser(),
+  Y: new _LocalWeekYearParser.LocalWeekYearParser(),
+  R: new _ISOWeekYearParser.ISOWeekYearParser(),
+  u: new _ExtendedYearParser.ExtendedYearParser(),
+  Q: new _QuarterParser.QuarterParser(),
+  q: new _StandAloneQuarterParser.StandAloneQuarterParser(),
+  M: new _MonthParser.MonthParser(),
+  L: new _StandAloneMonthParser.StandAloneMonthParser(),
+  w: new _LocalWeekParser.LocalWeekParser(),
+  I: new _ISOWeekParser.ISOWeekParser(),
+  d: new _DateParser.DateParser(),
+  D: new _DayOfYearParser.DayOfYearParser(),
+  E: new _DayParser.DayParser(),
+  e: new _LocalDayParser.LocalDayParser(),
+  c: new _StandAloneLocalDayParser.StandAloneLocalDayParser(),
+  i: new _ISODayParser.ISODayParser(),
+  a: new _AMPMParser.AMPMParser(),
+  b: new _AMPMMidnightParser.AMPMMidnightParser(),
+  B: new _DayPeriodParser.DayPeriodParser(),
+  h: new _Hour1to12Parser.Hour1to12Parser(),
+  H: new _Hour0to23Parser.Hour0to23Parser(),
+  K: new _Hour0To11Parser.Hour0To11Parser(),
+  k: new _Hour1To24Parser.Hour1To24Parser(),
+  m: new _MinuteParser.MinuteParser(),
+  s: new _SecondParser.SecondParser(),
+  S: new _FractionOfSecondParser.FractionOfSecondParser(),
+  X: new _ISOTimezoneWithZParser.ISOTimezoneWithZParser(),
+  x: new _ISOTimezoneParser.ISOTimezoneParser(),
+  t: new _TimestampSecondsParser.TimestampSecondsParser(),
+  T: new _TimestampMillisecondsParser.TimestampMillisecondsParser(),
+});

backend/node_modules/date-fns/parse/_lib/parsers.d.cts

@@ -0,0 +1,2 @@
+import type { Parser } from "./Parser.js";
+export declare const parsers: Record<string, Parser<any>>;

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

@@ -0,0 +1,2 @@
+import type { Parser } from "./Parser.js";
+export declare const parsers: Record<string, Parser<any>>;

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

@@ -0,0 +1,108 @@
+import { EraParser } from "./parsers/EraParser.js";
+import { YearParser } from "./parsers/YearParser.js";
+import { LocalWeekYearParser } from "./parsers/LocalWeekYearParser.js";
+import { ISOWeekYearParser } from "./parsers/ISOWeekYearParser.js";
+import { ExtendedYearParser } from "./parsers/ExtendedYearParser.js";
+import { QuarterParser } from "./parsers/QuarterParser.js";
+import { StandAloneQuarterParser } from "./parsers/StandAloneQuarterParser.js";
+import { MonthParser } from "./parsers/MonthParser.js";
+import { StandAloneMonthParser } from "./parsers/StandAloneMonthParser.js";
+import { LocalWeekParser } from "./parsers/LocalWeekParser.js";
+import { ISOWeekParser } from "./parsers/ISOWeekParser.js";
+import { DateParser } from "./parsers/DateParser.js";
+import { DayOfYearParser } from "./parsers/DayOfYearParser.js";
+import { DayParser } from "./parsers/DayParser.js";
+import { LocalDayParser } from "./parsers/LocalDayParser.js";
+import { StandAloneLocalDayParser } from "./parsers/StandAloneLocalDayParser.js";
+import { ISODayParser } from "./parsers/ISODayParser.js";
+import { AMPMParser } from "./parsers/AMPMParser.js";
+import { AMPMMidnightParser } from "./parsers/AMPMMidnightParser.js";
+import { DayPeriodParser } from "./parsers/DayPeriodParser.js";
+import { Hour1to12Parser } from "./parsers/Hour1to12Parser.js";
+import { Hour0to23Parser } from "./parsers/Hour0to23Parser.js";
+import { Hour0To11Parser } from "./parsers/Hour0To11Parser.js";
+import { Hour1To24Parser } from "./parsers/Hour1To24Parser.js";
+import { MinuteParser } from "./parsers/MinuteParser.js";
+import { SecondParser } from "./parsers/SecondParser.js";
+import { FractionOfSecondParser } from "./parsers/FractionOfSecondParser.js";
+import { ISOTimezoneWithZParser } from "./parsers/ISOTimezoneWithZParser.js";
+import { ISOTimezoneParser } from "./parsers/ISOTimezoneParser.js";
+import { TimestampSecondsParser } from "./parsers/TimestampSecondsParser.js";
+import { TimestampMillisecondsParser } from "./parsers/TimestampMillisecondsParser.js";
+
+/*
+ * |     | Unit                           |     | Unit                           |
+ * |-----|--------------------------------|-----|--------------------------------|
+ * |  a  | AM, PM                         |  A* | Milliseconds in day            |
+ * |  b  | AM, PM, noon, midnight         |  B  | Flexible day period            |
+ * |  c  | Stand-alone local day of week  |  C* | Localized hour w/ day period   |
+ * |  d  | Day of month                   |  D  | Day of year                    |
+ * |  e  | Local day of week              |  E  | Day of week                    |
+ * |  f  |                                |  F* | Day of week in month           |
+ * |  g* | Modified Julian day            |  G  | Era                            |
+ * |  h  | Hour [1-12]                    |  H  | Hour [0-23]                    |
+ * |  i! | ISO day of week                |  I! | ISO week of year               |
+ * |  j* | Localized hour w/ day period   |  J* | Localized hour w/o day period  |
+ * |  k  | Hour [1-24]                    |  K  | Hour [0-11]                    |
+ * |  l* | (deprecated)                   |  L  | Stand-alone month              |
+ * |  m  | Minute                         |  M  | Month                          |
+ * |  n  |                                |  N  |                                |
+ * |  o! | Ordinal number modifier        |  O* | Timezone (GMT)                 |
+ * |  p  |                                |  P  |                                |
+ * |  q  | Stand-alone quarter            |  Q  | Quarter                        |
+ * |  r* | Related Gregorian year         |  R! | ISO week-numbering year        |
+ * |  s  | Second                         |  S  | Fraction of second             |
+ * |  t! | Seconds timestamp              |  T! | Milliseconds timestamp         |
+ * |  u  | Extended year                  |  U* | Cyclic year                    |
+ * |  v* | Timezone (generic non-locat.)  |  V* | Timezone (location)            |
+ * |  w  | Local week of year             |  W* | Week of month                  |
+ * |  x  | Timezone (ISO-8601 w/o Z)      |  X  | Timezone (ISO-8601)            |
+ * |  y  | Year (abs)                     |  Y  | Local week-numbering year      |
+ * |  z* | Timezone (specific non-locat.) |  Z* | Timezone (aliases)             |
+ *
+ * Letters marked by * are not implemented but reserved by Unicode standard.
+ *
+ * Letters marked by ! are non-standard, but implemented by date-fns:
+ * - `o` modifies the previous token to turn it into an ordinal (see `parse` docs)
+ * - `i` is ISO day of week. For `i` and `ii` is returns numeric ISO week days,
+ *   i.e. 7 for Sunday, 1 for Monday, etc.
+ * - `I` is ISO week of year, as opposed to `w` which is local week of year.
+ * - `R` is ISO week-numbering year, as opposed to `Y` which is local week-numbering year.
+ *   `R` is supposed to be used in conjunction with `I` and `i`
+ *   for universal ISO week-numbering date, whereas
+ *   `Y` is supposed to be used in conjunction with `w` and `e`
+ *   for week-numbering date specific to the locale.
+ */
+export const parsers = {
+  G: new EraParser(),
+  y: new YearParser(),
+  Y: new LocalWeekYearParser(),
+  R: new ISOWeekYearParser(),
+  u: new ExtendedYearParser(),
+  Q: new QuarterParser(),
+  q: new StandAloneQuarterParser(),
+  M: new MonthParser(),
+  L: new StandAloneMonthParser(),
+  w: new LocalWeekParser(),
+  I: new ISOWeekParser(),
+  d: new DateParser(),
+  D: new DayOfYearParser(),
+  E: new DayParser(),
+  e: new LocalDayParser(),
+  c: new StandAloneLocalDayParser(),
+  i: new ISODayParser(),
+  a: new AMPMParser(),
+  b: new AMPMMidnightParser(),
+  B: new DayPeriodParser(),
+  h: new Hour1to12Parser(),
+  H: new Hour0to23Parser(),
+  K: new Hour0To11Parser(),
+  k: new Hour1To24Parser(),
+  m: new MinuteParser(),
+  s: new SecondParser(),
+  S: new FractionOfSecondParser(),
+  X: new ISOTimezoneWithZParser(),
+  x: new ISOTimezoneParser(),
+  t: new TimestampSecondsParser(),
+  T: new TimestampMillisecondsParser(),
+};

backend/node_modules/date-fns/parse/_lib/parsers/AMPMMidnightParser.cjs

@@ -0,0 +1,57 @@
+"use strict";
+exports.AMPMMidnightParser = void 0;
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+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;

backend/node_modules/date-fns/parse/_lib/parsers/AMPMMidnightParser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,54 @@
+import { Parser } from "../Parser.js";
+
+import { dayPeriodEnumToHours } from "../utils.js";
+
+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"];
+}

backend/node_modules/date-fns/parse/_lib/parsers/AMPMParser.cjs

@@ -0,0 +1,57 @@
+"use strict";
+exports.AMPMParser = void 0;
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+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;

backend/node_modules/date-fns/parse/_lib/parsers/AMPMParser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,54 @@
+import { Parser } from "../Parser.js";
+
+import { dayPeriodEnumToHours } from "../utils.js";
+
+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"];
+}

backend/node_modules/date-fns/parse/_lib/parsers/DateParser.cjs

@@ -0,0 +1,64 @@
+"use strict";
+exports.DateParser = void 0;
+var _constants = require("../constants.cjs");
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+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;

backend/node_modules/date-fns/parse/_lib/parsers/DateParser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,62 @@
+import { numericPatterns } from "../constants.js";
+import { Parser } from "../Parser.js";
+
+import {
+  isLeapYearIndex,
+  parseNDigits,
+  parseNumericPattern,
+} from "../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
+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",
+  ];
+}

backend/node_modules/date-fns/parse/_lib/parsers/DayOfYearParser.cjs

@@ -0,0 +1,62 @@
+"use strict";
+exports.DayOfYearParser = void 0;
+var _constants = require("../constants.cjs");
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+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;

backend/node_modules/date-fns/parse/_lib/parsers/DayOfYearParser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,60 @@
+import { numericPatterns } from "../constants.js";
+import { Parser } from "../Parser.js";
+
+import {
+  isLeapYearIndex,
+  parseNDigits,
+  parseNumericPattern,
+} from "../utils.js";
+
+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",
+  ];
+}

backend/node_modules/date-fns/parse/_lib/parsers/DayParser.cjs

@@ -0,0 +1,65 @@
+"use strict";
+exports.DayParser = void 0;
+var _index = require("../../../setDay.cjs");
+var _Parser = require("../Parser.cjs");
+
+// 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;

backend/node_modules/date-fns/parse/_lib/parsers/DayParser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,62 @@
+import { setDay } from "../../../setDay.js";
+import { Parser } from "../Parser.js";
+
+// 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"];
+}

backend/node_modules/date-fns/parse/_lib/parsers/DayPeriodParser.cjs

@@ -0,0 +1,58 @@
+"use strict";
+exports.DayPeriodParser = void 0;
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+// 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;

backend/node_modules/date-fns/parse/_lib/parsers/DayPeriodParser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,55 @@
+import { Parser } from "../Parser.js";
+
+import { dayPeriodEnumToHours } from "../utils.js";
+
+// 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"];
+}

backend/node_modules/date-fns/parse/_lib/parsers/EraParser.cjs

@@ -0,0 +1,43 @@
+"use strict";
+exports.EraParser = void 0;
+
+var _Parser = require("../Parser.cjs");
+
+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;

backend/node_modules/date-fns/parse/_lib/parsers/EraParser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,39 @@
+import { Parser } from "../Parser.js";
+
+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"];
+}

backend/node_modules/date-fns/parse/_lib/parsers/ExtendedYearParser.cjs

@@ -0,0 +1,26 @@
+"use strict";
+exports.ExtendedYearParser = void 0;
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+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;

backend/node_modules/date-fns/parse/_lib/parsers/ExtendedYearParser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,23 @@
+import { Parser } from "../Parser.js";
+
+import { parseNDigitsSigned } from "../utils.js";
+
+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"];
+}

backend/node_modules/date-fns/parse/_lib/parsers/FractionOfSecondParser.cjs

@@ -0,0 +1,26 @@
+"use strict";
+exports.FractionOfSecondParser = void 0;
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+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;

backend/node_modules/date-fns/parse/_lib/parsers/FractionOfSecondParser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,20 @@
+import { Parser } from "../Parser.js";
+
+import { mapValue, parseNDigits } from "../utils.js";
+
+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"];
+}

backend/node_modules/date-fns/parse/_lib/parsers/Hour0To11Parser.cjs

@@ -0,0 +1,41 @@
+"use strict";
+exports.Hour0To11Parser = void 0;
+var _constants = require("../constants.cjs");
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+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;

backend/node_modules/date-fns/parse/_lib/parsers/Hour0To11Parser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,35 @@
+import { numericPatterns } from "../constants.js";
+import { Parser } from "../Parser.js";
+
+import { parseNDigits, parseNumericPattern } from "../utils.js";
+
+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"];
+}

backend/node_modules/date-fns/parse/_lib/parsers/Hour0to23Parser.cjs

@@ -0,0 +1,36 @@
+"use strict";
+exports.Hour0to23Parser = void 0;
+var _constants = require("../constants.cjs");
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+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;

backend/node_modules/date-fns/parse/_lib/parsers/Hour0to23Parser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,30 @@
+import { numericPatterns } from "../constants.js";
+import { Parser } from "../Parser.js";
+
+import { parseNDigits, parseNumericPattern } from "../utils.js";
+
+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"];
+}

backend/node_modules/date-fns/parse/_lib/parsers/Hour1To24Parser.cjs

@@ -0,0 +1,37 @@
+"use strict";
+exports.Hour1To24Parser = void 0;
+var _constants = require("../constants.cjs");
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+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;

backend/node_modules/date-fns/parse/_lib/parsers/Hour1To24Parser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,31 @@
+import { numericPatterns } from "../constants.js";
+import { Parser } from "../Parser.js";
+
+import { parseNDigits, parseNumericPattern } from "../utils.js";
+
+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"];
+}

backend/node_modules/date-fns/parse/_lib/parsers/Hour1to12Parser.cjs

@@ -0,0 +1,43 @@
+"use strict";
+exports.Hour1to12Parser = void 0;
+var _constants = require("../constants.cjs");
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+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;

backend/node_modules/date-fns/parse/_lib/parsers/Hour1to12Parser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,37 @@
+import { numericPatterns } from "../constants.js";
+import { Parser } from "../Parser.js";
+
+import { parseNDigits, parseNumericPattern } from "../utils.js";
+
+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"];
+}

backend/node_modules/date-fns/parse/_lib/parsers/ISODayParser.cjs

@@ -0,0 +1,120 @@
+"use strict";
+exports.ISODayParser = void 0;
+var _index = require("../../../setISODay.cjs");
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+// 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;

backend/node_modules/date-fns/parse/_lib/parsers/ISODayParser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,117 @@
+import { setISODay } from "../../../setISODay.js";
+import { Parser } from "../Parser.js";
+
+import { mapValue, parseNDigits } from "../utils.js";
+
+// 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",
+  ];
+}

backend/node_modules/date-fns/parse/_lib/parsers/ISOTimezoneParser.cjs

@@ -0,0 +1,57 @@
+"use strict";
+exports.ISOTimezoneParser = void 0;
+var _index = require("../../../constructFrom.cjs");
+var _index2 = require("../../../_lib/getTimezoneOffsetInMilliseconds.cjs");
+var _constants = require("../constants.cjs");
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+// 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;

backend/node_modules/date-fns/parse/_lib/parsers/ISOTimezoneParser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,46 @@
+import { constructFrom } from "../../../constructFrom.js";
+import { getTimezoneOffsetInMilliseconds } from "../../../_lib/getTimezoneOffsetInMilliseconds.js";
+import { timezonePatterns } from "../constants.js";
+import { Parser } from "../Parser.js";
+
+import { parseTimezonePattern } from "../utils.js";
+
+// 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"];
+}

backend/node_modules/date-fns/parse/_lib/parsers/ISOTimezoneWithZParser.cjs

@@ -0,0 +1,57 @@
+"use strict";
+exports.ISOTimezoneWithZParser = void 0;
+var _index = require("../../../constructFrom.cjs");
+var _index2 = require("../../../_lib/getTimezoneOffsetInMilliseconds.cjs");
+var _constants = require("../constants.cjs");
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+// 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;

backend/node_modules/date-fns/parse/_lib/parsers/ISOTimezoneWithZParser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,46 @@
+import { constructFrom } from "../../../constructFrom.js";
+import { getTimezoneOffsetInMilliseconds } from "../../../_lib/getTimezoneOffsetInMilliseconds.js";
+import { timezonePatterns } from "../constants.js";
+import { Parser } from "../Parser.js";
+
+import { parseTimezonePattern } from "../utils.js";
+
+// 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"];
+}

backend/node_modules/date-fns/parse/_lib/parsers/ISOWeekParser.cjs

@@ -0,0 +1,53 @@
+"use strict";
+exports.ISOWeekParser = void 0;
+var _index = require("../../../setISOWeek.cjs");
+var _index2 = require("../../../startOfISOWeek.cjs");
+var _constants = require("../constants.cjs");
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+// 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;

backend/node_modules/date-fns/parse/_lib/parsers/ISOWeekParser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,47 @@
+import { setISOWeek } from "../../../setISOWeek.js";
+import { startOfISOWeek } from "../../../startOfISOWeek.js";
+import { numericPatterns } from "../constants.js";
+import { Parser } from "../Parser.js";
+
+import { parseNDigits, parseNumericPattern } from "../utils.js";
+
+// 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",
+  ];
+}

backend/node_modules/date-fns/parse/_lib/parsers/ISOWeekYearParser.cjs

@@ -0,0 +1,46 @@
+"use strict";
+exports.ISOWeekYearParser = void 0;
+var _index = require("../../../startOfISOWeek.cjs");
+var _index2 = require("../../../constructFrom.cjs");
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+// 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;

backend/node_modules/date-fns/parse/_lib/parsers/ISOWeekYearParser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,43 @@
+import { startOfISOWeek } from "../../../startOfISOWeek.js";
+import { constructFrom } from "../../../constructFrom.js";
+import { Parser } from "../Parser.js";
+
+import { parseNDigitsSigned } from "../utils.js";
+
+// 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",
+  ];
+}

backend/node_modules/date-fns/parse/_lib/parsers/LocalDayParser.cjs

@@ -0,0 +1,101 @@
+"use strict";
+exports.LocalDayParser = void 0;
+var _index = require("../../../setDay.cjs");
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+// 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;

backend/node_modules/date-fns/parse/_lib/parsers/LocalDayParser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,95 @@
+import { setDay } from "../../../setDay.js";
+import { Parser } from "../Parser.js";
+
+import { mapValue, parseNDigits } from "../utils.js";
+
+// 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",
+  ];
+}

backend/node_modules/date-fns/parse/_lib/parsers/LocalWeekParser.cjs

@@ -0,0 +1,55 @@
+"use strict";
+exports.LocalWeekParser = void 0;
+var _index = require("../../../setWeek.cjs");
+var _index2 = require("../../../startOfWeek.cjs");
+var _constants = require("../constants.cjs");
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+// 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;

backend/node_modules/date-fns/parse/_lib/parsers/LocalWeekParser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,46 @@
+import { setWeek } from "../../../setWeek.js";
+import { startOfWeek } from "../../../startOfWeek.js";
+import { numericPatterns } from "../constants.js";
+import { Parser } from "../Parser.js";
+
+import { parseNDigits, parseNumericPattern } from "../utils.js";
+
+// 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",
+  ];
+}

backend/node_modules/date-fns/parse/_lib/parsers/LocalWeekYearParser.cjs

@@ -0,0 +1,85 @@
+"use strict";
+exports.LocalWeekYearParser = void 0;
+var _index = require("../../../getWeekYear.cjs");
+
+var _index2 = require("../../../startOfWeek.cjs");
+var _Parser = require("../Parser.cjs");
+
+var _utils = require("../utils.cjs");
+
+// 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;

backend/node_modules/date-fns/parse/_lib/parsers/LocalWeekYearParser.d.cts

@@ -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[];
+}

backend/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[];
+}

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

@@ -0,0 +1,76 @@
+import { getWeekYear } from "../../../getWeekYear.js";
+
+import { startOfWeek } from "../../../startOfWeek.js";
+import { Parser } from "../Parser.js";
+
+import { mapValue, normalizeTwoDigitYear, parseNDigits } from "../utils.js";
+
+// 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",
+  ];
+}