chrono-node 2.3.8 → 2.3.9

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

@@ -0,0 +1,75 @@
+import { REGEX_PARTS, TIME_UNIT_DICTIONARY } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import dayjs from "dayjs";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { matchAnyPattern } from "../../../utils/pattern";
+
+const PATTERN = new RegExp(
+    `(в прошлом|на прошлой|на следующей|в следующем|на этой|в этом)\\s*(${matchAnyPattern(
+        TIME_UNIT_DICTIONARY
+    )})(?=\\s*)${REGEX_PARTS.rightBoundary}`,
+    REGEX_PARTS.flags
+);
+
+const MODIFIER_WORD_GROUP = 1;
+const RELATIVE_WORD_GROUP = 2;
+
+export default class RURelativeDateFormatParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const modifier = match[MODIFIER_WORD_GROUP].toLowerCase();
+        const unitWord = match[RELATIVE_WORD_GROUP].toLowerCase();
+        const timeunit = TIME_UNIT_DICTIONARY[unitWord];
+
+        if (modifier == "на следующей" || modifier == "в следующем") {
+            const timeUnits = {};
+            timeUnits[timeunit] = 1;
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+        }
+
+        if (modifier == "в прошлом" || modifier == "на прошлой") {
+            const timeUnits = {};
+            timeUnits[timeunit] = -1;
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+        }
+
+        const components = context.createParsingComponents();
+        let date = dayjs(context.reference.instant);
+
+        // This week
+        if (timeunit.match(/week/i)) {
+            date = date.add(-date.get("d"), "d");
+            components.imply("day", date.date());
+            components.imply("month", date.month() + 1);
+            components.imply("year", date.year());
+        }
+
+        // This month
+        else if (timeunit.match(/month/i)) {
+            date = date.add(-date.date() + 1, "d");
+            components.imply("day", date.date());
+            components.assign("year", date.year());
+            components.assign("month", date.month() + 1);
+        }
+
+        // This year
+        else if (timeunit.match(/year/i)) {
+            date = date.add(-date.date() + 1, "d");
+            date = date.add(-date.month(), "month");
+
+            components.imply("day", date.date());
+            components.imply("month", date.month() + 1);
+            components.assign("year", date.year());
+        }
+
+        return components;
+    }
+}

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

@@ -0,0 +1,64 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { Meridiem } from "../../../index";
+import { AbstractTimeExpressionParser } from "../../../common/parsers/AbstractTimeExpressionParser";
+import { REGEX_PARTS } from "../constants";
+
+export default class RUTimeExpressionParser extends AbstractTimeExpressionParser {
+    constructor(strictMode) {
+        super(strictMode);
+    }
+
+    patternFlags(): string {
+        return REGEX_PARTS.flags;
+    }
+
+    primaryPatternLeftBoundary(): string {
+        return `(^|\\s|T|(?:[^\\p{L}\\p{N}_]))`;
+    }
+
+    followingPhase(): string {
+        return `\\s*(?:\\-|\\–|\\~|\\〜|до|и|по|\\?)\\s*`;
+    }
+
+    primaryPrefix(): string {
+        return `(?:(?:в|с)\\s*)??`;
+    }
+
+    primarySuffix(): string {
+        return `(?:\\s*(?:утра|вечера|после полудня))?(?!\\/)${REGEX_PARTS.rightBoundary}`;
+    }
+
+    extractPrimaryTimeComponents(context: ParsingContext, match: RegExpMatchArray): null | ParsingComponents {
+        const components = super.extractPrimaryTimeComponents(context, match);
+        if (components) {
+            if (match[0].endsWith("вечера")) {
+                const hour = components.get("hour");
+                if (hour >= 6 && hour < 12) {
+                    components.assign("hour", components.get("hour") + 12);
+                    components.assign("meridiem", Meridiem.PM);
+                } else if (hour < 6) {
+                    components.assign("meridiem", Meridiem.AM);
+                }
+            }
+
+            if (match[0].endsWith("после полудня")) {
+                components.assign("meridiem", Meridiem.PM);
+                const hour = components.get("hour");
+                if (hour >= 0 && hour <= 6) {
+                    components.assign("hour", components.get("hour") + 12);
+                }
+            }
+
+            if (match[0].endsWith("утра")) {
+                components.assign("meridiem", Meridiem.AM);
+                const hour = components.get("hour");
+                if (hour < 12) {
+                    components.assign("hour", components.get("hour"));
+                }
+            }
+        }
+
+        return components;
+    }
+}

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

