chrono-node 2.7.8 → 2.8.0

package/src/locales/ja/parsers/JPCasualDateParser.ts

@@ -3,14 +3,14 @@ import dayjs from "dayjs";
 import { Meridiem } from "../../../types";
 import * as references from "../../../common/casualReferences";
 
-const PATTERN = /今日|きょう|当日|とうじつ|昨日|きのう|明日|あした|今夜|こんや|今夕|こんゆう|今晩|こんばん|今朝|けさ/i;
+const PATTERN = /今日|きょう|本日|ほんじつ|昨日|きのう|明日|あした|今夜|こんや|今夕|こんゆう|今晩|こんばん|今朝|けさ/i;
 
 function normalizeTextToKanji(text: string) {
     switch (text) {
         case "きょう":
             return "今日";
-        case "とうじつ":
-            return "当日";
+        case "ほんじつ":
+            return "本日";
         case "きのう":
             return "昨日";
         case "あした":
@@ -46,8 +46,8 @@ export default class JPCasualDateParser implements Parser {
             case "明日":
                 return references.tomorrow(context.reference);
 
+            case "本日":
             case "今日":
-            case "当日":
                 return references.today(context.reference);
         }
 

package/src/locales/ja/refiners/JPMergeDateRangeRefiner.ts

@@ -8,6 +8,6 @@ import AbstractMergeDateRangeRefiner from "../../../common/refiners/AbstractMerg
  */
 export default class JPMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner {
     patternBetween(): RegExp {
-        return /^\s*(から|ー|-)\s*$/i;
+        return /^\s*(から|ー|-|～|~)\s*$/i;
     }
 }

package/src/results.ts

@@ -14,6 +14,7 @@ export class ReferenceWithTimezone {
         input = input ?? new Date();
         if (input instanceof Date) {
             this.instant = input;
+            this.timezoneOffset = null;
         } else {
             this.instant = input.instant ?? new Date();
             this.timezoneOffset = toTimezoneOffset(input.timezone, this.instant);
@@ -25,7 +26,11 @@ export class ReferenceWithTimezone {
      * The output's instant is NOT the reference's instant when the reference's and system's timezone are different.
      */
     getDateWithAdjustedTimezone() {
-        return new Date(this.instant.getTime() + this.getSystemTimezoneAdjustmentMinute(this.instant) * 60000);
+        const date = new Date(this.instant);
+        if (this.timezoneOffset !== null) {
+            date.setMinutes(date.getMinutes() - this.getSystemTimezoneAdjustmentMinute(this.instant));
+        }
+        return date;
     }
 
     /**
@@ -44,6 +49,10 @@ export class ReferenceWithTimezone {
         const targetTimezoneOffset = overrideTimezoneOffset ?? this.timezoneOffset ?? currentTimezoneOffset;
         return currentTimezoneOffset - targetTimezoneOffset;
     }
+
+    getTimezoneOffset(): number {
+        return this.timezoneOffset ?? -this.instant.getTimezoneOffset();
+    }
 }
 
 export class ParsingComponents implements ParsedComponents {
@@ -62,10 +71,10 @@ export class ParsingComponents implements ParsedComponents {
             }
         }
 
-        const refDayJs = dayjs(reference.instant);
-        this.imply("day", refDayJs.date());
-        this.imply("month", refDayJs.month() + 1);
-        this.imply("year", refDayJs.year());
+        const refDayJs = reference.getDateWithAdjustedTimezone();
+        this.imply("day", refDayJs.getDate());
+        this.imply("month", refDayJs.getMonth() + 1);
+        this.imply("year", refDayJs.getFullYear());
         this.imply("hour", 12);
         this.imply("minute", 0);
         this.imply("second", 0);
@@ -166,7 +175,7 @@ export class ParsingComponents implements ParsedComponents {
     }
 
     dayjs() {
-        return dayjs(this.date());
+        return dayjs(this.dateWithoutTimezoneAdjustment());
     }
 
     date(): Date {
@@ -210,7 +219,7 @@ export class ParsingComponents implements ParsedComponents {
         reference: ReferenceWithTimezone,
         fragments: { [c in QUnitType]?: number }
     ): ParsingComponents {
-        let date = dayjs(reference.instant);
+        let date = dayjs(reference.getDateWithAdjustedTimezone());
         for (const key in fragments) {
             date = date.add(fragments[key as QUnitType], key as QUnitType);
         }
@@ -221,14 +230,10 @@ export class ParsingComponents implements ParsedComponents {
             components.addTag("result/relativeDateAndTime");
             assignSimilarTime(components, date);
             assignSimilarDate(components, date);
-            if (reference.timezoneOffset !== null) {
-                components.assign("timezoneOffset", -reference.instant.getTimezoneOffset());
-            }
+            components.assign("timezoneOffset", reference.getTimezoneOffset());
         } else {
             implySimilarTime(components, date);
-            if (reference.timezoneOffset !== null) {
-                components.imply("timezoneOffset", -reference.instant.getTimezoneOffset());
-            }
+            components.imply("timezoneOffset", reference.getTimezoneOffset());
 
             if (fragments["d"]) {
                 components.assign("day", date.date());

package/src/utils/dates.ts

@@ -0,0 +1,24 @@
+import { ParsingComponents } from "../results";
+
+/**
+ * Imply (weakly update) the parsing component to the same day as the `target`.
+ * @param component the component to be updated.
+ * @param target the target date with timezone adjusted.
+ */
+export function implySimilarDate(component: ParsingComponents, target: Date) {
+    component.imply("day", target.getDate());
+    component.imply("month", target.getMonth() + 1);
+    component.imply("year", target.getFullYear());
+}
+
+/**
+ * Imply (weakly update) the parsing component to the same time as the `target`.
+ * @param component the component to be updated.
+ * @param target the target date with timezone adjusted.
+ */
+export function implySimilarTime(component: ParsingComponents, target: Date) {
+    component.imply("hour", target.getHours());
+    component.imply("minute", target.getMinutes());
+    component.imply("second", target.getSeconds());
+    component.imply("millisecond", target.getMilliseconds());
+}

package/src/utils/dayjs.ts

@@ -32,12 +32,18 @@ export function assignSimilarTime(component: ParsingComponents, targetDayJs: day
     }
 }
 
+/**
+ * @deprecated Use `dates.implySimilarDate` with normal Javascript Date instead.
+ */
 export function implySimilarDate(component: ParsingComponents, targetDayJs: dayjs.Dayjs) {
     component.imply("day", targetDayJs.date());
     component.imply("month", targetDayJs.month() + 1);
     component.imply("year", targetDayJs.year());
 }
 
+/**
+ * @deprecated Use `dates.implySimilarTime` with normal Javascript Date instead.
+ */
 export function implySimilarTime(component: ParsingComponents, targetDayJs: dayjs.Dayjs) {
     component.imply("hour", targetDayJs.hour());
     component.imply("minute", targetDayJs.minute());

package/test/en/en_casual.test.ts

@@ -28,7 +28,10 @@ test("Test - Single Expression", () => {
         (result) => {
             expect(result.text).toBe("now");
             expect(result.start).toBeDate(new Date(1637674343000));
-            expect(result.start.isCertain("timezoneOffset")).toBe(false);
+
+            // Although the timezone is not specified, we need to assume it is similar to the system default.
+            // We also must allow the timezoneOffset to be overridden. Otherwise, the "now" meaning is incorrect.
+            // expect(result.start.isCertain("timezoneOffset")).toBe(false);
         }
     );
 

package/test/en/en_relative.test.ts

@@ -238,69 +238,156 @@ test("Test - Relative date components' certainty", () => {
     });
 });
 
-test("Test - Relative date components' certainty and imply timezone", () => {
-    const refDate = new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)");
-
+test("Test - Relative date when the timezone is irrelevant", () => {
     {
+        // Sun Nov 29 2020 13:24:13 GMT+0900 (JST)
+        // Sun Nov 29 2020 05:24:13 GMT+0100 (BST)
+        const refInstant = new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)");
+
+        // The "now" is always exactly the same as the reference instant (regardless of the timezone).
         const text = "now";
-        const result = chrono.parse(text, refDate)[0] as ParsingResult;
+        const result = chrono.parse(text, refInstant)[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (JST)"));
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 05:24:13 GMT+0100 (BST)"));
 
-        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"));
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (JST)"));
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 05:24:13 GMT+0100 (BST)"));
     }
-
     {
-        const text = "tomorrow at 5pm";
-        const result = chrono.parse(text, refDate)[0] as ParsingResult;
+        // Sun Nov 29 2020 13:24:13 GMT+0900 (JST)
+        // Sun Nov 29 2020 05:24:13 GMT+0100 (BST)
+        const refInstant = new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)");
 
-        expect(result.text).toBe(text);
-        result.start.imply("timezoneOffset", 60);
+        // Always "10 minutes" from the reference instant (regardless of the target timezone).
+        const text = "in 10 minutes";
+        const result = chrono.parse(text, refInstant)[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 13:34:13 GMT+0900 (JST)"));
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 05:34:13 GMT+0100 (BST)"));
 
-        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"));
+        result.start.imply("timezoneOffset", 60);
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 13:34:13 GMT+0900 (JST)"));
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 05:34:13 GMT+0100 (BST)"));
     }
-
     {
+        // Sun Nov 29 2020 13:24:13 GMT+0900 (JST)
+        // Sun Nov 29 2020 05:24:13 GMT+0100 (BST)
+        const refInstant = new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)");
+
+        // Always "10 minutes" from the reference instant (regardless of the reference timezone).
         const text = "in 10 minutes";
-        const result = chrono.parse(text, refDate)[0] as ParsingResult;
+        {
+            const result = chrono.parse(text, { instant: refInstant, timezone: "BST" })[0] as ParsingResult;
+            expect(result).toBeDate(new Date("Sun Nov 29 2020 13:34:13 GMT+0900 (JST)"));
+            expect(result).toBeDate(new Date("Sun Nov 29 2020 05:34:13 GMT+0100 (BST)"));
+        }
+        {
+            const result = chrono.parse(text, { instant: refInstant, timezone: "JST" })[0] as ParsingResult;
+            expect(result).toBeDate(new Date("Sun Nov 29 2020 13:34:13 GMT+0900 (JST)"));
+            expect(result).toBeDate(new Date("Sun Nov 29 2020 05:34:13 GMT+0100 (BST)"));
+        }
+    }
+    {
+        // Sun Nov 29 2020 13:24:13 GMT+0900 (JST)
+        // Sun Nov 29 2020 05:24:13 GMT+0100 (BST)
+        const refInstant = new Date("Sun Nov 29 2020 13:24:13 GMT+0900 (Japan Standard Time)");
 
-        expect(result.text).toBe(text);
-        result.start.imply("timezoneOffset", 60);
+        const text = "in 20 minutes";
+        const result = chrono.parse(text, { instant: refInstant, timezone: null })[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 13:44:13 GMT+0900 (JST)"));
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 05:44:13 GMT+0100 (BST)"));
 
-        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"));
+        // Although the timezone is not specified, we need to assume it is similar to the system default.
+        // We also must allow the timezoneOffset to be overridden. Otherwise, the relative meaning is incorrect.
+        // expect(result.start.isCertain("timezoneOffset")).toBe(false);
     }
+});
 
+test("Test - Relative date when the timezone is relevant but unknown", () => {
+    // Sun Nov 29 2020 13:24:13 (unknown timezone = system timezone)
+    const refInstant = new Date(2020, 11 - 1, 29, 13, 24, 13, 0);
+
+    // In the same (system) timezone, the "tomorrow" is 'Nov 30 2020'
+    const text = "tomorrow at 5pm";
+    const result = chrono.parse(text, refInstant)[0] as ParsingResult;
+    expect(result).toBeDate(new Date(2020, 11 - 1, 30, 17, 0, 0, 0));
+    expect(result.start.get("month")).toBe(11);
+    expect(result.start.get("day")).toBe(30);
+    expect(result.start.get("hour")).toBe(17);
+});
+
+test("Test - Relative date when the timezone is relevant and known", () => {
+    // Sun Nov 29 2020 13:24:13 GMT+0900 (JST)
+    // Sun Nov 29 2020 05:24:13 GMT+0100 (BST)
+    // 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)");
     {
-        const text = "in 10 minutes";
-        const result = chrono.parse(text, { instant: refDate, timezone: "BST" })[0] as ParsingResult;
+        // In JST (Nov 29 2020 13:24:13 GMT+0900), the "tomorrow" is 'Nov 30 2020'
+        const text = "tomorrow at 5pm";
+        const result = chrono.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);
+        // However, when implying the output timezone to be GMT+0100,
         result.start.imply("timezoneOffset", 60);
-
-        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).toBeDate(new Date("Mon Nov 30 2020 17:00:00 GMT+0100 (BST)"));
     }
-
     {
-        const text = "in 10 minutes";
-        const result = chrono.parse(text, { instant: refDate, timezone: "JST" })[0] as ParsingResult;
+        // In BST (Nov 29 2020 05:24:13 GMT+0100), the "tomorrow" is 'Nov 30 2020'
+        const text = "tomorrow at 5pm";
+        const result = chrono.parse(text, { instant: refInstant, timezone: "BST" })[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Mon Nov 30 2020 17:00:00 GMT+0100 (BST)"));
+        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);
+        // However, when implying the output timezone to be GMT+0900,
+        result.start.imply("timezoneOffset", 540);
+        expect(result).toBeDate(new Date("Mon Nov 30 2020 17:00:00 GMT+0900 (JST)"));
+    }
+    {
+        // In PST (Sat Nov 28 2020 21:24:13 GMT-0700), the "tomorrow" is 'Nov 29 2020'
+        const text = "tomorrow at 5pm";
+        const result = chrono.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"));
+        // However, when implying the output timezone to be GMT+0900,
+        result.start.imply("timezoneOffset", 540);
+        expect(result).toBeDate(new Date("Sun Nov 29 2020 17:00:00 GMT+0900 (JST)"));
     }
+});
 
+test("Test - Relative date when the timezone is relevant and known (2nd scenario)", () => {
+    // Thu Feb 27 2025 17:00:00 GMT+0000
+    // Thu Feb 27 2025 09:00:00 GMT-0800 (PST)
+    const refInstant = new Date("2025-02-27T17:00:00.000Z");
     {
-        const text = "in 20 minutes";
-        const result = chrono.parse(text, { instant: refDate, timezone: null })[0] as ParsingResult;
-
-        expect(result.text).toBe(text);
-        expect(result.start.isCertain("timezoneOffset")).toBe(false);
+        const text = "tomorrow at 9am";
+        const result = chrono.parse(text, { instant: refInstant, timezone: "PST" })[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Fri Feb 28 2025 09:00:00 GMT-0800 (PST)"));
+        expect(result).toBeDate(new Date("2025-02-28T17:00:00.000Z"));
+    }
+    {
+        const text = "in 2 weeks at 9am";
+        const result = chrono.parse(text, { instant: refInstant, timezone: "PST" })[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Thu Mar 13 2025 09:00:00 GMT-0800 (PST)"));
+        expect(result).toBeDate(new Date("2025-03-13T17:00:00.000Z"));
+    }
+    {
+        const text = "2 weeks ago at 9am";
+        const result = chrono.parse(text, { instant: refInstant, timezone: "PST" })[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Thu Feb 13 2025 09:00:00 GMT-0800 (PST)"));
+        expect(result).toBeDate(new Date("2025-02-13T17:00:00.000Z"));
+    }
+    {
+        const text = "next friday at 9am";
+        const result = chrono.parse(text, { instant: refInstant, timezone: "PST" })[0] as ParsingResult;
+        expect(result).toBeDate(new Date("Fri Mar 07 2025 09:00:00 GMT-0800 (PST)"));
+        expect(result).toBeDate(new Date("2025-03-07T17:00:00.000Z"));
     }
 });

package/test/en/en_time_exp.test.ts

@@ -456,24 +456,13 @@ test("Test - Parsing negative cases : 'at [some numbers] - [some numbers]' (Stri
     testUnexpectedResult(chrono.strict, "7-730");
 });
 
-test("Test - forward dates only option", function () {
-    testSingleCase(
-        chrono,
-        "1am",
-        {
-            instant: new Date("Wed May 26 2022 01:57:00 GMT-0500 (CDT)"),
-            timezone: "CDT",
-        },
-        {
-            forwardDate: true,
-        },
-        (result) => {
-            expect(result.start.get("year")).toBe(2022);
-            expect(result.start.get("month")).toBe(5);
-            expect(result.start.get("day")).toBe(27);
-            expect(result.start.get("hour")).toBe(1);
-        }
-    );
+test("Test - Forward time calculation 'forwardDate' flag", () => {
+    testSingleCase(chrono, "1am", new Date(2022, 5 - 1, 26, 1, 57), { forwardDate: true }, (result) => {
+        expect(result.start.get("year")).toBe(2022);
+        expect(result.start.get("month")).toBe(5);
+        expect(result.start.get("day")).toBe(27);
+        expect(result.start.get("hour")).toBe(1);
+    });
 
     testSingleCase(chrono, "11am", new Date(2016, 10 - 1, 1, 12), { forwardDate: true }, (result) => {
         expect(result.start.get("year")).toBe(2016);
@@ -508,3 +497,23 @@ test("Test - forward dates only option", function () {
         expect(result.end.get("hour")).toBe(12);
     });
 });
+
+test("Test - Test - Forward time calculation 'forwardDate' flag in different timezones", () => {
+    testSingleCase(
+        chrono,
+        "1am",
+        {
+            instant: new Date("Wed May 26 2022 01:57:00 GMT-0500 (CDT)"),
+            timezone: "CDT",
+        },
+        {
+            forwardDate: true,
+        },
+        (result) => {
+            expect(result.start.get("year")).toBe(2022);
+            expect(result.start.get("month")).toBe(5);
+            expect(result.start.get("day")).toBe(27);
+            expect(result.start.get("hour")).toBe(1);
+        }
+    );
+});

package/test/ja/ja_casual.test.ts

@@ -10,6 +10,14 @@ test("Test - Single Expression", function () {
         expect(result.text).toBe("きょう");
         expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 12));
     });
+    testSingleCase(chrono.ja, "本日はお日柄もよく", new Date(2012, 8 - 1, 10, 12), (result) => {
+        expect(result.text).toBe("本日");
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 12));
+    });
+    testSingleCase(chrono.ja, "ほんじつはお日柄もよく", new Date(2012, 8 - 1, 10, 12), (result) => {
+        expect(result.text).toBe("ほんじつ");
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 12));
+    });
 
     testSingleCase(chrono.ja, "昨日の全国観測値ランキング", new Date(2012, 8 - 1, 10, 12), (result) => {
         expect(result.text).toBe("昨日");

package/test/ja/ja_standard.test.ts

@@ -213,4 +213,23 @@ test("Test - Range Expression", function () {
 
         expect(result.end).toBeDate(new Date(2014, 1 - 1, 7, 12));
     });
+
+    testSingleCase(chrono.ja, "2013年12月26日 ～ ２０１４年１月７日", new Date(2012, 8 - 1, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("2013年12月26日 ～ ２０１４年１月７日");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2013);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.start.get("day")).toBe(26);
+
+        expect(result.start).toBeDate(new Date(2013, 12 - 1, 26, 12));
+
+        expect(result.end).not.toBeNull();
+        expect(result.end.get("year")).toBe(2014);
+        expect(result.end.get("month")).toBe(1);
+        expect(result.end.get("day")).toBe(7);
+
+        expect(result.end).toBeDate(new Date(2014, 1 - 1, 7, 12));
+    });
 });

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_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);