chrono-node 2.3.6 → 2.3.9

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

@@ -0,0 +1,56 @@
+import { ParsingContext } from "../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import * as references from "../../../common/casualReferences";
+import { assignSimilarDate } from "../../../utils/dayjs";
+import dayjs from "dayjs";
+import { REGEX_PARTS } from "../constants";
+
+const PATTERN = new RegExp(
+    `(сейчас|прошлым\\s*вечером|прошлой\\s*ночью|следующей\\s*ночью|сегодня\\s*ночью|этой\\s*ночью|ночью|этим утром|утром|утра|в\\s*полдень|вечером|вечера|в\\s*полночь)` +
+        `${REGEX_PARTS.rightBoundary}`,
+    REGEX_PARTS.flags
+);
+export default class RUCasualTimeParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern() {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        let targetDate = dayjs(context.refDate);
+        const lowerText = match[0].toLowerCase();
+        const component = context.createParsingComponents();
+
+        if (lowerText === "сейчас") {
+            return references.now(context.reference);
+        }
+        if (lowerText === "вечером" || lowerText === "вечера") {
+            return references.evening(context.reference);
+        }
+        if (lowerText.endsWith("утром") || lowerText.endsWith("утра")) {
+            return references.morning(context.reference);
+        }
+        if (lowerText.match(/в\s*полдень/)) {
+            return references.noon(context.reference);
+        }
+        if (lowerText.match(/прошлой\s*ночью/)) {
+            return references.lastNight(context.reference);
+        }
+        if (lowerText.match(/прошлым\s*вечером/)) {
+            return references.yesterdayEvening(context.reference);
+        }
+        if (lowerText.match(/следующей\s*ночью/)) {
+            const daysToAdd = targetDate.hour() < 22 ? 1 : 2;
+            targetDate = targetDate.add(daysToAdd, "day");
+            assignSimilarDate(component, targetDate);
+            component.imply("hour", 0);
+        }
+        if (lowerText.match(/в\s*полночь/) || lowerText.endsWith("ночью")) {
+            return references.midnight(context.reference);
+        }
+        return component;
+    }
+}

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

