chrono-node 2.9.0 → 2.9.1

package/test/vi/vi_casual.test.ts

@@ -0,0 +1,84 @@
+import * as chrono from "../../src/";
+import { testSingleCase } from "../test_util";
+
+test("Test - h\u00f4m nay (today)", () => {
+    testSingleCase(chrono.vi, "Cu\u1ed9c h\u1ecdn h\u00f4m nay.", new Date(2012, 7, 10, 12), (r) => {
+        expect(r.index).toBe(9);
+        expect(r.text).toBe("h\u00f4m nay");
+        expect(r.start.get("year")).toBe(2012);
+        expect(r.start.get("month")).toBe(8);
+        expect(r.start.get("day")).toBe(10);
+        expect(r.start).toBeDate(new Date(2012, 7, 10, 12));
+    });
+});
+
+test("Test - h\u00f4m qua (yesterday)", () => {
+    testSingleCase(chrono.vi, "H\u1ed9i ngh\u1ecb h\u00f4m qua.", new Date(2012, 7, 10, 12), (r) => {
+        expect(r.index).toBe(9);
+        expect(r.text).toBe("h\u00f4m qua");
+        expect(r.start.get("year")).toBe(2012);
+        expect(r.start.get("month")).toBe(8);
+        expect(r.start.get("day")).toBe(9);
+        expect(r.start).toBeDate(new Date(2012, 7, 9, 12));
+    });
+
+    testSingleCase(chrono.vi, "h\u00f4m qua", new Date(2012, 7, 1, 12), (r) => {
+        expect(r.start.get("month")).toBe(7); // July — crosses month boundary
+        expect(r.start.get("day")).toBe(31);
+    });
+});
+
+test("Test - ng\u00e0y mai (tomorrow)", () => {
+    testSingleCase(chrono.vi, "L\u1ecbch ng\u00e0y mai.", new Date(2012, 7, 10, 12), (r) => {
+        expect(r.index).toBe(5);
+        expect(r.text).toBe("ng\u00e0y mai");
+        expect(r.start.get("day")).toBe(11);
+        expect(r.start.get("month")).toBe(8);
+        expect(r.start).toBeDate(new Date(2012, 7, 11, 12));
+    });
+
+    testSingleCase(chrono.vi, "ng\u00e0y mai", new Date(2012, 7, 31, 12), (r) => {
+        expect(r.start.get("month")).toBe(9); // Sept — crosses month boundary
+        expect(r.start.get("day")).toBe(1);
+    });
+});
+
+test("Test - ng\u00e0y kia (day after tomorrow)", () => {
+    testSingleCase(chrono.vi, "ng\u00e0y kia", new Date(2012, 7, 10, 12), (r) => {
+        expect(r.text).toBe("ng\u00e0y kia");
+        expect(r.start.get("day")).toBe(12);
+    });
+});
+
+test("Test - b\u00e2y gi\u1edd / l\u00fac n\u00e0y (now)", () => {
+    testSingleCase(chrono.vi, "b\u00e2y gi\u1edd", new Date(2012, 7, 10, 8, 9, 10, 11), (r) => {
+        expect(r.start.get("year")).toBe(2012);
+        expect(r.start.get("month")).toBe(8);
+        expect(r.start.get("day")).toBe(10);
+        expect(r.start.get("hour")).toBe(8);
+        expect(r.start.get("minute")).toBe(9);
+        expect(r.start.get("second")).toBe(10);
+        expect(r.start).toBeDate(new Date(2012, 7, 10, 8, 9, 10, 11));
+    });
+
+    testSingleCase(chrono.vi, "l\u00fac n\u00e0y", new Date(2012, 7, 10, 8, 9, 10, 11), (r) => {
+        expect(r.start.get("hour")).toBe(8);
+    });
+});
+
+test("Test - hôm kia (day before yesterday, -2)", () => {
+    testSingleCase(chrono.vi, "hôm kia", new Date(2012, 7, 10, 12), (r) => {
+        expect(r.start.get("year")).toBe(2012);
+        expect(r.start.get("month")).toBe(8);
+        expect(r.start.get("day")).toBe(8); // 10 - 2
+    });
+});
+
+test("Test - isCertain: casual date sets day/month/year certain, hour not", () => {
+    testSingleCase(chrono.vi, "hôm nay", new Date(2012, 7, 10, 12), (r) => {
+        expect(r.start.isCertain("day")).toBe(true);
+        expect(r.start.isCertain("month")).toBe(true);
+        expect(r.start.isCertain("year")).toBe(true);
+        expect(r.start.isCertain("hour")).toBe(false);
+    });
+});

