chrono-node 2.7.9 → 2.8.1

package/test/ja/ja_time_exp.test.ts

@@ -0,0 +1,244 @@
+import * as chrono from "../../src";
+import { testSingleCase } from "../test_util";
+
+test("Test - Single Expression", function () {
+    testSingleCase(chrono.ja, "私は午前6時13分に起きた", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(2);
+        expect(result.text).toBe("午前6時13分");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("hour")).toBe(6);
+        expect(result.start.get("minute")).toBe(13);
+
+        const resultDate = result.start.date();
+        const expectDate = new Date(2012, 7, 10, 6, 13);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+    });
+
+    testSingleCase(chrono.ja, "私は午前8時に起きる", new Date(2012, 7, 10, 12), (result) => {
+        expect(result.index).toBe(2);
+        expect(result.text).toBe("午前8時");
+
+        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.start.get("hour")).toBe(8);
+
+        const resultDate = result.start.date();
+        const expectDate = new Date(2012, 7, 10, 8);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+    });
+
+    testSingleCase(chrono.ja, "午後8時", new Date(2012, 8 - 1, 10, 12), (result) => {
+        expect(result.text).toBe("午後8時");
+
+        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.start.get("hour")).toBe(20);
+
+        const resultDate = result.start.date();
+        const expectDate = new Date(2012, 8 - 1, 10, 20);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+    });
+    testSingleCase(chrono.ja, "12/9の16:00", new Date(2025, 12 - 1, 10, 12), (result) => {
+        expect(result.text).toBe("12/9の16:00");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2025);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.start.get("day")).toBe(9);
+        expect(result.start.get("hour")).toBe(16);
+
+        const resultDate = result.start.date();
+        const expectDate = new Date(2025, 12 - 1, 9, 16);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+    });
+    testSingleCase(chrono.ja, "１２月９日の１６：３０", new Date(2025, 12 - 1, 10, 12), (result) => {
+        expect(result.text).toBe("１２月９日の１６：３０");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2025);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.start.get("day")).toBe(9);
+        expect(result.start.get("hour")).toBe(16);
+        expect(result.start.get("minute")).toBe(30);
+
+        const resultDate = result.start.date();
+        const expectDate = new Date(2025, 12 - 1, 9, 16, 30);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+    });
+});
+
+test("Test - Range Expression", function () {
+    testSingleCase(
+        chrono.ja,
+        "私は本日午前八時十分から午後11時32分までゲームをした",
+        new Date(2012, 7, 10),
+        (result) => {
+            expect(result.index).toBe(2);
+            expect(result.text).toBe("本日午前八時十分から午後11時32分");
+
+            expect(result.start).not.toBeNull();
+            expect(result.start.get("hour")).toBe(8);
+            expect(result.start.get("minute")).toBe(10);
+
+            expect(result.start.isCertain("day")).toBe(true);
+            expect(result.start.isCertain("month")).toBe(true);
+            expect(result.start.isCertain("year")).toBe(true);
+            expect(result.start.isCertain("hour")).toBe(true);
+            expect(result.start.isCertain("minute")).toBe(true);
+            expect(result.start.isCertain("second")).toBe(false);
+            expect(result.start.isCertain("millisecond")).toBe(false);
+
+            let resultDate = result.start.date();
+            let expectDate = new Date(2012, 7, 10, 8, 10);
+            expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+
+            expect(result.end).not.toBeNull();
+            expect(result.end.get("hour")).toBe(23);
+            expect(result.end.get("minute")).toBe(32);
+
+            expect(result.end.isCertain("day")).toBe(true);
+            expect(result.end.isCertain("month")).toBe(true);
+            expect(result.end.isCertain("year")).toBe(true);
+            expect(result.end.isCertain("hour")).toBe(true);
+            expect(result.end.isCertain("minute")).toBe(true);
+            expect(result.end.isCertain("second")).toBe(false);
+            expect(result.end.isCertain("millisecond")).toBe(false);
+
+            resultDate = result.end.date();
+            expectDate = new Date(2012, 7, 10, 23, 32);
+            expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+        }
+    );
+
+    testSingleCase(chrono.ja, "6時30分PM-11時PM", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("6時30分PM-11時PM");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("hour")).toBe(18);
+        expect(result.start.get("minute")).toBe(30);
+        expect(result.start.get("meridiem")).toBe(1);
+
+        let resultDate = result.start.date();
+        let expectDate = new Date(2012, 7, 10, 18, 30);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+
+        expect(result.end).not.toBeNull();
+        expect(result.end.get("hour")).toBe(23);
+        expect(result.end.get("minute")).toBe(0);
+        expect(result.end.get("meridiem")).toBe(1);
+
+        resultDate = result.end.date();
+        expectDate = new Date(2012, 7, 10, 23, 0);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+    });
+});
+
+test("Test - Date + Time Expression", function () {
+    testSingleCase(
+        chrono.ja,
+        "僕は2018年11月26日午後三時半五十九秒にゲームを始めた",
+        new Date(2012, 7, 10),
+        (result) => {
+            expect(result.index).toBe(2);
+            expect(result.text).toBe("2018年11月26日午後三時半五十九秒");
+
+            expect(result.start.get("year")).toBe(2018);
+            expect(result.start.get("month")).toBe(11);
+            expect(result.start.get("day")).toBe(26);
+            expect(result.start.get("hour")).toBe(15);
+            expect(result.start.get("minute")).toBe(30);
+            expect(result.start.get("second")).toBe(59);
+            expect(result.start.get("millisecond")).toBe(0);
+            expect(result.start.isCertain("millisecond")).toBe(false);
+
+            const resultDate = result.start.date();
+            const expectDate = new Date(2018, 11 - 1, 26, 15, 30, 59);
+            expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+        }
+    );
+});
+
+test("Test - Time Expression's Meridiem imply", function () {
+    testSingleCase(chrono.ja, "午後1時から3時", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("午後1時から3時");
+
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+        expect(result.start.get("hour")).toBe(13);
+        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("second")).toBe(0);
+        expect(result.start.get("millisecond")).toBe(0);
+        expect(result.start.get("meridiem")).toBe(1);
+        expect(result.start.isCertain("meridiem")).toBe(true);
+
+        expect(result.end.get("year")).toBe(2012);
+        expect(result.end.get("month")).toBe(8);
+        expect(result.end.get("day")).toBe(10);
+        expect(result.end.get("hour")).toBe(15);
+        expect(result.end.get("minute")).toBe(0);
+        expect(result.end.get("second")).toBe(0);
+        expect(result.end.get("millisecond")).toBe(0);
+        expect(result.start.get("meridiem")).toBe(1);
+    });
+
+    testSingleCase(chrono.ja, "午後６時半－１１時", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("午後６時半－１１時");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("hour")).toBe(18);
+        expect(result.start.get("minute")).toBe(30);
+        expect(result.start.get("meridiem")).toBe(1);
+
+        const resultDate = result.start.date();
+        const expectDate = new Date(2012, 7, 10, 18, 30);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+
+        expect(result.end).not.toBeNull();
+        expect(result.end.get("hour")).toBe(23);
+        expect(result.end.get("minute")).toBe(0);
+        expect(result.end.get("meridiem")).toBe(1);
+    });
+});
+
+test("Test - Random date + time expression", function () {
+    testSingleCase(chrono.ja, "2014年3月5日午前 6 時から 7 時", new Date(2012, 7, 10), (result) => {
+        expect(result.text).toBe("2014年3月5日午前 6 時から 7 時");
+    });
+
+    testSingleCase(chrono.ja, "次の土曜日1時30分二十九秒", new Date(2012, 7, 10), (result) => {
+        expect(result.text).toBe("次の土曜日1時30分二十九秒");
+    });
+
+    testSingleCase(chrono.ja, "昨日午前六時", new Date(2012, 7, 10), (result) => {
+        expect(result.text).toBe("昨日午前六時");
+    });
+
+    testSingleCase(chrono.ja, "６月４日3:00am", new Date(2012, 7, 10), (result) => {
+        expect(result.text).toBe("６月４日3:00am");
+    });
+
+    testSingleCase(chrono.ja, "前の金曜日16時", new Date(2012, 7, 10), (result) => {
+        expect(result.text).toBe("前の金曜日16時");
+    });
+
+    testSingleCase(chrono.ja, "3月17日 20時15", new Date(2012, 7, 10), (result) => {
+        expect(result.text).toBe("3月17日 20時15");
+    });
+
+    testSingleCase(chrono.ja, "10時", new Date(2012, 7, 10), (result) => {
+        expect(result.text).toBe("10時");
+    });
+
+    testSingleCase(chrono.ja, "12時", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("hour")).toBe(12);
+    });
+});

