chrono-node 2.8.4 → 2.9.0

package/src/results.ts

@@ -1,11 +1,8 @@
 import { Component, ParsedComponents, ParsedResult, ParsingReference, TimezoneAbbrMap } from "./types";
 
-import quarterOfYear from "dayjs/plugin/quarterOfYear";
-import dayjs, { QUnitType } from "dayjs";
 import { assignSimilarDate, assignSimilarTime, implySimilarTime } from "./utils/dates";
 import { toTimezoneOffset } from "./timezone";
-import { addDuration, Duration } from "./calculation/duration";
-dayjs.extend(quarterOfYear);
+import { addDuration, Duration, EmptyDuration } from "./calculation/duration";
 
 export class ReferenceWithTimezone {
     readonly instant: Date;
@@ -79,16 +76,62 @@ export class ParsingComponents implements ParsedComponents {
             }
         }
 
-        const refDayJs = reference.getDateWithAdjustedTimezone();
-        this.imply("day", refDayJs.getDate());
-        this.imply("month", refDayJs.getMonth() + 1);
-        this.imply("year", refDayJs.getFullYear());
+        const date = reference.getDateWithAdjustedTimezone();
+        this.imply("day", date.getDate());
+        this.imply("month", date.getMonth() + 1);
+        this.imply("year", date.getFullYear());
         this.imply("hour", 12);
         this.imply("minute", 0);
         this.imply("second", 0);
         this.imply("millisecond", 0);
     }
 
