chrono-node 2.8.5 → 2.9.1

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

@@ -0,0 +1,31 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import * as references from "../../../common/casualReferences";
+
+const PATTERN = /\b(hôm nay|hôm qua|hôm kia|ngày mai|ngày kia|bây giờ|lúc này)(?=\W|$)/i;
+
+export default class VICasualDateParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        switch (match[1].toLowerCase()) {
+            case "bây giờ":
+            case "lúc này":
+                return references.now(context.reference);
+            case "hôm nay":
+                return references.today(context.reference);
+            case "hôm qua":
+                return references.yesterday(context.reference);
+            case "hôm kia":
+                return references.theDayBefore(context.reference, 2);
+            case "ngày mai":
+                return references.tomorrow(context.reference);
+            case "ngày kia":
+                return references.theDayAfter(context.reference, 2);
+        }
+        return context.createParsingComponents();
+    }
+}

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

@@ -0,0 +1,62 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents, ParsingResult } from "../../../results";
+import { Meridiem } from "../../../types";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { implySimilarTime } from "../../../utils/dates";
+
+// bu\u1ed5i s\u00e1ng  |  bu\u1ed5i tr\u01b0a  |  bu\u1ed5i chi\u1ec1u  |  bu\u1ed5i t\u1ed1i  |  n\u1eeda \u0111\u00eam
+const PATTERN = /(buổi\s*)?(sáng sớm|sáng|trưa|chiều|tối|đêm|nửa đêm|bình minh)(?=\W|$)/i;
+
+export default class VICasualTimeParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult {
+        const component = context.createParsingComponents();
+        implySimilarTime(component, context.refDate);
+        return VICasualTimeParser.extractTimeComponents(component, match[2].toLowerCase());
+    }
+
+    static extractTimeComponents(component: ParsingComponents, keyword: string): ParsingComponents {
+        switch (keyword) {
+            case "b\u00ecnh minh":
+            case "s\u00e1ng s\u1edbm":
+                component.imply("hour", 6);
+                component.imply("minute", 0);
+                component.imply("meridiem", Meridiem.AM);
+                break;
+            case "s\u00e1ng":
+                component.imply("hour", 9);
+                component.imply("minute", 0);
+                component.imply("meridiem", Meridiem.AM);
+                break;
+            case "tr\u01b0a":
+                component.imply("hour", 12);
+                component.imply("minute", 0);
+                component.imply("meridiem", Meridiem.PM); // noon = 12:00 PM in chrono's 12-hour convention
+                break;
+            case "chi\u1ec1u":
+                component.imply("hour", 15);
+                component.imply("minute", 0);
+                component.imply("meridiem", Meridiem.PM);
+                break;
+            case "t\u1ed1i":
+                component.imply("hour", 19);
+                component.imply("minute", 0);
+                component.imply("meridiem", Meridiem.PM);
+                break;
+            case "\u0111\u00eam":
+                component.imply("hour", 22);
+                component.imply("minute", 0);
+                component.imply("meridiem", Meridiem.PM);
+                break;
+            case "n\u1eeda \u0111\u00eam":
+                component.imply("hour", 0);
+                component.imply("minute", 0);
+                component.imply("meridiem", Meridiem.AM);
+                break;
+        }
+        return component;
+    }
+}

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

@@ -0,0 +1,35 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingResult } from "../../../results";
+import { MONTH_DICTIONARY, YEAR_PATTERN, parseYear } from "../constants";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+// tháng 3 năm 1975  |  tháng ba năm 1975  |  tháng chạp  |  tháng giêng/1975
+const PATTERN = new RegExp(
+    "(" + matchAnyPattern(MONTH_DICTIONARY) + ")" + "(?:\\s*(?:năm|/)\\s*(" + YEAR_PATTERN + "))?" + "(?=\\W|$)",
+    "i"
+);
+
+const MONTH_GROUP = 1;
+const YEAR_GROUP = 2;
+
+export default class VIMonthYearParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingResult {
+        const month = MONTH_DICTIONARY[match[MONTH_GROUP].toLowerCase()];
+        if (!month) return null;
+
+        const result = context.createParsingResult(match.index, match[0]);
+        result.start.assign("month", month);
+        result.start.imply("day", 1);
+        if (match[YEAR_GROUP]) {
+            result.start.assign("year", parseYear(match[YEAR_GROUP]));
+        } else {
+            result.start.imply("year", context.reference.getDateWithAdjustedTimezone().getFullYear());
+        }
+        return result;
+    }
+}

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/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/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