@@ -0,0 +1,72 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingResult } from "../../../results";
+import { findYearClosestToRef } from "../../../calculation/years";
+import { MONTH_DICTIONARY, REGEX_PARTS } from "../constants";
+import { YEAR_PATTERN, parseYear } from "../constants";
+import { ORDINAL_NUMBER_PATTERN, parseOrdinalNumberPattern } from "../constants";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+// prettier-ignore
+const PATTERN = new RegExp(
+    `(?:с)?\\s*(${ORDINAL_NUMBER_PATTERN})` +
+        `(?:` +
+            `\\s{0,3}(?:по|-|–|до)?\\s{0,3}` +
+            `(${ORDINAL_NUMBER_PATTERN})` +
+        `)?` +
+        `(?:-|\\/|\\s{0,3}(?:of)?\\s{0,3})` +
+        `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+        `(?:` +
+            `(?:-|\\/|,?\\s{0,3})` +
+            `(${YEAR_PATTERN}(?![^\\s]\\d))` +
+        `)?` +
+    `${REGEX_PARTS.rightBoundary}`,
+    REGEX_PARTS.flags
+);
+
+const DATE_GROUP = 1;
+const DATE_TO_GROUP = 2;
+const MONTH_NAME_GROUP = 3;
+const YEAR_GROUP = 4;
+
+export default class RUMonthNameLittleEndianParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingResult {
+        const result = context.createParsingResult(match.index, match[0]);
+
+        const month = MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];
+        const day = parseOrdinalNumberPattern(match[DATE_GROUP]);
+        if (day > 31) {
+            // e.g. "[96 Aug]" => "9[6 Aug]", we need to shift away from the next number
+            match.index = match.index + match[DATE_GROUP].length;
+            return null;
+        }
+
+        result.start.assign("month", month);
+        result.start.assign("day", day);
+
+        if (match[YEAR_GROUP]) {
+            const yearNumber = parseYear(match[YEAR_GROUP]);
+            result.start.assign("year", yearNumber);
+        } else {
+            const year = findYearClosestToRef(context.refDate, day, month);
+            result.start.imply("year", year);
+        }
+
+        if (match[DATE_TO_GROUP]) {
+            const endDate = parseOrdinalNumberPattern(match[DATE_TO_GROUP]);
+
+            result.end = result.start.clone();
+            result.end.assign("day", endDate);
+        }
+
+        return result;
+    }
+}

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

@@ -0,0 +1,61 @@
+import { FULL_MONTH_NAME_DICTIONARY, MONTH_DICTIONARY, REGEX_PARTS } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { findYearClosestToRef } from "../../../calculation/years";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { YEAR_PATTERN, parseYear } from "../constants";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const PATTERN = new RegExp(
+    `((?:в)\\s*)?` +
+        `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+        `\\s*` +
+        `(?:` +
+        `[,-]?\\s*(${YEAR_PATTERN})?` +
+        `)?` +
+        `(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)`,
+    REGEX_PARTS.flags
+);
+
+const MONTH_NAME_GROUP = 2;
+const YEAR_GROUP = 3;
+
+/**
+ * The parser for parsing month name and year.
+ * - Январь, 2012
+ * - Январь 2012
+ * - Январь
+ */
+export default class RUMonthNameParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const monthName = match[MONTH_NAME_GROUP].toLowerCase();
+
+        // skip some unlikely words "янв", "фер", ..
+        if (match[0].length <= 3 && !FULL_MONTH_NAME_DICTIONARY[monthName]) {
+            return null;
+        }
+
+        const result = context.createParsingResult(match.index, match.index + match[0].length);
+        result.start.imply("day", 1);
+
+        const month = MONTH_DICTIONARY[monthName];
+        result.start.assign("month", month);
+
+        if (match[YEAR_GROUP]) {
+            const year = parseYear(match[YEAR_GROUP]);
+            result.start.assign("year", year);
+        } else {
+            const year = findYearClosestToRef(context.refDate, 1, month);
+            result.start.imply("year", year);
+        }
+
+        return result;
+    }
+}

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,20 +1,19 @@
 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);
 
 export class ReferenceWithTimezone {
     readonly instant: Date;
-    readonly timezoneOffset?: number;
+    readonly timezoneOffset?: number | null;
 
     constructor(input?: ParsingReference | Date) {
         input = input ?? new Date();
         if (input instanceof Date) {
             this.instant = input;
-            this.timezoneOffset = -input.getTimezoneOffset();
         } else {
             this.instant = input.instant ?? new Date();
             this.timezoneOffset = toTimezoneOffset(input.timezone);
@@ -133,7 +132,7 @@ export class ParsingComponents implements ParsedComponents {
     toString() {
         return `[ParsingComponents {knownValues: ${JSON.stringify(this.knownValues)}, impliedValues: ${JSON.stringify(
             this.impliedValues
-        )}}]`;
+        )}}, reference: ${JSON.stringify(this.reference)}]`;
     }
 
     dayjs() {
@@ -176,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/timezone.ts

@@ -114,7 +114,7 @@ export const TIMEZONE_ABBR_MAP = {
     MHT: 720,
     MMT: 390,
     MSD: 240,
-    MSK: 240,
+    MSK: 180,
     MST: -420,
     MUT: 240,
     MVT: 300,
@@ -192,8 +192,8 @@ export const TIMEZONE_ABBR_MAP = {
     YEKT: 360,
 };
 
-export function toTimezoneOffset(timezoneInput: string | number): number | null {
-    if (timezoneInput === null) {
+export function toTimezoneOffset(timezoneInput?: string | number): number | null {
+    if (timezoneInput === null || timezoneInput === undefined) {
         return null;
     }
 
@@ -201,5 +201,5 @@ export function toTimezoneOffset(timezoneInput: string | number): number | null
         return timezoneInput;
     }
 
-    return TIMEZONE_ABBR_MAP[timezoneInput] ?? 0;
+    return TIMEZONE_ABBR_MAP[timezoneInput] ?? null;
 }

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/de/de_month_name_little_endian.test.ts

@@ -204,6 +204,18 @@ test("Test - Range expression", function () {
 
         expect(result.end).toBeDate(new Date(2013, 10 - 1, 12, 12));
     });
+
+    testSingleCase(chrono.de, "10. jänner 2012", new Date(2012, 7, 10), (result) => {
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(1);
+        expect(result.start.get("day")).toBe(10);
+
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("10. jänner 2012");
+
+        expect(result.start).toBeDate(new Date(2012, 1 - 1, 10, 12));
+    });
 });
 
 test("Test - Combined expression", function () {