chrono-node 2.3.6 → 2.3.9

package/src/locales/de/parsers/DETimeUnitRelativeFormatParser.ts

@@ -0,0 +1,42 @@
+import { ParsingContext } from "../../../chrono";
+import { NUMBER_PATTERN, parseNumberPattern, TIME_UNIT_DICTIONARY } from "../constants";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { reverseTimeUnits } from "../../../utils/timeunits";
+import { matchAnyPattern } from "../../../utils/pattern";
+
+export default class DETimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor() {
+        super();
+    }
+
+    innerPattern(): RegExp {
+        return new RegExp(
+            `(?:\\s*((?:nächste|kommende|folgende|letzte|vergangene|vorige|vor(?:her|an)gegangene)(?:s|n|m|r)?|vor|in)\\s*)?` +
+                `(${NUMBER_PATTERN})?` +
+                `(?:\\s*(nächste|kommende|folgende|letzte|vergangene|vorige|vor(?:her|an)gegangene)(?:s|n|m|r)?)?` +
+                `\\s*(${matchAnyPattern(TIME_UNIT_DICTIONARY)})`,
+            "i"
+        );
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const num = match[2] ? parseNumberPattern(match[2]) : 1;
+        const unit = TIME_UNIT_DICTIONARY[match[4].toLowerCase()];
+        let timeUnits = {};
+        timeUnits[unit] = num;
+
+        // Modifier
+        let modifier = match[1] || match[3] || "";
+        modifier = modifier.toLowerCase();
+        if (!modifier) {
+            return;
+        }
+
+        if (/vor/.test(modifier) || /letzte/.test(modifier) || /vergangen/.test(modifier)) {
+            timeUnits = reverseTimeUnits(timeUnits);
+        }
+
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}

package/src/locales/en/constants.ts

@@ -1,4 +1,4 @@
-import { OpUnitType } from "dayjs";
+import { OpUnitType, QUnitType } from "dayjs";
 import { matchAnyPattern, repeatedTimeunitPattern } from "../../utils/pattern";
 import { findMostLikelyADYear } from "../../calculation/years";
 import { TimeUnits } from "../../utils/timeunits";
@@ -133,7 +133,7 @@ export const ORDINAL_WORD_DICTIONARY: { [word: string]: number } = {
     "thirty-first": 31,
 };
 
