chrono-node 2.9.0 → 2.9.2

package/src/locales/vi/parsers/VIStandardParser.ts

@@ -0,0 +1,45 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingResult } from "../../../results";
+import { findYearClosestToRef } from "../../../calculation/years";
+import { YEAR_PATTERN, parseYear } from "../constants";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+// ngày 15 tháng 3 năm 1975  |  15 tháng 3 năm 1975  |  15 tháng 3
+const PATTERN = new RegExp(
+    "(?:ng\u00e0y\\s*)?" +
+        "([0-9]{1,2})" +
+        "\\s*th\u00e1ng\\s*" +
+        "([0-9]{1,2})" +
+        "(?:\\s*n\u0103m\\s*(" +
+        YEAR_PATTERN +
+        "))?" +
+        "(?=\\W|$)",
+    "i"
+);
+
+const DAY_GROUP = 1;
+const MONTH_GROUP = 2;
+const YEAR_GROUP = 3;
+
+export default class VIStandardParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingResult {
+        const day = parseInt(match[DAY_GROUP]);
+        const month = parseInt(match[MONTH_GROUP]);
+        if (day > 31 || month > 12) return null;
+
+        const result = context.createParsingResult(match.index, match[0]);
+        result.start.assign("day", day);
+        result.start.assign("month", month);
+
+        if (match[YEAR_GROUP]) {
+            result.start.assign("year", parseYear(match[YEAR_GROUP]));
+        } else {
+            result.start.imply("year", findYearClosestToRef(context.refDate, day, month));
+        }
+        return result;
+    }
+}

package/src/locales/vi/parsers/VITimeExpressionParser.ts

@@ -0,0 +1,66 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingResult } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { Meridiem } from "../../../types";
+
+// l\u00fac 7 gi\u1edd 30 ph\u00fat  |  7 gi\u1edd s\u00e1ng  |  7 gi\u1edd  |  15:30
+const PATTERN = new RegExp(
+    "(?:l\u00fac\\s*|v\u00e0o\\s*)?" +
+        "([0-9]{1,2})" +
+        "(?:\\s*gi\u1edd\\s*([0-9]{1,2})?\\s*(?:ph\u00fat\\s*)?" +
+        "(s\u00e1ng|tr\u01b0a|chi\u1ec1u|t\u1ed1i|\u0111\u00eam)?" +
+        "|:([0-9]{2}))" +
+        "(?=\\W|$)",
+    "i"
+);
+
+const HOUR_GROUP = 1;
+const MINUTE_GIO_GROUP = 2;
+const MERIDIEM_GROUP = 3;
+const MINUTE_COLON_GROUP = 4;
+
+export default class VITimeExpressionParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingResult {
+        const hour = parseInt(match[HOUR_GROUP]);
+        if (hour > 23) return null;
+
+        const result = context.createParsingResult(match.index, match[0]);
+        result.start.assign("hour", hour);
+
+        const minute = match[MINUTE_COLON_GROUP]
+            ? parseInt(match[MINUTE_COLON_GROUP])
+            : match[MINUTE_GIO_GROUP]
+              ? parseInt(match[MINUTE_GIO_GROUP])
+              : 0;
+        if (minute >= 60) return null;
+        result.start.assign("minute", minute);
+
+        const meridiem = match[MERIDIEM_GROUP]?.toLowerCase();
+        if (meridiem === "sáng") {
+            // "12 giờ sáng" = midnight (00:00), matching EN convention
+            result.start.assign("meridiem", Meridiem.AM);
+            if (hour === 12) result.start.assign("hour", 0);
+        } else if (meridiem === "trưa") {
+            // "trưa" = noon/midday (~11 AM - 1 PM)
+            // "1 giờ trưa" = 13:00, but "11 giờ trưa" = 11:00 (approaching noon)
+            if (hour < 10) {
+                result.start.assign("meridiem", Meridiem.PM);
+                result.start.assign("hour", hour + 12);
+            } else {
+                // 10-12: keep as-is (AM for 10-11, PM for 12)
+                result.start.assign("meridiem", hour >= 12 ? Meridiem.PM : Meridiem.AM);
+            }
+        } else if (meridiem === "chiều" || meridiem === "tối" || meridiem === "đêm") {
+            result.start.assign("meridiem", Meridiem.PM);
+            if (hour < 12) result.start.assign("hour", hour + 12);
+        }
+
+        result.start.imply("second", 0);
+        result.start.imply("millisecond", 0);
+        return result;
+    }
+}

