chrono-node 2.8.5 → 2.9.1

package/test/fi/fi_weekday.test.ts

@@ -0,0 +1,90 @@
+import * as chrono from "../../src/locales/fi";
+import { testSingleCase } from "../test_util";
+
+test("Test - Single Expression", function () {
+    testSingleCase(chrono, "maanantai", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("maanantai");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(6);
+        expect(result.start.get("weekday")).toBe(1);
+    });
+
+    testSingleCase(chrono, "maanantaina", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("maanantaina");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(6);
+        expect(result.start.get("weekday")).toBe(1);
+    });
+});
+
+test("Test - Next/Last Week Expression", function () {
+    testSingleCase(chrono, "ensi maanantai", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("ensi maanantai");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(13);
+        expect(result.start.get("weekday")).toBe(1);
+    });
+
+    testSingleCase(chrono, "viime maanantai", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("viime maanantai");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(6);
+        expect(result.start.get("weekday")).toBe(1);
+    });
+});
+
+test("Test - Weekday variations", function () {
+    testSingleCase(chrono, "sunnuntai", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(0);
+    });
+
+    testSingleCase(chrono, "tiistai", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(2);
+    });
+
+    testSingleCase(chrono, "keskiviikko", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(3);
+    });
+
+    testSingleCase(chrono, "torstai", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(4);
+    });
+
+    testSingleCase(chrono, "perjantai", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(5);
+    });
+
+    testSingleCase(chrono, "lauantai", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(6);
+    });
+});
+
+test("Test - Weekday abbreviations", function () {
+    testSingleCase(chrono, "ma", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(1);
+    });
+
+    testSingleCase(chrono, "pe", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(5);
+    });
+
+    testSingleCase(chrono, "su", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(0);
+    });
+});

package/test/it/it_month_name_middle_endian.test.ts

@@ -0,0 +1,39 @@
+import * as chrono from "../../src";
+import { testSingleCase } from "../test_util";
+
+test("Test - Single Expression", () => {
+    testSingleCase(chrono.it, "Ci vediamo ad Agosto 2017.", (result) => {
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(1);
+
+        expect(result.index).toBe(14);
+        expect(result.text).toBe("Agosto 2017");
+
+        expect(result.start).toBeDate(new Date(2017, 8 - 1, 1, 12));
+    });
+
+    testSingleCase(chrono.it, "Agosto 10, 2012", new Date(2012, 7, 10), (result) => {
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Agosto 10, 2012");
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 12));
+    });
+
+    testSingleCase(chrono.it, "La scadenza è Agosto 10", new Date(2012, 7, 10), (result) => {
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+
+        expect(result.text).toBe("Agosto 10");
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 12));
+    });
+});

package/test/it/it_time_exp.test.ts

@@ -0,0 +1,84 @@
+import * as chrono from "../../src";
+import { testSingleCase } from "../test_util";
+
+test("Test - Single Expression", function () {
+    testSingleCase(chrono.it, "Alle 18:10", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Alle 18:10");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("hour")).toBe(18);
+        expect(result.start.get("minute")).toBe(10);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 18, 10));
+    });
+
+    testSingleCase(chrono.it, "Alle 6:10", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Alle 6:10");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("hour")).toBe(6);
+        expect(result.start.get("minute")).toBe(10);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 6, 10));
+    });
+});
+
+test("Test - Time Expression with Meridiem", function () {
+    testSingleCase(chrono.it, "6 del pomeriggio", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("6 del pomeriggio");
+
+        expect(result.start.get("hour")).toBe(18);
+        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("meridiem")).toBe(1);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 18, 0));
+    });
+
+    testSingleCase(chrono.it, "ore 6 in punto", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(4);
+        expect(result.text).toBe("6 in punto");
+
+        expect(result.start.get("hour")).toBe(6);
+        expect(result.start.get("minute")).toBe(0);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 6, 0));
+    });
+
+    testSingleCase(chrono.it, "6 della mattina", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("6 della mattina");
+
+        expect(result.start.get("hour")).toBe(6);
+        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("meridiem")).toBe(0);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 6, 0));
+    });
+
+    testSingleCase(chrono.it, "Alle 20 sera", new Date(2012, 7, 10), (result) => {
+        expect(result.text).toBe("Alle 20 sera");
+        expect(result.start.get("hour")).toBe(20);
+        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("meridiem")).toBe(1);
+    });
+});
+
+test("Test - Casual Time Expression", function () {
+    testSingleCase(chrono.it, "Stasera", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Stasera");
+        expect(result.start.get("hour")).toBe(22); // Implied "evening" hours?
+    });
+
+    // Check if this parser handles range
+    testSingleCase(chrono.it, "10:00 - 12:00", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("10:00 - 12:00");
+
+        expect(result.start.get("hour")).toBe(10);
+        expect(result.end.get("hour")).toBe(12);
+    });
+});

