chrono-node 2.3.2 → 2.3.6

package/dist/utils/dayjs.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.implySimilarTime = exports.assignSimilarTime = exports.assignSimilarDate = exports.assignTheNextDay = void 0;
+const index_1 = require("../index");
 function assignTheNextDay(component, targetDayJs) {
     targetDayJs = targetDayJs.add(1, "day");
     assignSimilarDate(component, targetDayJs);
@@ -18,6 +19,12 @@ function assignSimilarTime(component, targetDayJs) {
     component.assign("minute", targetDayJs.minute());
     component.assign("second", targetDayJs.second());
     component.assign("millisecond", targetDayJs.millisecond());
+    if (component.get("hour") < 12) {
+        component.assign("meridiem", index_1.Meridiem.AM);
+    }
+    else {
+        component.assign("meridiem", index_1.Meridiem.PM);
+    }
 }
 exports.assignSimilarTime = assignSimilarTime;
 function implySimilarTime(component, targetDayJs) {

package/package.json

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

package/src/common/casualReferences.ts

@@ -8,7 +8,9 @@ export function now(reference: ReferenceWithTimezone): ParsingComponents {
     const component = new ParsingComponents(reference, {});
     assignSimilarDate(component, targetDate);
     assignSimilarTime(component, targetDate);
-    component.assign("timezoneOffset", targetDate.utcOffset());
+    if (reference.timezoneOffset !== null) {
+        component.assign("timezoneOffset", targetDate.utcOffset());
+    }
     return component;
 }
 

package/src/common/parsers/AbstractParserWithWordBoundary.ts

@@ -27,7 +27,7 @@ export abstract class AbstractParserWithWordBoundaryChecking implements Parser {
     }
 
     extract(context: ParsingContext, match: RegExpMatchArray) {
-        const header = match[1];
+        const header = match[1] ?? "";
         match.index = match.index + header.length;
         match[0] = match[0].substring(header.length);
         for (let i = 2; i < match.length; i++) {

package/src/common/refiners/ExtractTimezoneAbbrRefiner.ts

@@ -240,6 +240,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/index.ts

@@ -105,7 +105,8 @@ import * as fr from "./locales/fr";
 import * as ja from "./locales/ja";
 import * as pt from "./locales/pt";
 import * as nl from "./locales/nl";
-export { de, fr, ja, pt, nl };
+import * as zh from "./locales/zh";
+export { de, fr, ja, pt, nl, zh };
 
 /**
  * A shortcut for {@link en | chrono.en.strict}

package/src/locales/de/constants.ts

@@ -108,7 +108,7 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType } = {
 
 export const NUMBER_PATTERN = `(?:${matchAnyPattern(
     INTEGER_WORD_DICTIONARY
-)}|[0-9]+|[0-9]+\\.[0-9]+|half(?:\\s*an?)?|an?(?:\\s*few)?|few|several|a?\\s*couple\\s*(?:of)?)`;
+)}|[0-9]+|[0-9]+\\.[0-9]+|half(?:\\s*an?)?|an?\\b(?:\\s*few)?|few|several|a?\\s*couple\\s*(?:of)?)`;
 
 export function parseNumberPattern(match: string): number {
     const num = match.toLowerCase();

package/src/locales/en/constants.ts

@@ -162,7 +162,7 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType } = {
 
 export const NUMBER_PATTERN = `(?:${matchAnyPattern(
     INTEGER_WORD_DICTIONARY
-)}|[0-9]+|[0-9]+\\.[0-9]+|half(?:\\s{0,2}an?)?|an?(?:\\s{0,2}few)?|few|several|a?\\s{0,2}couple\\s{0,2}(?:of)?)`;
+)}|[0-9]+|[0-9]+\\.[0-9]+|half(?:\\s{0,2}an?)?|an?\\b(?:\\s{0,2}few)?|few|several|a?\\s{0,2}couple\\s{0,2}(?:of)?)`;
 
 export function parseNumberPattern(match: string): number {
     const num = match.toLowerCase();

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

@@ -26,17 +26,17 @@ export default class ENRelativeDateFormatParser extends AbstractParserWithWordBo
         if (modifier == "next") {
             const timeUnits = {};
             timeUnits[timeunit] = 1;
-            return ParsingComponents.createRelativeFromRefInstant(context.refDate, timeUnits);
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
         }
 
         if (modifier == "last" || modifier == "past") {
             const timeUnits = {};
             timeUnits[timeunit] = -1;
-            return ParsingComponents.createRelativeFromRefInstant(context.refDate, timeUnits);
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
         }
 
         const components = context.createParsingComponents();
-        let date = dayjs(context.refDate);
+        let date = dayjs(context.reference.instant);
 
         // This week
         if (unitWord.match(/week/i)) {

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

@@ -20,6 +20,6 @@ export default class ENTimeUnitAgoFormatParser extends AbstractParserWithWordBou
         const timeUnits = parseTimeUnits(match[1]);
         const outputTimeUnits = reverseTimeUnits(timeUnits);
 
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, outputTimeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
     }
 }

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

@@ -22,6 +22,6 @@ export default class ENTimeUnitCasualRelativeFormatParser extends AbstractParser
                 break;
         }
 
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, timeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

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

@@ -22,6 +22,6 @@ export default class ENTimeUnitLaterFormatParser extends AbstractParserWithWordB
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
         const fragments = parseTimeUnits(match[GROUP_NUM_TIMEUNITS]);
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, fragments);
+        return ParsingComponents.createRelativeFromReference(context.reference, fragments);
     }
 }

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

@@ -21,6 +21,6 @@ export default class ENTimeUnitWithinFormatParser extends AbstractParserWithWord
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
         const timeUnits = parseTimeUnits(match[1]);
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, timeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

package/src/locales/fr/constants.ts

@@ -105,7 +105,7 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } =
 
 export const NUMBER_PATTERN = `(?:${matchAnyPattern(
     INTEGER_WORD_DICTIONARY
-)}|[0-9]+|[0-9]+\\.[0-9]+|une?|quelques?|demi-?)`;
+)}|[0-9]+|[0-9]+\\.[0-9]+|une?\\b|quelques?|demi-?)`;
 
 export function parseNumberPattern(match: string): number {
     const num = match.toLowerCase();

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

@@ -17,6 +17,6 @@ export default class FRTimeUnitAgoFormatParser extends AbstractParserWithWordBou
         const timeUnits = parseTimeUnits(match[1]);
         const outputTimeUnits = reverseTimeUnits(timeUnits);
 
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, outputTimeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
     }
 }

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

@@ -38,6 +38,6 @@ export default class FRTimeUnitAgoFormatParser extends AbstractParserWithWordBou
             timeUnits = reverseTimeUnits(timeUnits);
         }
 
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, timeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

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

@@ -10,6 +10,6 @@ export default class FRTimeUnitWithinFormatParser extends AbstractParserWithWord
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
         const timeUnits = parseTimeUnits(match[1]);
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, timeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

package/src/locales/nl/parsers/NLRelativeDateFormatParser.ts

@@ -27,17 +27,17 @@ export default class NLRelativeDateFormatParser extends AbstractParserWithWordBo
         if (modifier == "volgend" || modifier == "volgende" || modifier == "komende") {
             const timeUnits = {};
             timeUnits[timeunit] = 1;
-            return ParsingComponents.createRelativeFromRefInstant(context.refDate, timeUnits);
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
         }
 
         if (modifier == "afgelopen" || modifier == "vorige") {
             const timeUnits = {};
             timeUnits[timeunit] = -1;
-            return ParsingComponents.createRelativeFromRefInstant(context.refDate, timeUnits);
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
         }
 
         const components = context.createParsingComponents();
-        let date = dayjs(context.refDate);
+        let date = dayjs(context.reference.instant);
 
         // This week
         if (unitWord.match(/week/i)) {

package/src/locales/nl/parsers/NLTimeUnitAgoFormatParser.ts

@@ -21,6 +21,6 @@ export default class NLTimeUnitAgoFormatParser extends AbstractParserWithWordBou
         const timeUnits = parseTimeUnits(match[1]);
         const outputTimeUnits = reverseTimeUnits(timeUnits);
 
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, outputTimeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
     }
 }

package/src/locales/nl/parsers/NLTimeUnitCasualRelativeFormatParser.ts

@@ -22,6 +22,6 @@ export default class NLTimeUnitCasualRelativeFormatParser extends AbstractParser
                 break;
         }
 
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, timeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

package/src/locales/nl/parsers/NLTimeUnitLaterFormatParser.ts

@@ -22,6 +22,6 @@ export default class NLTimeUnitLaterFormatParser extends AbstractParserWithWordB
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
         const fragments = parseTimeUnits(match[GROUP_NUM_TIMEUNITS]);
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, fragments);
+        return ParsingComponents.createRelativeFromReference(context.reference, fragments);
     }
 }

package/src/locales/nl/parsers/NLTimeUnitWithinFormatParser.ts

@@ -10,6 +10,6 @@ export default class NLTimeUnitWithinFormatParser extends AbstractParserWithWord
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
         const timeUnits = parseTimeUnits(match[1]);
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, timeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

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);
+}

package/src/locales/zh/hans/index.ts

@@ -0,0 +1,62 @@
+/**
+ * Chrono components for zh support
+ */
+
+import { Chrono, Configuration } from "../../../chrono";
+import ExtractTimezoneOffsetRefiner from "../../../common/refiners/ExtractTimezoneOffsetRefiner";
+import { includeCommonConfiguration } from "../../../configurations";
+import { ParsedResult, ParsingOption } from "../../../index";
+import ZHHansCasualDateParser from "./parsers/ZHHansCasualDateParser";
+import ZHHansDateParser from "./parsers/ZHHansDateParser";
+import ZHHansDeadlineFormatParser from "./parsers/ZHHansDeadlineFormatParser";
+import ZHHansRelationWeekdayParser from "./parsers/ZHHansRelationWeekdayParser";
+import ZHHansTimeExpressionParser from "./parsers/ZHHansTimeExpressionParser";
+import ZHHansWeekdayParser from "./parsers/ZHHansWeekdayParser";
+import ZHHansMergeDateRangeRefiner from "./refiners/ZHHansMergeDateRangeRefiner";
+import ZHHansMergeDateTimeRefiner from "./refiners/ZHHansMergeDateTimeRefiner";
+
+// Shortcuts
+export const hans = new Chrono(createCasualConfiguration());
+
+export const casual = new Chrono(createCasualConfiguration());
+export const strict = new Chrono(createConfiguration());
+
+export function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[] {
+    return casual.parse(text, ref, option);
+}
+
+export function parseDate(text: string, ref?: Date, option?: ParsingOption): Date {
+    return casual.parseDate(text, ref, option);
+}
+
+/**
+ * @ignore (to be documented later)
+ */
+export function createCasualConfiguration(): Configuration {
+    const option = createConfiguration();
+    option.parsers.unshift(new ZHHansCasualDateParser());
+    return option;
+}
+
+/**
+ * @ignore (to be documented later)
+ */
+export function createConfiguration(): Configuration {
+    const configuration = includeCommonConfiguration({
+        parsers: [
+            new ZHHansDateParser(),
+            new ZHHansRelationWeekdayParser(),
+            new ZHHansWeekdayParser(),
+            new ZHHansTimeExpressionParser(),
+            new ZHHansDeadlineFormatParser(),
+        ],
+        refiners: [new ZHHansMergeDateRangeRefiner(), new ZHHansMergeDateTimeRefiner()],
+    });
+
+    // REMOVE ExtractTimezoneOffsetRefiner
+    configuration.refiners = configuration.refiners.filter(
+        (refiner) => !(refiner instanceof ExtractTimezoneOffsetRefiner)
+    );
+
+    return configuration;
+}

package/src/locales/zh/hans/parsers/ZHHansCasualDateParser.ts

@@ -0,0 +1,128 @@
+import dayjs from "dayjs";
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+import { ParsingComponents, ParsingResult } from "../../../../results";
+
+const NOW_GROUP = 1;
+const DAY_GROUP_1 = 2;
+const TIME_GROUP_1 = 3;
+const TIME_GROUP_2 = 4;
+const DAY_GROUP_3 = 5;
+const TIME_GROUP_3 = 6;
+
+export default class ZHHansCasualDateParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(context: ParsingContext): RegExp {
+        return new RegExp(
+            "(现在|立(?:刻|即)|即刻)|" +
+                "(今|明|前|大前|后|大后|昨)(早|晚)|" +
+                "(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨))|" +
+                "(今|明|前|大前|后|大后|昨)(?:日|天)" +
+                "(?:[\\s|,|，]*)" +
+                "(?:(上(?:午)|早(?:上)|下(?:午)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨)))?",
+            "i"
+        );
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult {
+        const index = match.index;
+        const result = context.createParsingResult(index, match[0]);
+
+        const refMoment = dayjs(context.refDate);
+        let startMoment = refMoment;
+
+        if (match[NOW_GROUP]) {
+            result.start.imply("hour", refMoment.hour());
+            result.start.imply("minute", refMoment.minute());
+            result.start.imply("second", refMoment.second());
+            result.start.imply("millisecond", refMoment.millisecond());
+        } else if (match[DAY_GROUP_1]) {
+            const day1 = match[DAY_GROUP_1];
+            const time1 = match[TIME_GROUP_1];
+
+            if (day1 == "明") {
+                // Check not "Tomorrow" on late night
+                if (refMoment.hour() > 1) {
+                    startMoment = startMoment.add(1, "day");
+                }
+            } else if (day1 == "昨") {
+                startMoment = startMoment.add(-1, "day");
+            } else if (day1 == "前") {
+                startMoment = startMoment.add(-2, "day");
+            } else if (day1 == "大前") {
+                startMoment = startMoment.add(-3, "day");
+            } else if (day1 == "后") {
+                startMoment = startMoment.add(2, "day");
+            } else if (day1 == "大后") {
+                startMoment = startMoment.add(3, "day");
+            }
+
+            if (time1 == "早") {
+                result.start.imply("hour", 6);
+            } else if (time1 == "晚") {
+                result.start.imply("hour", 22);
+                result.start.imply("meridiem", 1);
+            }
+        } else if (match[TIME_GROUP_2]) {
+            const timeString2 = match[TIME_GROUP_2];
+            const time2 = timeString2[0];
+            if (time2 == "早" || time2 == "上") {
+                result.start.imply("hour", 6);
+            } else if (time2 == "下") {
+                result.start.imply("hour", 15);
+                result.start.imply("meridiem", 1);
+            } else if (time2 == "中") {
+                result.start.imply("hour", 12);
+                result.start.imply("meridiem", 1);
+            } else if (time2 == "夜" || time2 == "晚") {
+                result.start.imply("hour", 22);
+                result.start.imply("meridiem", 1);
+            } else if (time2 == "凌") {
+                result.start.imply("hour", 0);
+            }
+        } else if (match[DAY_GROUP_3]) {
+            const day3 = match[DAY_GROUP_3];
+
+            if (day3 == "明") {
+                // Check not "Tomorrow" on late night
+                if (refMoment.hour() > 1) {
+                    startMoment = startMoment.add(1, "day");
+                }
+            } else if (day3 == "昨") {
+                startMoment = startMoment.add(-1, "day");
+            } else if (day3 == "前") {
+                startMoment = startMoment.add(-2, "day");
+            } else if (day3 == "大前") {
+                startMoment = startMoment.add(-3, "day");
+            } else if (day3 == "后") {
+                startMoment = startMoment.add(2, "day");
+            } else if (day3 == "大后") {
+                startMoment = startMoment.add(3, "day");
+            }
+
+            const timeString3 = match[TIME_GROUP_3];
+            if (timeString3) {
+                const time3 = timeString3[0];
+                if (time3 == "早" || time3 == "上") {
+                    result.start.imply("hour", 6);
+                } else if (time3 == "下") {
+                    result.start.imply("hour", 15);
+                    result.start.imply("meridiem", 1);
+                } else if (time3 == "中") {
+                    result.start.imply("hour", 12);
+                    result.start.imply("meridiem", 1);
+                } else if (time3 == "夜" || time3 == "晚") {
+                    result.start.imply("hour", 22);
+                    result.start.imply("meridiem", 1);
+                } else if (time3 == "凌") {
+                    result.start.imply("hour", 0);
+                }
+            }
+        }
+
+        result.start.assign("day", startMoment.date());
+        result.start.assign("month", startMoment.month() + 1);
+        result.start.assign("year", startMoment.year());
+
+        return result;
+    }
+}

package/src/locales/zh/hans/parsers/ZHHansDateParser.ts

@@ -0,0 +1,75 @@
+import dayjs from "dayjs";
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+import { NUMBER, zhStringToNumber, zhStringToYear } from "../constants";
+
+const YEAR_GROUP = 1;
+const MONTH_GROUP = 2;
+const DAY_GROUP = 3;
+
+export default class ZHHansDateParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        // prettier-ignore
+        return new RegExp(
+            "(" +
+                "\\d{2,4}|" +
+                "[" +
+                Object.keys(NUMBER).join("") +
+                "]{4}|" +
+                "[" +
+                Object.keys(NUMBER).join("") +
+                "]{2}" +
+                ")?" +
+                "(?:\\s*)" +
+                "(?:年)?" +
+                "(?:[\\s|,|，]*)" +
+                "(" +
+                "\\d{1,2}|" +
+                "[" +
+                Object.keys(NUMBER).join("") +
+                "]{1,3}" +
+                ")" +
+                "(?:\\s*)" +
+                "(?:月)" +
+                "(?:\\s*)" +
+                "(" +
+                "\\d{1,2}|" +
+                "[" +
+                Object.keys(NUMBER).join("") +
+                "]{1,3}" +
+                ")?" +
+                "(?:\\s*)" +
+                "(?:日|号)?"
+        );
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const startMoment = dayjs(context.refDate);
+        const result = context.createParsingResult(match.index, match[0]);
+
+        //Month
+        let month = parseInt(match[MONTH_GROUP]);
+        if (isNaN(month)) month = zhStringToNumber(match[MONTH_GROUP]);
+        result.start.assign("month", month);
+
+        //Day
+        if (match[DAY_GROUP]) {
+            let day = parseInt(match[DAY_GROUP]);
+            if (isNaN(day)) day = zhStringToNumber(match[DAY_GROUP]);
+            result.start.assign("day", day);
+        } else {
+            result.start.imply("day", startMoment.date());
+        }
+
+        //Year
+        if (match[YEAR_GROUP]) {
+            let year = parseInt(match[YEAR_GROUP]);
+            if (isNaN(year)) year = zhStringToYear(match[YEAR_GROUP]);
+            result.start.assign("year", year);
+        } else {
+            result.start.imply("year", startMoment.year());
+        }
+
+        return result;
+    }
+}