chrono-node 2.9.0 → 2.9.1

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

@@ -26,12 +26,14 @@ export default class NLCasualTimeParser extends AbstractParserWithWordBoundaryCh
             case "'s namiddags":
                 component.imply("meridiem", Meridiem.PM);
                 component.imply("hour", 15);
+                component.addTag("casualReference/afternoon");
                 break;
 
             case "avond":
             case "'s avonds'":
                 component.imply("meridiem", Meridiem.PM);
                 component.imply("hour", 20);
+                component.addTag("casualReference/evening");
                 break;
 
             case "middernacht":
@@ -42,18 +44,21 @@ export default class NLCasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("hour", 0);
                 component.imply("minute", 0);
                 component.imply("second", 0);
+                component.addTag("casualReference/midnight");
                 break;
 
             case "ochtend":
             case "'s ochtends":
                 component.imply("meridiem", Meridiem.AM);
                 component.imply("hour", 6);
+                component.addTag("casualReference/morning");
                 break;
 
             case "middag":
             case "'s middags":
                 component.imply("meridiem", Meridiem.AM);
                 component.imply("hour", 12);
+                component.addTag("casualReference/noon");
                 break;
         }
 

package/src/locales/pt/parsers/PTCasualTimeParser.ts

@@ -15,17 +15,20 @@ export default class PTCasualTimeParser extends AbstractParserWithWordBoundaryCh
             case "tarde":
                 component.imply("meridiem", Meridiem.PM);
                 component.imply("hour", 15);
+                component.addTag("casualReference/afternoon");
                 break;
 
             case "noite":
                 component.imply("meridiem", Meridiem.PM);
                 component.imply("hour", 22);
+                component.addTag("casualReference/evening");
                 break;
 
             case "manha":
             case "manhã":
                 component.imply("meridiem", Meridiem.AM);
                 component.imply("hour", 6);
+                component.addTag("casualReference/morning");
                 break;
 
             case "meia-noite":
@@ -36,11 +39,13 @@ export default class PTCasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("hour", 0);
                 component.imply("minute", 0);
                 component.imply("second", 0);
+                component.addTag("casualReference/midnight");
                 break;
 
             case "meio-dia":
                 component.imply("meridiem", Meridiem.AM);
                 component.imply("hour", 12);
+                component.addTag("casualReference/noon");
                 break;
         }
 

package/src/locales/vi/constants.ts

@@ -0,0 +1,113 @@
+import { matchAnyPattern, repeatedTimeunitPattern } from "../../utils/pattern";
+import { findMostLikelyADYear } from "../../calculation/years";
+import { Duration } from "../../calculation/duration";
+import { Timeunit } from "../../types";
+
+export const WEEKDAY_DICTIONARY: { [word: string]: number } = {
+    "ch\u1ee7 nh\u1eadt": 0,
+    "cn": 0,
+    "th\u1ee9 hai": 1,
+    "t2": 1,
+    "th\u1ee9 ba": 2,
+    "t3": 2,
+    "th\u1ee9 t\u01b0": 3,
+    "t4": 3,
+    "th\u1ee9 n\u0103m": 4,
+    "t5": 4,
+    "th\u1ee9 s\u00e1u": 5,
+    "t6": 5,
+    "th\u1ee9 b\u1ea3y": 6,
+    "t7": 6,
+};
+
+export const MONTH_DICTIONARY: { [word: string]: number } = {
+    "th\u00e1ng 1": 1,
+    "th\u00e1ng m\u1ed9t": 1,
+    "th\u00e1ng gi\u00eang": 1,
+    "th\u00e1ng 2": 2,
+    "th\u00e1ng hai": 2,
+    "th\u00e1ng 3": 3,
+    "th\u00e1ng ba": 3,
+    "th\u00e1ng 4": 4,
+    "th\u00e1ng t\u01b0": 4,
+    "th\u00e1ng 5": 5,
+    "th\u00e1ng n\u0103m": 5,
+    "th\u00e1ng 6": 6,
+    "th\u00e1ng s\u00e1u": 6,
+    "th\u00e1ng 7": 7,
+    "th\u00e1ng b\u1ea3y": 7,
+    "th\u00e1ng 8": 8,
+    "th\u00e1ng t\u00e1m": 8,
+    "th\u00e1ng 9": 9,
+    "th\u00e1ng ch\u00edn": 9,
+    "th\u00e1ng 10": 10,
+    "th\u00e1ng m\u01b0\u1eddi": 10,
+    "th\u00e1ng 11": 11,
+    "th\u00e1ng m\u01b0\u1eddi m\u1ed9t": 11,
+    "th\u00e1ng 12": 12,
+    "th\u00e1ng m\u01b0\u1eddi hai": 12,
+    "th\u00e1ng ch\u1ea1p": 12,
+};
+
+export const INTEGER_WORD_DICTIONARY: { [word: string]: number } = {
+    "m\u1ed9t": 1,
+    "hai": 2,
+    "ba": 3,
+    "b\u1ed1n": 4,
+    "n\u0103m": 5,
+    "s\u00e1u": 6,
+    "b\u1ea3y": 7,
+    "t\u00e1m": 8,
+    "ch\u00edn": 9,
+    "m\u01b0\u1eddi": 10,
+    "m\u01b0\u1eddi m\u1ed9t": 11,
+    "m\u01b0\u1eddi hai": 12,
+};
+
+export const TIME_UNIT_DICTIONARY: { [word: string]: Timeunit } = {
+    "gi\u00e2y": "second",
+    "ph\u00fat": "minute",
+    "gi\u1edd": "hour",
+    "ng\u00e0y": "day",
+    "tu\u1ea7n": "week",
+    "th\u00e1ng": "month",
+    "n\u0103m": "year",
+};
+
+export const NUMBER_PATTERN = "(?:" + matchAnyPattern(INTEGER_WORD_DICTIONARY) + "|[0-9]+|[0-9]+\\.[0-9]+)";
+
+export function parseNumberPattern(match: string): number {
+    const num = match.toLowerCase();
+    if (INTEGER_WORD_DICTIONARY[num] !== undefined) return INTEGER_WORD_DICTIONARY[num];
+    return parseFloat(num);
+}
+
+// YYYY, YYYY TCN (Tr\u01b0\u1edbc C\u00f4ng nguy\u00ean = BC)
+export const YEAR_PATTERN = "(?:[0-9]{1,4}(?:\\s*TCN)?)";
+
+export function parseYear(match: string): number {
+    const upper = match.toUpperCase();
+    const num = parseInt(match.replace(/[^0-9]+/g, ""));
+    if (/TCN/.test(upper)) return -num;
+    return findMostLikelyADYear(num);
+}
+
+const SINGLE_TIME_UNIT_PATTERN =
+    "(" + NUMBER_PATTERN + ")\\s{0,5}(" + matchAnyPattern(TIME_UNIT_DICTIONARY) + ")\\s{0,5}";
+const SINGLE_TIME_UNIT_REGEX = new RegExp(SINGLE_TIME_UNIT_PATTERN, "i");
+
+export const TIME_UNITS_PATTERN = repeatedTimeunitPattern("", SINGLE_TIME_UNIT_PATTERN);
+
+export function parseDuration(timeunitText: string): Duration {
+    const fragments: { [key: string]: number } = {};
+    let remainingText = timeunitText;
+    let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
+    while (match) {
+        const num = parseNumberPattern(match[1]);
+        const unit = TIME_UNIT_DICTIONARY[match[2].toLowerCase()];
+        fragments[unit] = num;
+        remainingText = remainingText.substring(match[0].length);
+        match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
+    }
+    return fragments as Duration;
+}