package/test/vi/vi_casual_time.test.ts

@@ -0,0 +1,77 @@
+import * as chrono from "../../src/";
+import { testSingleCase } from "../test_util";
+
+const REF = new Date(2012, 7, 10, 12); // 2012-08-10 noon
+
+test("Test - sáng (morning, AM)", () => {
+    // "buổi sáng" is a time-of-day modifier; test it with an explicit time expression
+    testSingleCase(chrono.vi, "7 giờ sáng", REF, (r) => {
+        expect(r.start.get("hour")).toBe(7);
+        expect(r.start.get("meridiem")).toBe(0); // AM
+    });
+    // standalone "sáng" sets implied hour=9, AM
+    testSingleCase(chrono.vi, "hôm nay buổi sáng", new Date(2012, 7, 10, 6), (r) => {
+        expect(r.start.get("hour")).toBe(9);
+        expect(r.start.get("meridiem")).toBe(0); // AM
+    });
+});
+
+test("Test - trưa (noon, PM)", () => {
+    testSingleCase(chrono.vi, "buổi trưa", REF, (r) => {
+        expect(r.start.get("hour")).toBe(12);
+        expect(r.start.get("meridiem")).toBe(1); // PM — noon is 12:00 PM
+    });
+});
+
+test("Test - chiều (afternoon, PM)", () => {
+    testSingleCase(chrono.vi, "buổi chiều", REF, (r) => {
+        expect(r.start.get("hour")).toBe(15);
+        expect(r.start.get("meridiem")).toBe(1); // PM
+    });
+});
+
+test("Test - tối (evening, PM)", () => {
+    testSingleCase(chrono.vi, "buổi tối", REF, (r) => {
+        expect(r.start.get("hour")).toBe(19);
+        expect(r.start.get("meridiem")).toBe(1); // PM
+    });
+});
+
+test("Test - đêm (late night, PM)", () => {
+    testSingleCase(chrono.vi, "buổi đêm", REF, (r) => {
+        expect(r.start.get("hour")).toBe(22);
+        expect(r.start.get("meridiem")).toBe(1); // PM
+    });
+
+    // Standalone "đêm" without "buổi" prefix — works after removing \b from pattern
+    testSingleCase(chrono.vi, "đêm", REF, (r) => {
+        expect(r.start.get("hour")).toBe(22);
+        expect(r.start.get("meridiem")).toBe(1); // PM
+    });
+});
+
+test("Test - nửa đêm (midnight, AM)", () => {
+    testSingleCase(chrono.vi, "nửa đêm", REF, (r) => {
+        expect(r.start.get("hour")).toBe(0);
+        expect(r.start.get("meridiem")).toBe(0); // AM
+    });
+});
+
+test("Test - bình minh / sáng sớm (dawn)", () => {
+    testSingleCase(chrono.vi, "bình minh", REF, (r) => {
+        expect(r.start.get("hour")).toBe(6);
+        expect(r.start.get("meridiem")).toBe(0); // AM
+    });
+
+    testSingleCase(chrono.vi, "sáng sớm", REF, (r) => {
+        expect(r.start.get("hour")).toBe(6);
+        expect(r.start.get("meridiem")).toBe(0); // AM
+    });
+});
+
+test("Test - time keyword merges with date", () => {
+    testSingleCase(chrono.vi, "hôm nay buổi chiều", REF, (r) => {
+        expect(r.start.get("day")).toBe(10);
+        expect(r.start.get("hour")).toBe(15);
+    });
+});

package/test/vi/vi_date_range.test.ts