package/src/locales/vi/parsers/VITimeUnitAgoFormatParser.ts

@@ -0,0 +1,23 @@
+import { ParsingContext } from "../../../chrono";
+import { parseDuration, TIME_UNITS_PATTERN } from "../constants";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { reverseDuration } from "../../../calculation/duration";
+
+// 2 ng\u00e0y tr\u01b0\u1edbc  |  3 th\u00e1ng qua  |  1 n\u0103m tr\u01b0\u1edbc
+const PATTERN = new RegExp("(" + TIME_UNITS_PATTERN + ")" + "\\s{0,5}(?:tr\u01b0\u1edbc|qua)(?=\\W|$)", "i");
+export default class VITimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor(private strictMode = false) {
+        super();
+    }
+    innerPattern(): RegExp {
+        // VI has no unit abbreviations, so strict and casual patterns are identical.
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const duration = parseDuration(match[1]);
+        if (!duration) return null;
+        return ParsingComponents.createRelativeFromReference(context.reference, reverseDuration(duration));
+    }
+}

package/src/locales/vi/parsers/VITimeUnitCasualRelativeFormatParser.ts

@@ -0,0 +1,46 @@
+import { TIME_UNIT_DICTIONARY, NUMBER_PATTERN, parseDuration } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { reverseDuration } from "../../../calculation/duration";
+import { matchAnyPattern } from "../../../utils/pattern";
+
+// tuần này  |  tháng trước  |  năm sau  |  tuần tới  |  2 tuần trước
+// NUMBER is optional so bare unit words ("tuần này") are matched
+const CASUAL_UNIT_PATTERN = "(?:" + NUMBER_PATTERN + "\\s{0,5})?(?:" + matchAnyPattern(TIME_UNIT_DICTIONARY) + ")";
+
+const PATTERN = new RegExp(
+    "(này|trước|qua|sau|tới|tiếp)\\s*(" +
+        CASUAL_UNIT_PATTERN +
+        ")" +
+        "|(" +
+        CASUAL_UNIT_PATTERN +
+        ")\\s*(này|trước|qua|sau|tới|tiếp)" +
+        "(?=\\W|$)",
+    "i"
+);
+
+export default class VITimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        // prefix form (trước tuần) or suffix form (tuần trước)
+        const modifier = (match[1] || match[4] || "").toLowerCase();
+        const unitText = (match[2] || match[3] || "").toLowerCase();
+
+        let duration = parseDuration(unitText);
+        if (Object.keys(duration).length === 0) {
+            // bare unit word with no number — implies 1
+            const unit = TIME_UNIT_DICTIONARY[unitText];
+            if (!unit) return null;
+            duration = { [unit]: 1 };
+        }
+
+        if (modifier === "trước" || modifier === "qua") {
+            duration = reverseDuration(duration);
+        }
+        return ParsingComponents.createRelativeFromReference(context.reference, duration);
+    }
+}

package/src/locales/vi/parsers/VITimeUnitLaterFormatParser.ts

@@ -0,0 +1,25 @@
+import { ParsingContext } from "../../../chrono";
+import { parseDuration, TIME_UNITS_PATTERN } from "../constants";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+// 2 ng\u00e0y sau  |  3 tu\u1ea7n n\u1eefa  |  1 th\u00e1ng t\u1edbi
+const PATTERN = new RegExp(
+    "(" + TIME_UNITS_PATTERN + ")" + "\\s{0,5}(?:sau|n\u1eefa|t\u1edbi|ti\u1ebfp)(?=\\W|$)",
+    "i"
+);
+export default class VITimeUnitLaterFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor(private strictMode = false) {
+        super();
+    }
+    innerPattern(): RegExp {
+        // VI has no unit abbreviations, so strict and casual patterns are identical.
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const duration = parseDuration(match[1]);
+        if (!duration) return null;
+        return ParsingComponents.createRelativeFromReference(context.reference, duration);
+    }
+}

package/src/locales/vi/parsers/VITimeUnitWithinFormatParser.ts

