@checkdigit/time 1.0.0-PR.11-fede → 1.1.0

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

@@ -1,34 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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'];
-}