@@ -0,0 +1,61 @@
+import * as chrono from "../../src/";
+import { testSingleCase } from "../test_util";
+
+const REF = new Date(2012, 7, 10, 12); // 2012-08-10 noon
+
+test("Test - từ ngày X đến ngày Y (đến connector)", () => {
+    testSingleCase(chrono.vi, "từ ngày 5 tháng 8 đến ngày 10 tháng 8 năm 2012", REF, (r) => {
+        expect(r.start.get("day")).toBe(5);
+        expect(r.start.get("month")).toBe(8);
+        expect(r.start.get("year")).toBe(2012);
+
+        expect(r.end).not.toBeNull();
+        expect(r.end.get("day")).toBe(10);
+        expect(r.end.get("month")).toBe(8);
+        expect(r.end.get("year")).toBe(2012);
+    });
+});
+
+test("Test - em dash separator (–)", () => {
+    testSingleCase(chrono.vi, "ngày 1 tháng 4 – ngày 30 tháng 4 năm 2000", REF, (r) => {
+        expect(r.start.get("day")).toBe(1);
+        expect(r.start.get("month")).toBe(4);
+
+        expect(r.end).not.toBeNull();
+        expect(r.end.get("day")).toBe(30);
+        expect(r.end.get("month")).toBe(4);
+        expect(r.end.get("year")).toBe(2000);
+    });
+});
+
+test("Test - hyphen separator (-)", () => {
+    testSingleCase(chrono.vi, "ngày 3 tháng 9 - ngày 5 tháng 9 năm 1945", REF, (r) => {
+        expect(r.start.get("day")).toBe(3);
+        expect(r.start.get("month")).toBe(9);
+        expect(r.start.get("year")).toBe(1945);
+
+        expect(r.end).not.toBeNull();
+        expect(r.end.get("day")).toBe(5);
+        expect(r.end.get("month")).toBe(9);
+        expect(r.end.get("year")).toBe(1945);
+    });
+});
+
+test("Test - tới connector", () => {
+    testSingleCase(chrono.vi, "tháng 3 tới tháng 5 năm 1975", REF, (r) => {
+        expect(r.start.get("month")).toBe(3);
+
+        expect(r.end).not.toBeNull();
+        expect(r.end.get("month")).toBe(5);
+        expect(r.end.get("year")).toBe(1975);
+    });
+});
+
+test("Test - start is before end", () => {
+    testSingleCase(chrono.vi, "ngày 1 tháng 1 đến ngày 31 tháng 12 năm 2020", REF, (r) => {
+        expect(r.end).not.toBeNull();
+        const startDate = r.start.date();
+        const endDate = r.end.date();
+        expect(startDate.getTime()).toBeLessThan(endDate.getTime());
+    });
+});

package/test/vi/vi_forward_date.test.ts

@@ -0,0 +1,45 @@
+import * as chrono from "../../src/";
+import { testSingleCase } from "../test_util";
+
+test("Test - forwardDate: time-only rolls to next day when ref is past", () => {
+    // "7 gi\u1edd s\u00e1ng" = 7:00 AM; ref is 8:00 AM same day \u2192 next day
+    testSingleCase(chrono.vi, "7 gi\u1edd s\u00e1ng", new Date(2012, 7, 10, 8, 0), { forwardDate: true }, (r) => {
+        expect(r.start.get("day")).toBe(11);
+        expect(r.start.get("hour")).toBe(7);
+    });
+});
+
+test("Test - forwardDate: weekday rolls to next occurrence", () => {
+    // REF = Tuesday Aug 14, 2012; "th\u1ee9 hai" (Monday) last was Aug 13 \u2192 next Monday = Aug 20
+    testSingleCase(chrono.vi, "th\u1ee9 hai", new Date(2012, 7, 14, 12), { forwardDate: true }, (r) => {
+        expect(r.start.get("weekday")).toBe(1);
+        expect(r.start.get("day")).toBe(20);
+        expect(r.start.get("month")).toBe(8);
+    });
+});
+
+test("Test - forwardDate: slash date without year rolls to next year", () => {
+    // "15/3" = March 15; ref is Aug 10 (past March) \u2192 year 2013
+    testSingleCase(chrono.vi, "15/3", new Date(2012, 7, 10, 12), { forwardDate: true }, (r) => {
+        expect(r.start.get("day")).toBe(15);
+        expect(r.start.get("month")).toBe(3);
+        expect(r.start.get("year")).toBe(2013);
+    });
+});
+
+test("Test - forwardDate: same weekday as ref stays on same day", () => {
+    // REF = Thursday Aug 9, 2012; "thứ năm" (Thursday) = same day → stays on Aug 9 (not past)
+    testSingleCase(chrono.vi, "th\u1ee9 n\u0103m", new Date(2012, 7, 9, 12), { forwardDate: true }, (r) => {
+        expect(r.start.get("weekday")).toBe(4);
+        expect(r.start.get("day")).toBe(9);
+        expect(r.start.get("month")).toBe(8);
+    });
+});
+
+test("Test - forwardDate: month without year rolls to next year", () => {
+    // "th\u00e1ng 3" = March; ref is Aug 10 \u2192 next March = 2013
+    testSingleCase(chrono.vi, "th\u00e1ng 3", new Date(2012, 7, 10, 12), { forwardDate: true }, (r) => {
+        expect(r.start.get("month")).toBe(3);
+        expect(r.start.get("year")).toBe(2013);
+    });
+});

