chrono-node 2.3.5 → 2.3.8

package/dist/results.js

@@ -15,7 +15,6 @@ class ReferenceWithTimezone {
         input = input !== null && input !== void 0 ? input : new Date();
         if (input instanceof Date) {
             this.instant = input;
-            this.timezoneOffset = -input.getTimezoneOffset();
         }
         else {
             this.instant = (_a = input.instant) !== null && _a !== void 0 ? _a : new Date();
@@ -113,7 +112,7 @@ class ParsingComponents {
         return true;
     }
     toString() {
-        return `[ParsingComponents {knownValues: ${JSON.stringify(this.knownValues)}, impliedValues: ${JSON.stringify(this.impliedValues)}}]`;
+        return `[ParsingComponents {knownValues: ${JSON.stringify(this.knownValues)}, impliedValues: ${JSON.stringify(this.impliedValues)}}, reference: ${JSON.stringify(this.reference)}]`;
     }
     dayjs() {
         return dayjs_1.default(this.date());

package/dist/timezone.d.ts

@@ -191,4 +191,4 @@ export declare const TIMEZONE_ABBR_MAP: {
     YEKST: number;
     YEKT: number;
 };
-export declare function toTimezoneOffset(timezoneInput: string | number): number | null;
+export declare function toTimezoneOffset(timezoneInput?: string | number): number | null;

package/dist/timezone.js

@@ -117,7 +117,7 @@ exports.TIMEZONE_ABBR_MAP = {
     MHT: 720,
     MMT: 390,
     MSD: 240,
-    MSK: 240,
+    MSK: 180,
     MST: -420,
     MUT: 240,
     MVT: 300,
@@ -196,12 +196,12 @@ exports.TIMEZONE_ABBR_MAP = {
 };
 function toTimezoneOffset(timezoneInput) {
     var _a;
-    if (timezoneInput === null) {
+    if (timezoneInput === null || timezoneInput === undefined) {
         return null;
     }
     if (typeof timezoneInput === "number") {
         return timezoneInput;
     }
-    return (_a = exports.TIMEZONE_ABBR_MAP[timezoneInput]) !== null && _a !== void 0 ? _a : 0;
+    return (_a = exports.TIMEZONE_ABBR_MAP[timezoneInput]) !== null && _a !== void 0 ? _a : null;
 }
 exports.toTimezoneOffset = toTimezoneOffset;

package/package.json

@@ -15,7 +15,7 @@
     "preset": "ts-jest"
   },
   "license": "MIT",
-  "version": "2.3.5",
+  "version": "2.3.8",
   "directories": {
     "source": "./src",
     "test": "./test"

package/src/common/refiners/ExtractTimezoneAbbrRefiner.ts

@@ -221,7 +221,9 @@ export default class ExtractTimezoneAbbrRefiner implements Refiner {
             }
 
             context.debug(() => {
-                console.log(`Extracting timezone: '${timezoneAbbr}' into : ${extractedTimezoneOffset}`);
+                console.log(
+                    `Extracting timezone: '${timezoneAbbr}' into: ${extractedTimezoneOffset} for: ${result.start}`
+                );
             });
 
             const currentTimezoneOffset = result.start.get("timezoneOffset");
@@ -240,6 +242,14 @@ export default class ExtractTimezoneAbbrRefiner implements Refiner {
                 }
             }
 
+            if (result.start.isOnlyDate()) {
+                // If the time is not explicitly mentioned,
+                // Then, we also want to double check the abbr case (e.g. "GET" not "get")
+                if (timezoneAbbr != match[1]) {
+                    return;
+                }
+            }
+
             result.text += match[0];
 
             if (!result.start.isCertain("timezoneOffset")) {

package/src/locales/de/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";
@@ -22,9 +22,12 @@ export const WEEKDAY_DICTIONARY: { [word: string]: number } = {
 
 export const MONTH_DICTIONARY: { [word: string]: number } = {
     "januar": 1,
+    "jänner": 1,
+    "janner": 1,
     "jan": 1,
     "jan.": 1,
     "februar": 2,
+    "feber": 2,
     "feb": 2,
     "feb.": 2,
     "märz": 3,
@@ -64,6 +67,10 @@ export const MONTH_DICTIONARY: { [word: string]: number } = {
 
 export const INTEGER_WORD_DICTIONARY: { [word: string]: number } = {
     "eins": 1,
+    "eine": 1,
+    "einem": 1,
+    "einen": 1,
+    "einer": 1,
     "zwei": 2,
     "drei": 3,
     "vier": 4,
@@ -79,29 +86,37 @@ export const INTEGER_WORD_DICTIONARY: { [word: string]: number } = {
     "zwoelf": 12,
 };
 
-export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType } = {
-    sec: "second",
-    second: "second",
-    seconds: "second",
+export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } = {
+    sek: "second",
+    sekunde: "second",
+    sekunden: "second",
     min: "minute",
-    mins: "minute",
     minute: "minute",
-    minutes: "minute",
+    minuten: "minute",
     h: "hour",
-    hr: "hour",
-    hrs: "hour",
-    hour: "hour",
-    hours: "hour",
-    day: "d",
-    days: "d",
-    week: "week",
-    weeks: "week",
-    month: "month",
-    months: "month",
-    y: "year",
-    yr: "year",
-    year: "year",
-    years: "year",
+    std: "hour",
+    stunde: "hour",
+    stunden: "hour",
+    tag: "d",
+    tage: "d",
+    tagen: "d",
+    woche: "week",
+    wochen: "week",
+    monat: "month",
+    monate: "month",
+    monaten: "month",
+    monats: "month",
+    quartal: "quarter",
+    quartals: "quarter",
+    quartale: "quarter",
+    quartalen: "quarter",
+    a: "year",
+    j: "year",
+    jr: "year",
+    jahr: "year",
+    jahre: "year",
+    jahren: "year",
+    jahres: "year",
 };
 
 //-----------------------------
@@ -131,7 +146,7 @@ export function parseNumberPattern(match: string): number {
 
 //-----------------------------
 
-export const YEAR_PATTERN = `(?:[0-9]{1,4}(?:\\s*[vn]\\.?\\s*C(?:hr)?\\.?)?)`;
+export const YEAR_PATTERN = `(?:[0-9]{1,4}(?:\\s*[vn]\\.?\\s*(?:C(?:hr)?|(?:u\\.?|d\\.?(?:\\s*g\\.?)?)?\\s*Z)\\.?|\\s*(?:u\\.?|d\\.?(?:\\s*g\\.)?)\\s*Z\\.?)?)`;
 export function parseYear(match: string): number {
     if (/v/i.test(match)) {
         // v.Chr.
@@ -143,6 +158,11 @@ export function parseYear(match: string): number {
         return parseInt(match.replace(/[^0-9]+/gi, ""));
     }
 
+    if (/z/i.test(match)) {
+        // n.Chr. as "uZ" or "dgZ"
+        return parseInt(match.replace(/[^0-9]+/gi, ""));
+    }
+
     const rawYearNumber = parseInt(match);
     return findMostLikelyADYear(rawYearNumber);
 }

package/src/locales/de/index.ts

@@ -5,11 +5,13 @@ import SlashDateFormatParser from "../../common/parsers/SlashDateFormatParser";
 import ISOFormatParser from "../../common/parsers/ISOFormatParser";
 import DETimeExpressionParser from "./parsers/DETimeExpressionParser";
 import DEWeekdayParser from "./parsers/DEWeekdayParser";
+import DESpecificTimeExpressionParser from "./parsers/DESpecificTimeExpressionParser";
 import DEMergeDateRangeRefiner from "./refiners/DEMergeDateRangeRefiner";
 import DEMergeDateTimeRefiner from "./refiners/DEMergeDateTimeRefiner";
 import DECasualDateParser from "./parsers/DECasualDateParser";
 import DECasualTimeParser from "./parsers/DECasualTimeParser";
 import DEMonthNameLittleEndianParser from "./parsers/DEMonthNameLittleEndianParser";
+import DETimeUnitRelativeFormatParser from "./parsers/DETimeUnitRelativeFormatParser";
 
 // Shortcuts
 export const casual = new Chrono(createCasualConfiguration());
@@ -27,6 +29,7 @@ export function createCasualConfiguration(littleEndian = true): Configuration {
     const option = createConfiguration(false, littleEndian);
     option.parsers.unshift(new DECasualTimeParser());
     option.parsers.unshift(new DECasualDateParser());
+    option.parsers.unshift(new DETimeUnitRelativeFormatParser());
     return option;
 }
 
@@ -37,6 +40,7 @@ export function createConfiguration(strictMode = true, littleEndian = true): Con
                 new ISOFormatParser(),
                 new SlashDateFormatParser(littleEndian),
                 new DETimeExpressionParser(),
+                new DESpecificTimeExpressionParser(),
                 new DEMonthNameLittleEndianParser(),
                 new DEWeekdayParser(),
             ],

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

@@ -0,0 +1,150 @@
+import { Parser, ParsingContext } from "../../../chrono";
+import { ParsingComponents, ParsingResult } from "../../../results";
+import { Meridiem } from "../../../index";
+
+/**
+ * 8h10m00s
+ * 8h10m00
+ * 8h10
+ * 8 Uhr
+ * 8h10m00s Uhr
+ * 8:10 Uhr
+ */
+const FIRST_REG_PATTERN = new RegExp(
+    "(^|\\s|T)" +
+        "(?:(?:um|von)\\s*)?" +
+        "(\\d{1,2})(?:h|:)?" +
+        "(?:(\\d{1,2})(?:m|:)?)?" +
+        "(?:(\\d{1,2})(?:s)?)?" +
+        "(?:\\s*Uhr)?" +
+        "(?:\\s*(morgens|vormittags|nachmittags|abends|nachts|am\\s+(?:Morgen|Vormittag|Nachmittag|Abend)|in\\s+der\\s+Nacht))?" +
+        "(?=\\W|$)",
+    "i"
+);
+
+const SECOND_REG_PATTERN = new RegExp(
+    "^\\s*(\\-|\\–|\\~|\\〜|bis(?:\\s+um)?|\\?)\\s*" +
+        "(\\d{1,2})(?:h|:)?" +
+        "(?:(\\d{1,2})(?:m|:)?)?" +
+        "(?:(\\d{1,2})(?:s)?)?" +
+        "(?:\\s*Uhr)?" +
+        "(?:\\s*(morgens|vormittags|nachmittags|abends|nachts|am\\s+(?:Morgen|Vormittag|Nachmittag|Abend)|in\\s+der\\s+Nacht))?" +
+        "(?=\\W|$)",
+    "i"
+);
+
+const HOUR_GROUP = 2;
+const MINUTE_GROUP = 3;
+const SECOND_GROUP = 4;
+const AM_PM_HOUR_GROUP = 5;
+
+export default class DESpecificTimeExpressionParser implements Parser {
+    pattern(context): RegExp {
+        return FIRST_REG_PATTERN;
+    }
+
+    extract(context: ParsingContext, match: RegExpMatchArray): ParsingResult | null {
+        const result = context.createParsingResult(match.index + match[1].length, match[0].substring(match[1].length));
+
+        // This looks more like a year e.g. 2020
+        if (result.text.match(/^\d{4}$/)) {
+            match.index += match[0].length;
+            return null;
+        }
+
+        result.start = DESpecificTimeExpressionParser.extractTimeComponent(result.start.clone(), match);
+        if (!result.start) {
+            match.index += match[0].length;
+            return null;
+        }
+
+        const remainingText = context.text.substring(match.index + match[0].length);
+        const secondMatch = SECOND_REG_PATTERN.exec(remainingText);
+        if (secondMatch) {
+            result.end = DESpecificTimeExpressionParser.extractTimeComponent(result.start.clone(), secondMatch);
+            if (result.end) {
+                result.text += secondMatch[0];
+            }
+        }
+
+        return result;
+    }
+
+    private static extractTimeComponent(
+        extractingComponents: ParsingComponents,
+        match: RegExpMatchArray
+    ): ParsingComponents | null {
+        let hour = 0;
+        let minute = 0;
+        let meridiem = null;
+
+        // ----- Hours
+        hour = parseInt(match[HOUR_GROUP]);
+
+        // ----- Minutes
+        if (match[MINUTE_GROUP] != null) {
+            minute = parseInt(match[MINUTE_GROUP]);
+        }
+
+        if (minute >= 60 || hour > 24) {
+            return null;
+        }
+
+        if (hour >= 12) {
+            meridiem = Meridiem.PM;
+        }
+
+        // ----- AM & PM
+        if (match[AM_PM_HOUR_GROUP] != null) {
+            if (hour > 12) return null;
+            const ampm = match[AM_PM_HOUR_GROUP].toLowerCase();
+            if (ampm.match(/morgen|vormittag/)) {
+                meridiem = Meridiem.AM;
+                if (hour == 12) {
+                    hour = 0;
+                }
+            }
+
+            if (ampm.match(/nachmittag|abend/)) {
+                meridiem = Meridiem.PM;
+                if (hour != 12) {
+                    hour += 12;
+                }
+            }
+
+            if (ampm.match(/nacht/)) {
+                if (hour == 12) {
+                    meridiem = Meridiem.AM;
+                    hour = 0;
+                } else if (hour < 6) {
+                    meridiem = Meridiem.AM;
+                } else {
+                    meridiem = Meridiem.PM;
+                    hour += 12;
+                }
+            }
+        }
+
+        extractingComponents.assign("hour", hour);
+        extractingComponents.assign("minute", minute);
+        if (meridiem !== null) {
+            extractingComponents.assign("meridiem", meridiem);
+        } else {
+            if (hour < 12) {
+                extractingComponents.imply("meridiem", Meridiem.AM);
+            } else {
+                extractingComponents.imply("meridiem", Meridiem.PM);
+            }
+        }
+
+        // ----- Second
+        if (match[SECOND_GROUP] != null) {
+            const second = parseInt(match[SECOND_GROUP]);
+            if (second >= 60) return null;
+
+            extractingComponents.assign("second", second);
+        }
+
+        return extractingComponents;
+    }
+}

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

@@ -1,7 +1,6 @@
 import { AbstractTimeExpressionParser } from "../../../common/parsers/AbstractTimeExpressionParser";
 import { ParsingComponents } from "../../../results";
 import { ParsingContext } from "../../../chrono";
-import { Meridiem } from "../../../index";
 
 export default class DETimeExpressionParser extends AbstractTimeExpressionParser {
     primaryPrefix(): string {
@@ -12,30 +11,12 @@ export default class DETimeExpressionParser extends AbstractTimeExpressionParser
         return "\\s*(?:\\-|\\–|\\~|\\〜|bis)\\s*";
     }
 
-    primarySuffix(): string {
-        return "(?:\\s*uhr)?(?:\\s*(?:morgens|vormittags|nachmittags|abends|nachts))?(?=\\W|$)";
-    }
-
     extractPrimaryTimeComponents(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | null {
-        const components = super.extractPrimaryTimeComponents(context, match);
-        if (components) {
-            if (match[0].endsWith("morgens") || match[0].endsWith("vormittags")) {
-                components.assign("meridiem", Meridiem.AM);
-                const hour = components.get("hour");
-                if (hour < 12) {
-                    components.assign("hour", components.get("hour"));
-                }
-            }
-
-            if (match[0].endsWith("nachmittags") || match[0].endsWith("abends") || match[0].endsWith("nachts")) {
-                components.assign("meridiem", Meridiem.PM);
-                const hour = components.get("hour");
-                if (hour < 12) {
-                    components.assign("hour", components.get("hour") + 12);
-                }
-            }
+        // This looks more like a year e.g. 2020
+        if (match[0].match(/^\s*\d{4}\s*$/)) {
+            return null;
         }
 
-        return components;
+        return super.extractPrimaryTimeComponents(context, match);
     }
 }

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/ENMonthNameLittleEndianParser.ts

@@ -36,8 +36,6 @@ export default class ENMonthNameLittleEndianParser extends AbstractParserWithWor
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingResult {
-        //console.log(match)
-
         const result = context.createParsingResult(match.index, match[0]);
 
         const month = MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];

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/zh/hans/constants.ts

@@ -0,0 +1,52 @@
+export const NUMBER = {
+    "零": 0,
+    "〇": 0,
+    "一": 1,
+    "二": 2,
+    "两": 2,
+    "三": 3,
+    "四": 4,
+    "五": 5,
+    "六": 6,
+    "七": 7,
+    "八": 8,
+    "九": 9,
+    "十": 10,
+};
+
+export const WEEKDAY_OFFSET = {
+    "天": 0,
+    "日": 0,
+    "一": 1,
+    "二": 2,
+    "三": 3,
+    "四": 4,
+    "五": 5,
+    "六": 6,
+};
+
+export function zhStringToNumber(text: string) {
+    let number = 0;
+
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (char === "十") {
+            number = number === 0 ? NUMBER[char] : number * NUMBER[char];
+        } else {
+            number += NUMBER[char];
+        }
+    }
+
+    return number;
+}
+
+export function zhStringToYear(text: string) {
+    let string = "";
+
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        string = string + NUMBER[char];
+    }
+
+    return parseInt(string);
+}