@@ -0,0 +1,22 @@
+import { ParsingContext } from "../../../chrono";
+import { parseDuration, TIME_UNITS_PATTERN } from "../constants";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+// trong 2 ng\u00e0y  |  trong 3 tu\u1ea7n  |  trong v\u00f2ng 1 th\u00e1ng
+const PATTERN = new RegExp("(?:trong\\s*(?:v\u00f2ng\\s*)?)" + "(" + TIME_UNITS_PATTERN + ")(?=\\W|$)", "i");
+export default class VITimeUnitWithinFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor(private strictMode = false) {
+        super();
+    }
+    innerPattern(): RegExp {
+        // VI has no unit abbreviations, so strict and casual patterns are identical.
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const timeUnits = parseDuration(match[1]);
+        if (!timeUnits) return null;
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}

package/src/locales/vi/parsers/VIWeekdayParser.ts

@@ -0,0 +1,41 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { WEEKDAY_DICTIONARY } from "../constants";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { createParsingComponentsAtWeekday } from "../../../calculation/weekdays";
+
+const PATTERN = new RegExp(
+    "(" +
+        matchAnyPattern(WEEKDAY_DICTIONARY) +
+        ")" +
+        // 'sau khi' is a conjunction ("after when") — exclude via negative lookahead
+        "(?:\\s*(này|tới|sau(?!\\s*khi)|qua))?" +
+        "(?=\\W|$)",
+    "i"
+);
+
+const WEEKDAY_GROUP = 1;
+const MODIFIER_GROUP = 2;
+
+export default class VIWeekdayParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const dowText = match[WEEKDAY_GROUP].toLowerCase();
+        const dow = WEEKDAY_DICTIONARY[dowText];
+        if (dow === undefined) return null;
+
+        const modifier = match[MODIFIER_GROUP];
+        let modifierType: "this" | "next" | "last" | null = null;
+        if (modifier) {
+            const m = modifier.toLowerCase();
+            if (m.includes("tới") || m.includes("sau")) modifierType = "next";
+            else if (m.includes("qua")) modifierType = "last";
+        }
+
+        return createParsingComponentsAtWeekday(context.reference, dow, modifierType);
+    }
+}

package/src/locales/vi/parsers/VIYearParser.ts

@@ -0,0 +1,31 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingResult } from "../../../results";
+import { YEAR_PATTERN, parseYear } from "../constants";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+// năm 1975  |  năm 43 TCN  |  179 TCN (bare BC year without năm prefix)
+const PATTERN = new RegExp("(?:\\bnăm\\s*(" + YEAR_PATTERN + ")|\\b([0-9]{1,4})\\s*(TCN))(?=\\W|$)", "i");
+
+const YEAR_WITH_NAM_GROUP = 1; // năm YYYY or năm YYYY TCN
+const BARE_BC_YEAR_GROUP = 2; // bare YYYY in "YYYY TCN"
+const BARE_BC_SUFFIX_GROUP = 3; // "TCN" in bare form
+
+export default class VIYearParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingResult {
+        let yearText: string;
+        if (match[YEAR_WITH_NAM_GROUP]) {
+            yearText = match[YEAR_WITH_NAM_GROUP];
+        } else {
+            yearText = match[BARE_BC_YEAR_GROUP] + " " + match[BARE_BC_SUFFIX_GROUP];
+        }
+        const result = context.createParsingResult(match.index, match[0]);
+        result.start.assign("year", parseYear(yearText));
+        result.start.imply("month", 1);
+        result.start.imply("day", 1);
+        return result;
+    }
+}

package/src/locales/vi/refiners/VIMergeDateRangeRefiner.ts

@@ -0,0 +1,7 @@
+import AbstractMergeDateRangeRefiner from "../../../common/refiners/AbstractMergeDateRangeRefiner";
+
+export default class VIMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner {
+    patternBetween(): RegExp {
+        return /^\s*(?:–|-|đến|tới|và)\s*$/;
+    }
+}

package/src/locales/vi/refiners/VIMergeDateTimeRefiner.ts

@@ -0,0 +1,7 @@
+import AbstractMergeDateTimeRefiner from "../../../common/refiners/AbstractMergeDateTimeRefiner";
+
+export default class VIMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner {
+    patternBetween(): RegExp {
+        return /^\s*(?:lúc|vào|,|T|-)?\s*$/;
+    }
+}

package/src/locales/vi/refiners/VIMergeWeekdayComponentRefiner.ts