package/test/vi/vi_month_year.test.ts

@@ -0,0 +1,40 @@
+import * as chrono from "../../src/";
+import { testSingleCase, testUnexpectedResult } from "../test_util";
+
+const REF = new Date(2012, 7, 10, 12); // 2012-08-10
+
+test("Test - tháng M năm YYYY", () => {
+    testSingleCase(chrono.vi, "tháng 4 năm 1975", REF, (r) => {
+        expect(r.text).toBe("tháng 4 năm 1975");
+        expect(r.start.get("month")).toBe(4);
+        expect(r.start.get("year")).toBe(1975);
+        expect(r.start.isCertain("month")).toBe(true);
+        expect(r.start.isCertain("year")).toBe(true);
+        expect(r.start.isCertain("day")).toBe(false); // day is implied
+    });
+
+    testSingleCase(chrono.vi, "tháng 1 năm 1863", REF, (r) => {
+        expect(r.start.get("month")).toBe(1);
+        expect(r.start.get("year")).toBe(1863);
+    });
+});
+
+test("Test - tháng M/YYYY (slash separator)", () => {
+    testSingleCase(chrono.vi, "tháng 3/1975", REF, (r) => {
+        expect(r.start.get("month")).toBe(3);
+        expect(r.start.get("year")).toBe(1975);
+    });
+});
+
+test("Test - tháng M only (implies current year)", () => {
+    testSingleCase(chrono.vi, "tháng 3", REF, (r) => {
+        expect(r.start.get("month")).toBe(3);
+        expect(r.start.isCertain("year")).toBe(false); // year implied from reference
+        expect(r.start.get("year")).toBe(2012);
+    });
+});
+
+test("Test - negative: month > 12 rejected", () => {
+    testUnexpectedResult(chrono.vi, "tháng 13", REF);
+    testUnexpectedResult(chrono.vi, "tháng 0", REF);
+});

package/test/vi/vi_negative_cases.test.ts

