@checkdigit/time 1.0.0-PR.11-7d2f

package/src/date-fns/parse/_lib/parsers/ISOTimezoneWithZParser.ts

@@ -0,0 +1,34 @@
+import constructFrom from '../../../constructFrom/index';
+import getTimezoneOffsetInMilliseconds from '../../../_lib/getTimezoneOffsetInMilliseconds/index';
+import { timezonePatterns } from '../constants';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+import { parseTimezonePattern } from '../utils';
+
+// Timezone (ISO-8601. +00:00 is `'Z'`)
+export class ISOTimezoneWithZParser extends Parser<number> {
+  priority = 10;
+
+  parse(dateString: string, token: string): ParseResult<number> {
+    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<DateType extends Date>(date: DateType, flags: ParseFlags, value: number): DateType {
+    if (flags.timestampIsSet) return date;
+    return constructFrom(date, date.getTime() - getTimezoneOffsetInMilliseconds(date) - value);
+  }
+
+  incompatibleTokens = ['t', 'T', 'x'];
+}

package/src/date-fns/parse/_lib/parsers/ISOWeekParser.ts

@@ -0,0 +1,33 @@
+import type { Match } from '../../../locale/types';
+import setISOWeek from '../../../setISOWeek/index';
+import startOfISOWeek from '../../../startOfISOWeek/index';
+import { numericPatterns } from '../constants';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+import { parseNDigits, parseNumericPattern } from '../utils';
+
+// ISO week of year
+export class ISOWeekParser extends Parser<number> {
+  priority = 100;
+
+  parse(dateString: string, token: string, match: Match): ParseResult<number> {
+    switch (token) {
+      case 'I':
+        return parseNumericPattern(numericPatterns.week, dateString);
+      case 'Io':
+        return match.ordinalNumber(dateString, { unit: 'week' });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  override validate<DateType extends Date>(_date: DateType, value: number): boolean {
+    return value >= 1 && value <= 53;
+  }
+
+  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
+    return startOfISOWeek(setISOWeek(date, value));
+  }
+
+  incompatibleTokens = ['y', 'Y', 'u', 'q', 'Q', 'M', 'L', 'w', 'd', 'D', 'e', 'c', 't', 'T'];
+}

package/src/date-fns/parse/_lib/parsers/ISOWeekYearParser.ts

@@ -0,0 +1,27 @@
+import startOfISOWeek from '../../../startOfISOWeek/index';
+import constructFrom from '../../../constructFrom/index';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+import { parseNDigitsSigned } from '../utils';
+
+// ISO week-numbering year
+export class ISOWeekYearParser extends Parser<number> {
+  priority = 130;
+
+  parse(dateString: string, token: string): ParseResult<number> {
+    if (token === 'R') {
+      return parseNDigitsSigned(4, dateString);
+    }
+
+    return parseNDigitsSigned(token.length, dateString);
+  }
+
+  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
+    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'];
+}

package/src/date-fns/parse/_lib/parsers/LocalDayParser.ts

@@ -0,0 +1,77 @@
+import type { Match } from '../../../locale/types';
+import setDay from '../../../setDay/index';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult, ParserOptions } from '../types';
+import { mapValue, parseNDigits } from '../utils';
+
+// Local day of week
+export class LocalDayParser extends Parser<number> {
+  priority = 90;
+  parse(dateString: string, token: string, match: Match, options: ParserOptions): ParseResult<number> {
+    const valueCallback = (value: number) => {
+      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' })
+        );
+    }
+  }
+
+  override validate<DateType extends Date>(_date: DateType, value: number): boolean {
+    return value >= 0 && value <= 6;
+  }
+
+  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number, options: ParserOptions): DateType {
+    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'];
+}

package/src/date-fns/parse/_lib/parsers/LocalWeekParser.ts