@@ -0,0 +1,7 @@
+import MergeWeekdayComponentRefiner from "../../../common/refiners/MergeWeekdayComponentRefiner";
+
+/**
+ * Merge weekday with adjacent date/time component.
+ * e.g. [th\u1ee9 Hai] [l\u00fac 7 gi\u1edd] => [th\u1ee9 Hai l\u00fac 7 gi\u1edd]
+ */
+export default class VIMergeWeekdayComponentRefiner extends MergeWeekdayComponentRefiner {}

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

@@ -10,6 +10,7 @@ import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Wee
 import ZHHansCasualDateParser from "./parsers/ZHHansCasualDateParser";
 import ZHHansDateParser from "./parsers/ZHHansDateParser";
 import ZHHansDeadlineFormatParser from "./parsers/ZHHansDeadlineFormatParser";
+import ZHHansAgoFormatParser from "./parsers/ZHHansAgoFormatParser";
 import ZHHansRelationWeekdayParser from "./parsers/ZHHansRelationWeekdayParser";
 import ZHHansTimeExpressionParser from "./parsers/ZHHansTimeExpressionParser";
 import ZHHansWeekdayParser from "./parsers/ZHHansWeekdayParser";
@@ -53,6 +54,7 @@ export function createConfiguration(): Configuration {
             new ZHHansWeekdayParser(),
             new ZHHansTimeExpressionParser(),
             new ZHHansDeadlineFormatParser(),
+            new ZHHansAgoFormatParser(),
         ],
         refiners: [new ZHHansMergeDateRangeRefiner(), new ZHHansMergeDateTimeRefiner()],
     });

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

@@ -0,0 +1,87 @@
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+import { addDuration, Duration, reverseDuration } from "../../../../calculation/duration";
+import { NUMBER, zhStringToNumber } from "../constants";
+
+const PATTERN = new RegExp(
+    "(\\d+|[" +
+        Object.keys(NUMBER).join("") +
+        "]+|半|几)(?:\\s*)" +
+        "(?:个)?" +
+        "(秒(?:钟)?|分钟|小时|钟|日|天|星期|礼拜|月|年)" +
+        "(?:之)?前",
+    "i"
+);
+
+const NUMBER_GROUP = 1;
+const UNIT_GROUP = 2;
+
+export default class ZHHansAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const result = context.createParsingResult(match.index, match[0]);
+
+        let number = parseInt(match[NUMBER_GROUP]);
+        if (isNaN(number)) {
+            number = zhStringToNumber(match[NUMBER_GROUP]);
+        }
+
+        if (isNaN(number)) {
+            const string = match[NUMBER_GROUP];
+            if (string === "几") {
+                number = 3;
+            } else if (string === "半") {
+                number = 0.5;
+            } else {
+                //just in case
+                return null;
+            }
+        }
+
+        let duration: Duration = {};
+        const unit = match[UNIT_GROUP];
+        const unitAbbr = unit[0];
+
+        if (unitAbbr.match(/[日天星礼月年]/)) {
+            if (unitAbbr == "日" || unitAbbr == "天") {
+                duration.day = number;
+            } else if (unitAbbr == "星" || unitAbbr == "礼") {
+                duration.week = number;
+            } else if (unitAbbr == "月") {
+                duration.month = number;
+            } else if (unitAbbr == "年") {
+                duration.year = number;
+            }
+
+            duration = reverseDuration(duration);
+
+            const date = addDuration(context.refDate, duration);
+            result.start.assign("year", date.getFullYear());
+            result.start.assign("month", date.getMonth() + 1);
+            result.start.assign("day", date.getDate());
+            return result;
+        }
+
+        if (unitAbbr == "秒") {
+            duration.second = number;
+        } else if (unitAbbr == "分") {
+            duration.minute = number;
+        } else if (unitAbbr == "小" || unitAbbr == "钟") {
+            duration.hour = number;
+        }
+
+        duration = reverseDuration(duration);
+
+        const date = addDuration(context.refDate, duration);
+        result.start.imply("year", date.getFullYear());
+        result.start.imply("month", date.getMonth() + 1);
+        result.start.imply("day", date.getDate());
+        result.start.assign("hour", date.getHours());
+        result.start.assign("minute", date.getMinutes());
+        result.start.assign("second", date.getSeconds());
+        return result;
+    }
+}

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