@@ -0,0 +1,60 @@
+import * as chrono from "../../src/";
+import { testUnexpectedResult } from "../test_util";
+
+const REF = new Date(2012, 7, 10, 12); // 2012-08-10
+
+test("Test - invalid day rejected", () => {
+    testUnexpectedResult(chrono.vi, "ngày 0 tháng 4 năm 2000", REF);
+    // "ngày 32 tháng 4" — VIStandardParser skips "ngày 3" and sub-matches "2 tháng 4"
+    // (day bounds are not pre-validated in the regex). This is known parser behaviour.
+});
+
+test("Test - invalid month rejected", () => {
+    testUnexpectedResult(chrono.vi, "tháng 0", REF);
+    testUnexpectedResult(chrono.vi, "tháng 13", REF);
+    testUnexpectedResult(chrono.vi, "ngày 1 tháng 13", REF);
+});
+
+test("Test - invalid slash date rejected", () => {
+    testUnexpectedResult(chrono.vi, "32/13/2020", REF);
+});
+
+test("Test - bare 4-digit number without năm prefix is not a year", () => {
+    testUnexpectedResult(chrono.vi, "Có 1975 người tham gia.", REF);
+});
+
+test("Test - phone number not parsed as date", () => {
+    testUnexpectedResult(chrono.vi, "0912345678", REF);
+});
+
+test("Test - bare numbers not parsed as dates", () => {
+    testUnexpectedResult(chrono.vi, "3", REF);
+    testUnexpectedResult(chrono.vi, "11", REF);
+    testUnexpectedResult(chrono.vi, "0.5", REF);
+    testUnexpectedResult(chrono.vi, "35.49", REF);
+    testUnexpectedResult(chrono.vi, "12.53%", REF);
+});
+
+test("Test - currency and measurement not parsed as dates", () => {
+    testUnexpectedResult(chrono.vi, "$1,194.09", REF);
+    testUnexpectedResult(chrono.vi, "at 6.5 kilograms", REF);
+});
+
+test("Test - version numbers not parsed as dates", () => {
+    testUnexpectedResult(chrono.vi, "1.1.3", REF);
+    testUnexpectedResult(chrono.vi, "1.10.30", REF);
+});
+
+test("Test - hyphenated number ranges not parsed as dates", () => {
+    testUnexpectedResult(chrono.vi, "1-2", REF);
+    testUnexpectedResult(chrono.vi, "1-2-3", REF);
+});
+
+test("Test - URL-encoded strings not parsed as dates", () => {
+    testUnexpectedResult(chrono.vi, "%e7%b7%8a", REF);
+});
+
+test("Test - impossible minute rejected", () => {
+    testUnexpectedResult(chrono.vi, "7 giờ 61 phút", REF);
+    testUnexpectedResult(chrono.vi, "7 giờ 99 phút", REF);
+});

package/test/vi/vi_slash.test.ts

@@ -0,0 +1,36 @@
+import * as chrono from "../../src/";
+import { testSingleCase } from "../test_util";
+
+const REF = new Date(2012, 7, 10, 12);
+
+test("Test - DD/MM/YYYY (little-endian)", () => {
+    testSingleCase(chrono.vi, "Ng\u00e0y 30/04/1975.", REF, (r) => {
+        expect(r.index).toBe(5);
+        expect(r.start.get("day")).toBe(30);
+        expect(r.start.get("month")).toBe(4);
+        expect(r.start.get("year")).toBe(1975);
+    });
+
+    testSingleCase(chrono.vi, "H\u1ed9i ngh\u1ecb 01/01/1954", REF, (r) => {
+        expect(r.index).toBe(9);
+        expect(r.start.get("day")).toBe(1);
+        expect(r.start.get("month")).toBe(1);
+        expect(r.start.get("year")).toBe(1954);
+    });
+});
+
+test("Test - D/M/YYYY (no zero padding)", () => {
+    testSingleCase(chrono.vi, "3/5/1968", REF, (r) => {
+        expect(r.start.get("day")).toBe(3);
+        expect(r.start.get("month")).toBe(5);
+        expect(r.start.get("year")).toBe(1968);
+    });
+});
+
+test("Test - ISO 2024-03-15 also parses", () => {
+    testSingleCase(chrono.vi, "Ng\u00e0y 2024-03-15 l\u00e0 quan tr\u1ecdng.", REF, (r) => {
+        expect(r.start.get("year")).toBe(2024);
+        expect(r.start.get("month")).toBe(3);
+        expect(r.start.get("day")).toBe(15);
+    });
+});

package/test/vi/vi_standard.test.ts