@@ -0,0 +1,33 @@
+import type { Match } from '../../../locale/types';
+import setWeek from '../../../setWeek/index';
+import startOfWeek from '../../../startOfWeek/index';
+import { numericPatterns } from '../constants';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult, ParserOptions } from '../types';
+import { parseNDigits, parseNumericPattern } from '../utils';
+
+// Local week of year
+export class LocalWeekParser extends Parser<number> {
+  priority = 100;
+
+  parse(dateString: string, token: string, match: Match): ParseResult<number> {
+    switch (token) {
+      case 'w':
+        return parseNumericPattern(numericPatterns.week, dateString);
+      case 'wo':
+        return match.ordinalNumber(dateString, { unit: 'week' });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  override validate<DateType extends Date>(_date: DateType, value: number): boolean {
+    return value >= 1 && value <= 53;
+  }
+
+  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number, options: ParserOptions): DateType {
+    return startOfWeek(setWeek(date, value, options), options);
+  }
+
+  incompatibleTokens = ['y', 'R', 'u', 'q', 'Q', 'M', 'L', 'I', 'd', 'D', 'i', 't', 'T'];
+}

package/src/date-fns/parse/_lib/parsers/LocalWeekYearParser.ts

@@ -0,0 +1,60 @@
+import getWeekYear from '../../../getWeekYear/index';
+import type { Match } from '../../../locale/types';
+import startOfWeek from '../../../startOfWeek/index';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult, ParserOptions } from '../types';
+import { mapValue, normalizeTwoDigitYear, parseNDigits } from '../utils';
+import type { YearParserValue } from './YearParser';
+
+// Local week-numbering year
+export class LocalWeekYearParser extends Parser<YearParserValue> {
+  priority = 130;
+
+  parse(dateString: string, token: string, match: Match): ParseResult<YearParserValue> {
+    const valueCallback = (year: number) => ({
+      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);
+    }
+  }
+
+  override validate<DateType extends Date>(_date: DateType, value: YearParserValue): boolean {
+    return value.isTwoDigitYear || value.year > 0;
+  }
+
+  set<DateType extends Date>(
+    date: DateType,
+    flags: ParseFlags,
+    value: YearParserValue,
+    options: ParserOptions
+  ): DateType {
+    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'];
+}

package/src/date-fns/parse/_lib/parsers/MinuteParser.ts

@@ -0,0 +1,31 @@
+import type { Match } from '../../../locale/types';
+import { numericPatterns } from '../constants';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+import { parseNDigits, parseNumericPattern } from '../utils';
+
+export class MinuteParser extends Parser<number> {
+  priority = 60;
+
+  parse(dateString: string, token: string, match: Match): ParseResult<number> {
+    switch (token) {
+      case 'm':
+        return parseNumericPattern(numericPatterns.minute, dateString);
+      case 'mo':
+        return match.ordinalNumber(dateString, { unit: 'minute' });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  override validate<DateType extends Date>(_date: DateType, value: number): boolean {
+    return value >= 0 && value <= 59;
+  }
+
+  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
+    date.setMinutes(value, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ['t', 'T'];
+}

package/src/date-fns/parse/_lib/parsers/MonthParser.ts

@@ -0,0 +1,66 @@
+import type { Match } from '../../../locale/types';
+import { numericPatterns } from '../constants';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+import { mapValue, parseNDigits, parseNumericPattern } from '../utils';
+
+export class MonthParser extends Parser<number> {
+  incompatibleTokens = ['Y', 'R', 'q', 'Q', 'L', 'w', 'I', 'D', 'i', 'e', 'c', 't', 'T'];
+  priority = 110;
+
+  parse(dateString: string, token: string, match: Match): ParseResult<number> {
+    const valueCallback = (value: number) => value - 1;
+
+    switch (token) {
+      // 1, 2, ..., 12
+      case 'M':
+        return mapValue(parseNumericPattern(numericPatterns.month, dateString), valueCallback);
+      // 01, 02, ..., 12
+      case 'MM':
+        return mapValue(parseNDigits(2, dateString), valueCallback);
+      // 1st, 2nd, ..., 12th
+      case 'Mo':
+        return mapValue(
+          match.ordinalNumber(dateString, {
+            unit: 'month',
+          }),
+          valueCallback
+        );
+      // Jan, Feb, ..., Dec
+      case 'MMM':
+        return (
+          match.month(dateString, {
+            width: 'abbreviated',
+            context: 'formatting',
+          }) || match.month(dateString, { width: 'narrow', context: 'formatting' })
+        );
+      // J, F, ..., D
+      case 'MMMMM':
+        return match.month(dateString, {
+          width: 'narrow',
+          context: 'formatting',
+        });
+      // January, February, ..., December
+      case 'MMMM':
+      default:
+        return (
+          match.month(dateString, { width: 'wide', context: 'formatting' }) ||
+          match.month(dateString, {
+            width: 'abbreviated',
+            context: 'formatting',
+          }) ||
+          match.month(dateString, { width: 'narrow', context: 'formatting' })
+        );
+    }
+  }
+
+  override validate<DateType extends Date>(_date: DateType, value: number): boolean {
+    return value >= 0 && value <= 11;
+  }
+
+  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
+    date.setMonth(value, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+}

package/src/date-fns/parse/_lib/parsers/QuarterParser.ts

@@ -0,0 +1,67 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+import { parseNDigits } from '../utils';
+
+export class QuarterParser extends Parser<number> {
+  priority = 120;
+
+  parse(dateString: string, token: string, match: Match): ParseResult<number> {
+    switch (token) {
+      // 1, 2, 3, 4
+      case 'Q':
+      case 'QQ': // 01, 02, 03, 04
+        return parseNDigits(token.length, dateString);
+      // 1st, 2nd, 3rd, 4th
+      case 'Qo':
+        return match.ordinalNumber(dateString, { unit: 'quarter' });
+      // Q1, Q2, Q3, Q4
+      case 'QQQ':
+        return (
+          match.quarter(dateString, {
+            width: 'abbreviated',
+            context: 'formatting',
+          }) ||
+          match.quarter(dateString, {
+            width: 'narrow',
+            context: 'formatting',
+          })
+        );
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case 'QQQQQ':
+        return match.quarter(dateString, {
+          width: 'narrow',
+          context: 'formatting',
+        });
+      // 1st quarter, 2nd quarter, ...
+      case 'QQQQ':
+      default:
+        return (
+          match.quarter(dateString, {
+            width: 'wide',
+            context: 'formatting',
+          }) ||
+          match.quarter(dateString, {
+            width: 'abbreviated',
+            context: 'formatting',
+          }) ||
+          match.quarter(dateString, {
+            width: 'narrow',
+            context: 'formatting',
+          })
+        );
+    }
+  }
+
+  override validate<DateType extends Date>(_date: DateType, value: number): boolean {
+    return value >= 1 && value <= 4;
+  }
+
+  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
+    date.setMonth((value - 1) * 3, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ['Y', 'R', 'q', 'M', 'L', 'w', 'I', 'd', 'D', 'i', 'e', 'c', 't', 'T'];
+}

package/src/date-fns/parse/_lib/parsers/SecondParser.ts

@@ -0,0 +1,31 @@
+import type { Match } from '../../../locale/types';
+import { numericPatterns } from '../constants';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+import { parseNDigits, parseNumericPattern } from '../utils';
+
+export class SecondParser extends Parser<number> {
+  priority = 50;
+
+  parse(dateString: string, token: string, match: Match): ParseResult<number> {
+    switch (token) {
+      case 's':
+        return parseNumericPattern(numericPatterns.second, dateString);
+      case 'so':
+        return match.ordinalNumber(dateString, { unit: 'second' });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  override validate<DateType extends Date>(_date: DateType, value: number): boolean {
+    return value >= 0 && value <= 59;
+  }
+
+  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
+    date.setSeconds(value, 0);
+    return date;
+  }
+
+  incompatibleTokens = ['t', 'T'];
+}

package/src/date-fns/parse/_lib/parsers/StandAloneLocalDayParser.ts

@@ -0,0 +1,78 @@
+import type { Match } from '../../../locale/types';
+import setDay from '../../../setDay/index';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult, ParserOptions } from '../types';
+import { mapValue, parseNDigits } from '../utils';
+
+// Stand-alone local day of week
+export class StandAloneLocalDayParser extends Parser<number> {
+  priority = 90;
+
+  parse(dateString: string, token: string, match: Match, options: ParserOptions): ParseResult<number> {
+    const valueCallback = (value: number) => {
+      const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
+      return ((value + options.weekStartsOn + 6) % 7) + wholeWeekDays;
+    };
+
+    switch (token) {
+      // 3
+      case 'c':
+      case 'cc': // 03
+        return mapValue(parseNDigits(token.length, dateString), valueCallback);
+      // 3rd
+      case 'co':
+        return mapValue(
+          match.ordinalNumber(dateString, {
+            unit: 'day',
+          }),
+          valueCallback
+        );
+      // Tue
+      case 'ccc':
+        return (
+          match.day(dateString, {
+            width: 'abbreviated',
+            context: 'standalone',
+          }) ||
+          match.day(dateString, { width: 'short', context: 'standalone' }) ||
+          match.day(dateString, { width: 'narrow', context: 'standalone' })
+        );
+      // T
+      case 'ccccc':
+        return match.day(dateString, {
+          width: 'narrow',
+          context: 'standalone',
+        });
+      // Tu
+      case 'cccccc':
+        return (
+          match.day(dateString, { width: 'short', context: 'standalone' }) ||
+          match.day(dateString, { width: 'narrow', context: 'standalone' })
+        );
+      // Tuesday
+      case 'cccc':
+      default:
+        return (
+          match.day(dateString, { width: 'wide', context: 'standalone' }) ||
+          match.day(dateString, {
+            width: 'abbreviated',
+            context: 'standalone',
+          }) ||
+          match.day(dateString, { width: 'short', context: 'standalone' }) ||
+          match.day(dateString, { width: 'narrow', context: 'standalone' })
+        );
+    }
+  }
+
+  override validate<DateType extends Date>(_date: DateType, value: number): boolean {
+    return value >= 0 && value <= 6;
+  }
+
+  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number, options: ParserOptions): DateType {
+    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', 'e', 't', 'T'];
+}

package/src/date-fns/parse/_lib/parsers/StandAloneMonthParser.ts

@@ -0,0 +1,67 @@
+import type { Match } from '../../../locale/types';
+import { numericPatterns } from '../constants';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+import { mapValue, parseNDigits, parseNumericPattern } from '../utils';
+
+export class StandAloneMonthParser extends Parser<number> {
+  priority = 110;
+
+  parse(dateString: string, token: string, match: Match): ParseResult<number> {
+    const valueCallback = (value: number) => value - 1;
+
+    switch (token) {
+      // 1, 2, ..., 12
+      case 'L':
+        return mapValue(parseNumericPattern(numericPatterns.month, dateString), valueCallback);
+      // 01, 02, ..., 12
+      case 'LL':
+        return mapValue(parseNDigits(2, dateString), valueCallback);
+      // 1st, 2nd, ..., 12th
+      case 'Lo':
+        return mapValue(
+          match.ordinalNumber(dateString, {
+            unit: 'month',
+          }),
+          valueCallback
+        );
+      // Jan, Feb, ..., Dec
+      case 'LLL':
+        return (
+          match.month(dateString, {
+            width: 'abbreviated',
+            context: 'standalone',
+          }) || match.month(dateString, { width: 'narrow', context: 'standalone' })
+        );
+      // J, F, ..., D
+      case 'LLLLL':
+        return match.month(dateString, {
+          width: 'narrow',
+          context: 'standalone',
+        });
+      // January, February, ..., December
+      case 'LLLL':
+      default:
+        return (
+          match.month(dateString, { width: 'wide', context: 'standalone' }) ||
+          match.month(dateString, {
+            width: 'abbreviated',
+            context: 'standalone',
+          }) ||
+          match.month(dateString, { width: 'narrow', context: 'standalone' })
+        );
+    }
+  }
+
+  override validate<DateType extends Date>(_date: DateType, value: number): boolean {
+    return value >= 0 && value <= 11;
+  }
+
+  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
+    date.setMonth(value, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ['Y', 'R', 'q', 'Q', 'M', 'w', 'I', 'D', 'i', 'e', 'c', 't', 'T'];
+}

package/src/date-fns/parse/_lib/parsers/StandAloneQuarterParser.ts

@@ -0,0 +1,67 @@
+import type { Match } from '../../../locale/types';
+import { Parser } from '../Parser';
+import type { ParseFlags, ParseResult } from '../types';
+import { parseNDigits } from '../utils';
+
+export class StandAloneQuarterParser extends Parser<number> {
+  priority = 120;
+
+  parse(dateString: string, token: string, match: Match): ParseResult<number> {
+    switch (token) {
+      // 1, 2, 3, 4
+      case 'q':
+      case 'qq': // 01, 02, 03, 04
+        return parseNDigits(token.length, dateString);
+      // 1st, 2nd, 3rd, 4th
+      case 'qo':
+        return match.ordinalNumber(dateString, { unit: 'quarter' });
+      // Q1, Q2, Q3, Q4
+      case 'qqq':
+        return (
+          match.quarter(dateString, {
+            width: 'abbreviated',
+            context: 'standalone',
+          }) ||
+          match.quarter(dateString, {
+            width: 'narrow',
+            context: 'standalone',
+          })
+        );
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case 'qqqqq':
+        return match.quarter(dateString, {
+          width: 'narrow',
+          context: 'standalone',
+        });
+      // 1st quarter, 2nd quarter, ...
+      case 'qqqq':
+      default:
+        return (
+          match.quarter(dateString, {
+            width: 'wide',
+            context: 'standalone',
+          }) ||
+          match.quarter(dateString, {
+            width: 'abbreviated',
+            context: 'standalone',
+          }) ||
+          match.quarter(dateString, {
+            width: 'narrow',
+            context: 'standalone',
+          })
+        );
+    }
+  }
+
+  override validate<DateType extends Date>(_date: DateType, value: number): boolean {
+    return value >= 1 && value <= 4;
+  }
+
+  set<DateType extends Date>(date: DateType, _flags: ParseFlags, value: number): DateType {
+    date.setMonth((value - 1) * 3, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = ['Y', 'R', 'Q', 'M', 'L', 'w', 'I', 'd', 'D', 'i', 'e', 'c', 't', 'T'];
+}