@@ -63,6 +63,12 @@ const SECOND_GROUP = 8;
 const AM_PM_HOUR_GROUP = 9;
 
 export default class ZHHansTimeExpressionParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        // Return a capturing group to ensure that the match index is correct in the base class
+        // while avoiding matching CJK characters as word boundaries.
+        return "()";
+    }
+
     innerPattern(): RegExp {
         return FIRST_REG_PATTERN;
     }
@@ -74,14 +80,14 @@ export default class ZHHansTimeExpressionParser extends AbstractParserWithWordBo
         }
 
         const result = context.createParsingResult(match.index, match[0]);
-        const startMoment = new Date(context.refDate.getTime());
+        const startMoment = new Date(context.reference.instant.getTime());
 
         // ----- Day
         if (match[DAY_GROUP_1]) {
             const day1 = match[DAY_GROUP_1];
             if (day1 == "明") {
                 // Check not "Tomorrow" on late night
-                if (context.refDate.getHours() > 1) {
+                if (context.reference.instant.getHours() > 1) {
                     startMoment.setDate(startMoment.getDate() + 1);
                 }
             } else if (day1 == "昨") {
@@ -240,7 +246,12 @@ export default class ZHHansTimeExpressionParser extends AbstractParserWithWordBo
             return result;
         }
 
-        const endMoment = new Date(startMoment.getTime());
+        let endMoment = new Date(startMoment.getTime());
+        if (secondMatch[DAY_GROUP_1] || secondMatch[DAY_GROUP_3]) {
+            // If the end time expression has a relative day specified (e.g. "Tomorrow"),
+            // we should reset the end date to the reference date to calculate the relative date correctly.
+            endMoment = new Date(context.reference.instant.getTime());
+        }
         result.end = context.createParsingComponents();
 
         // ----- Day
@@ -248,7 +259,7 @@ export default class ZHHansTimeExpressionParser extends AbstractParserWithWordBo
             const day1 = secondMatch[DAY_GROUP_1];
             if (day1 == "明") {
                 // Check not "Tomorrow" on late night
-                if (context.refDate.getHours() > 1) {
+                if (context.reference.instant.getHours() > 1) {
                     endMoment.setDate(endMoment.getDate() + 1);
                 }
             } else if (day1 == "昨") {

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

@@ -11,6 +11,7 @@ import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Wee
 import ZHHantCasualDateParser from "./parsers/ZHHantCasualDateParser";
 import ZHHantDateParser from "./parsers/ZHHantDateParser";
 import ZHHantDeadlineFormatParser from "./parsers/ZHHantDeadlineFormatParser";
+import ZHHantAgoFormatParser from "./parsers/ZHHantAgoFormatParser";
 import ZHHantRelationWeekdayParser from "./parsers/ZHHantRelationWeekdayParser";
 import ZHHantTimeExpressionParser from "./parsers/ZHHantTimeExpressionParser";
 import ZHHantWeekdayParser from "./parsers/ZHHantWeekdayParser";
@@ -54,6 +55,7 @@ export function createConfiguration(): Configuration {
             new ZHHantWeekdayParser(),
             new ZHHantTimeExpressionParser(),
             new ZHHantDeadlineFormatParser(),
+            new ZHHantAgoFormatParser(),
         ],
         refiners: [new ZHHantMergeDateRangeRefiner(), new ZHHantMergeDateTimeRefiner()],
     });

package/src/locales/zh/hant/parsers/ZHHantAgoFormatParser.ts

@@ -0,0 +1,87 @@
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+import { addDuration, Duration, reverseDuration } from "../../../../calculation/duration";
+import { NUMBER, zhStringToNumber } from "../constants";
+
+const PATTERN = new RegExp(
+    "(\\d+|[" +
+        Object.keys(NUMBER).join("") +
+        "]+|半|幾)(?:\\s*)" +
+        "(?:個)?" +
+        "(秒(?:鐘)?|分鐘|小時|鐘|日|天|星期|禮拜|月|年)" +
+        "(?:之)?前",
+    "i"
+);
+
+const NUMBER_GROUP = 1;
+const UNIT_GROUP = 2;
+
+export default class ZHHantAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const result = context.createParsingResult(match.index, match[0]);
+
+        let number = parseInt(match[NUMBER_GROUP]);
+        if (isNaN(number)) {
+            number = zhStringToNumber(match[NUMBER_GROUP]);
+        }
+
+        if (isNaN(number)) {
+            const string = match[NUMBER_GROUP];
+            if (string === "幾") {
+                number = 3;
+            } else if (string === "半") {
+                number = 0.5;
+            } else {
+                //just in case
+                return null;
+            }
+        }
+
+        let duration: Duration = {};
+        const unit = match[UNIT_GROUP];
+        const unitAbbr = unit[0];
+
+        if (unitAbbr.match(/[日天星禮月年]/)) {
+            if (unitAbbr == "日" || unitAbbr == "天") {
+                duration.day = number;
+            } else if (unitAbbr == "星" || unitAbbr == "禮") {
+                duration.week = number;
+            } else if (unitAbbr == "月") {
+                duration.month = number;
+            } else if (unitAbbr == "年") {
+                duration.year = number;
+            }
+
+            duration = reverseDuration(duration);
+
+            const date = addDuration(context.refDate, duration);
+            result.start.assign("year", date.getFullYear());
+            result.start.assign("month", date.getMonth() + 1);
+            result.start.assign("day", date.getDate());
+            return result;
+        }
+
+        if (unitAbbr == "秒") {
+            duration.second = number;
+        } else if (unitAbbr == "分") {
+            duration.minute = number;
+        } else if (unitAbbr == "小" || unitAbbr == "鐘") {
+            duration.hour = number;
+        }
+
+        duration = reverseDuration(duration);
+
+        const date = addDuration(context.refDate, duration);
+        result.start.imply("year", date.getFullYear());
+        result.start.imply("month", date.getMonth() + 1);
+        result.start.imply("day", date.getDate());
+        result.start.assign("hour", date.getHours());
+        result.start.assign("minute", date.getMinutes());
+        result.start.assign("second", date.getSeconds());
+        return result;
+    }
+}