@@ -0,0 +1,86 @@
+import * as chrono from "../../src/";
+import { testSingleCase, testUnexpectedResult } from "../test_util";
+
+const REF = new Date(2012, 7, 10, 12, 0, 0); // 2012-08-10
+
+test("Test - ng\u00e0y D th\u00e1ng M n\u0103m YYYY (full with ng\u00e0y prefix)", () => {
+    testSingleCase(
+        chrono.vi,
+        "Ng\u00e0y 30 th\u00e1ng 4 n\u0103m 1975 l\u00e0 ng\u00e0y gi\u1ea3i ph\u00f3ng.",
+        REF,
+        (r) => {
+            expect(r.start.get("year")).toBe(1975);
+            expect(r.start.get("month")).toBe(4);
+            expect(r.start.get("day")).toBe(30);
+            expect(r.start.isCertain("year")).toBe(true);
+            expect(r.start.isCertain("month")).toBe(true);
+            expect(r.start.isCertain("day")).toBe(true);
+        }
+    );
+
+    testSingleCase(
+        chrono.vi,
+        "Hi\u1ec7p \u0111\u1ecbnh \u0111\u01b0\u1ee3c k\u00fd ng\u00e0y 27 th\u00e1ng 1 n\u0103m 1973.",
+        REF,
+        (r) => {
+            expect(r.text).toBe("ng\u00e0y 27 th\u00e1ng 1 n\u0103m 1973");
+            expect(r.start.get("year")).toBe(1973);
+            expect(r.start.get("month")).toBe(1);
+            expect(r.start.get("day")).toBe(27);
+        }
+    );
+
+    testSingleCase(chrono.vi, "ng\u00e0y 2 th\u00e1ng 9 n\u0103m 1945", REF, (r) => {
+        expect(r.start.get("year")).toBe(1945);
+        expect(r.start.get("month")).toBe(9);
+        expect(r.start.get("day")).toBe(2);
+    });
+});
+
+test("Test - D th\u00e1ng M n\u0103m YYYY (no ng\u00e0y prefix)", () => {
+    testSingleCase(
+        chrono.vi,
+        "7 th\u00e1ng 5 n\u0103m 1954 l\u00e0 ng\u00e0y ch\u1ea5m d\u1ee9t tr\u1eadn \u0110i\u1ec7n Bi\u00ean Ph\u1ee7.",
+        REF,
+        (r) => {
+            expect(r.start.get("day")).toBe(7);
+            expect(r.start.get("month")).toBe(5);
+            expect(r.start.get("year")).toBe(1954);
+        }
+    );
+
+    testSingleCase(chrono.vi, "1 th\u00e1ng 1 n\u0103m 1863", REF, (r) => {
+        expect(r.start.get("day")).toBe(1);
+        expect(r.start.get("month")).toBe(1);
+        expect(r.start.get("year")).toBe(1863);
+    });
+});
+
+test("Test - Date without year implies closest year", () => {
+    testSingleCase(chrono.vi, "ng\u00e0y 15 th\u00e1ng 3", REF, (r) => {
+        expect(r.start.get("day")).toBe(15);
+        expect(r.start.get("month")).toBe(3);
+        expect(r.start.isCertain("year")).toBe(false);
+        expect(r.start.isCertain("day")).toBe(true);
+        expect(r.start.isCertain("month")).toBe(true);
+    });
+});
+
+test("Test - index position is correct", () => {
+    testSingleCase(
+        chrono.vi,
+        "S\u1ef1 ki\u1ec7n ng\u00e0y 30 th\u00e1ng 4 n\u0103m 1975 quan tr\u1ecdng.",
+        REF,
+        (r) => {
+            expect(r.index).toBe(8);
+            expect(r.text).toBe("ng\u00e0y 30 th\u00e1ng 4 n\u0103m 1975");
+            expect(r.start.get("year")).toBe(1975);
+        }
+    );
+});
+
+test("Test - negative: invalid month rejected", () => {
+    // tháng 13 is rejected; without a year, no other parser fires
+    testUnexpectedResult(chrono.vi, "ngày 1 tháng 13", REF);
+    // "ngày 32 tháng 4" partially matches as "2 tháng 4" — day bounds enforced by VIStandardParser (day > 31)
+});

package/test/vi/vi_strict.test.ts