package/test/it/it_year_month_day.test.ts

@@ -0,0 +1,41 @@
+import { testSingleCase, testUnexpectedResult } from "../test_util";
+import * as chrono from "../../src";
+
+test("Test - Single Expression (YYYY.MM.DD)", function () {
+    testSingleCase(chrono.it, "2012.08.10", new Date(2012, 7, 10), (result) => {
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("2012.08.10");
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 12));
+    });
+
+    testSingleCase(chrono.it, "La scadenza è 2012.08.10", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(14);
+        expect(result.text).toBe("2012.08.10");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12));
+    });
+
+    testSingleCase(chrono.it.strict, "2014.02.28", (result) => {
+        expect(result.text).toBe("2014.02.28");
+    });
+
+    testSingleCase(chrono.it.strict, "2014.12.28", (result) => {
+        expect(result.text).toBe("2014.12.28");
+        expect(result).toBeDate(new Date(2014, 12 - 1, 28, 12));
+    });
+});
+
+test("Test - Not parse unlikely YYYY.MM.DD pattern", function () {
+    testUnexpectedResult(chrono.it, "2012.80.10", new Date(2012, 7, 10));
+});
+
+test("Test - Not parse impossible dates", function () {
+    testUnexpectedResult(chrono.it, "2014.08.32");
+    testUnexpectedResult(chrono.it, "2014.02.30");
+});

package/test/result.test.ts