+    static createRelativeFromReference(
+        reference: ReferenceWithTimezone,
+        duration: Duration = EmptyDuration
+    ): ParsingComponents {
+        let date = addDuration(reference.getDateWithAdjustedTimezone(), duration);
+
+        const components = new ParsingComponents(reference);
+        components.addTag("result/relativeDate");
+        if ("hour" in duration || "minute" in duration || "second" in duration || "millisecond" in duration) {
+            components.addTag("result/relativeDateAndTime");
+            assignSimilarTime(components, date);
+            assignSimilarDate(components, date);
+            components.assign("timezoneOffset", reference.getTimezoneOffset());
+        } else {
+            implySimilarTime(components, date);
+            components.imply("timezoneOffset", reference.getTimezoneOffset());
+
+            if ("day" in duration) {
+                components.assign("day", date.getDate());
+                components.assign("month", date.getMonth() + 1);
+                components.assign("year", date.getFullYear());
+                components.assign("weekday", date.getDay());
+            } else if ("week" in duration) {
+                components.assign("day", date.getDate());
+                components.assign("month", date.getMonth() + 1);
+                components.assign("year", date.getFullYear());
+                components.imply("weekday", date.getDay());
+            } else {
+                components.imply("day", date.getDate());
+                if ("month" in duration) {
+                    components.assign("month", date.getMonth() + 1);
+                    components.assign("year", date.getFullYear());
+                } else {
+                    components.imply("month", date.getMonth() + 1);
+                    if ("year" in duration) {
+                        components.assign("year", date.getFullYear());
+                    } else {
+                        components.imply("year", date.getFullYear());
+                    }
+                }
+            }
+        }
+
+        return components;
+    }
+
     get(component: Component): number | null {
         if (component in this.knownValues) {
             return this.knownValues[component];
@@ -123,9 +166,37 @@ export class ParsingComponents implements ParsedComponents {
         return this;
     }
 
-    delete(component: Component) {
-        delete this.knownValues[component];
-        delete this.impliedValues[component];
+    /**
+     * Add the `duration` into this component, mark the modified date and/or time as implied.
+     * @param duration
+     */
+    addDurationAsImplied(duration: Duration): ParsingComponents {
+        const currentDate = this.dateWithoutTimezoneAdjustment();
+        const date = addDuration(currentDate, duration);
+        if ("day" in duration || "week" in duration || "month" in duration || "year" in duration) {
+            this.delete(["day", "weekday", "month", "year"]);
+            this.imply("day", date.getDate());
+            this.imply("weekday", date.getDay());
+            this.imply("month", date.getMonth() + 1);
+            this.imply("year", date.getFullYear());
+        }
+        if ("second" in duration || "minute" in duration || "hour" in duration) {
+            this.delete(["second", "minute", "hour"]);
+            this.imply("second", date.getSeconds());
+            this.imply("minute", date.getMinutes());
+            this.imply("hour", date.getHours());
+        }
+        return this;
+    }
+
+    delete(components: Component | Component[]) {
+        if (typeof components === "string") {
+            components = [components];
+        }
+        for (const component of components) {
+            delete this.knownValues[component];
+            delete this.impliedValues[component];
+        }
     }
 
     clone(): ParsingComponents {
@@ -182,10 +253,6 @@ export class ParsingComponents implements ParsedComponents {
             reference: ${JSON.stringify(this.reference)}]`;
     }
 
-    dayjs() {
-        return dayjs(this.dateWithoutTimezoneAdjustment());
-    }
-
     date(): Date {
         const date = this.dateWithoutTimezoneAdjustment();
         const timezoneAdjustment = this.reference.getSystemTimezoneAdjustmentMinute(date, this.get("timezoneOffset"));
@@ -222,49 +289,6 @@ export class ParsingComponents implements ParsedComponents {
         date.setFullYear(this.get("year"));
         return date;
     }
-
-    static createRelativeFromReference(reference: ReferenceWithTimezone, duration: Duration): ParsingComponents {
-        let date = addDuration(reference.getDateWithAdjustedTimezone(), duration);
-
-        const components = new ParsingComponents(reference);
-        components.addTag("result/relativeDate");
-        if (duration["hour"] || duration["minute"] || duration["second"]) {
-            components.addTag("result/relativeDateAndTime");
-            assignSimilarTime(components, date);
-            assignSimilarDate(components, date);
-            components.assign("timezoneOffset", reference.getTimezoneOffset());
-        } else {
-            implySimilarTime(components, date);
-            components.imply("timezoneOffset", reference.getTimezoneOffset());
-
-            if (duration["day"]) {
-                components.assign("day", date.getDate());
-                components.assign("month", date.getMonth() + 1);
-                components.assign("year", date.getFullYear());
-                components.assign("weekday", date.getDay());
-            } else if (duration["week"]) {
-                components.assign("day", date.getDate());
-                components.assign("month", date.getMonth() + 1);
-                components.assign("year", date.getFullYear());
-                components.imply("weekday", date.getDay());
-            } else {
-                components.imply("day", date.getDate());
-                if (duration["month"]) {
-                    components.assign("month", date.getMonth() + 1);
-                    components.assign("year", date.getFullYear());
-                } else {
-                    components.imply("month", date.getMonth() + 1);
-                    if (duration["year"]) {
-                        components.assign("year", date.getFullYear());
-                    } else {
-                        components.imply("year", date.getFullYear());
-                    }
-                }
-            }
-        }
-
-        return components;
-    }
 }
 
 export class ParsingResult implements ParsedResult {

package/src/timezone.ts

@@ -1,4 +1,3 @@
-import dayjs from "dayjs";
 import { TimezoneAbbrMap, Weekday, Month } from "./types";
 
 export const TIMEZONE_ABBR_MAP: TimezoneAbbrMap = {
@@ -310,10 +309,7 @@ export function toTimezoneOffset(
     }
 
     // Return DST offset if the refDate is during daylight savings
-    if (
-        dayjs(date).isAfter(matchedTimezone.dstStart(date.getFullYear())) &&
-        !dayjs(date).isAfter(matchedTimezone.dstEnd(date.getFullYear()))
-    ) {
+    if (date > matchedTimezone.dstStart(date.getFullYear()) && !(date > matchedTimezone.dstEnd(date.getFullYear()))) {
         return matchedTimezone.timezoneOffsetDuringDst;
     }
 

package/src/types.ts

@@ -129,7 +129,7 @@ export type Component =
     | "meridiem"
     | "timezoneOffset";
 
-export type Timeunit = "year" | "month" | "week" | "day" | "hour" | "minute" | "second" | "millisecond";
+export type Timeunit = "year" | "month" | "week" | "day" | "hour" | "minute" | "second" | "millisecond" | "quarter";
 
 export enum Meridiem {
     AM = 0,

package/test/calculation_weekdays.test.ts

@@ -114,3 +114,20 @@ test("Test - Closest Weekday Calculation", () => {
         expect(getDaysToWeekday(refDate, Weekday.WEDNESDAY)).toBe(-3);
     }
 });
+
+test("Test - Weekdays calculation with timezone", () => {
+    // Thu Feb 27 2025 17:00:00 GMT+0000
+    // Thu Feb 27 2025 09:00:00 GMT-0800 (PST)
+    // Fri Feb 28 2025 02:00:00 GMT+0900 (JST)
+    const refInstant = new Date("2025-02-27T17:00:00.000Z");
+    {
+        const reference = ReferenceWithTimezone.fromInput({ instant: refInstant, timezone: "JST" });
+        const output = createParsingComponentsAtWeekday(reference, Weekday.FRIDAY, "this");
+        expect(output.date()).toStrictEqual(new Date("Fri Feb 28 2025 12:00:00 GMT+0900 (JST)"));
+    }
+    {
+        const reference = ReferenceWithTimezone.fromInput({ instant: refInstant, timezone: "PST" });
+        const output = createParsingComponentsAtWeekday(reference, Weekday.FRIDAY, "this");
+        expect(output.date()).toStrictEqual(new Date("Fri Feb 28 2025 12:00:00 GMT-0800 (PST)"));
+    }
+});

package/test/en/en_time_exp.test.ts

@@ -432,6 +432,8 @@ test("Test - Parsing negative cases : [year-like] pattern", function () {
     testUnexpectedResult(chrono, "2020");
 
     testUnexpectedResult(chrono, "2020  ");
+
+    testUnexpectedResult(chrono, "2019 to 2020");
 });
 
 test("Test - Parsing negative cases : 'at [some numbers]'", function () {

package/test/it/it_casual.test.ts

@@ -0,0 +1,44 @@
+import * as chrono from "../../src/";
+import { testSingleCase } from "../test_util";
+
+test("Test - Single Expression", () => {
+    testSingleCase(chrono.it.casual, "La scadenza è ora", new Date(2012, 7, 10, 8, 9, 10, 11), (result) => {
+        expect(result.index).toBe(14);
+        expect(result.text).toBe("ora");
+
+        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);
+        expect(result.start.get("minute")).toBe(9);
+        expect(result.start.get("second")).toBe(10);
+        expect(result.start.get("millisecond")).toBe(11);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 8, 9, 10, 11));
+    });
+
+    testSingleCase(chrono.it.casual, "La scadenza è oggi", new Date(2012, 7, 10, 14, 12), (result) => {
+        expect(result.index).toBe(14);
+        expect(result.text).toBe("oggi");
+
+        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).toBeDate(new Date(2012, 7, 10, 14, 12));
+    });
+
+    testSingleCase(chrono.it.casual, "La scadenza è domani", new Date(2012, 7, 10, 17, 10), (result) => {
+        expect(result.index).toBe(14);
+        expect(result.text).toBe("domani");
+
+        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(11);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 11, 17, 10));
+    });
+});

package/test/it/it_month_name_little_endian.test.ts

@@ -0,0 +1,28 @@
+import * as chrono from "../../src/";
+import { testSingleCase, testUnexpectedResult } from "../test_util";
+
+test("Test - Single expression", () => {
+    testSingleCase(chrono.it, "10 Agosto 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("10 Agosto 2012");
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 12));
+    });
+
+    testSingleCase(chrono.it, "La scadenza è il 10 Agosto", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(17);
+        expect(result.text).toBe("10 Agosto");
+
+        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).toBeDate(new Date(2012, 8 - 1, 10, 12));
+    });
+});

package/test/it/it_weekday.test.ts

@@ -0,0 +1,37 @@
+import * as chrono from "../../src/";
+import { testSingleCase } from "../test_util";
+
+test("Test - Single Expression", function () {
+    testSingleCase(chrono.it, "Lunedì", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Lunedì");
+
+        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.it, "Giovedì", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Giovedì");
+
+        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(9);
+        expect(result.start.get("weekday")).toBe(4);
+    });
+
+    testSingleCase(chrono.it, "Domenica", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Domenica");
+
+        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(12);
+        expect(result.start.get("weekday")).toBe(0);
+    });
+});

package/test/ja/ja_time_exp.test.ts

@@ -1,5 +1,6 @@
 import * as chrono from "../../src";
-import { testSingleCase } from "../test_util";
+import { testSingleCase, testUnexpectedResult } from "../test_util";
+import { Meridiem } from "../../src";
 
 test("Test - Single Expression", function () {
     testSingleCase(chrono.ja, "私は午前6時13分に起きた", new Date(2012, 7, 10), (result) => {
@@ -165,28 +166,34 @@ test("Test - Date + Time Expression", function () {
 });
 
 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時");
+    testSingleCase(chrono.ja, "午後1時30分から3時10分", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("hour")).toBe(13);
+        expect(result.start.get("minute")).toBe(30);
+        expect(result.start.get("second")).toBe(0);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
+        expect(result.start.isCertain("meridiem")).toBe(true);
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 13, 30));
 
-        expect(result.start.get("year")).toBe(2012);
-        expect(result.start.get("month")).toBe(8);
-        expect(result.start.get("day")).toBe(10);
+        expect(result.end.get("hour")).toBe(15);
+        expect(result.end.get("minute")).toBe(10);
+        expect(result.end.get("second")).toBe(0);
+        expect(result.end.get("meridiem")).toBe(Meridiem.PM);
+        expect(result.end).toBeDate(new Date(2012, 8 - 1, 10, 15, 10));
+    });
+
+    testSingleCase(chrono.ja, "1時20分P.M.から3時", new Date(2012, 7, 10), (result) => {
         expect(result.start.get("hour")).toBe(13);
-        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("minute")).toBe(20);
         expect(result.start.get("second")).toBe(0);
-        expect(result.start.get("millisecond")).toBe(0);
-        expect(result.start.get("meridiem")).toBe(1);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
         expect(result.start.isCertain("meridiem")).toBe(true);
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 13, 20));
 
-        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);
+        expect(result.end.get("meridiem")).toBe(Meridiem.PM);
+        expect(result.end).toBeDate(new Date(2012, 8 - 1, 10, 15, 0));
     });
 
     testSingleCase(chrono.ja, "午後６時半－１１時", new Date(2012, 7, 10), (result) => {
@@ -196,16 +203,44 @@ test("Test - Time Expression's Meridiem imply", function () {
         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.start.get("meridiem")).toBe(Meridiem.PM);
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 18, 30));
 
         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);
+        expect(result.end.get("meridiem")).toBe(Meridiem.PM);
+        expect(result.end).toBeDate(new Date(2012, 8 - 1, 10, 23, 0));
+    });
+
+    testSingleCase(chrono.ja, "午後１１時半－１時", new Date(2012, 8 - 1, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("午後１１時半－１時");
+
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("minute")).toBe(30);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 23, 30));
+
+        expect(result.end.get("hour")).toBe(1);
+        expect(result.end.get("minute")).toBe(0);
+        expect(result.end.get("meridiem")).toBe(Meridiem.AM);
+        expect(result.end).toBeDate(new Date(2012, 8 - 1, 11, 1, 0));
+    });
+
+    testSingleCase(chrono.ja, "23時20分から2時", new Date(2012, 8 - 1, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("23時20分から2時");
+
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("minute")).toBe(20);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 23, 20));
+
+        expect(result.end.get("hour")).toBe(2);
+        expect(result.end.get("minute")).toBe(0);
+        expect(result.end.get("meridiem")).toBe(Meridiem.AM);
+        expect(result.end).toBeDate(new Date(2012, 8 - 1, 11, 2, 0));
     });
 });
 
@@ -242,3 +277,29 @@ test("Test - Random date + time expression", function () {
         expect(result.start.get("hour")).toBe(12);
     });
 });
+
+test("Test - Incorrect time expressions", () => {
+    testUnexpectedResult(chrono.ja, "午後１3時");
+
+    testUnexpectedResult(chrono.ja, "25時");
+
+    testUnexpectedResult(chrono.ja, "5時70分");
+
+    testUnexpectedResult(chrono.ja, "5時30分65秒");
+
+    testUnexpectedResult(chrono.ja, "23時-25時");
+
+    testUnexpectedResult(chrono.ja, "3時-5時70分");
+
+    testUnexpectedResult(chrono.ja, "3時-5時30分65秒");
+});
+
+test("Test - Non time expressions", () => {
+    testUnexpectedResult(chrono.ja, "1");
+    testUnexpectedResult(chrono.ja, "12");
+    testUnexpectedResult(chrono.ja, "12a");
+
+    testUnexpectedResult(chrono.ja, "1時間");
+
+    testUnexpectedResult(chrono.ja, "25時間");
+});

package/test/result.test.ts

@@ -38,6 +38,30 @@ test("Test - Create & manipulate parsing components", () => {
     expect(components.toString()).toContain("custom/testing_component_tag");
 });
 
+test("Test - Creating component from reference date (and duration)", () => {
+    {
+        const reference = ReferenceWithTimezone.fromDate(new Date("Sat, Aug 27 2022 12:52:11"));
+        const components = ParsingComponents.createRelativeFromReference(reference);
+        expect(components.date()).toStrictEqual(new Date("Sat, Aug 27 2022 12:52:11"));
+        expect(components.isCertain("day")).toBe(true);
+        expect(components.isCertain("hour")).toBe(true);
+    }
+    {
+        const reference = ReferenceWithTimezone.fromDate(new Date("Sat, Aug 27 2022 12:52:11"));
+        const components = ParsingComponents.createRelativeFromReference(reference, { day: 3 });
+        expect(components.date()).toStrictEqual(new Date("Sat, Aug 30 2022 12:52:11"));
+        expect(components.isCertain("day")).toBe(true);
+        expect(components.isCertain("hour")).toBe(false);
+    }
+    {
+        const reference = ReferenceWithTimezone.fromDate(new Date("Sat, Aug 27 2022 12:52:11"));
+        const components = ParsingComponents.createRelativeFromReference(reference, { day: 1, hour: 3 });
+        expect(components.date()).toStrictEqual(new Date("Sat, Aug 28 2022 15:52:11"));
+        expect(components.isCertain("day")).toBe(true);
+        expect(components.isCertain("hour")).toBe(true);
+    }
+});
+
 test("Test - Create & manipulate parsing results", () => {
     const reference = new ReferenceWithTimezone(new Date());
     const text = "1 - 2 hour later";
@@ -199,3 +223,53 @@ test("Test - Getting timezone adjust date from references", () => {
         expect(reference.getDateWithAdjustedTimezone()).toStrictEqual(new Date(2021, 6 - 1, 9, 7, 21, 32));
     }
 });
+
+test("Test - ParsingComponents.addDurationAsImplied", () => {
+    {
+        const reference = ReferenceWithTimezone.fromDate(new Date("Sat, Aug 27 2022 12:52:11"));
+        const components = ParsingComponents.createRelativeFromReference(reference);
+        components.addDurationAsImplied({ hour: 3 });
+
+        expect(components.date()).toStrictEqual(new Date("Sat, Aug 27 2022 15:52:11"));
+        expect(components.isCertain("second")).toBe(false);
+        expect(components.isCertain("minute")).toBe(false);
+        expect(components.isCertain("hour")).toBe(false);
+    }
+    {
+        const reference = ReferenceWithTimezone.fromDate(new Date("Sat, Aug 27 2022 12:52:11"));
+        const components = ParsingComponents.createRelativeFromReference(reference);
+        components.addDurationAsImplied({ day: 3 });
+        expect(components.date()).toStrictEqual(new Date("Sat, Aug 30 2022 12:52:11"));
+        expect(components.isCertain("day")).toBe(false);
+        expect(components.isCertain("weekday")).toBe(false);
+        expect(components.isCertain("month")).toBe(false);
+        expect(components.isCertain("year")).toBe(false);
+    }
+});
+
+test("Test - ParsingComponents.addDurationAsImplied on different timezones", () => {
+    {
+        // Thu Feb 27 2025 17:00:00 GMT+0000
+        // Fri Feb 28 2025 02:00:00 GMT+0900 (JST)
+        const refInstant = new Date("Thu Feb 27 2025 17:00:00 GMT+0000");
+        const reference = ReferenceWithTimezone.fromInput({ instant: refInstant, timezone: "JST" });
+        const components = ParsingComponents.createRelativeFromReference(reference);
+        components.addDurationAsImplied({ hour: 3 });
+        expect(components.date()).toStrictEqual(new Date("Fri Feb 28 2025 05:00:00 GMT+0900 (JST)"));
+
+        components.addDurationAsImplied({ day: 3 });
+        expect(components.date()).toStrictEqual(new Date("Mon Mar 3 2025 05:00:00 GMT+0900 (JST)"));
+    }
+    {
+        // Thu Feb 27 2025 17:00:00 GMT+0000
+        // Thu Feb 27 2025 09:00:00 GMT-0800 (PST)
+        const refInstant = new Date("Thu Feb 27 2025 17:00:00 GMT+0000");
+        const reference = ReferenceWithTimezone.fromInput({ instant: refInstant, timezone: "PST" });
+        const components = ParsingComponents.createRelativeFromReference(reference);
+        components.addDurationAsImplied({ hour: 3 });
+        expect(components.date()).toStrictEqual(new Date("Thu Feb 27 2025 12:00:00 GMT-0800 (PST)"));
+
+        components.addDurationAsImplied({ day: 3 });
+        expect(components.date()).toStrictEqual(new Date("Mon Mar 2 2025 12:00:00 GMT-0800 (PST)"));
+    }
+});

package/test/sv/sv_casual.test.ts

@@ -35,6 +35,48 @@ test("Test - Combined Expression", function () {
         expect(result.start.get("hour")).toBe(6);
     });
 
+    testSingleCase(chrono, "idag på förmiddagen", new Date(2012, 7, 10), (result) => {
+        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(9);
+    });
+
+    testSingleCase(chrono, "idag på middagen", new Date(2012, 7, 10), (result) => {
+        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(12);
+    });
+
+    testSingleCase(chrono, "idag på eftermiddagen", new Date(2012, 7, 10), (result) => {
+        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(15);
+    });
+
+    testSingleCase(chrono, "idag på kvällen", new Date(2012, 7, 10), (result) => {
+        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);
+    });
+
+    testSingleCase(chrono, "idag på natten", new Date(2012, 7, 10), (result) => {
+        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(2);
+    });
+
+    testSingleCase(chrono, "idag vid midnatt", new Date(2012, 7, 10), (result) => {
+        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(0);
+    });
+
     // Denna funktionalitet behöver ytterligare utveckling
     // testSingleCase(chrono, "imorgon kväll", new Date(2012, 7, 10), (result) => {
     //     expect(result.start.get("year")).toBe(2012);