@@ -0,0 +1,67 @@
+import * as chrono from "../../src/";
+import { testSingleCase, testUnexpectedResult } from "../test_util";
+
+const REF = new Date(2012, 7, 10, 12); // 2012-08-10
+
+test("Test - Strict rejects casual date expressions", () => {
+    testUnexpectedResult(chrono.vi.strict, "h\u00f4m nay", REF);
+    testUnexpectedResult(chrono.vi.strict, "h\u00f4m qua", REF);
+    testUnexpectedResult(chrono.vi.strict, "ng\u00e0y mai", REF);
+    testUnexpectedResult(chrono.vi.strict, "ng\u00e0y kia", REF);
+});
+
+test("Test - Strict rejects casual time-of-day expressions", () => {
+    testUnexpectedResult(chrono.vi.strict, "bu\u1ed5i s\u00e1ng", REF);
+    testUnexpectedResult(chrono.vi.strict, "bu\u1ed5i tr\u01b0a", REF);
+    testUnexpectedResult(chrono.vi.strict, "bu\u1ed5i chi\u1ec1u", REF);
+    testUnexpectedResult(chrono.vi.strict, "bu\u1ed5i t\u1ed1i", REF);
+});
+
+test("Test - Strict rejects casual relative expressions", () => {
+    testUnexpectedResult(chrono.vi.strict, "tu\u1ea7n n\u00e0y", REF);
+    testUnexpectedResult(chrono.vi.strict, "th\u00e1ng tr\u01b0\u1edbc", REF);
+    testUnexpectedResult(chrono.vi.strict, "n\u0103m sau", REF);
+});
+
+test("Test - Strict rejects weekday-only expressions", () => {
+    testUnexpectedResult(chrono.vi.strict, "th\u1ee9 hai", REF);
+    testUnexpectedResult(chrono.vi.strict, "ch\u1ee7 nh\u1eadt", REF);
+});
+
+test("Test - Strict accepts standard full dates and times", () => {
+    testSingleCase(chrono.vi.strict, "ng\u00e0y 30 th\u00e1ng 4 n\u0103m 1975", REF, (r) => {
+        expect(r.start.get("year")).toBe(1975);
+        expect(r.start.get("month")).toBe(4);
+        expect(r.start.get("day")).toBe(30);
+    });
+
+    testSingleCase(chrono.vi.strict, "l\u00fac 7 gi\u1edd 30 ph\u00fat", REF, (r) => {
+        expect(r.start.get("hour")).toBe(7);
+        expect(r.start.get("minute")).toBe(30);
+    });
+});
+
+test("Test - Strict accepts slash dates", () => {
+    testSingleCase(chrono.vi.strict, "30/4/1975", REF, (r) => {
+        expect(r.start.get("day")).toBe(30);
+        expect(r.start.get("month")).toBe(4);
+        expect(r.start.get("year")).toBe(1975);
+    });
+
+    testSingleCase(chrono.vi.strict, "15/3", REF, (r) => {
+        expect(r.start.get("day")).toBe(15);
+        expect(r.start.get("month")).toBe(3);
+    });
+});
+
+test("Test - Strict accepts explicit time unit expressions", () => {
+    testSingleCase(chrono.vi.strict, "3 ng\u00e0y tr\u01b0\u1edbc", REF, (r) => {
+        expect(r.start.get("day")).toBe(7);
+        expect(r.start.get("month")).toBe(8);
+    });
+
+    testSingleCase(chrono.vi.strict, "2 tu\u1ea7n sau", REF, (r) => {
+        expect(r.start.get("day")).toBe(24);
+        expect(r.start.get("month")).toBe(8);
+    });
+});

package/test/vi/vi_time_exp.test.ts

