chrono-node 2.6.2 → 2.6.3

package/src/timezone.ts

@@ -1,4 +1,7 @@
-export const TIMEZONE_ABBR_MAP = {
+import dayjs from "dayjs";
+import { TimezoneAbbrMap, Weekday, Month } from "./index";
+
+export const TIMEZONE_ABBR_MAP: TimezoneAbbrMap = {
     ACDT: 630,
     ACST: 570,
     ADT: -180,
@@ -32,7 +35,14 @@ export const TIMEZONE_ABBR_MAP = {
     CCT: 390,
     CDT: -300,
     CEST: 120,
-    CET: 60,
+    // Note: Many sources define CET as a constant UTC+1. In common usage, however,
+    // CET usually refers to the time observed in most of Europe, be it standard time or daylight saving time.
+    CET: {
+        timezoneOffsetDuringDst: 2 * 60,
+        timezoneOffsetNonDst: 60,
+        dstStart: (year: number) => getLastWeekdayOfMonth(year, Month.MARCH, Weekday.SUNDAY, 2),
+        dstEnd: (year: number) => getLastWeekdayOfMonth(year, Month.OCTOBER, Weekday.SUNDAY, 3),
+    },
     CHADT: 825,
     CHAST: 765,
     CKT: -600,
@@ -40,6 +50,12 @@ export const TIMEZONE_ABBR_MAP = {
     CLT: -240,
     COT: -300,
     CST: -360,
+    CT: {
+        timezoneOffsetDuringDst: -5 * 60,
+        timezoneOffsetNonDst: -6 * 60,
+        dstStart: (year: number) => getNthWeekdayOfMonth(year, Month.MARCH, Weekday.SUNDAY, 2, 2),
+        dstEnd: (year: number) => getNthWeekdayOfMonth(year, Month.NOVEMBER, Weekday.SUNDAY, 1, 2),
+    },
     CVT: -60,
     CXT: 420,
     ChST: 600,
@@ -54,7 +70,12 @@ export const TIMEZONE_ABBR_MAP = {
     EGST: 0,
     EGT: -60,
     EST: -300,
-    ET: -300,
+    ET: {
+        timezoneOffsetDuringDst: -4 * 60,
+        timezoneOffsetNonDst: -5 * 60,
+        dstStart: (year: number) => getNthWeekdayOfMonth(year, Month.MARCH, Weekday.SUNDAY, 2, 2),
+        dstEnd: (year: number) => getNthWeekdayOfMonth(year, Month.NOVEMBER, Weekday.SUNDAY, 1, 2),
+    },
     FJST: 780,
     FJT: 720,
     FKST: -180,
@@ -116,6 +137,12 @@ export const TIMEZONE_ABBR_MAP = {
     MSD: 240,
     MSK: 180,
     MST: -420,
+    MT: {
+        timezoneOffsetDuringDst: -6 * 60,
+        timezoneOffsetNonDst: -7 * 60,
+        dstStart: (year: number) => getNthWeekdayOfMonth(year, Month.MARCH, Weekday.SUNDAY, 2, 2),
+        dstEnd: (year: number) => getNthWeekdayOfMonth(year, Month.NOVEMBER, Weekday.SUNDAY, 1, 2),
+    },
     MUT: 240,
     MVT: 300,
     MYT: 480,
@@ -143,7 +170,12 @@ export const TIMEZONE_ABBR_MAP = {
     PMST: -180,
     PONT: 660,
     PST: -480,
-    PT: -480,
+    PT: {
+        timezoneOffsetDuringDst: -7 * 60,
+        timezoneOffsetNonDst: -8 * 60,
+        dstStart: (year: number) => getNthWeekdayOfMonth(year, Month.MARCH, Weekday.SUNDAY, 2, 2),
+        dstEnd: (year: number) => getNthWeekdayOfMonth(year, Month.NOVEMBER, Weekday.SUNDAY, 1, 2),
+    },
     PWT: 540,
     PYST: -180,
     PYT: -240,
@@ -192,8 +224,67 @@ export const TIMEZONE_ABBR_MAP = {
     YEKT: 360,
 };
 
-export function toTimezoneOffset(timezoneInput?: string | number): number | null {
-    if (timezoneInput === null || timezoneInput === undefined) {
+/**
+ * Get the date which is the nth occurence of a given weekday in a given month and year.
+ *
+ * @param year The year for which to find the date
+ * @param month The month in which the date occurs
+ * @param weekday The weekday on which the date occurs
+ * @param n The nth occurence of the given weekday on the month to return
+ * @param hour The hour of day which should be set on the returned date
+ * @return The date which is the nth occurence of a given weekday in a given
+ *         month and year, at the given hour of day
+ */
+export function getNthWeekdayOfMonth(year: number, month: Month, weekday: Weekday, n: 1 | 2 | 3 | 4, hour = 0): Date {
+    let dayOfMonth = 0;
+    let i = 0;
+    while (i < n) {
+        dayOfMonth++;
+        const date = new Date(year, month - 1, dayOfMonth);
+        if (date.getDay() === weekday) i++;
+    }
+    return new Date(year, month - 1, dayOfMonth, hour);
+}
+
+/**
+ * Get the date which is the last occurence of a given weekday in a given month and year.
+ *
+ * @param year The year for which to find the date
+ * @param month The month in which the date occurs
+ * @param weekday The weekday on which the date occurs
+ * @param hour The hour of day which should be set on the returned date
+ * @return The date which is the last occurence of a given weekday in a given
+ *         month and year, at the given hour of day
+ */
+export function getLastWeekdayOfMonth(year: number, month: Month, weekday: Weekday, hour = 0): Date {
+    // Procedure: Find the first weekday of the next month, compare with the given weekday,
+    // and use the difference to determine how many days to subtract from the first of the next month.
+    const oneIndexedWeekday = weekday === 0 ? 7 : weekday;
+    const date = new Date(year, month - 1 + 1, 1, 12);
+    const firstWeekdayNextMonth = date.getDay() === 0 ? 7 : date.getDay();
+    let dayDiff;
+    if (firstWeekdayNextMonth === oneIndexedWeekday) dayDiff = 7;
+    else if (firstWeekdayNextMonth < oneIndexedWeekday) dayDiff = 7 + firstWeekdayNextMonth - oneIndexedWeekday;
+    else dayDiff = firstWeekdayNextMonth - oneIndexedWeekday;
+    date.setDate(date.getDate() - dayDiff);
+    return new Date(year, month - 1, date.getDate(), hour);
+}
+
+/**
+ * Finds and returns timezone offset. If timezoneInput is numeric, it is returned. Otherwise, look for timezone offsets
+ * in the following order: timezoneOverrides -> {@link TIMEZONE_ABBR_MAP}.
+ *
+ * @param timezoneInput Uppercase timezone abbreviation or numeric offset in minutes
+ * @param date The date to use to determine whether to return DST offsets for ambiguous timezones
+ * @param timezoneOverrides Overrides for timezones
+ * @return timezone offset in minutes
+ */
+export function toTimezoneOffset(
+    timezoneInput?: string | number,
+    date?: Date,
+    timezoneOverrides: TimezoneAbbrMap = {}
+): number | null {
+    if (timezoneInput == null) {
         return null;
     }
 
@@ -201,5 +292,31 @@ export function toTimezoneOffset(timezoneInput?: string | number): number | null
         return timezoneInput;
     }
 
-    return TIMEZONE_ABBR_MAP[timezoneInput] ?? null;
+    const matchedTimezone = timezoneOverrides[timezoneInput] ?? TIMEZONE_ABBR_MAP[timezoneInput];
+    if (matchedTimezone == null) {
+        return null;
+    }
+    // This means that we have matched an unambiguous timezone
+    if (typeof matchedTimezone == "number") {
+        return matchedTimezone;
+    }
+
+    // The matched timezone is an ambiguous timezone, where the offset depends on whether the context (refDate)
+    // is during daylight savings or not.
+
+    // Without refDate as context, there's no way to know if DST or non-DST offset should be used. Return null instead.
+    if (date == null) {
+        return null;
+    }
+
+    // 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()))
+    ) {
+        return matchedTimezone.timezoneOffsetDuringDst;
+    }
+
+    // refDate is not during DST => return non-DST offset
+    return matchedTimezone.timezoneOffsetNonDst;
 }

package/test/de/de_time_exp.test.ts

@@ -180,22 +180,22 @@ test("Test - Range Expression", function () {
 });
 
 test("Test - Timezone extraction", function () {
-    testSingleCase(chrono.de, "um 14 Uhr", new Date(2016, 3, 28), (result, text) => {
+    testSingleCase(chrono.de, "um 14 Uhr", new Date(2016, 1, 28), (result, text) => {
         expect(result.text).toBe(text);
         expect(result.start.isCertain("timezoneOffset")).toBe(false);
         expect(!result.start.get("timezoneOffset")).not.toBeNull();
     });
 
-    testSingleCase(chrono.de, "um 14 Uhr CET", new Date(2016, 3, 28), (result, text) => {
+    testSingleCase(chrono.de, "um 14 Uhr CET", new Date(2016, 1, 28), (result, text) => {
         expect(result.text).toBe(text);
         expect(result.start.isCertain("timezoneOffset")).toBe(true);
         expect(result.start.get("timezoneOffset")).toBe(60);
     });
 
-    testSingleCase(chrono.de, "14 Uhr cet", new Date(2016, 3, 28), (result, text) => {
+    testSingleCase(chrono.de, "14 Uhr cet", new Date(2016, 4, 28), (result, text) => {
         expect(result.text).toBe(text);
         expect(result.start.isCertain("timezoneOffset")).toBe(true);
-        expect(result.start.get("timezoneOffset")).toBe(60);
+        expect(result.start.get("timezoneOffset")).toBe(120);
     });
 });
 
@@ -209,15 +209,15 @@ test("Test - Random date + time expression", function () {
         expect(result.start.get("hour")).toBe(12);
     });
 
-    testSingleCase(chrono.de, "am Freitag um 14 Uhr cetteln wir etwas an", new Date(2016, 3, 28), (result, text) => {
+    testSingleCase(chrono.de, "am Freitag um 14 Uhr cetteln wir etwas an", new Date(2016, 1, 28), (result, text) => {
         expect(result.text).toBe("am Freitag um 14 Uhr");
         expect(result.start.isCertain("timezoneOffset")).toBe(false);
         expect(!result.start.get("timezoneOffset")).not.toBeNull();
     });
 
-    testSingleCase(chrono.de, "Freitag um 14 Uhr CET", new Date(2016, 3, 28), (result, text) => {
+    testSingleCase(chrono.de, "Freitag um 14 Uhr CET", new Date(2016, 4, 28), (result, text) => {
         expect(result.text).toBe(text);
         expect(result.start.isCertain("timezoneOffset")).toBe(true);
-        expect(result.start.get("timezoneOffset")).toBe(60);
+        expect(result.start.get("timezoneOffset")).toBe(120);
     });
 });

package/test/en/en_month.test.ts

@@ -117,6 +117,76 @@ test("Test - Month-Only expression", function () {
     });
 });
 
+test("Test - Month-Only Range expression", () => {
+    testSingleCase(chrono, "From May to December", new Date(2023, 4 - 1, 9), (result) => {
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(5);
+        expect(result.end.get("year")).toBe(2023);
+        expect(result.end.get("month")).toBe(12);
+    });
+
+    testSingleCase(chrono, "From December to May", new Date(2023, 4 - 1, 9), (result) => {
+        expect(result.start.get("year")).toBe(2022);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.end.get("year")).toBe(2023);
+        expect(result.end.get("month")).toBe(5);
+    });
+
+    testSingleCase(chrono, "From May to December, 2022", new Date(2023, 4 - 1, 9), (result) => {
+        expect(result.start.get("year")).toBe(2022);
+        expect(result.start.get("month")).toBe(5);
+        expect(result.end.get("year")).toBe(2022);
+        expect(result.end.get("month")).toBe(12);
+    });
+
+    testSingleCase(chrono, "From December to May 2022", new Date(2023, 4 - 1, 9), (result) => {
+        expect(result.start.get("year")).toBe(2021);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.end.get("year")).toBe(2022);
+        expect(result.end.get("month")).toBe(5);
+    });
+
+    testSingleCase(chrono, "From December to May 2020", new Date(2023, 4 - 1, 9), (result) => {
+        expect(result.start.get("year")).toBe(2019);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.end.get("year")).toBe(2020);
+        expect(result.end.get("month")).toBe(5);
+    });
+
+    testSingleCase(chrono, "From December to May 2025", new Date(2023, 4 - 1, 9), (result) => {
+        expect(result.start.get("year")).toBe(2024);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.end.get("year")).toBe(2025);
+        expect(result.end.get("month")).toBe(5);
+    });
+});
+
+test("Test - Month with farward date option", () => {
+    testSingleCase(chrono, "in December", new Date(2023, 4 - 1, 9), { forwardDate: true }, (result) => {
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(12);
+    });
+
+    testSingleCase(chrono, "in May", new Date(2023, 4 - 1, 9), { forwardDate: true }, (result) => {
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(5);
+    });
+
+    testSingleCase(chrono, "From May to December", new Date(2023, 4 - 1, 9), { forwardDate: true }, (result) => {
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(5);
+        expect(result.end.get("year")).toBe(2023);
+        expect(result.end.get("month")).toBe(12);
+    });
+
+    testSingleCase(chrono, "From December to May", new Date(2023, 4 - 1, 9), { forwardDate: true }, (result) => {
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.end.get("year")).toBe(2024);
+        expect(result.end.get("month")).toBe(5);
+    });
+});
+
 test("Test - Month expression in context", function () {
     testSingleCase(chrono, "The date is Sep 2012 is the date", (result) => {
         expect(result.index).toBe(12);

package/test/en/en_time_units_ago.test.ts

@@ -300,6 +300,18 @@ test("Test - Before with reference", () => {
     });
 });
 
+test("Test - Strict mode", function () {
+    testSingleCase(chrono.strict, "5 minutes ago", new Date(2012, 7, 10, 12, 14), (result, text) => {
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(9);
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 9));
+    });
+
+    testUnexpectedResult(chrono.strict, "5m ago", new Date(2012, 7, 10, 12, 14));
+    testUnexpectedResult(chrono.strict, "5hr before", new Date(2012, 7, 10, 12, 14));
+    testUnexpectedResult(chrono.strict, "5 h ago", new Date(2012, 7, 10, 12, 14));
+});
+
 test("Test - Negative cases", function () {
     testUnexpectedResult(chrono, "15 hours 29 min");
     testUnexpectedResult(chrono, "a few hour");

package/test/en/en_time_units_casual_relative.test.ts

@@ -1,5 +1,6 @@
 import * as chrono from "../../src";
 import { testSingleCase, testUnexpectedResult } from "../test_util";
+import ENTimeUnitCasualRelativeFormatParser from "../../src/locales/en/parsers/ENTimeUnitCasualRelativeFormatParser";
 
 test("Test - Positive time units", () => {
     testSingleCase(chrono, "next 2 weeks", new Date(2016, 10 - 1, 1, 12), (result, text) => {
@@ -141,6 +142,23 @@ test("Test - Minus '-' sign", () => {
     });
 });
 
+test("Test - Without custom parser without abbreviations", function () {
+    const custom = chrono.en.strict.clone();
+    custom.parsers.push(new ENTimeUnitCasualRelativeFormatParser(false));
+
+    testUnexpectedResult(custom, "-3y");
+    testUnexpectedResult(custom, "last 2m");
+
+    testSingleCase(custom, "-2 hours 5 minutes", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(9);
+        expect(result.start.get("minute")).toBe(55);
+    });
+});
+
 test("Test - Negative cases", () => {
     testUnexpectedResult(chrono.casual, "3y", new Date(2015, 7 - 1, 10, 12, 14));
     testUnexpectedResult(chrono.casual, "1 m", new Date(2015, 7 - 1, 10, 12, 14));

package/test/en/en_time_units_later.test.ts

@@ -1,5 +1,5 @@
 import * as chrono from "../../src/";
-import { testSingleCase } from "../test_util";
+import { testSingleCase, testUnexpectedResult } from "../test_util";
 import { Meridiem } from "../../src/";
 
 test("Test - Later Expression", function () {
@@ -262,6 +262,16 @@ test("Test - From now Expression", () => {
 });
 
 test("Test - Strict mode", function () {
+    testSingleCase(chrono, "the min after", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("the min after");
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(15);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 15));
+    });
+
     testSingleCase(chrono.strict, "15 minutes from now", new Date(2012, 7, 10, 12, 14), (result, text) => {
         expect(result.text).toBe(text);
         expect(result.start.get("hour")).toBe(12);
@@ -279,15 +289,8 @@ test("Test - Strict mode", function () {
         expect(result.start).toBeDate(new Date(2012, 7, 10, 13, 5));
     });
 
-    testSingleCase(chrono, "the min after", new Date(2012, 7, 10, 12, 14), (result) => {
-        expect(result.index).toBe(0);
-        expect(result.text).toBe("the min after");
-        expect(result.start.get("hour")).toBe(12);
-        expect(result.start.get("minute")).toBe(15);
-        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
-
-        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 15));
-    });
+    testUnexpectedResult(chrono.strict, "15m from now");
+    testUnexpectedResult(chrono.strict, "15s later");
 });
 
 test("Test - After with reference", () => {

package/test/en/en_time_units_within.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 - The normal within expression", () => {
     testSingleCase(chrono, "we have to make something in 5 days.", new Date(2012, 7, 10), (result) => {
@@ -327,3 +328,13 @@ test("Test - Time units' certainty", () => {
         expect(result.start.isCertain("minute")).toBeFalsy();
     });
 });
+
+test("Test - Strict mode", function () {
+    testSingleCase(chrono, "in 2hour", new Date(2016, 10 - 1, 1, 14, 52), (result, text) => {
+        expect(result.start.get("hour")).toBe(16);
+        expect(result.start.get("minute")).toBe(52);
+    });
+
+    testUnexpectedResult(chrono.strict, "in 15m");
+    testUnexpectedResult(chrono.strict, "within 5hr");
+});

package/test/en/en_timezone_exp.test.ts

@@ -1,4 +1,6 @@
 import * as chrono from "../../src";
+import { Month, Weekday } from "../../src";
+import { getLastWeekdayOfMonth } from "../../src/timezone";
 import { testSingleCase } from "../test_util";
 
 test("Test - Parsing date/time with UTC offset", function () {
@@ -100,6 +102,146 @@ test("Test - Parsing date/time with timezone abbreviation", function () {
     });
 });
 
+test("Test - Parsing date/time with ambiguous timezone abbreviations", function () {
+    // Test dates around transition to DST for ET
+    testSingleCase(chrono, "2022-03-12 23:00 ET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-5 * 60); // ET during standard time (EST) in 2022
+    });
+    testSingleCase(chrono, "2022-03-13 23:00 ET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-4 * 60); // ET during DST (EDT) in 2022
+    });
+    testSingleCase(chrono, "2021-03-13 23:00 ET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-5 * 60); // ET during standard time (EST) in 2021
+    });
+    testSingleCase(chrono, "2021-03-14 23:00 ET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-4 * 60); // ET during DST (EDT) in 2021
+    });
+
+    // Also test around transition *from* DST
+    testSingleCase(chrono, "2021-11-06 23:00 ET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-4 * 60); // ET during DST (EDT) in 2021
+    });
+    testSingleCase(chrono, "2021-11-07 23:00 ET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-5 * 60); // ET during standard time (EST) in 2021
+    });
+    testSingleCase(chrono, "2020-10-31 23:00 ET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-4 * 60); // ET during DST (EDT) in 2020
+    });
+    testSingleCase(chrono, "2020-11-01 23:00 ET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-5 * 60); // ET during standard time (EST) in 2020
+    });
+
+    // Same checks, but for CET (which transitions at different dates with different rules)
+    // Test dates around transition to DST for CET
+    testSingleCase(chrono, "2022-03-26 23:00 CET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(60); // CET during standard time (CET) in 2022
+    });
+    testSingleCase(chrono, "2022-03-27 23:00 CET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(2 * 60); // CET during DST (CEST) in 2022
+    });
+    testSingleCase(chrono, "2021-03-27 23:00 CET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(60); // CET during standard time (CET) in 2021
+    });
+    testSingleCase(chrono, "2021-03-28 23:00 CET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(2 * 60); // CET during DST (CEST) in 2021
+    });
+
+    // Also test around transition *from* DST for CET
+    testSingleCase(chrono, "2022-10-29 23:00 CET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(2 * 60); // CET during DST (CEST) in 2022
+    });
+    testSingleCase(chrono, "2022-10-30 23:00 CET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(60); // CET during standard time (CET) in 2022
+    });
+    testSingleCase(chrono, "2021-10-30 23:00 CET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(2 * 60); // CET during DST (CEST) in 2021
+    });
+    testSingleCase(chrono, "2021-10-31 23:00 CET", (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(60); // CET during standard time (CET) in 2021
+    });
+});
+
+test("Test - Timezone parsing overrides", function () {
+    // chrono.parse('at 10:00 XYZ', new Date(2023, 3, 20), {timezones: {XYZ: -180}})
+    // XYZ shouldn't be recognized or parsed as a timezone
+    testSingleCase(chrono, "Jan 1st 2023 at 10:00 XYZ", (result) => {
+        expect(result.text).toBe("Jan 1st 2023 at 10:00");
+        expect(result.start).toBeDate(new Date(2023, 1 - 1, 1, 10));
+    });
+    // Parse the correct tzoffset when XYZ is provided as a custom tz in parsingOptions
+    testSingleCase(
+        chrono,
+        "Jan 1st 2023 at 10:00 XYZ",
+        new Date(2023, 1, 1),
+        { timezones: { XYZ: -180 } },
+        (result) => {
+            expect(result.text).toBe("Jan 1st 2023 at 10:00 XYZ");
+            expect(result.start.get("timezoneOffset")).toBe(-180);
+        }
+    );
+    // Parse the correct tzoffset when XYZ is provided as a custom ambiguous tz in parsingOptions
+    const parseXYZAsAmbiguousTz = {
+        timezoneOffsetDuringDst: -120,
+        timezoneOffsetNonDst: -180,
+        dstStart: (year: number) => getLastWeekdayOfMonth(year, Month.MARCH, Weekday.SUNDAY, 2),
+        dstEnd: (year: number) => getLastWeekdayOfMonth(year, Month.OCTOBER, Weekday.SUNDAY, 3),
+    };
+    // Parsing a non-DST date
+    testSingleCase(
+        chrono,
+        "Jan 1st 2023 at 10:00 XYZ",
+        new Date(2023, 1, 1),
+        { timezones: { XYZ: parseXYZAsAmbiguousTz } },
+        (result) => {
+            expect(result.text).toBe("Jan 1st 2023 at 10:00 XYZ");
+            expect(result.start.get("timezoneOffset")).toBe(-180);
+        }
+    );
+    // Parsing a DST date
+    testSingleCase(
+        chrono,
+        "Jun 1st 2023 at 10:00 XYZ",
+        new Date(2023, 1, 1),
+        { timezones: { XYZ: parseXYZAsAmbiguousTz } },
+        (result) => {
+            expect(result.text).toBe("Jun 1st 2023 at 10:00 XYZ");
+            expect(result.start.get("timezoneOffset")).toBe(-120);
+        }
+    );
+});
+
 test("Test - Parsing date with timezone abbreviation", function () {
     testSingleCase(chrono, "Wednesday, September 16, 2020, EST", (result, text) => {
         expect(result.text).toBe(text);

package/test/en/en_weekday.test.ts

@@ -273,6 +273,32 @@ test("Test - Weekday Overlap", function () {
     });
 });
 
+test("Test - Weekday range", () => {
+    testSingleCase(chrono.casual, "Friday to Monday", new Date(2023, 4 - 1, 9) /*Sunday*/, (result) => {
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(4);
+        expect(result.start.get("day")).toBe(7);
+        expect(result.start.get("weekday")).toBe(5);
+
+        expect(result.end.get("year")).toBe(2023);
+        expect(result.end.get("month")).toBe(4);
+        expect(result.end.get("day")).toBe(10);
+        expect(result.end.get("weekday")).toBe(1);
+    });
+
+    testSingleCase(chrono.casual, "Monday to Friday", new Date(2023, 4 - 1, 9) /*Sunday*/, (result) => {
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(4);
+        expect(result.start.get("day")).toBe(10);
+        expect(result.start.get("weekday")).toBe(1);
+
+        expect(result.end.get("year")).toBe(2023);
+        expect(result.end.get("month")).toBe(4);
+        expect(result.end.get("day")).toBe(14);
+        expect(result.end.get("weekday")).toBe(5);
+    });
+});
+
 test("Test - forward dates only option", () => {
     testSingleCase(
         chrono.casual,

package/test/en/negative_cases.test.ts

@@ -63,6 +63,8 @@ test("Test - Skip impossible dates/times", () => {
 
     testUnexpectedResult(chrono, "14PM");
     testUnexpectedResult(chrono, "25:12");
+
+    testUnexpectedResult(chrono, "An appointment on 13/31/2018");
 });
 
 test("Test - Skip version number pattern", () => {

package/test/fr/fr_time_exp.test.ts

@@ -488,13 +488,13 @@ test("Test - Timezone extraction", function () {
         expect(result.start.get("timezoneOffset")).toBe(-300);
     });
 
-    testSingleCase(chrono.fr, "vendredi 15h CET", new Date(2016, 3, 28), (result, text) => {
+    testSingleCase(chrono.fr, "vendredi 15h CET", new Date(2016, 1, 28), (result, text) => {
         expect(result.text).toBe(text);
         expect(result.start.isCertain("timezoneOffset")).toBe(true);
         expect(result.start.get("timezoneOffset")).toBe(60);
     });
 
-    testSingleCase(chrono.fr, "vendredi 15h cest", new Date(2016, 3, 28), (result, text) => {
+    testSingleCase(chrono.fr, "vendredi 15h cest", new Date(2016, 1, 28), (result, text) => {
         expect(result.text).toBe(text);
         expect(result.start.isCertain("timezoneOffset")).toBe(true);
         expect(result.start.get("timezoneOffset")).toBe(120);