chrono-node 2.6.2 → 2.6.4

package/src/types.ts

@@ -0,0 +1,150 @@
+import { DebugConsume, DebugHandler } from "./debugging";
+
+export interface ParsingOption {
+    /**
+     * To parse only forward dates (the results should be after the reference date).
+     * This effects date/time implication (e.g. weekday or time mentioning)
+     */
+    forwardDate?: boolean;
+
+    /**
+     * Additional timezone keywords for the parsers to recognize.
+     * Any value provided will override the default handling of that value.
+     */
+    timezones?: TimezoneAbbrMap;
+
+    /**
+     * Internal debug event handler.
+     * @internal
+     */
+    debug?: DebugHandler | DebugConsume;
+}
+
+/**
+ * Some timezone abbreviations are ambiguous in that they refer to different offsets
+ * depending on the time of year — daylight savings time (DST), or non-DST. This interface
+ * allows defining such timezones
+ */
+export interface AmbiguousTimezoneMap {
+    timezoneOffsetDuringDst: number;
+    timezoneOffsetNonDst: number;
+    /**
+     * Return the start date of DST for the given year.
+     * timezone.ts contains helper methods for common such rules.
+     */
+    dstStart: (year: number) => Date;
+    /**
+     * Return the end date of DST for the given year.
+     * timezone.ts contains helper methods for common such rules.
+     */
+    dstEnd: (year: number) => Date;
+}
+
+/**
+ * A map describing how timezone abbreviations should map to time offsets.
+ * Supports both unambigous mappings abbreviation => offset,
+ * and ambiguous mappings, where the offset will depend on whether the
+ * time in question is during daylight savings time or not.
+ */
+export type TimezoneAbbrMap = { [key: string]: number | AmbiguousTimezoneMap };
+
+export interface ParsingReference {
+    /**
+     * Reference date. The instant (JavaScript Date object) when the input is written or mention.
+     * This effect date/time implication (e.g. weekday or time mentioning).
+     * (default = now)
+     */
+    instant?: Date;
+
+    /**
+     * Reference timezone. The timezone where the input is written or mention.
+     * Date/time implication will account the difference between input timezone and the current system timezone.
+     * (default = current timezone)
+     */
+    timezone?: string | number;
+}
+
+/**
+ * Parsed result or final output.
+ * Each result object represents a date/time (or date/time-range) mentioning in the input.
+ */
+export interface ParsedResult {
+    readonly refDate: Date;
+    readonly index: number;
+    readonly text: string;
+
+    readonly start: ParsedComponents;
+    readonly end?: ParsedComponents;
+
+    /**
+     * Create a javascript date object (from the result.start).
+     */
+    date(): Date;
+}
+
+/**
+ * A collection of parsed date/time components (e.g. day, hour, minute, ..., etc).
+ *
+ * Each parsed component has three different levels of certainty.
+ * - *Certain* (or *Known*): The component is directly mentioned and parsed.
+ * - *Implied*: The component is not directly mentioned, but implied by other parsed information.
+ * - *Unknown*: Completely no mention of the component.
+ */
+export interface ParsedComponents {
+    /**
+     * Check the component certainly if the component is *Certain* (or *Known*)
+     */
+    isCertain(component: Component): boolean;
+
+    /**
+     * Get the component value for either *Certain* or *Implied* value.
+     */
+    get(component: Component): number | null;
+
+    /**
+     * @return a javascript date object.
+     */
+    date(): Date;
+}
+
+export type Component =
+    | "year"
+    | "month"
+    | "day"
+    | "weekday"
+    | "hour"
+    | "minute"
+    | "second"
+    | "millisecond"
+    | "meridiem"
+    | "timezoneOffset";
+
+export enum Meridiem {
+    AM = 0,
+    PM = 1,
+}
+
+export enum Weekday {
+    SUNDAY = 0,
+    MONDAY = 1,
+    TUESDAY = 2,
+    WEDNESDAY = 3,
+    THURSDAY = 4,
+    FRIDAY = 5,
+    SATURDAY = 6,
+}
+
+export enum Month {
+    JANUARY = 1,
+    FEBRUARY = 2,
+    MARCH = 3,
+    APRIL = 4,
+    MAY = 5,
+    JUNE = 6,
+    JULY = 7,
+    AUGUST = 8,
+    SEPTEMBER = 9,
+    OCTOBER = 10,
+    NOVEMBER = 11,
+    DECEMBER = 12,
+}

package/src/utils/dayjs.ts

@@ -1,6 +1,6 @@
 import { ParsingComponents } from "../results";
 import dayjs from "dayjs";
-import { Meridiem } from "../index";
+import { Meridiem } from "../types";
 
 export function assignTheNextDay(component: ParsingComponents, targetDayJs: dayjs.Dayjs) {
     targetDayJs = targetDayJs.add(1, "day");

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/debugging.test.ts

@@ -0,0 +1,17 @@
+import { BufferedDebugHandler } from "../src/debugging";
+
+test("Test - BufferedDebugHandler", () => {
+    const debugHandler = new BufferedDebugHandler();
+
+    const debugBlockA = jest.fn();
+    debugHandler.debug(() => debugBlockA());
+    expect(debugBlockA).not.toBeCalled();
+
+    const debugBlockB = jest.fn();
+    debugHandler.debug(() => debugBlockB());
+    expect(debugBlockB).not.toBeCalled();
+
+    debugHandler.executeBufferedBlocks();
+    expect(debugBlockA).toBeCalled();
+    expect(debugBlockB).toBeCalled();
+});

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_month_name_little_endian.test.ts

@@ -211,6 +211,18 @@ test("Test - Range expression", () => {
 
         expect(result.end).toBeDate(new Date(2013, 9 - 1, 12, 12));
     });
+
+    testSingleCase(chrono, " 17 August 2013 to 19 August 2013", new Date(2012, 7, 10), (result) => {
+        expect(result.text).toBe("17 August 2013 to 19 August 2013");
+
+        expect(result.start.get("year")).toBe(2013);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(17);
+
+        expect(result.end.get("year")).toBe(2013);
+        expect(result.end.get("month")).toBe(8);
+        expect(result.end.get("day")).toBe(19);
+    });
 });
 
 test("Test - Combined expression", () => {

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/types";
+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);