@@ -0,0 +1,99 @@
+import * as chrono from "../../src/";
+import { testSingleCase } from "../test_util";
+
+const REF = new Date(2012, 7, 10, 12);
+
+test("Test - X gi\u1edd", () => {
+    testSingleCase(chrono.vi, "Cu\u1ed9c h\u1ecdn l\u00fac 7 gi\u1edd.", REF, (r) => {
+        expect(r.index).toBe(9);
+        expect(r.text).toBe("l\u00fac 7 gi\u1edd");
+        expect(r.start.get("hour")).toBe(7);
+        expect(r.start.get("minute")).toBe(0);
+    });
+
+    testSingleCase(chrono.vi, "7 gi\u1edd s\u00e1ng", REF, (r) => {
+        expect(r.start.get("hour")).toBe(7);
+        expect(r.start.get("meridiem")).toBe(0); // AM
+    });
+
+    testSingleCase(chrono.vi, "7 gi\u1edd t\u1ed1i", REF, (r) => {
+        expect(r.start.get("hour")).toBe(19);
+    });
+});
+
+test("Test - X gi\u1edd Y ph\u00fat", () => {
+    testSingleCase(chrono.vi, "l\u00fac 7 gi\u1edd 30 ph\u00fat", REF, (r) => {
+        expect(r.start.get("hour")).toBe(7);
+        expect(r.start.get("minute")).toBe(30);
+    });
+
+    testSingleCase(chrono.vi, "v\u00e0o 15 gi\u1edd 45 ph\u00fat", REF, (r) => {
+        expect(r.start.get("hour")).toBe(15);
+        expect(r.start.get("minute")).toBe(45);
+    });
+});
+
+test("Test - colon format HH:MM", () => {
+    testSingleCase(chrono.vi, "H\u1ecdn l\u00fac 15:30.", REF, (r) => {
+        expect(r.start.get("hour")).toBe(15);
+        expect(r.start.get("minute")).toBe(30);
+    });
+});
+
+test("Test - date + time combined", () => {
+    testSingleCase(chrono.vi, "ng\u00e0y 30 th\u00e1ng 4 n\u0103m 1975 l\u00fac 11 gi\u1edd", REF, (r) => {
+        expect(r.start.get("day")).toBe(30);
+        expect(r.start.get("month")).toBe(4);
+        expect(r.start.get("year")).toBe(1975);
+        expect(r.start.get("hour")).toBe(11);
+    });
+});
+
+test("Test - meridiem: s\u00e1ng/chi\u1ec1u/t\u1ed1i/\u0111\u00eam", () => {
+    testSingleCase(chrono.vi, "9 gi\u1edd s\u00e1ng", REF, (r) => {
+        expect(r.start.get("hour")).toBe(9);
+        expect(r.start.get("meridiem")).toBe(0); // AM
+    });
+    testSingleCase(chrono.vi, "3 gi\u1edd chi\u1ec1u", REF, (r) => {
+        expect(r.start.get("hour")).toBe(15);
+    });
+    testSingleCase(chrono.vi, "10 gi\u1edd \u0111\u00eam", REF, (r) => {
+        expect(r.start.get("hour")).toBe(22);
+    });
+});
+
+test("Test - trưa meridiem: X giờ trưa → PM (hour + 12)", () => {
+    // trưa = noon/midday — times expressed with trưa are PM
+    testSingleCase(chrono.vi, "1 giờ trưa", REF, (r) => {
+        expect(r.start.get("hour")).toBe(13);
+        expect(r.start.get("meridiem")).toBe(1); // PM
+    });
+    testSingleCase(chrono.vi, "11 giờ trưa", REF, (r) => {
+        expect(r.start.get("hour")).toBe(11);
+        expect(r.start.get("meridiem")).toBe(0); // AM — 11 giờ trưa = approaching noon
+    });
+    // 12 giờ trưa = noon, no offset applied (12 < 12 is false)
+    testSingleCase(chrono.vi, "12 giờ trưa", REF, (r) => {
+        expect(r.start.get("hour")).toBe(12);
+        expect(r.start.get("meridiem")).toBe(1); // PM
+    });
+});
+
+test("Test - 12 giờ sáng = midnight (00:00)", () => {
+    testSingleCase(chrono.vi, "12 giờ sáng", REF, (r) => {
+        expect(r.start.get("hour")).toBe(0);
+        expect(r.start.get("meridiem")).toBe(0); // AM
+    });
+});
+
+test("Test - isCertain: hour and meridiem certainty", () => {
+    testSingleCase(chrono.vi, "lúc 7 giờ", REF, (r) => {
+        expect(r.start.isCertain("hour")).toBe(true);
+        expect(r.start.isCertain("meridiem")).toBe(false);
+    });
+
+    testSingleCase(chrono.vi, "7 giờ sáng", REF, (r) => {
+        expect(r.start.isCertain("hour")).toBe(true);
+        expect(r.start.isCertain("meridiem")).toBe(true);
+    });
+});