-export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType } = {
+export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } = {
     sec: "second",
     second: "second",
     seconds: "second",
@@ -152,6 +152,9 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType } = {
     weeks: "week",
     month: "month",
     months: "month",
+    qtr: "quarter",
+    quarter: "quarter",
+    quarters: "quarter",
     y: "year",
     yr: "year",
     year: "year",

package/src/locales/en/index.ts

@@ -26,6 +26,7 @@ import { ParsedResult, ParsingOption } from "../../index";
 import { Chrono, Configuration } from "../../chrono";
 import SlashDateFormatParser from "../../common/parsers/SlashDateFormatParser";
 import ENTimeUnitCasualRelativeFormatParser from "./parsers/ENTimeUnitCasualRelativeFormatParser";
+import ENMergeRelativeDateRefiner from "./refiners/ENMergeRelativeDateRefiner";
 
 /**
  * Chrono object configured for parsing *casual* English
@@ -91,7 +92,7 @@ export function createConfiguration(strictMode = true, littleEndian = false): Co
                 new ENTimeUnitAgoFormatParser(strictMode),
                 new ENTimeUnitLaterFormatParser(strictMode),
             ],
-            refiners: [new ENMergeDateTimeRefiner(), new ENMergeDateRangeRefiner()],
+            refiners: [new ENMergeRelativeDateRefiner(), new ENMergeDateTimeRefiner(), new ENMergeDateRangeRefiner()],
         },
         strictMode
     );

package/src/locales/en/parsers/ENRelativeDateFormatParser.ts

@@ -6,7 +6,7 @@ import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/
 import { matchAnyPattern } from "../../../utils/pattern";
 
 const PATTERN = new RegExp(
-    `(this|next|last|past)\\s*(${matchAnyPattern(TIME_UNIT_DICTIONARY)})(?=\\s*)` + "(?=\\W|$)",
+    `(this|last|past|next|after\\s*this)\\s*(${matchAnyPattern(TIME_UNIT_DICTIONARY)})(?=\\s*)` + "(?=\\W|$)",
     "i"
 );
 
@@ -23,7 +23,7 @@ export default class ENRelativeDateFormatParser extends AbstractParserWithWordBo
         const unitWord = match[RELATIVE_WORD_GROUP].toLowerCase();
         const timeunit = TIME_UNIT_DICTIONARY[unitWord];
 
-        if (modifier == "next") {
+        if (modifier == "next" || modifier.startsWith("after")) {
             const timeUnits = {};
             timeUnits[timeunit] = 1;
             return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);

package/src/locales/en/parsers/ENTimeUnitCasualRelativeFormatParser.ts

@@ -4,7 +4,7 @@ import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { reverseTimeUnits } from "../../../utils/timeunits";
 
-const PATTERN = new RegExp(`(this|last|past|next|\\+|-)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+const PATTERN = new RegExp(`(this|last|past|next|after|\\+|-)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
 
 export default class ENTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
     innerPattern(): RegExp {

package/src/locales/en/refiners/ENMergeRelativeDateRefiner.ts

@@ -0,0 +1,58 @@
+import { MergingRefiner } from "../../../common/abstractRefiners";
+import { ParsingComponents, ParsingResult, ReferenceWithTimezone } from "../../../results";
+import { parseTimeUnits } from "../constants";
+import { reverseTimeUnits } from "../../../utils/timeunits";
+
+function hasImpliedEarlierReferenceDate(result: ParsingResult): boolean {
+    return result.text.match(/\s+(before|from)$/i) != null;
+}
+
+function hasImpliedLaterReferenceDate(result: ParsingResult): boolean {
+    return result.text.match(/\s+(after|since)$/i) != null;
+}
+
+/**
+ * Merges an absolute date with a relative date.
+ * - 2 weeks before 2020-02-13
+ * - 2 days after next Friday
+ */
+export default class ENMergeRelativeDateRefiner extends MergingRefiner {
+    patternBetween(): RegExp {
+        return /^\s*$/i;
+    }
+
+    shouldMergeResults(textBetween: string, currentResult: ParsingResult, nextResult: ParsingResult): boolean {
+        // Dates need to be next to each other to get merged
+        if (!textBetween.match(this.patternBetween())) {
+            return false;
+        }
+
+        // Check if any relative tokens were swallowed by the first date.
+        // E.g. [<relative_date1> from] [<date2>]
+        if (!hasImpliedEarlierReferenceDate(currentResult) && !hasImpliedLaterReferenceDate(currentResult)) {
+            return false;
+        }
+
+        // make sure that <date2> implies an absolute date
+        return !!nextResult.start.get("day") && !!nextResult.start.get("month") && !!nextResult.start.get("year");
+    }
+
+    mergeResults(textBetween: string, currentResult: ParsingResult, nextResult: ParsingResult): ParsingResult {
+        let timeUnits = parseTimeUnits(currentResult.text);
+        if (hasImpliedEarlierReferenceDate(currentResult)) {
+            timeUnits = reverseTimeUnits(timeUnits);
+        }
+
+        const components = ParsingComponents.createRelativeFromReference(
+            new ReferenceWithTimezone(nextResult.start.date()),
+            timeUnits
+        );
+
+        return new ParsingResult(
+            nextResult.reference,
+            currentResult.index,
+            `${currentResult.text}${textBetween}${nextResult.text}`,
+            components
+        );
+    }
+}

package/src/locales/fr/parsers/FRTimeUnitWithinFormatParser.ts

@@ -5,7 +5,7 @@ import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/
 
 export default class FRTimeUnitWithinFormatParser extends AbstractParserWithWordBoundaryChecking {
     innerPattern(): RegExp {
-        return new RegExp(`(?:dans|en|pour|pendant)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+        return new RegExp(`(?:dans|en|pour|pendant|de)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {

package/src/locales/ru/constants.ts

@@ -0,0 +1,344 @@
+import { OpUnitType, QUnitType } from "dayjs";
+import { matchAnyPattern, repeatedTimeunitPattern } from "../../utils/pattern";
+import { findMostLikelyADYear } from "../../calculation/years";
+import { TimeUnits } from "../../utils/timeunits";
+
+export const REGEX_PARTS = {
+    leftBoundary: "([^\\p{L}\\p{N}_]|^)",
+    rightBoundary: "(?=[^\\p{L}\\p{N}_]|$)",
+    flags: "iu",
+};
+
+export const WEEKDAY_DICTIONARY: { [word: string]: number } = {
+    воскресенье: 0,
+    воскресенья: 0,
+    вск: 0,
+    "вск.": 0,
+    понедельник: 1,
+    понедельника: 1,
+    пн: 1,
+    "пн.": 1,
+    вторник: 2,
+    вторника: 2,
+    вт: 2,
+    "вт.": 2,
+    среда: 3,
+    среды: 3,
+    среду: 3,
+    ср: 3,
+    "ср.": 3,
+    четверг: 4,
+    четверга: 4,
+    чт: 4,
+    "чт.": 4,
+    пятница: 5,
+    пятницу: 5,
+    пятницы: 5,
+    пт: 5,
+    "пт.": 5,
+    суббота: 6,
+    субботу: 6,
+    субботы: 6,
+    сб: 6,
+    "сб.": 6,
+};
+
+export const FULL_MONTH_NAME_DICTIONARY: { [word: string]: number } = {
+    январь: 1,
+    января: 1,
+    январе: 1,
+    февряль: 2,
+    февряля: 2,
+    февряле: 2,
+    март: 3,
+    марта: 3,
+    марте: 3,
+    апрель: 4,
+    апреля: 4,
+    апреле: 4,
+    май: 5,
+    мая: 5,
+    мае: 5,
+    июнь: 6,
+    июня: 6,
+    июне: 6,
+    июль: 7,
+    июля: 7,
+    июле: 7,
+    август: 8,
+    августа: 8,
+    августе: 8,
+    сентябрь: 9,
+    сентября: 9,
+    сентябре: 9,
+    октябрь: 10,
+    октября: 10,
+    октябре: 10,
+    ноябрь: 11,
+    ноября: 11,
+    ноябре: 11,
+    декабрь: 12,
+    декабря: 12,
+    декабре: 12,
+};
+
+export const MONTH_DICTIONARY: { [word: string]: number } = {
+    ...FULL_MONTH_NAME_DICTIONARY,
+    янв: 1,
+    "янв.": 1,
+    фев: 2,
+    "фев.": 2,
+    мар: 3,
+    "мар.": 3,
+    апр: 4,
+    "апр.": 4,
+    авг: 8,
+    "авг.": 8,
+    сен: 9,
+    "сен.": 9,
+    окт: 10,
+    "окт.": 10,
+    ноя: 11,
+    "ноя.": 11,
+    дек: 12,
+    "дек.": 12,
+};
+
+export const INTEGER_WORD_DICTIONARY: { [word: string]: number } = {
+    один: 1,
+    одна: 1,
+    одной: 1,
+    одну: 1,
+    две: 2,
+    два: 2,
+    двух: 2,
+    три: 3,
+    трех: 3,
+    трёх: 3,
+    четыре: 4,
+    четырех: 4,
+    четырёх: 4,
+    пять: 5,
+    пяти: 5,
+    шесть: 6,
+    шести: 6,
+    семь: 7,
+    семи: 7,
+    восемь: 8,
+    восемьми: 8,
+    девять: 9,
+    девяти: 9,
+    десять: 10,
+    десяти: 10,
+    одиннадцать: 11,
+    одиннадцати: 11,
+    двенадцать: 12,
+    двенадцати: 12,
+};
+
+export const ORDINAL_WORD_DICTIONARY: { [word: string]: number } = {
+    первое: 1,
+    первого: 1,
+    второе: 2,
+    второго: 2,
+    третье: 3,
+    третьего: 3,
+    четвертое: 4,
+    четвертого: 4,
+    пятое: 5,
+    пятого: 5,
+    шестое: 6,
+    шестого: 6,
+    седьмое: 7,
+    седьмого: 7,
+    восьмое: 8,
+    восьмого: 8,
+    девятое: 9,
+    девятого: 9,
+    десятое: 10,
+    десятого: 10,
+    одиннадцатое: 11,
+    одиннадцатого: 11,
+    двенадцатое: 12,
+    двенадцатого: 12,
+    тринадцатое: 13,
+    тринадцатого: 13,
+    четырнадцатое: 14,
+    четырнадцатого: 14,
+    пятнадцатое: 15,
+    пятнадцатого: 15,
+    шестнадцатое: 16,
+    шестнадцатого: 16,
+    семнадцатое: 17,
+    семнадцатого: 17,
+    восемнадцатое: 18,
+    восемнадцатого: 18,
+    девятнадцатое: 19,
+    девятнадцатого: 19,
+    двадцатое: 20,
+    двадцатого: 20,
+    "двадцать первое": 21,
+    "двадцать первого": 21,
+    "двадцать второе": 22,
+    "двадцать второго": 22,
+    "двадцать третье": 23,
+    "двадцать третьего": 23,
+    "двадцать четвертое": 24,
+    "двадцать четвертого": 24,
+    "двадцать пятое": 25,
+    "двадцать пятого": 25,
+    "двадцать шестое": 26,
+    "двадцать шестого": 26,
+    "двадцать седьмое": 27,
+    "двадцать седьмого": 27,
+    "двадцать восьмое": 28,
+    "двадцать восьмого": 28,
+    "двадцать девятое": 29,
+    "двадцать девятого": 29,
+    "тридцатое": 30,
+    "тридцатого": 30,
+    "тридцать первое": 31,
+    "тридцать первого": 31,
+};
+
+export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } = {
+    сек: "second",
+    секунда: "second",
+    секунд: "second",
+    секунды: "second",
+    секунду: "second",
+    секундочка: "second",
+    секундочки: "second",
+    секундочек: "second",
+    секундочку: "second",
+    мин: "minute",
+    минута: "minute",
+    минут: "minute",
+    минуты: "minute",
+    минуту: "minute",
+    минуток: "minute",
+    минутки: "minute",
+    минутку: "minute",
+    час: "hour",
+    часов: "hour",
+    часа: "hour",
+    часу: "hour",
+    часиков: "hour",
+    часика: "hour",
+    часике: "hour",
+    часик: "hour",
+    день: "d",
+    дня: "d",
+    дней: "d",
+    суток: "d",
+    сутки: "d",
+    неделя: "week",
+    неделе: "week",
+    недели: "week",
+    неделю: "week",
+    недель: "week",
+    недельке: "week",
+    недельки: "week",
+    неделек: "week",
+    месяц: "month",
+    месяце: "month",
+    месяцев: "month",
+    месяца: "month",
+    квартал: "quarter",
+    квартале: "quarter",
+    кварталов: "quarter",
+    год: "year",
+    года: "year",
+    году: "year",
+    годов: "year",
+    лет: "year",
+    годик: "year",
+    годика: "year",
+    годиков: "year",
+};
+
+//-----------------------------
+
+export const NUMBER_PATTERN = `(?:${matchAnyPattern(
+    INTEGER_WORD_DICTIONARY
+)}|[0-9]+|[0-9]+\\.[0-9]+|пол|несколько|пар(?:ы|у)|\\s{0,3})`;
+
+export function parseNumberPattern(match: string): number {
+    const num = match.toLowerCase();
+    if (INTEGER_WORD_DICTIONARY[num] !== undefined) {
+        return INTEGER_WORD_DICTIONARY[num];
+    }
+    if (num.match(/несколько/)) {
+        return 3;
+    } else if (num.match(/пол/)) {
+        return 0.5;
+    } else if (num.match(/пар/)) {
+        return 2;
+    } else if (num === "") {
+        return 1;
+    }
+    return parseFloat(num);
+}
+
+//-----------------------------
+
+export const ORDINAL_NUMBER_PATTERN = `(?:${matchAnyPattern(ORDINAL_WORD_DICTIONARY)}|[0-9]{1,2}(?:го|ого|е|ое)?)`;
+export function parseOrdinalNumberPattern(match: string): number {
+    let num = match.toLowerCase();
+    if (ORDINAL_WORD_DICTIONARY[num] !== undefined) {
+        return ORDINAL_WORD_DICTIONARY[num];
+    }
+
+    num = num.replace(/(?:st|nd|rd|th)$/i, "");
+    return parseInt(num);
+}
+
+//-----------------------------
+
+const year = "(?:\\s+(?:году|года|год|г|г.))?";
+export const YEAR_PATTERN = `(?:[1-9][0-9]{0,3}${year}\\s*(?:н.э.|до н.э.|н. э.|до н. э.)|[1-2][0-9]{3}${year}|[5-9][0-9]${year})`;
+export function parseYear(match: string): number {
+    if (/(год|года|г|г.)/i.test(match)) {
+        match = match.replace(/(год|года|г|г.)/i, "");
+    }
+
+    if (/(до н.э.|до н. э.)/i.test(match)) {
+        //Before Common Era
+        match = match.replace(/(до н.э.|до н. э.)/i, "");
+        return -parseInt(match);
+    }
+
+    if (/(н. э.|н.э.)/i.test(match)) {
+        //Common Era
+        match = match.replace(/(н. э.|н.э.)/i, "");
+        return parseInt(match);
+    }
+
+    const rawYearNumber = parseInt(match);
+    return findMostLikelyADYear(rawYearNumber);
+}
+
+//-----------------------------
+
+const SINGLE_TIME_UNIT_PATTERN = `(${NUMBER_PATTERN})\\s{0,3}(${matchAnyPattern(TIME_UNIT_DICTIONARY)})`;
+const SINGLE_TIME_UNIT_REGEX = new RegExp(SINGLE_TIME_UNIT_PATTERN, "i");
+
+export const TIME_UNITS_PATTERN = repeatedTimeunitPattern(`(?:(?:около|примерно)\\s{0,3})?`, SINGLE_TIME_UNIT_PATTERN);
+
+export function parseTimeUnits(timeunitText): TimeUnits {
+    const fragments = {};
+    let remainingText = timeunitText;
+    let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
+    while (match) {
+        collectDateTimeFragment(fragments, match);
+        remainingText = remainingText.substring(match[0].length).trim();
+        match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
+    }
+    return fragments;
+}
+
+function collectDateTimeFragment(fragments, match) {
+    const num = parseNumberPattern(match[1]);
+    const unit = TIME_UNIT_DICTIONARY[match[2].toLowerCase()];
+    fragments[unit] = num;
+}

package/src/locales/ru/index.ts

@@ -0,0 +1,84 @@
+/**
+ * Chrono components for Russian support (*parsers*, *refiners*, and *configuration*)
+ *
+ * @module
+ */
+
+import RUTimeUnitWithinFormatParser from "./parsers/RUTimeUnitWithinFormatParser";
+import RUMonthNameLittleEndianParser from "./parsers/RUMonthNameLittleEndianParser";
+import RUMonthNameParser from "./parsers/RUMonthNameParser";
+import RUTimeExpressionParser from "./parsers/RUTimeExpressionParser";
+import RUTimeUnitAgoFormatParser from "./parsers/RUTimeUnitAgoFormatParser";
+import RUMergeDateRangeRefiner from "./refiners/RUMergeDateRangeRefiner";
+import RUMergeDateTimeRefiner from "./refiners/RUMergeDateTimeRefiner";
+
+import { includeCommonConfiguration } from "../../configurations";
+import RUCasualDateParser from "./parsers/RUCasualDateParser";
+import RUCasualTimeParser from "./parsers/RUCasualTimeParser";
+import RUWeekdayParser from "./parsers/RUWeekdayParser";
+import RURelativeDateFormatParser from "./parsers/RURelativeDateFormatParser";
+
+import { ParsedResult, ParsingOption } from "../../index";
+import { Chrono, Configuration } from "../../chrono";
+import SlashDateFormatParser from "../../common/parsers/SlashDateFormatParser";
+import RUTimeUnitCasualRelativeFormatParser from "./parsers/RUTimeUnitCasualRelativeFormatParser";
+
+/**
+ * Chrono object configured for parsing *casual* Russian
+ */
+export const casual = new Chrono(createCasualConfiguration());
+
+/**
+ * Chrono object configured for parsing *strict* Russian
+ */
+export const strict = new Chrono(createConfiguration(true));
+
+/**
+ * A shortcut for ru.casual.parse()
+ */
+export function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[] {
+    return casual.parse(text, ref, option);
+}
+
+/**
+ * A shortcut for ru.casual.parseDate()
+ */
+export function parseDate(text: string, ref?: Date, option?: ParsingOption): Date {
+    return casual.parseDate(text, ref, option);
+}
+
+/**
+ * Create a default *casual* {@Link Configuration} for Russian chrono.
+ * It calls {@Link createConfiguration} and includes additional parsers.
+ */
+export function createCasualConfiguration(): Configuration {
+    const option = createConfiguration(false);
+    option.parsers.unshift(new RUCasualDateParser());
+    option.parsers.unshift(new RUCasualTimeParser());
+    option.parsers.unshift(new RUMonthNameParser());
+    option.parsers.unshift(new RURelativeDateFormatParser());
+    option.parsers.unshift(new RUTimeUnitCasualRelativeFormatParser());
+    return option;
+}
+
+/**
+ * Create a default {@Link Configuration} for Russian chrono
+ *
+ * @param strictMode If the timeunit mentioning should be strict, not casual
+ */
+export function createConfiguration(strictMode = true): Configuration {
+    return includeCommonConfiguration(
+        {
+            parsers: [
+                new SlashDateFormatParser(true),
+                new RUTimeUnitWithinFormatParser(),
+                new RUMonthNameLittleEndianParser(),
+                new RUWeekdayParser(),
+                new RUTimeExpressionParser(strictMode),
+                new RUTimeUnitAgoFormatParser(),
+            ],
+            refiners: [new RUMergeDateTimeRefiner(), new RUMergeDateRangeRefiner()],
+        },
+        strictMode
+    );
+}

package/src/locales/ru/parsers/RUCasualDateParser.ts

@@ -0,0 +1,44 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents, ParsingResult } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import * as references from "../../../common/casualReferences";
+import { REGEX_PARTS } from "../constants";
+
+const PATTERN = new RegExp(
+    `(?:с|со)?\\s*(сегодня|вчера|завтра|послезавтра|позавчера)${REGEX_PARTS.rightBoundary}`,
+    REGEX_PARTS.flags
+);
+
+export default class RUCasualDateParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(context: ParsingContext): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult {
+        const lowerText = match[1].toLowerCase();
+        const component = context.createParsingComponents();
+
+        switch (lowerText) {
+            case "сегодня":
+                return references.today(context.reference);
+
+            case "вчера":
+                return references.yesterday(context.reference);
+
+            case "завтра":
+                return references.tomorrow(context.reference);
+
+            case "послезавтра":
+                return references.theDayAfter(context.reference, 2);
+
+            case "позавчера":
+                return references.theDayBefore(context.reference, 2);
+        }
+
+        return component;
+    }
+}