@@ -0,0 +1,24 @@
+import { ParsingContext } from "../../../chrono";
+import { parseTimeUnits, REGEX_PARTS, TIME_UNITS_PATTERN } from "../constants";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { reverseTimeUnits } from "../../../utils/timeunits";
+
+const PATTERN = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}назад(?=(?:\\W|$))`, REGEX_PARTS.flags);
+
+export default class RUTimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const timeUnits = parseTimeUnits(match[1]);
+        const outputTimeUnits = reverseTimeUnits(timeUnits);
+
+        return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
+    }
+}

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

@@ -0,0 +1,34 @@
+import { TIME_UNITS_PATTERN, parseTimeUnits, REGEX_PARTS } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { reverseTimeUnits } from "../../../utils/timeunits";
+
+const PATTERN = new RegExp(
+    `(эти|последние|прошлые|следующие|после|через|\\+|-)\\s*(${TIME_UNITS_PATTERN})${REGEX_PARTS.rightBoundary}`,
+    REGEX_PARTS.flags
+);
+
+export default class RUTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const prefix = match[1].toLowerCase();
+        let timeUnits = parseTimeUnits(match[2]);
+        switch (prefix) {
+            case "последние":
+            case "прошлые":
+            case "-":
+                timeUnits = reverseTimeUnits(timeUnits);
+                break;
+        }
+
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}

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

@@ -0,0 +1,24 @@
+import { TIME_UNITS_PATTERN, parseTimeUnits, REGEX_PARTS } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const PATTERN = `(?:(?:около|примерно)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})${REGEX_PARTS.rightBoundary}`;
+const PATTERN_WITH_PREFIX = new RegExp(`(?:в течение|в течении)\\s*${PATTERN}`, REGEX_PARTS.flags);
+
+const PATTERN_WITHOUT_PREFIX = new RegExp(PATTERN, "i");
+
+export default class RUTimeUnitWithinFormatParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(context: ParsingContext): RegExp {
+        return context.option.forwardDate ? PATTERN_WITHOUT_PREFIX : PATTERN_WITH_PREFIX;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const timeUnits = parseTimeUnits(match[1]);
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}

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

@@ -0,0 +1,63 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { REGEX_PARTS, WEEKDAY_DICTIONARY } from "../constants";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { toDayJSWeekday } from "../../../calculation/weeks";
+
+const PATTERN = new RegExp(
+    `(?:(?:,|\\(|（)\\s*)?` +
+        `(?:в\\s*?)?` +
+        `(?:(эту|этот|прошлый|прошлую|следующий|следующую|следующего)\\s*)?` +
+        `(${matchAnyPattern(WEEKDAY_DICTIONARY)})` +
+        `(?:\\s*(?:,|\\)|）))?` +
+        `(?:\\s*на\\s*(этой|прошлой|следующей)\\s*неделе)?` +
+        `${REGEX_PARTS.rightBoundary}`,
+    REGEX_PARTS.flags
+);
+
+const PREFIX_GROUP = 1;
+const WEEKDAY_GROUP = 2;
+const POSTFIX_GROUP = 3;
+
+export default class RUWeekdayParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const dayOfWeek = match[WEEKDAY_GROUP].toLowerCase();
+        const offset = WEEKDAY_DICTIONARY[dayOfWeek];
+        const prefix = match[PREFIX_GROUP];
+        const postfix = match[POSTFIX_GROUP];
+        let modifierWord = prefix || postfix;
+        modifierWord = modifierWord || "";
+        modifierWord = modifierWord.toLowerCase();
+
+        let modifier = null;
+        if (modifierWord == "прошлый" || modifierWord == "прошлую" || modifierWord == "прошлой") {
+            modifier = "last";
+        } else if (
+            modifierWord == "следующий" ||
+            modifierWord == "следующую" ||
+            modifierWord == "следующей" ||
+            modifierWord == "следующего"
+        ) {
+            modifier = "next";
+        } else if (modifierWord == "этот" || modifierWord == "эту" || modifierWord == "этой") {
+            modifier = "this";
+        }
+
+        const date = toDayJSWeekday(context.refDate, offset, modifier);
+        return context
+            .createParsingComponents()
+            .assign("weekday", offset)
+            .imply("day", date.date())
+            .imply("month", date.month() + 1)
+            .imply("year", date.year());
+    }
+}

package/src/locales/ru/refiners/RUMergeDateRangeRefiner.ts

@@ -0,0 +1,13 @@
+import AbstractMergeDateRangeRefiner from "../../../common/refiners/AbstractMergeDateRangeRefiner";
+
+/**
+ * Merging before and after results (see. AbstractMergeDateRangeRefiner)
+ * This implementation should provide Russian connecting phases
+ * - c 06.09.1989 [до|по] 11.12.1996
+ * - c пятницы и до среды
+ */
+export default class xf extends AbstractMergeDateRangeRefiner {
+    patternBetween(): RegExp {
+        return /^\s*(и до|и по|до|по|-)\s*$/i;
+    }
+}

package/src/locales/ru/refiners/RUMergeDateTimeRefiner.ts

@@ -0,0 +1,13 @@
+import AbstractMergeDateTimeRefiner from "../../../common/refiners/AbstractMergeDateTimeRefiner";
+
+/**
+ * Merging date-only result and time-only result (see. AbstractMergeDateTimeRefiner).
+ * This implementation should provide English connecting phases
+ * - 2020-02-13 [в] 6:00
+ * - Завтра [,] 7:00
+ */
+export default class RUMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner {
+    patternBetween(): RegExp {
+        return new RegExp(`^\\s*(T|в|,|-)?\\s*$`);
+    }
+}

package/src/locales/zh/index.ts

@@ -1,2 +1,2 @@
 export * from "./hant";
-export { hans } from "./hans";
+export * as hans from "./hans";

package/src/results.ts

@@ -1,7 +1,7 @@
 import { Component, ParsedComponents, ParsedResult, ParsingReference } from "./index";
 
 import quarterOfYear from "dayjs/plugin/quarterOfYear";
-import dayjs, { OpUnitType, QUnitType } from "dayjs";
+import dayjs, { QUnitType } from "dayjs";
 import { assignSimilarDate, assignSimilarTime, implySimilarTime } from "./utils/dayjs";
 import { toTimezoneOffset } from "./timezone";
 dayjs.extend(quarterOfYear);
@@ -175,11 +175,11 @@ export class ParsingComponents implements ParsedComponents {
 
     static createRelativeFromReference(
         reference: ReferenceWithTimezone,
-        fragments: { [c in OpUnitType | QUnitType]?: number }
+        fragments: { [c in QUnitType]?: number }
     ): ParsingComponents {
         let date = dayjs(reference.instant);
         for (const key in fragments) {
-            date = date.add(fragments[key as OpUnitType], key as OpUnitType);
+            date = date.add(fragments[key as QUnitType], key as QUnitType);
         }
 
         const components = new ParsingComponents(reference);

package/src/utils/timeunits.ts

@@ -18,8 +18,8 @@ export function addImpliedTimeUnits(components: ParsingComponents, timeUnits: Ti
 
     let date = components.dayjs();
     for (const key in timeUnits) {
-        // noinspection JSUnfilteredForInLoop
-        date = date.add(timeUnits[key], key as OpUnitType);
+        // noinspection JSUnfilteredForInLoop,TypeScriptValidateTypes
+        date = date.add(timeUnits[key], key as QUnitType);
     }
 
     if ("day" in timeUnits || "d" in timeUnits || "week" in timeUnits || "month" in timeUnits || "year" in timeUnits) {

package/test/en/en_relative.test.ts

@@ -194,6 +194,12 @@ test("Test - Future relative expressions", () => {
         expect(result.start.isCertain("millisecond")).toBe(false);
         expect(result.start.isCertain("timezoneOffset")).toBe(false);
     });
+
+    testSingleCase(chrono, "Connect back after this year", new Date(2022, 4 - 1, 16, 12), (result, text) => {
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(4);
+        expect(result.start.get("day")).toBe(16);
+    });
 });
 
 test("Test - Relative date components' certainty", () => {

package/test/en/en_timezone_exp.test.ts

@@ -27,6 +27,25 @@ test("Test - Parsing date/time with UTC offset", function () {
     });
 });
 
+test("Test - Parsing date/time with numeric offset", () => {
+    testSingleCase(chrono, "wednesday, september 16, 2020 at 23.00+14", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.isCertain("timezoneOffset")).toBe(true);
+        expect(result.start.get("timezoneOffset")).toBe(14 * 60);
+    });
+
+    testSingleCase(chrono, "wednesday, september 16, 2020 at 23.00+1400", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.isCertain("timezoneOffset")).toBe(true);
+        expect(result.start.get("timezoneOffset")).toBe(14 * 60);
+    });
+
+    testSingleCase(chrono, "wednesday, september 16, 2020 at 23.00+15", (result, text) => {
+        expect(result.text).toBe("wednesday, september 16, 2020 at 23.00");
+        expect(result.start.isCertain("timezoneOffset")).toBe(false);
+    });
+});
+
 test("Test - Parsing date/time with GMT offset", function () {
     testSingleCase(chrono, "wednesday, september 16, 2020 at 11 am GMT -08:45 ", (result, text) => {
         expect(result.text).toBe("wednesday, september 16, 2020 at 11 am GMT -08:45");
@@ -43,6 +62,14 @@ test("Test - Parsing date/time with GMT offset", function () {
         expect(result.start.get("minute")).toBe(0);
         expect(result.start.get("timezoneOffset")).toBe(2 * 60);
     });
+
+    testSingleCase(chrono, "published: 10:30 (gmt-2:30).", (result, text) => {
+        expect(result.text).toBe("10:30 (gmt-2:30)");
+
+        expect(result.start.get("hour")).toBe(10);
+        expect(result.start.get("minute")).toBe(30);
+        expect(result.start.get("timezoneOffset")).toBe(-(2 * 60 + 30));
+    });
 });
 
 test("Test - Parsing date/time with timezone abbreviation", function () {

package/test/en/negative_cases.test.ts

@@ -44,6 +44,14 @@ test("Test - Skip hyphenated numbers pattern", () => {
     testUnexpectedResult(chrono, "4-5-6");
 
     testUnexpectedResult(chrono, "20-30-12");
+
+    testUnexpectedResult(chrono, "2012");
+
+    testUnexpectedResult(chrono, "2012-14");
+
+    testUnexpectedResult(chrono, "2012-1400");
+
+    testUnexpectedResult(chrono, "2200-25");
 });
 
 test("Test - Skip version number pattern", () => {

package/test/fr/fr_time_units_within.test.ts

@@ -52,6 +52,13 @@ test("Test - Single Expression", function () {
         expect(result.start).toBeDate(new Date(2012, 7, 10, 13, 14));
     });
 
+    testSingleCase(chrono.fr, "régler une minuterie de 5 minutes", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(21);
+        expect(result.text).toBe("de 5 minutes");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 19));
+    });
+
     testSingleCase(chrono.fr, "Dans 5 minutes je vais rentrer chez moi", new Date(2012, 7, 10, 12, 14), (result) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe("Dans 5 minutes");

package/test/ru/ru_casual.test.ts

@@ -0,0 +1,147 @@
+import * as chrono from "../../src/";
+import { testSingleCase, testUnexpectedResult } from "../test_util";
+
+test("Test - Single Expression", () => {
+    testSingleCase(chrono.ru.casual, "Дедлайн сегодня", new Date(2012, 7, 10, 17, 10), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("сегодня");
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 17, 10));
+    });
+
+    testSingleCase(chrono.ru.casual, "Дедлайн завтра", new Date(2012, 7, 10, 17, 10), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("завтра");
+        expect(result.start).toBeDate(new Date(2012, 7, 11, 17, 10));
+    });
+
+    testSingleCase(chrono.ru.casual, "Дедлайн послезавтра", new Date(2012, 7, 10, 17, 10), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("послезавтра");
+        expect(result.start).toBeDate(new Date(2012, 7, 12, 17, 10));
+    });
+
+    testSingleCase(chrono.ru.casual, "Дедлайн вчера", new Date(2012, 7, 10, 17, 10), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("вчера");
+        expect(result.start).toBeDate(new Date(2012, 7, 9, 17, 10));
+    });
+
+    testSingleCase(chrono.ru.casual, "Дедлайн позавчера", new Date(2012, 7, 10, 17, 10), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("позавчера");
+        expect(result.start).toBeDate(new Date(2012, 7, 8, 17, 10));
+    });
+
+    testSingleCase(chrono.ru.casual, "Дедлайн сейчас", new Date(2012, 7, 10, 8, 9, 10, 11), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("сейчас");
+        expect(result.start).toBeDate(result.refDate);
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 8, 9, 10, 11));
+    });
+
+    testSingleCase(chrono.ru.casual, "Дедлайн утром", new Date(2012, 7, 10, 8, 9, 10, 11), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("утром");
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 6, 0, 0, 0));
+    });
+
+    testSingleCase(chrono.ru.casual, "Дедлайн этим утром", new Date(2012, 7, 10, 8, 9, 10, 11), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("этим утром");
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 6, 0, 0, 0));
+    });
+
+    testSingleCase(chrono.ru.casual, "Дедлайн в полдень", new Date(2012, 7, 10, 8, 9, 10, 11), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("в полдень");
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 0, 0, 0));
+    });
+
+    testSingleCase(chrono.ru.casual, "Дедлайн прошлым вечером", new Date(2012, 7, 10, 8, 9, 10, 11), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("прошлым вечером");
+        expect(result.start).toBeDate(new Date(2012, 7, 9, 20, 0, 0, 0));
+    });
+
+    testSingleCase(chrono.ru.casual, "Дедлайн вечером", new Date(2012, 7, 10, 8, 9, 10, 11), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("вечером");
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 20, 0, 0, 0));
+    });
+
+    testSingleCase(chrono.ru.casual, "Дедлайн прошлой ночью", new Date(2012, 7, 10, 8, 9, 10, 11), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("прошлой ночью");
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 0, 0, 0, 0));
+    });
+
+    testSingleCase(chrono.ru.casual, "Дедлайн прошлой ночью", new Date(2012, 7, 10, 2, 9, 10, 11), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("прошлой ночью");
+        expect(result.start).toBeDate(new Date(2012, 7, 9, 0, 0, 0, 0));
+    });
+
+    testSingleCase(chrono.ru.casual, "Дедлайн сегодня ночью", new Date(2012, 7, 10, 2, 9, 10, 11), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("сегодня ночью");
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 0, 0, 0, 0));
+    });
+
+    testSingleCase(chrono.ru.casual, "Дедлайн этой ночью", new Date(2012, 7, 10, 2, 9, 10, 11), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("этой ночью");
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 0, 0, 0, 0));
+    });
+
+    testSingleCase(chrono.ru.casual, "Дедлайн ночью", new Date(2012, 7, 10, 2, 9, 10, 11), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("ночью");
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 0, 0, 0, 0));
+    });
+
+    testSingleCase(chrono.ru.casual, "Дедлайн в полночь", new Date(2012, 7, 10, 2, 9, 10, 11), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("в полночь");
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 0, 0, 0, 0));
+    });
+});
+
+test("Test - Combined Expression", () => {
+    testSingleCase(chrono.ru.casual, "Дедлайн вчера вечером", new Date(2012, 7, 10, 12), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("вчера вечером");
+        expect(result.start).toBeDate(new Date(2012, 7, 9, 20));
+    });
+
+    testSingleCase(chrono.ru.casual, "Дедлайн завтра утром", new Date(2012, 8, 10, 14), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("завтра утром");
+        expect(result.start).toBeDate(new Date(2012, 8, 11, 6));
+    });
+});
+
+test("Test - Casual date range", () => {
+    testSingleCase(chrono.ru.casual, "Событие с сегодня и до послезавтра", new Date(2012, 7, 4, 12), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("с сегодня и до послезавтра");
+        expect(result.start).toBeDate(new Date(2012, 7, 4, 12));
+        expect(result.end).toBeDate(new Date(2012, 7, 6, 12));
+    });
+
+    testSingleCase(chrono.ru.casual, "Событие сегодня-завтра", new Date(2012, 7, 10, 12), (result) => {
+        expect(result.index).toBe(8);
+        expect(result.text).toBe("сегодня-завтра");
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12));
+        expect(result.end).toBeDate(new Date(2012, 7, 11, 12));
+    });
+});
+
+test("Test - Random negative text", () => {
+    testUnexpectedResult(chrono.ru, "несегодня");
+
+    testUnexpectedResult(chrono.ru, "зявтра");
+
+    testUnexpectedResult(chrono.ru, "вчеера");
+
+    testUnexpectedResult(chrono.ru, "январ");
+});

package/test/ru/ru_month.test.ts

@@ -0,0 +1,70 @@
+import * as chrono from "../../src";
+import { testSingleCase } from "../test_util";
+
+test("Test - Month-Year expression", function () {
+    testSingleCase(chrono.ru, "Сентябрь 2012", (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Сентябрь 2012");
+        expect(result.start).toBeDate(new Date(2012, 9 - 1, 1, 12));
+    });
+
+    testSingleCase(chrono.ru, "сен 2012", (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("сен 2012");
+        expect(result.start).toBeDate(new Date(2012, 9 - 1, 1, 12));
+    });
+
+    testSingleCase(chrono.ru, "сен. 2012", (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("сен. 2012");
+        expect(result.start).toBeDate(new Date(2012, 9 - 1, 1, 12));
+    });
+
+    testSingleCase(chrono.ru, "сен-2012", (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("сен-2012");
+        expect(result.start).toBeDate(new Date(2012, 9 - 1, 1, 12));
+    });
+});
+
+test("Test - Month-Only expression", function () {
+    testSingleCase(chrono.ru, "в январе", new Date(2020, 11 - 1, 22), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("в январе");
+        expect(result.start).toBeDate(new Date(2021, 1 - 1, 1, 12));
+    });
+
+    testSingleCase(chrono.ru, "в янв", new Date(2020, 11 - 1, 22), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("в янв");
+        expect(result.start).toBeDate(new Date(2021, 1 - 1, 1, 12));
+    });
+
+    testSingleCase(chrono.ru, "май", new Date(2020, 11 - 1, 22), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("май");
+        expect(result.start).toBeDate(new Date(2021, 5 - 1, 1, 12));
+    });
+});
+
+test("Test - Month expression in context", function () {
+    testSingleCase(chrono.ru, "Это было в сентябре 2012 перед новым годом", (result) => {
+        expect(result.index).toBe(9);
+        expect(result.text).toBe("в сентябре 2012");
+        expect(result.start).toBeDate(new Date(2012, 9 - 1, 1, 12));
+    });
+});
+
+test("Test - year 90's parsing", () => {
+    testSingleCase(chrono.ru, "авг 96", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("авг 96");
+        expect(result.start).toBeDate(new Date(1996, 8 - 1, 1, 12));
+    });
+
+    testSingleCase(chrono.ru, "96 авг 96", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(3);
+        expect(result.text).toBe("авг 96");
+        expect(result.start).toBeDate(new Date(1996, 8 - 1, 1, 12));
+    });
+});