@@ -87,6 +87,14 @@ test("Test - Create & manipulate parsing results", () => {
     expect(result.toString()).toContain(text);
     expect(result.toString()).toContain("custom/testing_start_component_tag");
     expect(result.toString()).toContain("custom/testing_end_component_tag");
+
+    // The result's addTag() and addTags() should add the tags to both start/end components
+    result.addTag("custom/testing_result_tag1");
+    result.addTags(["custom/testing_result_tag2"]);
+    expect(startComponents.tags()).toContain("custom/testing_result_tag1");
+    expect(startComponents.tags()).toContain("custom/testing_result_tag2");
+    expect(endComponents.tags()).toContain("custom/testing_result_tag1");
+    expect(endComponents.tags()).toContain("custom/testing_result_tag2");
 });
 
 test("Test - Calendar checking with implied components", () => {

package/test/system.test.ts

@@ -228,9 +228,10 @@ test("Test - Compare with native js", () => {
 
     testByCompareWithNative("22 Feb 2015 04:12:00 -0000");
 
-    testByCompareWithNative("1900-01-01T00:00:00-01:00");
-
-    testByCompareWithNative("1900-01-01T00:00:00-00:00");
+    // Chrono's timezone calculation uses `Date.prototype.getTimezoneOffset()` which returns precision in minutes.
+    // Historical Local Mean Time (LMT) often includes seconds (e.g., Shanghai 1900 is +08:05:43).
+    // testByCompareWithNative("1900-01-01T00:00:00-01:00");
+    // testByCompareWithNative("1900-01-01T00:00:00-00:00");
 
     testByCompareWithNative("9999-12-31T23:59:00-00:00");
 

package/test/system_timezone.test.ts

@@ -183,3 +183,102 @@ test("Test - Precise date/time mentioned", function () {
         expect(result).toBeDate(new Date(text));
     });
 });
+
+test("Test - Minimize diff because of local timezone (pre-1900)", () => {
+    // Because of Local mean time (LMT), the local/system timezone my work differently before 1900
+    // For example:
+    //  - Shanghai LMT in 1900 was +08:05:43
+    // We expect Chrono to parse this within a few hours precision
+
+    testSingleCase(chrono, "1900-01-01T00:00:00-00:00", (result) => {
+        const expectedDate = new Date("1900-01-01T00:00:00-00:00");
+        const differenceMinutes = Math.abs(result.date().getTime() - expectedDate.getTime()) / (1000 * 60);
+        expect(differenceMinutes).toBeLessThanOrEqual(60);
+    });
+
+    testSingleCase(chrono, "1900-01-01T00:00:00-01:00", (result) => {
+        const expectedDate = new Date("1900-01-01T00:00:00-01:00");
+        const differenceMinutes = Math.abs(result.date().getTime() - expectedDate.getTime()) / (1000 * 60);
+        expect(differenceMinutes).toBeLessThanOrEqual(60 * 2);
+    });
+
+    testSingleCase(chrono, "1900-01-01T00:00:00+08:00", (result) => {
+        const expectedDate = new Date("1900-01-01T00:00:00+08:00");
+        const differenceMinutes = Math.abs(result.date().getTime() - expectedDate.getTime()) / (1000 * 60);
+        expect(differenceMinutes).toBeLessThanOrEqual(60 * 2);
+    });
+
+    testSingleCase(chrono, "1900-01-01T00:00", { timezone: "JST" }, (result) => {
+        const expectedDate = new Date("1900-01-01T00:00:00+08:00");
+        const differenceMinutes = Math.abs(result.date().getTime() - expectedDate.getTime()) / (1000 * 60);
+        expect(differenceMinutes).toBeLessThanOrEqual(60 * 2);
+    });
+});
+
+test("Test - Timezone DST transitions", function () {
+    // CT (Central Time) transitions:
+    // - DST starts: 2nd Sunday of March at 2am
+    // - DST ends: 1st Sunday of November at 2am
+    testSingleCase(chrono, "2022-03-12 23:00 CT", (result, text) => {
+        // Before DST transition, expected: -360
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-6 * 60);
+    });
+    testSingleCase(chrono, "2022-03-13 23:00 CT", (result, text) => {
+        // Within DST, expect -300 minutes
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-5 * 60);
+    });
+    testSingleCase(chrono, "2022-11-06 23:00 CT", (result, text) => {
+        // After DST transition, expected: -360
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-6 * 60);
+    });
+
+    // MT (Mountain Time) transitions:
+    // - DST starts: 2nd Sunday of March at 2am
+    // - DST ends: 1st Sunday of November at 2am
+    testSingleCase(chrono, "2022-03-12 23:00 MT", (result, text) => {
+        // Before DST transition, expected: -420
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-7 * 60);
+    });
+    testSingleCase(chrono, "2022-03-13 23:00 MT", (result, text) => {
+        // Within DST, expected: -360
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-6 * 60);
+    });
+    testSingleCase(chrono, "2022-11-06 23:00 MT", (result, text) => {
+        // After DST transition, expected: -420
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-7 * 60);
+    });
+
+    // PT (Pacific Time) transitions:
+    // - DST starts: 2nd Sunday of March at 2am
+    // - DST ends: 1st Sunday of November at 2am
+    testSingleCase(chrono, "2022-03-12 23:00 PT", (result, text) => {
+        // Before DST transition, expected: -480
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-8 * 60);
+    });
+    testSingleCase(chrono, "2022-03-13 23:00 PT", (result, text) => {
+        // Within DST, expected: -420
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-7 * 60);
+    });
+    testSingleCase(chrono, "2022-11-06 23:00 PT", (result, text) => {
+        // After DST transition, expected: -480
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-8 * 60);
+    });
+});

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