chrono-node 2.8.3 → 2.8.5

package/src/locales/zh/hant/parsers/ZHHantTimeExpressionParser.ts

@@ -1,4 +1,3 @@
-import dayjs from "dayjs";
 import { ParsingContext } from "../../../../chrono";
 import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
 import { NUMBER, zhStringToNumber } from "../constants";
@@ -74,54 +73,53 @@ export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBo
             return null;
         }
 
-        const refMoment = dayjs(context.refDate);
         const result = context.createParsingResult(match.index, match[0]);
-        let startMoment = refMoment.clone();
+        const startMoment = new Date(context.refDate.getTime());
 
         // ----- Day
         if (match[DAY_GROUP_1]) {
-            var day1 = match[DAY_GROUP_1];
+            const day1 = match[DAY_GROUP_1];
             if (day1 == "明" || day1 == "聽") {
                 // Check not "Tomorrow" on late night
-                if (refMoment.hour() > 1) {
-                    startMoment = startMoment.add(1, "day");
+                if (context.refDate.getHours() > 1) {
+                    startMoment.setDate(startMoment.getDate() + 1);
                 }
             } else if (day1 == "昨" || day1 == "尋" || day1 == "琴") {
-                startMoment = startMoment.add(-1, "day");
+                startMoment.setDate(startMoment.getDate() - 1);
             } else if (day1 == "前") {
-                startMoment = startMoment.add(-2, "day");
+                startMoment.setDate(startMoment.getDate() - 2);
             } else if (day1 == "大前") {
-                startMoment = startMoment.add(-3, "day");
+                startMoment.setDate(startMoment.getDate() - 3);
             } else if (day1 == "後") {
-                startMoment = startMoment.add(2, "day");
+                startMoment.setDate(startMoment.getDate() + 2);
             } else if (day1 == "大後") {
-                startMoment = startMoment.add(3, "day");
+                startMoment.setDate(startMoment.getDate() + 3);
             }
-            result.start.assign("day", startMoment.date());
-            result.start.assign("month", startMoment.month() + 1);
-            result.start.assign("year", startMoment.year());
+            result.start.assign("day", startMoment.getDate());
+            result.start.assign("month", startMoment.getMonth() + 1);
+            result.start.assign("year", startMoment.getFullYear());
         } else if (match[DAY_GROUP_3]) {
-            var day3 = match[DAY_GROUP_3];
+            const day3 = match[DAY_GROUP_3];
             if (day3 == "明" || day3 == "聽") {
-                startMoment = startMoment.add(1, "day");
+                startMoment.setDate(startMoment.getDate() + 1);
             } else if (day3 == "昨" || day3 == "尋" || day3 == "琴") {
-                startMoment = startMoment.add(-1, "day");
+                startMoment.setDate(startMoment.getDate() - 1);
             } else if (day3 == "前") {
-                startMoment = startMoment.add(-2, "day");
+                startMoment.setDate(startMoment.getDate() - 2);
             } else if (day3 == "大前") {
-                startMoment = startMoment.add(-3, "day");
+                startMoment.setDate(startMoment.getDate() - 3);
             } else if (day3 == "後") {
-                startMoment = startMoment.add(2, "day");
+                startMoment.setDate(startMoment.getDate() + 2);
             } else if (day3 == "大後") {
-                startMoment = startMoment.add(3, "day");
+                startMoment.setDate(startMoment.getDate() + 3);
             }
-            result.start.assign("day", startMoment.date());
-            result.start.assign("month", startMoment.month() + 1);
-            result.start.assign("year", startMoment.year());
+            result.start.assign("day", startMoment.getDate());
+            result.start.assign("month", startMoment.getMonth() + 1);
+            result.start.assign("year", startMoment.getFullYear());
         } else {
-            result.start.imply("day", startMoment.date());
-            result.start.imply("month", startMoment.month() + 1);
-            result.start.imply("year", startMoment.year());
+            result.start.imply("day", startMoment.getDate());
+            result.start.imply("month", startMoment.getMonth() + 1);
+            result.start.imply("year", startMoment.getFullYear());
         }
 
         let hour = 0;
@@ -233,8 +231,8 @@ export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBo
         //                  Extracting the 'to' chunk
         // ==============================================================
 
-        match = SECOND_REG_PATTERN.exec(context.text.substring(result.index + result.text.length));
-        if (!match) {
+        const secondMatch = SECOND_REG_PATTERN.exec(context.text.substring(result.index + result.text.length));
+        if (!secondMatch) {
             // Not accept number only result
             if (result.text.match(/^\d+$/)) {
                 return null;
@@ -242,53 +240,53 @@ export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBo
             return result;
         }
 
-        let endMoment = startMoment.clone();
+        const endMoment = new Date(startMoment.getTime());
         result.end = context.createParsingComponents();
 
         // ----- Day
-        if (match[DAY_GROUP_1]) {
-            var day1 = match[DAY_GROUP_1];
+        if (secondMatch[DAY_GROUP_1]) {
+            const day1 = secondMatch[DAY_GROUP_1];
             if (day1 == "明" || day1 == "聽") {
                 // Check not "Tomorrow" on late night
-                if (refMoment.hour() > 1) {
-                    endMoment = endMoment.add(1, "day");
+                if (context.refDate.getHours() > 1) {
+                    endMoment.setDate(endMoment.getDate() + 1);
                 }
             } else if (day1 == "昨" || day1 == "尋" || day1 == "琴") {
-                endMoment = endMoment.add(-1, "day");
+                endMoment.setDate(endMoment.getDate() - 1);
             } else if (day1 == "前") {
-                endMoment = endMoment.add(-2, "day");
+                endMoment.setDate(endMoment.getDate() - 2);
             } else if (day1 == "大前") {
-                endMoment = endMoment.add(-3, "day");
+                endMoment.setDate(endMoment.getDate() - 3);
             } else if (day1 == "後") {
-                endMoment = endMoment.add(2, "day");
+                endMoment.setDate(endMoment.getDate() + 2);
             } else if (day1 == "大後") {
-                endMoment = endMoment.add(3, "day");
+                endMoment.setDate(endMoment.getDate() + 3);
             }
-            result.end.assign("day", endMoment.date());
-            result.end.assign("month", endMoment.month() + 1);
-            result.end.assign("year", endMoment.year());
-        } else if (match[DAY_GROUP_3]) {
-            var day3 = match[DAY_GROUP_3];
+            result.end.assign("day", endMoment.getDate());
+            result.end.assign("month", endMoment.getMonth() + 1);
+            result.end.assign("year", endMoment.getFullYear());
+        } else if (secondMatch[DAY_GROUP_3]) {
+            const day3 = secondMatch[DAY_GROUP_3];
             if (day3 == "明" || day3 == "聽") {
-                endMoment = endMoment.add(1, "day");
+                endMoment.setDate(endMoment.getDate() + 1);
             } else if (day3 == "昨" || day3 == "尋" || day3 == "琴") {
-                endMoment = endMoment.add(-1, "day");
+                endMoment.setDate(endMoment.getDate() - 1);
             } else if (day3 == "前") {
-                endMoment = endMoment.add(-2, "day");
+                endMoment.setDate(endMoment.getDate() - 2);
             } else if (day3 == "大前") {
-                endMoment = endMoment.add(-3, "day");
+                endMoment.setDate(endMoment.getDate() - 3);
             } else if (day3 == "後") {
-                endMoment = endMoment.add(2, "day");
+                endMoment.setDate(endMoment.getDate() + 2);
             } else if (day3 == "大後") {
-                endMoment = endMoment.add(3, "day");
+                endMoment.setDate(endMoment.getDate() + 3);
             }
-            result.end.assign("day", endMoment.date());
-            result.end.assign("month", endMoment.month() + 1);
-            result.end.assign("year", endMoment.year());
+            result.end.assign("day", endMoment.getDate());
+            result.end.assign("month", endMoment.getMonth() + 1);
+            result.end.assign("year", endMoment.getFullYear());
         } else {
-            result.end.imply("day", endMoment.date());
-            result.end.imply("month", endMoment.month() + 1);
-            result.end.imply("year", endMoment.year());
+            result.end.imply("day", endMoment.getDate());
+            result.end.imply("month", endMoment.getMonth() + 1);
+            result.end.imply("year", endMoment.getFullYear());
         }
 
         hour = 0;
@@ -296,31 +294,31 @@ export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBo
         meridiem = -1;
 
         // ----- Second
-        if (match[SECOND_GROUP]) {
-            var second = parseInt(match[SECOND_GROUP]);
+        if (secondMatch[SECOND_GROUP]) {
+            let second = parseInt(secondMatch[SECOND_GROUP]);
             if (isNaN(second)) {
-                second = zhStringToNumber(match[SECOND_GROUP]);
+                second = zhStringToNumber(secondMatch[SECOND_GROUP]);
             }
 
             if (second >= 60) return null;
             result.end.assign("second", second);
         }
 
-        hour = parseInt(match[HOUR_GROUP]);
+        hour = parseInt(secondMatch[HOUR_GROUP]);
         if (isNaN(hour)) {
-            hour = zhStringToNumber(match[HOUR_GROUP]);
+            hour = zhStringToNumber(secondMatch[HOUR_GROUP]);
         }
 
         // ----- Minutes
-        if (match[MINUTE_GROUP]) {
-            if (match[MINUTE_GROUP] == "半") {
+        if (secondMatch[MINUTE_GROUP]) {
+            if (secondMatch[MINUTE_GROUP] == "半") {
                 minute = 30;
-            } else if (match[MINUTE_GROUP] == "正" || match[MINUTE_GROUP] == "整") {
+            } else if (secondMatch[MINUTE_GROUP] == "正" || secondMatch[MINUTE_GROUP] == "整") {
                 minute = 0;
             } else {
-                minute = parseInt(match[MINUTE_GROUP]);
+                minute = parseInt(secondMatch[MINUTE_GROUP]);
                 if (isNaN(minute)) {
-                    minute = zhStringToNumber(match[MINUTE_GROUP]);
+                    minute = zhStringToNumber(secondMatch[MINUTE_GROUP]);
                 }
             }
         } else if (hour > 100) {
@@ -340,9 +338,9 @@ export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBo
         }
 
         // ----- AM & PM
-        if (match[AM_PM_HOUR_GROUP]) {
+        if (secondMatch[AM_PM_HOUR_GROUP]) {
             if (hour > 12) return null;
-            var ampm = match[AM_PM_HOUR_GROUP][0].toLowerCase();
+            var ampm = secondMatch[AM_PM_HOUR_GROUP][0].toLowerCase();
             if (ampm == "a") {
                 meridiem = 0;
                 if (hour == 12) hour = 0;
@@ -368,8 +366,8 @@ export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBo
                     }
                 }
             }
-        } else if (match[ZH_AM_PM_HOUR_GROUP_1]) {
-            var zhAMPMString1 = match[ZH_AM_PM_HOUR_GROUP_1];
+        } else if (secondMatch[ZH_AM_PM_HOUR_GROUP_1]) {
+            const zhAMPMString1 = secondMatch[ZH_AM_PM_HOUR_GROUP_1];
             var zhAMPM1 = zhAMPMString1[0];
             if (zhAMPM1 == "朝" || zhAMPM1 == "早") {
                 meridiem = 0;
@@ -378,8 +376,8 @@ export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBo
                 meridiem = 1;
                 if (hour != 12) hour += 12;
             }
-        } else if (match[ZH_AM_PM_HOUR_GROUP_2]) {
-            var zhAMPMString2 = match[ZH_AM_PM_HOUR_GROUP_2];
+        } else if (secondMatch[ZH_AM_PM_HOUR_GROUP_2]) {
+            const zhAMPMString2 = secondMatch[ZH_AM_PM_HOUR_GROUP_2];
             var zhAMPM2 = zhAMPMString2[0];
             if (zhAMPM2 == "上" || zhAMPM2 == "朝" || zhAMPM2 == "早" || zhAMPM2 == "凌") {
                 meridiem = 0;
@@ -388,8 +386,8 @@ export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBo
                 meridiem = 1;
                 if (hour != 12) hour += 12;
             }
-        } else if (match[ZH_AM_PM_HOUR_GROUP_3]) {
-            var zhAMPMString3 = match[ZH_AM_PM_HOUR_GROUP_3];
+        } else if (secondMatch[ZH_AM_PM_HOUR_GROUP_3]) {
+            const zhAMPMString3 = secondMatch[ZH_AM_PM_HOUR_GROUP_3];
             var zhAMPM3 = zhAMPMString3[0];
             if (zhAMPM3 == "上" || zhAMPM3 == "朝" || zhAMPM3 == "早" || zhAMPM3 == "凌") {
                 meridiem = 0;
@@ -400,7 +398,7 @@ export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBo
             }
         }
 
-        result.text = result.text + match[0];
+        result.text = result.text + secondMatch[0];
         result.end.assign("hour", hour);
         result.end.assign("minute", minute);
         if (meridiem >= 0) {

package/src/locales/zh/hant/parsers/ZHHantWeekdayParser.ts

@@ -1,4 +1,3 @@
-import dayjs from "dayjs";
 import { ParsingContext } from "../../../../chrono";
 import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
 import { ParsingResult } from "../../../../results";
@@ -18,27 +17,29 @@ export default class ZHHantWeekdayParser extends AbstractParserWithWordBoundaryC
         const offset = WEEKDAY_OFFSET[dayOfWeek];
         if (offset === undefined) return null;
 
-        let startMoment = dayjs(context.refDate);
+        const date = new Date(context.refDate.getTime());
         const startMomentFixed = false;
-        const refOffset = startMoment.day();
+        const refOffset = date.getDay();
 
-        if (Math.abs(offset - 7 - refOffset) < Math.abs(offset - refOffset)) {
-            startMoment = startMoment.day(offset - 7);
-        } else if (Math.abs(offset + 7 - refOffset) < Math.abs(offset - refOffset)) {
-            startMoment = startMoment.day(offset + 7);
-        } else {
-            startMoment = startMoment.day(offset);
+        let diff = offset - refOffset;
+        if (Math.abs(diff - 7) < Math.abs(diff)) {
+            diff -= 7;
+        }
+        if (Math.abs(diff + 7) < Math.abs(diff)) {
+            diff += 7;
         }
 
+        date.setDate(date.getDate() + diff);
+
         result.start.assign("weekday", offset);
         if (startMomentFixed) {
-            result.start.assign("day", startMoment.date());
-            result.start.assign("month", startMoment.month() + 1);
-            result.start.assign("year", startMoment.year());
+            result.start.assign("day", date.getDate());
+            result.start.assign("month", date.getMonth() + 1);
+            result.start.assign("year", date.getFullYear());
         } else {
-            result.start.imply("day", startMoment.date());
-            result.start.imply("month", startMoment.month() + 1);
-            result.start.imply("year", startMoment.year());
+            result.start.imply("day", date.getDate());
+            result.start.imply("month", date.getMonth() + 1);
+            result.start.imply("year", date.getFullYear());
         }
 
         return result;

package/src/results.ts

@@ -1,25 +1,32 @@
-import { Component, ParsedComponents, ParsedResult, ParsingReference } from "./types";
+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";
+import { addDuration, Duration, EmptyDuration } from "./calculation/duration";
 dayjs.extend(quarterOfYear);
 
 export class ReferenceWithTimezone {
     readonly instant: Date;
     readonly timezoneOffset?: number | null;
 
-    constructor(input?: ParsingReference | Date) {
-        input = input ?? new Date();
+    constructor(instant?: Date, timezoneOffset?: number) {
+        this.instant = instant ?? new Date();
+        this.timezoneOffset = timezoneOffset ?? null;
+    }
+
+    static fromDate(date: Date): ReferenceWithTimezone {
+        return new ReferenceWithTimezone(date);
+    }
+
+    static fromInput(input?: ParsingReference | Date, timezoneOverrides?: TimezoneAbbrMap) {
         if (input instanceof Date) {
-            this.instant = input;
-            this.timezoneOffset = null;
-        } else {
-            this.instant = input.instant ?? new Date();
-            this.timezoneOffset = toTimezoneOffset(input.timezone, this.instant);
+            return ReferenceWithTimezone.fromDate(input);
         }
+        const instant: Date = input?.instant ?? new Date();
+        const timezoneOffset = toTimezoneOffset(input?.timezone, instant, timezoneOverrides);
+        return new ReferenceWithTimezone(instant, timezoneOffset);
     }
 
     /**
@@ -72,16 +79,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];
@@ -116,9 +169,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 {
@@ -215,49 +296,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));
+    });
+});