@@ -1,11 +1,8 @@
 import { Component, ParsedComponents, ParsedResult, ParsingReference, TimezoneAbbrMap } from "./types";
 
-import quarterOfYear from "dayjs/plugin/quarterOfYear";
-import dayjs, { QUnitType } from "dayjs";
 import { assignSimilarDate, assignSimilarTime, implySimilarTime } from "./utils/dates";
 import { toTimezoneOffset } from "./timezone";
 import { addDuration, Duration, EmptyDuration } from "./calculation/duration";
-dayjs.extend(quarterOfYear);
 
 export class ReferenceWithTimezone {
     readonly instant: Date;
@@ -47,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();
         }
 
@@ -256,10 +251,6 @@ export class ParsingComponents implements ParsedComponents {
             reference: ${JSON.stringify(this.reference)}]`;
     }
 
-    dayjs() {
-        return dayjs(this.dateWithoutTimezoneAdjustment());
-    }
-
     date(): Date {
         const date = this.dateWithoutTimezoneAdjustment();
         const timezoneAdjustment = this.reference.getSystemTimezoneAdjustmentMinute(date, this.get("timezoneOffset"));

package/test/de/de_time_units_casual_relative.test.ts

@@ -106,3 +106,15 @@ test("Test - de - relative date", function () {
         expect(result.start.isCertain("second")).toBeFalsy();
     });
 });
+
+test("Test - de - false positive prevention for single-letter time units", function () {
+    // Test that "Letzte A" in "Letzte Aktualisierun" doesn't match as "letzte a" (last year)
+    // The word boundary check should prevent "A" from matching the time unit "a"
+    testSingleCase(chrono.de, "Letzte Aktualisierun 03/12/2025", (result) => {
+        expect(result.text).toBe("03/12/2025");
+        expect(result.start.get("year")).toBe(2025);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.start.get("day")).toBe(3);
+        expect(result).toBeDate(new Date(2025, 12 - 1, 3, 12));
+    });
+});

package/test/en/en_month_name_little_endian.test.ts

@@ -416,3 +416,33 @@ test("Test - Impossible Dates (Strict Mode)", function () {
 
     testUnexpectedResult(chrono.strict, "29 February", new Date(2013, 7, 10));
 });
+
+test("Test - Year 3000+ support (Issue #636)", () => {
+    testSingleCase(chrono, "Jan 1 3000, 9:30", (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Jan 1 3000, 9:30");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(3000);
+        expect(result.start.get("month")).toBe(1);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(9);
+        expect(result.start.get("minute")).toBe(30);
+
+        expect(result.start).toBeDate(new Date(3000, 1 - 1, 1, 9, 30));
+    });
+
+    testSingleCase(chrono, "Jan 1 2025, 9:30", (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Jan 1 2025, 9:30");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2025);
+        expect(result.start.get("month")).toBe(1);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(9);
+        expect(result.start.get("minute")).toBe(30);
+
+        expect(result.start).toBeDate(new Date(2025, 1 - 1, 1, 9, 30));
+    });
+});

package/test/en/en_time_units_casual_relative.test.ts

@@ -145,6 +145,17 @@ test("Test - Minus '-' sign", () => {
         expect(result.start.get("hour")).toBe(9);
         expect(result.start.get("minute")).toBe(55);
     });
+
+    testSingleCase(chrono, "-5d 00", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(26);
+        expect(result.start.get("hour")).toBe(0);
+        expect(result.start.get("minute")).toBe(0);
+
+        expect(result.start).toBeDate(new Date(2016, 9 - 1, 26, 0, 0));
+    });
 });
 
 test("Test - Without custom parser without abbreviations", function () {