package/src/locales/vi/index.ts

@@ -0,0 +1,73 @@
+/**
+ * Chrono components for Vietnamese support (*parsers*, *refiners*, and *configuration*)
+ *
+ * @module
+ */
+import { includeCommonConfiguration } from "../../configurations";
+import { Chrono, Configuration, Parser, Refiner } from "../../chrono";
+import { ParsingResult, ParsingComponents, ReferenceWithTimezone } from "../../results";
+import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday } from "../../types";
+import ISOFormatParser from "../../common/parsers/ISOFormatParser";
+import SlashDateFormatParser from "../../common/parsers/SlashDateFormatParser";
+import VIStandardParser from "./parsers/VIStandardParser";
+import VIMonthYearParser from "./parsers/VIMonthYearParser";
+import VIYearParser from "./parsers/VIYearParser";
+import VICasualDateParser from "./parsers/VICasualDateParser";
+import VICasualTimeParser from "./parsers/VICasualTimeParser";
+import VIWeekdayParser from "./parsers/VIWeekdayParser";
+import VITimeExpressionParser from "./parsers/VITimeExpressionParser";
+import VITimeUnitAgoFormatParser from "./parsers/VITimeUnitAgoFormatParser";
+import VITimeUnitLaterFormatParser from "./parsers/VITimeUnitLaterFormatParser";
+import VITimeUnitWithinFormatParser from "./parsers/VITimeUnitWithinFormatParser";
+import VITimeUnitCasualRelativeFormatParser from "./parsers/VITimeUnitCasualRelativeFormatParser";
+import VIMergeDateRangeRefiner from "./refiners/VIMergeDateRangeRefiner";
+import VIMergeDateTimeRefiner from "./refiners/VIMergeDateTimeRefiner";
+import VIMergeWeekdayComponentRefiner from "./refiners/VIMergeWeekdayComponentRefiner";
+
+export { Chrono, Parser, Refiner, ParsingResult, ParsingComponents, ReferenceWithTimezone };
+export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday };
+
+// Shortcuts
+export const casual = new Chrono(createCasualConfiguration());
+export const strict = new Chrono(createConfiguration(true));
+
+export function parse(text: string, ref?: ParsingReference | Date, option?: ParsingOption): ParsedResult[] {
+    return casual.parse(text, ref, option);
+}
+
+export function parseDate(text: string, ref?: ParsingReference | Date, option?: ParsingOption): Date {
+    return casual.parseDate(text, ref, option);
+}
+
+export function createCasualConfiguration(littleEndian = true): Configuration {
+    const option = createConfiguration(false, littleEndian);
+    option.parsers.unshift(new VICasualTimeParser());
+    option.parsers.unshift(new VICasualDateParser());
+    option.parsers.unshift(new VITimeUnitCasualRelativeFormatParser());
+    return option;
+}
+
+export function createConfiguration(strictMode = true, littleEndian = true): Configuration {
+    return includeCommonConfiguration(
+        {
+            parsers: [
+                new ISOFormatParser(),
+                new SlashDateFormatParser(littleEndian),
+                new VIStandardParser(),
+                new VIMonthYearParser(),
+                new VIYearParser(),
+                new VIWeekdayParser(),
+                new VITimeExpressionParser(),
+                new VITimeUnitAgoFormatParser(strictMode),
+                new VITimeUnitLaterFormatParser(strictMode),
+                new VITimeUnitWithinFormatParser(strictMode),
+            ],
+            refiners: [
+                new VIMergeWeekdayComponentRefiner(),
+                new VIMergeDateRangeRefiner(),
+                new VIMergeDateTimeRefiner(),
+            ],
+        },
+        strictMode
+    );
+}

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