package/test/ja/ja_weekday.test.ts

@@ -0,0 +1,183 @@
+import * as chrono from "../../src";
+import { testSingleCase } from "../test_util";
+
+test("Test - Single Expression", function () {
+    testSingleCase(chrono.ja, "木曜日", new Date(2016, 9 - 1, 2), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("木曜日");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("weekday")).toBe(4);
+
+        expect(result.start.isCertain("day")).toBe(false);
+        expect(result.start.isCertain("month")).toBe(false);
+        expect(result.start.isCertain("year")).toBe(false);
+        expect(result.start.isCertain("weekday")).toBe(true);
+
+        const resultDate = result.start.date();
+        const expectDate = new Date(2016, 9 - 1, 1, 12);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+    });
+
+    testSingleCase(chrono.ja, "前の水曜日", new Date(2016, 9 - 1, 2), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("前の水曜日");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(31);
+        expect(result.start.get("weekday")).toBe(3);
+
+        const resultDate = result.start.date();
+        const expectDate = new Date(2016, 8 - 1, 31, 12);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+    });
+});
+
+test("Test - Single Expression - weekday with parentheses", function () {
+    testSingleCase(chrono.ja, "(木)", new Date(2016, 9 - 1, 2), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("(木)");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("weekday")).toBe(4);
+
+        expect(result.start.isCertain("day")).toBe(false);
+        expect(result.start.isCertain("month")).toBe(false);
+        expect(result.start.isCertain("year")).toBe(false);
+        expect(result.start.isCertain("weekday")).toBe(true);
+
+        const resultDate = result.start.date();
+        const expectDate = new Date(2016, 9 - 1, 1, 12);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+    });
+    testSingleCase(chrono.ja, "（木）", new Date(2016, 9 - 1, 2), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("（木）");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("weekday")).toBe(4);
+
+        expect(result.start.isCertain("day")).toBe(false);
+        expect(result.start.isCertain("month")).toBe(false);
+        expect(result.start.isCertain("year")).toBe(false);
+        expect(result.start.isCertain("weekday")).toBe(true);
+
+        const resultDate = result.start.date();
+        const expectDate = new Date(2016, 9 - 1, 1, 12);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+    });
+});
+
+test("Test - forward dates only option", function () {
+    testSingleCase(chrono.ja, "土曜日～月曜日", new Date(2016, 9 - 1, 2), { forwardDate: true }, (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("土曜日～月曜日");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(3);
+        expect(result.start.get("weekday")).toBe(6);
+
+        expect(result.start.isCertain("day")).toBe(false);
+        expect(result.start.isCertain("month")).toBe(false);
+        expect(result.start.isCertain("year")).toBe(false);
+        expect(result.start.isCertain("weekday")).toBe(true);
+
+        let resultDate = result.start.date();
+        let expectDate = new Date(2016, 9 - 1, 3, 12);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+
+        expect(result.end).not.toBeNull();
+        expect(result.end.get("year")).toBe(2016);
+        expect(result.end.get("month")).toBe(9);
+        expect(result.end.get("day")).toBe(5);
+        expect(result.end.get("weekday")).toBe(1);
+
+        expect(result.end.isCertain("day")).toBe(false);
+        expect(result.end.isCertain("month")).toBe(false);
+        expect(result.end.isCertain("year")).toBe(false);
+        expect(result.end.isCertain("weekday")).toBe(true);
+
+        resultDate = result.end.date();
+        expectDate = new Date(2016, 9 - 1, 5, 12);
+        expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+    });
+});
+
+test("Test - merge date and weekday", function () {
+    testSingleCase(chrono.ja, "8月27日水曜日", new Date(2012, 8 - 1, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("8月27日水曜日");
+
+        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(27);
+        expect(result.start.get("weekday")).toBe(3);
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 27, 12));
+    });
+    testSingleCase(chrono.ja, "8月27日（水）", new Date(2012, 8 - 1, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("8月27日（水）");
+
+        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(27);
+        expect(result.start.get("weekday")).toBe(3);
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 27, 12));
+    });
+    testSingleCase(chrono.ja, "2012/8/27（水）", new Date(2012, 8 - 1, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("2012/8/27（水）");
+
+        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(27);
+        expect(result.start.get("weekday")).toBe(3);
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 27, 12));
+    });
+    testSingleCase(chrono.ja, "１／３０（木）", new Date(2025, 1, 10), (result) => {
+        expect(result.text).toBe("１／３０（木）");
+    });
+    testSingleCase(chrono.ja, "1/30の木曜日", new Date(2025, 1, 10), (result) => {
+        expect(result.text).toBe("1/30の木曜日");
+    });
+    testSingleCase(chrono.ja, "1/30(木)", new Date(2025, 1, 10), (result) => {
+        expect(result.text).toBe("1/30(木)");
+    });
+    testSingleCase(chrono.ja, "１月３０日（木）１４：００", new Date(2025, 1, 10), (result) => {
+        expect(result.text).toBe("１月３０日（木）１４：００");
+    });
+    testSingleCase(chrono.ja, "１月３１日（金）１２：００－１６：００", new Date(2025, 1, 10), (result) => {
+        expect(result.text).toBe("１月３１日（金）１２：００－１６：００");
+    });
+    testSingleCase(
+        chrono.ja,
+        "１月３０日（木）１２：００－１月３１日（金）１６：００",
+        new Date(2025, 1, 10),
+        (result) => {
+            expect(result.text).toBe("１月３０日（木）１２：００－１月３１日（金）１６：００");
+            expect(result.start).toBeDate(new Date(2025, 1 - 1, 30, 12));
+            expect(result.start.get("weekday")).toBe(4);
+            expect(result.end).toBeDate(new Date(2025, 1 - 1, 31, 16));
+            expect(result.end.get("weekday")).toBe(5);
+        }
+    );
+});

