chrono-node 2.3.5 → 2.3.8

package/README.md

@@ -133,7 +133,7 @@ For example:
 ```js
 const results = chrono.parse('I have an appointment tomorrow from 10 to 11 AM');
 
-results[0].index;     // 15
+results[0].index;     // 22
 results[0].text;      // 'tomorrow from 10 to 11 AM'
 results[0].refDate;   // Sat Dec 13 2014 21:50:14 GMT-0600 (CST)
 

package/dist/common/refiners/ExtractTimezoneAbbrRefiner.js

@@ -214,7 +214,7 @@ class ExtractTimezoneAbbrRefiner {
                 return;
             }
             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");
             if (currentTimezoneOffset !== null && extractedTimezoneOffset != currentTimezoneOffset) {
@@ -225,6 +225,11 @@ class ExtractTimezoneAbbrRefiner {
                     return;
                 }
             }
+            if (result.start.isOnlyDate()) {
+                if (timezoneAbbr != match[1]) {
+                    return;
+                }
+            }
             result.text += match[0];
             if (!result.start.isCertain("timezoneOffset")) {
                 result.start.assign("timezoneOffset", extractedTimezoneOffset);

package/dist/locales/de/constants.d.ts

@@ -1,4 +1,4 @@
-import { OpUnitType } from "dayjs";
+import { OpUnitType, QUnitType } from "dayjs";
 import { TimeUnits } from "../../utils/timeunits";
 export declare const WEEKDAY_DICTIONARY: {
     [word: string]: number;
@@ -10,11 +10,11 @@ export declare const INTEGER_WORD_DICTIONARY: {
     [word: string]: number;
 };
 export declare const TIME_UNIT_DICTIONARY: {
-    [word: string]: OpUnitType;
+    [word: string]: OpUnitType | QUnitType;
 };
 export declare const NUMBER_PATTERN: string;
 export declare function parseNumberPattern(match: string): number;
-export declare const YEAR_PATTERN = "(?:[0-9]{1,4}(?:\\s*[vn]\\.?\\s*C(?:hr)?\\.?)?)";
+export declare 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 declare function parseYear(match: string): number;
 export declare const TIME_UNITS_PATTERN: string;
 export declare function parseTimeUnits(timeunitText: any): TimeUnits;

package/dist/locales/de/constants.js

@@ -21,9 +21,12 @@ exports.WEEKDAY_DICTIONARY = {
 };
 exports.MONTH_DICTIONARY = {
     "januar": 1,
+    "jänner": 1,
+    "janner": 1,
     "jan": 1,
     "jan.": 1,
     "februar": 2,
+    "feber": 2,
     "feb": 2,
     "feb.": 2,
     "märz": 3,
@@ -62,6 +65,10 @@ exports.MONTH_DICTIONARY = {
 };
 exports.INTEGER_WORD_DICTIONARY = {
     "eins": 1,
+    "eine": 1,
+    "einem": 1,
+    "einen": 1,
+    "einer": 1,
     "zwei": 2,
     "drei": 3,
     "vier": 4,
@@ -77,28 +84,36 @@ exports.INTEGER_WORD_DICTIONARY = {
     "zwoelf": 12,
 };
 exports.TIME_UNIT_DICTIONARY = {
-    sec: "second",
-    second: "second",
-    seconds: "second",
+    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",
 };
 exports.NUMBER_PATTERN = `(?:${pattern_1.matchAnyPattern(exports.INTEGER_WORD_DICTIONARY)}|[0-9]+|[0-9]+\\.[0-9]+|half(?:\\s*an?)?|an?\\b(?:\\s*few)?|few|several|a?\\s*couple\\s*(?:of)?)`;
 function parseNumberPattern(match) {
@@ -124,7 +139,7 @@ function parseNumberPattern(match) {
     return parseFloat(num);
 }
 exports.parseNumberPattern = parseNumberPattern;
-exports.YEAR_PATTERN = `(?:[0-9]{1,4}(?:\\s*[vn]\\.?\\s*C(?:hr)?\\.?)?)`;
+exports.YEAR_PATTERN = `(?:[0-9]{1,4}(?:\\s*[vn]\\.?\\s*(?:C(?:hr)?|(?:u\\.?|d\\.?(?:\\s*g\\.?)?)?\\s*Z)\\.?|\\s*(?:u\\.?|d\\.?(?:\\s*g\\.)?)\\s*Z\\.?)?)`;
 function parseYear(match) {
     if (/v/i.test(match)) {
         return -parseInt(match.replace(/[^0-9]+/gi, ""));
@@ -132,6 +147,9 @@ function parseYear(match) {
     if (/n/i.test(match)) {
         return parseInt(match.replace(/[^0-9]+/gi, ""));
     }
+    if (/z/i.test(match)) {
+        return parseInt(match.replace(/[^0-9]+/gi, ""));
+    }
     const rawYearNumber = parseInt(match);
     return years_1.findMostLikelyADYear(rawYearNumber);
 }

package/dist/locales/de/index.js

@@ -10,11 +10,13 @@ const SlashDateFormatParser_1 = __importDefault(require("../../common/parsers/Sl
 const ISOFormatParser_1 = __importDefault(require("../../common/parsers/ISOFormatParser"));
 const DETimeExpressionParser_1 = __importDefault(require("./parsers/DETimeExpressionParser"));
 const DEWeekdayParser_1 = __importDefault(require("./parsers/DEWeekdayParser"));
+const DESpecificTimeExpressionParser_1 = __importDefault(require("./parsers/DESpecificTimeExpressionParser"));
 const DEMergeDateRangeRefiner_1 = __importDefault(require("./refiners/DEMergeDateRangeRefiner"));
 const DEMergeDateTimeRefiner_1 = __importDefault(require("./refiners/DEMergeDateTimeRefiner"));
 const DECasualDateParser_1 = __importDefault(require("./parsers/DECasualDateParser"));
 const DECasualTimeParser_1 = __importDefault(require("./parsers/DECasualTimeParser"));
 const DEMonthNameLittleEndianParser_1 = __importDefault(require("./parsers/DEMonthNameLittleEndianParser"));
+const DETimeUnitRelativeFormatParser_1 = __importDefault(require("./parsers/DETimeUnitRelativeFormatParser"));
 exports.casual = new chrono_1.Chrono(createCasualConfiguration());
 exports.strict = new chrono_1.Chrono(createConfiguration(true));
 function parse(text, ref, option) {
@@ -29,6 +31,7 @@ function createCasualConfiguration(littleEndian = true) {
     const option = createConfiguration(false, littleEndian);
     option.parsers.unshift(new DECasualTimeParser_1.default());
     option.parsers.unshift(new DECasualDateParser_1.default());
+    option.parsers.unshift(new DETimeUnitRelativeFormatParser_1.default());
     return option;
 }
 exports.createCasualConfiguration = createCasualConfiguration;
@@ -38,6 +41,7 @@ function createConfiguration(strictMode = true, littleEndian = true) {
             new ISOFormatParser_1.default(),
             new SlashDateFormatParser_1.default(littleEndian),
             new DETimeExpressionParser_1.default(),
+            new DESpecificTimeExpressionParser_1.default(),
             new DEMonthNameLittleEndianParser_1.default(),
             new DEWeekdayParser_1.default(),
         ],

package/dist/locales/de/parsers/DESpecificTimeExpressionParser.d.ts

@@ -0,0 +1,7 @@
+import { Parser, ParsingContext } from "../../../chrono";
+import { ParsingResult } from "../../../results";
+export default class DESpecificTimeExpressionParser implements Parser {
+    pattern(context: any): RegExp;
+    extract(context: ParsingContext, match: RegExpMatchArray): ParsingResult | null;
+    private static extractTimeComponent;
+}

package/dist/locales/de/parsers/DESpecificTimeExpressionParser.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../../index");
+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;
+class DESpecificTimeExpressionParser {
+    pattern(context) {
+        return FIRST_REG_PATTERN;
+    }
+    extract(context, match) {
+        const result = context.createParsingResult(match.index + match[1].length, match[0].substring(match[1].length));
+        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;
+    }
+    static extractTimeComponent(extractingComponents, match) {
+        let hour = 0;
+        let minute = 0;
+        let meridiem = null;
+        hour = parseInt(match[HOUR_GROUP]);
+        if (match[MINUTE_GROUP] != null) {
+            minute = parseInt(match[MINUTE_GROUP]);
+        }
+        if (minute >= 60 || hour > 24) {
+            return null;
+        }
+        if (hour >= 12) {
+            meridiem = index_1.Meridiem.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 = index_1.Meridiem.AM;
+                if (hour == 12) {
+                    hour = 0;
+                }
+            }
+            if (ampm.match(/nachmittag|abend/)) {
+                meridiem = index_1.Meridiem.PM;
+                if (hour != 12) {
+                    hour += 12;
+                }
+            }
+            if (ampm.match(/nacht/)) {
+                if (hour == 12) {
+                    meridiem = index_1.Meridiem.AM;
+                    hour = 0;
+                }
+                else if (hour < 6) {
+                    meridiem = index_1.Meridiem.AM;
+                }
+                else {
+                    meridiem = index_1.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", index_1.Meridiem.AM);
+            }
+            else {
+                extractingComponents.imply("meridiem", index_1.Meridiem.PM);
+            }
+        }
+        if (match[SECOND_GROUP] != null) {
+            const second = parseInt(match[SECOND_GROUP]);
+            if (second >= 60)
+                return null;
+            extractingComponents.assign("second", second);
+        }
+        return extractingComponents;
+    }
+}
+exports.default = DESpecificTimeExpressionParser;

package/dist/locales/de/parsers/DETimeExpressionParser.d.ts

@@ -4,6 +4,5 @@ import { ParsingContext } from "../../../chrono";
 export default class DETimeExpressionParser extends AbstractTimeExpressionParser {
     primaryPrefix(): string;
     followingPhase(): string;
-    primarySuffix(): string;
     extractPrimaryTimeComponents(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | null;
 }

package/dist/locales/de/parsers/DETimeExpressionParser.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const AbstractTimeExpressionParser_1 = require("../../../common/parsers/AbstractTimeExpressionParser");
-const index_1 = require("../../../index");
 class DETimeExpressionParser extends AbstractTimeExpressionParser_1.AbstractTimeExpressionParser {
     primaryPrefix() {
         return "(?:(?:um|von)\\s*)?";
@@ -9,28 +8,11 @@ class DETimeExpressionParser extends AbstractTimeExpressionParser_1.AbstractTime
     followingPhase() {
         return "\\s*(?:\\-|\\–|\\~|\\〜|bis)\\s*";
     }
-    primarySuffix() {
-        return "(?:\\s*uhr)?(?:\\s*(?:morgens|vormittags|nachmittags|abends|nachts))?(?=\\W|$)";
-    }
     extractPrimaryTimeComponents(context, match) {
-        const components = super.extractPrimaryTimeComponents(context, match);
-        if (components) {
-            if (match[0].endsWith("morgens") || match[0].endsWith("vormittags")) {
-                components.assign("meridiem", index_1.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", index_1.Meridiem.PM);
-                const hour = components.get("hour");
-                if (hour < 12) {
-                    components.assign("hour", components.get("hour") + 12);
-                }
-            }
+        if (match[0].match(/^\s*\d{4}\s*$/)) {
+            return null;
         }
-        return components;
+        return super.extractPrimaryTimeComponents(context, match);
     }
 }
 exports.default = DETimeExpressionParser;

package/dist/locales/de/parsers/DETimeUnitRelativeFormatParser.d.ts

@@ -0,0 +1,8 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+export default class DETimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor();
+    innerPattern(): RegExp;
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents;
+}

package/dist/locales/de/parsers/DETimeUnitRelativeFormatParser.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const results_1 = require("../../../results");
+const AbstractParserWithWordBoundary_1 = require("../../../common/parsers/AbstractParserWithWordBoundary");
+const timeunits_1 = require("../../../utils/timeunits");
+const pattern_1 = require("../../../utils/pattern");
+class DETimeUnitAgoFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {
+    constructor() {
+        super();
+    }
+    innerPattern() {
+        return new RegExp(`(?:\\s*((?:nächste|kommende|folgende|letzte|vergangene|vorige|vor(?:her|an)gegangene)(?:s|n|m|r)?|vor|in)\\s*)?` +
+            `(${constants_1.NUMBER_PATTERN})?` +
+            `(?:\\s*(nächste|kommende|folgende|letzte|vergangene|vorige|vor(?:her|an)gegangene)(?:s|n|m|r)?)?` +
+            `\\s*(${pattern_1.matchAnyPattern(constants_1.TIME_UNIT_DICTIONARY)})`, "i");
+    }
+    innerExtract(context, match) {
+        const num = match[2] ? constants_1.parseNumberPattern(match[2]) : 1;
+        const unit = constants_1.TIME_UNIT_DICTIONARY[match[4].toLowerCase()];
+        let timeUnits = {};
+        timeUnits[unit] = num;
+        let modifier = match[1] || match[3] || "";
+        modifier = modifier.toLowerCase();
+        if (!modifier) {
+            return;
+        }
+        if (/vor/.test(modifier) || /letzte/.test(modifier) || /vergangen/.test(modifier)) {
+            timeUnits = timeunits_1.reverseTimeUnits(timeUnits);
+        }
+        return results_1.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}
+exports.default = DETimeUnitAgoFormatParser;

package/dist/locales/en/constants.d.ts

@@ -1,4 +1,4 @@
-import { OpUnitType } from "dayjs";
+import { OpUnitType, QUnitType } from "dayjs";
 import { TimeUnits } from "../../utils/timeunits";
 export declare const WEEKDAY_DICTIONARY: {
     [word: string]: number;
@@ -16,7 +16,7 @@ export declare const ORDINAL_WORD_DICTIONARY: {
     [word: string]: number;
 };
 export declare const TIME_UNIT_DICTIONARY: {
-    [word: string]: OpUnitType;
+    [word: string]: OpUnitType | QUnitType;
 };
 export declare const NUMBER_PATTERN: string;
 export declare function parseNumberPattern(match: string): number;

package/dist/locales/en/constants.js

@@ -121,6 +121,9 @@ exports.TIME_UNIT_DICTIONARY = {
     weeks: "week",
     month: "month",
     months: "month",
+    qtr: "quarter",
+    quarter: "quarter",
+    quarters: "quarter",
     y: "year",
     yr: "year",
     year: "year",

package/dist/locales/en/index.js

@@ -23,6 +23,7 @@ const ENRelativeDateFormatParser_1 = __importDefault(require("./parsers/ENRelati
 const chrono_1 = require("../../chrono");
 const SlashDateFormatParser_1 = __importDefault(require("../../common/parsers/SlashDateFormatParser"));
 const ENTimeUnitCasualRelativeFormatParser_1 = __importDefault(require("./parsers/ENTimeUnitCasualRelativeFormatParser"));
+const ENMergeRelativeDateRefiner_1 = __importDefault(require("./refiners/ENMergeRelativeDateRefiner"));
 exports.casual = new chrono_1.Chrono(createCasualConfiguration(false));
 exports.strict = new chrono_1.Chrono(createConfiguration(true, false));
 exports.GB = new chrono_1.Chrono(createConfiguration(false, true));
@@ -58,7 +59,7 @@ function createConfiguration(strictMode = true, littleEndian = false) {
             new ENTimeUnitAgoFormatParser_1.default(strictMode),
             new ENTimeUnitLaterFormatParser_1.default(strictMode),
         ],
-        refiners: [new ENMergeDateTimeRefiner_1.default(), new ENMergeDateRangeRefiner_1.default()],
+        refiners: [new ENMergeRelativeDateRefiner_1.default(), new ENMergeDateTimeRefiner_1.default(), new ENMergeDateRangeRefiner_1.default()],
     }, strictMode);
 }
 exports.createConfiguration = createConfiguration;

package/dist/locales/en/parsers/ENRelativeDateFormatParser.js

@@ -8,7 +8,7 @@ const results_1 = require("../../../results");
 const dayjs_1 = __importDefault(require("dayjs"));
 const AbstractParserWithWordBoundary_1 = require("../../../common/parsers/AbstractParserWithWordBoundary");
 const pattern_1 = require("../../../utils/pattern");
-const PATTERN = new RegExp(`(this|next|last|past)\\s*(${pattern_1.matchAnyPattern(constants_1.TIME_UNIT_DICTIONARY)})(?=\\s*)` + "(?=\\W|$)", "i");
+const PATTERN = new RegExp(`(this|last|past|next|after\\s*this)\\s*(${pattern_1.matchAnyPattern(constants_1.TIME_UNIT_DICTIONARY)})(?=\\s*)` + "(?=\\W|$)", "i");
 const MODIFIER_WORD_GROUP = 1;
 const RELATIVE_WORD_GROUP = 2;
 class ENRelativeDateFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {
@@ -19,7 +19,7 @@ class ENRelativeDateFormatParser extends AbstractParserWithWordBoundary_1.Abstra
         const modifier = match[MODIFIER_WORD_GROUP].toLowerCase();
         const unitWord = match[RELATIVE_WORD_GROUP].toLowerCase();
         const timeunit = constants_1.TIME_UNIT_DICTIONARY[unitWord];
-        if (modifier == "next") {
+        if (modifier == "next" || modifier.startsWith("after")) {
             const timeUnits = {};
             timeUnits[timeunit] = 1;
             return results_1.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);

package/dist/locales/en/parsers/ENTimeUnitCasualRelativeFormatParser.js

@@ -4,7 +4,7 @@ const constants_1 = require("../constants");
 const results_1 = require("../../../results");
 const AbstractParserWithWordBoundary_1 = require("../../../common/parsers/AbstractParserWithWordBoundary");
 const timeunits_1 = require("../../../utils/timeunits");
-const PATTERN = new RegExp(`(this|last|past|next|\\+|-)\\s*(${constants_1.TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+const PATTERN = new RegExp(`(this|last|past|next|after|\\+|-)\\s*(${constants_1.TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
 class ENTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {
     innerPattern() {
         return PATTERN;

package/dist/locales/en/refiners/ENMergeRelativeDateRefiner.d.ts

@@ -0,0 +1,7 @@
+import { MergingRefiner } from "../../../common/abstractRefiners";
+import { ParsingResult } from "../../../results";
+export default class ENMergeRelativeDateRefiner extends MergingRefiner {
+    patternBetween(): RegExp;
+    shouldMergeResults(textBetween: string, currentResult: ParsingResult, nextResult: ParsingResult): boolean;
+    mergeResults(textBetween: string, currentResult: ParsingResult, nextResult: ParsingResult): ParsingResult;
+}

package/dist/locales/en/refiners/ENMergeRelativeDateRefiner.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const abstractRefiners_1 = require("../../../common/abstractRefiners");
+const results_1 = require("../../../results");
+const constants_1 = require("../constants");
+const timeunits_1 = require("../../../utils/timeunits");
+function hasImpliedEarlierReferenceDate(result) {
+    return result.text.match(/\s+(before|from)$/i) != null;
+}
+function hasImpliedLaterReferenceDate(result) {
+    return result.text.match(/\s+(after|since)$/i) != null;
+}
+class ENMergeRelativeDateRefiner extends abstractRefiners_1.MergingRefiner {
+    patternBetween() {
+        return /^\s*$/i;
+    }
+    shouldMergeResults(textBetween, currentResult, nextResult) {
+        if (!textBetween.match(this.patternBetween())) {
+            return false;
+        }
+        if (!hasImpliedEarlierReferenceDate(currentResult) && !hasImpliedLaterReferenceDate(currentResult)) {
+            return false;
+        }
+        return !!nextResult.start.get("day") && !!nextResult.start.get("month") && !!nextResult.start.get("year");
+    }
+    mergeResults(textBetween, currentResult, nextResult) {
+        let timeUnits = constants_1.parseTimeUnits(currentResult.text);
+        if (hasImpliedEarlierReferenceDate(currentResult)) {
+            timeUnits = timeunits_1.reverseTimeUnits(timeUnits);
+        }
+        const components = results_1.ParsingComponents.createRelativeFromReference(new results_1.ReferenceWithTimezone(nextResult.start.date()), timeUnits);
+        return new results_1.ParsingResult(nextResult.reference, currentResult.index, `${currentResult.text}${textBetween}${nextResult.text}`, components);
+    }
+}
+exports.default = ENMergeRelativeDateRefiner;

package/dist/locales/zh/hans/constants.d.ts

@@ -0,0 +1,27 @@
+export declare const NUMBER: {
+    零: number;
+    〇: number;
+    一: number;
+    二: number;
+    两: number;
+    三: number;
+    四: number;
+    五: number;
+    六: number;
+    七: number;
+    八: number;
+    九: number;
+    十: number;
+};
+export declare const WEEKDAY_OFFSET: {
+    天: number;
+    日: number;
+    一: number;
+    二: number;
+    三: number;
+    四: number;
+    五: number;
+    六: number;
+};
+export declare function zhStringToNumber(text: string): number;
+export declare function zhStringToYear(text: string): number;

package/dist/locales/zh/hans/constants.js

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

package/dist/locales/zh/hans/index.d.ts

@@ -0,0 +1,9 @@
+import { Chrono, Configuration } from "../../../chrono";
+import { ParsedResult, ParsingOption } from "../../../index";
+export declare const hans: Chrono;
+export declare const casual: Chrono;
+export declare const strict: Chrono;
+export declare function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[];
+export declare function parseDate(text: string, ref?: Date, option?: ParsingOption): Date;
+export declare function createCasualConfiguration(): Configuration;
+export declare function createConfiguration(): Configuration;

package/dist/locales/zh/hans/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfiguration = exports.createCasualConfiguration = exports.parseDate = exports.parse = exports.strict = exports.casual = exports.hans = void 0;
+const chrono_1 = require("../../../chrono");
+const ExtractTimezoneOffsetRefiner_1 = __importDefault(require("../../../common/refiners/ExtractTimezoneOffsetRefiner"));
+const configurations_1 = require("../../../configurations");
+const ZHHansCasualDateParser_1 = __importDefault(require("./parsers/ZHHansCasualDateParser"));
+const ZHHansDateParser_1 = __importDefault(require("./parsers/ZHHansDateParser"));
+const ZHHansDeadlineFormatParser_1 = __importDefault(require("./parsers/ZHHansDeadlineFormatParser"));
+const ZHHansRelationWeekdayParser_1 = __importDefault(require("./parsers/ZHHansRelationWeekdayParser"));
+const ZHHansTimeExpressionParser_1 = __importDefault(require("./parsers/ZHHansTimeExpressionParser"));
+const ZHHansWeekdayParser_1 = __importDefault(require("./parsers/ZHHansWeekdayParser"));
+const ZHHansMergeDateRangeRefiner_1 = __importDefault(require("./refiners/ZHHansMergeDateRangeRefiner"));
+const ZHHansMergeDateTimeRefiner_1 = __importDefault(require("./refiners/ZHHansMergeDateTimeRefiner"));
+exports.hans = new chrono_1.Chrono(createCasualConfiguration());
+exports.casual = new chrono_1.Chrono(createCasualConfiguration());
+exports.strict = new chrono_1.Chrono(createConfiguration());
+function parse(text, ref, option) {
+    return exports.casual.parse(text, ref, option);
+}
+exports.parse = parse;
+function parseDate(text, ref, option) {
+    return exports.casual.parseDate(text, ref, option);
+}
+exports.parseDate = parseDate;
+function createCasualConfiguration() {
+    const option = createConfiguration();
+    option.parsers.unshift(new ZHHansCasualDateParser_1.default());
+    return option;
+}
+exports.createCasualConfiguration = createCasualConfiguration;
+function createConfiguration() {
+    const configuration = configurations_1.includeCommonConfiguration({
+        parsers: [
+            new ZHHansDateParser_1.default(),
+            new ZHHansRelationWeekdayParser_1.default(),
+            new ZHHansWeekdayParser_1.default(),
+            new ZHHansTimeExpressionParser_1.default(),
+            new ZHHansDeadlineFormatParser_1.default(),
+        ],
+        refiners: [new ZHHansMergeDateRangeRefiner_1.default(), new ZHHansMergeDateTimeRefiner_1.default()],
+    });
+    configuration.refiners = configuration.refiners.filter((refiner) => !(refiner instanceof ExtractTimezoneOffsetRefiner_1.default));
+    return configuration;
+}
+exports.createConfiguration = createConfiguration;