package/src/locales/zh/hant/parsers/ZHHantTimeExpressionParser.ts

@@ -63,6 +63,12 @@ const SECOND_GROUP = 8;
 const AM_PM_HOUR_GROUP = 9;
 
 export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        // Return a capturing group to ensure that the match index is correct in the base class
+        // while avoiding matching CJK characters as word boundaries.
+        return "()";
+    }
+
     innerPattern(): RegExp {
         return FIRST_REG_PATTERN;
     }
@@ -74,7 +80,7 @@ export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBo
         }
 
         const result = context.createParsingResult(match.index, match[0]);
-        const startMoment = new Date(context.refDate.getTime());
+        const startMoment = new Date(context.reference.instant.getTime());
 
         // ----- Day
         if (match[DAY_GROUP_1]) {
@@ -240,7 +246,13 @@ export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBo
             return result;
         }
 
-        const endMoment = new Date(startMoment.getTime());
+        let endMoment = new Date(startMoment.getTime());
+        if (secondMatch[DAY_GROUP_1] || secondMatch[DAY_GROUP_3]) {
+            // If the end time expression has a relative day specified (e.g. "Tomorrow"),
+            // we should reset the end date to the reference date to calculate the relative date correctly.
+            endMoment = new Date(context.reference.instant.getTime());
+        }
+
         result.end = context.createParsingComponents();
 
         // ----- Day

package/src/results.ts

@@ -44,9 +44,7 @@ export class ReferenceWithTimezone {
      * @param overrideTimezoneOffset
      */
     getSystemTimezoneAdjustmentMinute(date?: Date, overrideTimezoneOffset?: number): number {
-        if (!date || date.getTime() < 0) {
-            // Javascript date timezone calculation got effect when the time epoch < 0
-            // e.g. new Date('Tue Feb 02 1300 00:00:00 GMT+0900 (JST)') => Tue Feb 02 1300 00:18:59 GMT+0918 (JST)
+        if (!date) {
             date = new Date();
         }
 

package/test/de/de_casual.test.ts

@@ -320,3 +320,17 @@ test("Test - Random negative text", function () {
 
     testUnexpectedResult(chrono.de, "ljetztlich");
 });
+
+test("Test - Casual time keeps its meridiem when merged with an explicit time", () => {
+    testSingleCase(chrono.de, "nachmittag um 5", new Date(2016, 7, 10, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(17);
+        expect(result.start.get("meridiem")).toBe(1);
+    });
+
+    testSingleCase(chrono.de, "abend um 5", new Date(2016, 7, 10, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(17);
+        expect(result.start.get("meridiem")).toBe(1);
+    });
+});