package/test/nl/nl_relative.test.ts

@@ -185,42 +185,58 @@ test("Test - Relative date components' certainty", () => {
     });
 });
 
-test("Test - Relative date components' certainty and imply timezone", () => {
+test("Test - Relative date when the timezone is irrelevant", () => {
     const refDate = new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)");
-
     {
         // now
         const text = "nu";
         const result = chrono.nl.parse(text, refDate)[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)"));
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 5:24:13 GMT+0100"));
 
-        expect(result.text).toBe(text);
         result.start.imply("timezoneOffset", 60);
-
         expect(result).toBeDate(new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)"));
         expect(result).toBeDate(new Date("Sun Nov 29 2020 5:24:13 GMT+0100"));
     }
-
     {
-        // tomorrow at 5pm
-        const text = "morgen om 17 uur";
+        // in 10 minutes
+        const text = "binnen 10 minuten";
         const result = chrono.nl.parse(text, refDate)[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 13:34:13 GMT+0900 (Japan Standard Time)"));
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 5:34:13 GMT+0100"));
 
-        expect(result.text).toBe(text);
         result.start.imply("timezoneOffset", 60);
-
-        expect(result).toBeDate(new Date("Sun Dec 1 2020 1:00:00 GMT+0900 (Japan Standard Time)"));
-        expect(result).toBeDate(new Date("Sun Nov 30 2020 17:00:00 GMT+0100"));
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 13:34:13 GMT+0900 (Japan Standard Time)"));
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 5:34:13 GMT+0100"));
     }
+});
 
+test("Test - Relative date when the timezone is relevant and known", () => {
+    // Sun Nov 29 2020 13:24:13 GMT+0900 (JST)
+    // Sat Nov 28 2020 21:24:13 GMT-0700 (PDT)
+    const refInstant = new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)");
     {
-        // in 10 minutes
-        const text = "binnen 10 minuten";
-        const result = chrono.nl.parse(text, refDate)[0] as ParsingResult;
+        // In JST (Nov 29 2020 13:24:13 GMT+0900), "tomorrow at 5pm"
+        const text = "morgen om 17 uur";
+        const result = chrono.nl.parse(text, { instant: refInstant, timezone: "JST" })[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Mon Nov 30 2020 17:00:00 GMT+0900 (JST)"));
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(30);
+        expect(result.start.get("hour")).toBe(17);
 
-        expect(result.text).toBe(text);
         result.start.imply("timezoneOffset", 60);
+        expect(result).toBeDate(new Date("Mon Nov 30 2020 17:00:00 GMT+0100 (BST)"));
+    }
+    {
+        // In PDT (Sat Nov 28 2020 21:24:13 GMT-0700), "tomorrow at 5pm"
+        const text = "morgen om 17 uur";
+        const result = chrono.nl.parse(text, { instant: refInstant, timezone: -7 * 60 })[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 17:00:00 GMT-0700 (PST)"));
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(29);
+        expect(result.start.get("hour")).toBe(17);
 
-        expect(result).toBeDate(new Date("Sun Nov 29 2020 13:34:13 GMT+0900 (Japan Standard Time)"));
-        expect(result).toBeDate(new Date("Sun Nov 29 2020 5:34:13 GMT+0100"));
+        result.start.imply("timezoneOffset", 60);
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 17:00:00 GMT+0100 (BST)"));
     }
 });

package/test/result.test.ts

@@ -175,3 +175,27 @@ test("Test - Checking non-existing date during DST skip", () => {
         ).toBe(true);
     }
 });
+
+test("Test - Getting timezone adjust date from references", () => {
+    {
+        const reference = new ReferenceWithTimezone({
+            instant: new Date("Wed Jun 09 2021 07:21:32 GMT+0900 (JST)"),
+            timezone: 9 * 60,
+        });
+        expect(reference.getDateWithAdjustedTimezone()).toStrictEqual(new Date(2021, 6 - 1, 9, 7, 21, 32));
+    }
+    {
+        const reference = new ReferenceWithTimezone({
+            instant: new Date("Wed Jun 09 2021 07:21:32 GMT+0900 (JST)"),
+            timezone: "JST",
+        });
+        expect(reference.getDateWithAdjustedTimezone()).toStrictEqual(new Date(2021, 6 - 1, 9, 7, 21, 32));
+    }
+    {
+        const reference = new ReferenceWithTimezone({
+            instant: new Date("Wed Jun 09 2021 07:21:32 GMT-0500 (CDT)"),
+            timezone: "CDT",
+        });
+        expect(reference.getDateWithAdjustedTimezone()).toStrictEqual(new Date(2021, 6 - 1, 9, 7, 21, 32));
+    }
+});

package/test/system.test.ts

@@ -9,7 +9,7 @@ import { ParsingComponents } from "../src/";
 
 //-------------------------------------
 
-test("Test - Load modules", function () {
+test("Test - Load modules", () => {
     expect(chrono).toBeDefined();
 
     expect(chrono.Chrono).toBeDefined();

package/test/system_timezone.test.ts

@@ -1,7 +1,7 @@
 import * as chrono from "../src/";
 import { testSingleCase } from "./test_util";
 
-test("Test - Timezone difference on reference example", function () {
+test("Test - Using reference with timezone", function () {
     testSingleCase(
         chrono,
         "Friday at 4pm",
@@ -11,12 +11,26 @@ test("Test - Timezone difference on reference example", function () {
         },
         (result) => {
             expect(result).toBeDate(new Date("Fri Jun 11 2021 16:00:00 GMT-0500 (CDT)"));
-            expect(result).toBeDate(new Date("Fri Jun 12 2021 06:00:00 GMT+0900 (JST)"));
+            expect(result).toBeDate(new Date("Sat Jun 12 2021 06:00:00 GMT+0900 (JST)"));
+        }
+    );
+    testSingleCase(
+        chrono,
+        "1am",
+        {
+            instant: new Date("Wed May 26 2022 01:57:00 GMT-0500 (CDT)"),
+            timezone: "CDT",
+        },
+        (result) => {
+            expect(result.start.get("year")).toBe(2022);
+            expect(result.start.get("month")).toBe(5);
+            expect(result.start.get("day")).toBe(26);
+            expect(result.start.get("hour")).toBe(1);
         }
     );
 });
 
-test("Test - Timezone difference on default timezone", function () {
+test("Test - Using reference with missing/default timezone", function () {
     const INPUT = "Friday at 4pm";
     const REF_INSTANT = new Date(2021, 6 - 1, 9, 7, 0, 0);
     const EXPECTED_INSTANT = new Date(2021, 6 - 1, 11, 16, 0, 0);
@@ -38,16 +52,18 @@ test("Test - Timezone difference on default timezone", function () {
     });
 });
 
-test("Test - Timezone difference on reference date", function () {
+test("Test - Using reference instance with different timezone", function () {
     // Sun Jun 06 2021 19:00:00 GMT+0900 (JST)
     // Sun Jun 06 2021 11:00:00 GMT+0100 (BST)
     const refInstant = new Date("Sun Jun 06 2021 19:00:00 GMT+0900 (JST)");
 
+    // "At 4pm tomorrow" at "Sun Jun 06 2021 11:00:00 (BST)"
     testSingleCase(chrono, "At 4pm tomorrow", { instant: refInstant, timezone: "BST" }, (result) => {
         const expectedInstant = new Date("Mon Jun 07 2021 16:00:00 GMT+0100 (BST)");
         expect(result).toBeDate(expectedInstant);
     });
 
+    // "At 4pm tomorrow" at "Sun Jun 06 2021 19:00:00 (JST)"
     testSingleCase(chrono, "At 4pm tomorrow", { instant: refInstant, timezone: "JST" }, (result) => {
         const expectedInstant = new Date("Mon Jun 07 2021 16:00:00 GMT+0900 (JST)");
         expect(result).toBeDate(expectedInstant);