chrono-node 2.6.1 → 2.6.3

package/src/common/refiners/ForwardDateRefiner.ts

@@ -30,22 +30,6 @@ export default class ForwardDateRefiner implements Refiner {
                 }
             }
 
-            if (result.start.isOnlyDayMonthComponent() && refMoment.isAfter(result.start.dayjs())) {
-                for (let i = 0; i < 3 && refMoment.isAfter(result.start.dayjs()); i++) {
-                    result.start.imply("year", result.start.get("year") + 1);
-                    context.debug(() => {
-                        console.log(`Forward yearly adjusted for ${result} (${result.start})`);
-                    });
-
-                    if (result.end && !result.end.isCertain("year")) {
-                        result.end.imply("year", result.end.get("year") + 1);
-                        context.debug(() => {
-                            console.log(`Forward yearly adjusted for ${result} (${result.end})`);
-                        });
-                    }
-                }
-            }
-
             if (result.start.isOnlyWeekdayComponent() && refMoment.isAfter(result.start.dayjs())) {
                 if (refMoment.day() >= result.start.get("weekday")) {
                     refMoment = refMoment.day(result.start.get("weekday") + 7);
@@ -76,6 +60,24 @@ export default class ForwardDateRefiner implements Refiner {
                     });
                 }
             }
+
+            // In case where we know the month, but not which year (e.g. "in December", "25th December"),
+            // try move to another year
+            if (result.start.isDateWithUnknownYear() && refMoment.isAfter(result.start.dayjs())) {
+                for (let i = 0; i < 3 && refMoment.isAfter(result.start.dayjs()); i++) {
+                    result.start.imply("year", result.start.get("year") + 1);
+                    context.debug(() => {
+                        console.log(`Forward yearly adjusted for ${result} (${result.start})`);
+                    });
+
+                    if (result.end && !result.end.isCertain("year")) {
+                        result.end.imply("year", result.end.get("year") + 1);
+                        context.debug(() => {
+                            console.log(`Forward yearly adjusted for ${result} (${result.end})`);
+                        });
+                    }
+                }
+            }
         });
 
         return results;

package/src/configurations.ts

@@ -12,10 +12,12 @@ export function includeCommonConfiguration(configuration: Configuration, strictM
     configuration.parsers.unshift(new ISOFormatParser());
 
     configuration.refiners.unshift(new MergeWeekdayComponentRefiner());
-    configuration.refiners.unshift(new ExtractTimezoneAbbrRefiner());
     configuration.refiners.unshift(new ExtractTimezoneOffsetRefiner());
     configuration.refiners.unshift(new OverlapRemovalRefiner());
 
+    // Unlike ExtractTimezoneOffsetRefiner, this refiner relies on knowing both date and time in cases where the tz
+    // is ambiguous (in terms of DST/non-DST). It therefore needs to be applied as late as possible in the parsing.
+    configuration.refiners.push(new ExtractTimezoneAbbrRefiner());
     configuration.refiners.push(new OverlapRemovalRefiner());
     configuration.refiners.push(new ForwardDateRefiner());
     configuration.refiners.push(new UnlikelyFormatFilter(strictMode));

package/src/index.ts

@@ -1,8 +1,9 @@
 import { DebugHandler, DebugConsume } from "./debugging";
 import * as en from "./locales/en";
 import { Chrono, Parser, Refiner } from "./chrono";
+import type { ParsingResult } from "./results";
 
-export { en, Chrono, Parser, Refiner };
+export { en, Chrono, Parser, Refiner, ParsingResult };
 
 export interface ParsingOption {
     /**
@@ -12,9 +13,10 @@ export interface ParsingOption {
     forwardDate?: boolean;
 
     /**
-     * Additional timezone keywords for the parsers to recognize
+     * Additional timezone keywords for the parsers to recognize.
+     * Any value provided will override the default handling of that value.
      */
-    timezones?: { [tzKeyword: string]: number };
+    timezones?: TimezoneAbbrMap;
 
     /**
      * Internal debug event handler.
@@ -23,6 +25,34 @@ export interface ParsingOption {
     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.
@@ -109,6 +139,21 @@ export enum Weekday {
     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,
+}
+
 // Export all locales
 import * as de from "./locales/de";
 import * as fr from "./locales/fr";

package/src/locales/en/constants.ts

@@ -134,6 +134,25 @@ export const ORDINAL_WORD_DICTIONARY: { [word: string]: number } = {
     "thirty-first": 31,
 };
 
+export const TIME_UNIT_DICTIONARY_NO_ABBR: { [word: string]: OpUnitType | QUnitType } = {
+    second: "second",
+    seconds: "second",
+    minute: "minute",
+    minutes: "minute",
+    hour: "hour",
+    hours: "hour",
+    day: "d",
+    days: "d",
+    week: "week",
+    weeks: "week",
+    month: "month",
+    months: "month",
+    quarter: "quarter",
+    quarters: "quarter",
+    year: "year",
+    years: "year",
+};
+
 export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } = {
     s: "second",
     sec: "second",
@@ -167,6 +186,9 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } =
     yr: "year",
     year: "year",
     years: "year",
+    // Also, merge the entries from the full-name dictionary.
+    // We leave the duplicated entries for readability.
+    ...TIME_UNIT_DICTIONARY_NO_ABBR,
 };
 
 //-----------------------------
@@ -238,7 +260,15 @@ export function parseYear(match: string): number {
 const SINGLE_TIME_UNIT_PATTERN = `(${NUMBER_PATTERN})\\s{0,3}(${matchAnyPattern(TIME_UNIT_DICTIONARY)})`;
 const SINGLE_TIME_UNIT_REGEX = new RegExp(SINGLE_TIME_UNIT_PATTERN, "i");
 
+const SINGLE_TIME_UNIT_NO_ABBR_PATTERN = `(${NUMBER_PATTERN})\\s{0,3}(${matchAnyPattern(
+    TIME_UNIT_DICTIONARY_NO_ABBR
+)})`;
+
 export const TIME_UNITS_PATTERN = repeatedTimeunitPattern(`(?:(?:about|around)\\s{0,3})?`, SINGLE_TIME_UNIT_PATTERN);
+export const TIME_UNITS_NO_ABBR_PATTERN = repeatedTimeunitPattern(
+    `(?:(?:about|around)\\s{0,3})?`,
+    SINGLE_TIME_UNIT_NO_ABBR_PATTERN
+);
 
 export function parseTimeUnits(timeunitText): TimeUnits {
     const fragments = {};

package/src/locales/en/index.ts

@@ -82,7 +82,7 @@ export function createConfiguration(strictMode = true, littleEndian = false): Co
         {
             parsers: [
                 new SlashDateFormatParser(littleEndian),
-                new ENTimeUnitWithinFormatParser(),
+                new ENTimeUnitWithinFormatParser(strictMode),
                 new ENMonthNameLittleEndianParser(),
                 new ENMonthNameMiddleEndianParser(),
                 new ENWeekdayParser(),

package/src/locales/en/parsers/ENTimeUnitAgoFormatParser.ts

@@ -1,11 +1,11 @@
 import { ParsingContext } from "../../../chrono";
-import { parseTimeUnits, TIME_UNITS_PATTERN } from "../constants";
+import { parseTimeUnits, TIME_UNITS_NO_ABBR_PATTERN, TIME_UNITS_PATTERN } from "../constants";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { reverseTimeUnits } from "../../../utils/timeunits";
 
-const PATTERN = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}(?:ago|before|earlier)(?=(?:\\W|$))`, "i");
-const STRICT_PATTERN = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}ago(?=(?:\\W|$))`, "i");
+const PATTERN = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}(?:ago|before|earlier)(?=\\W|$)`, "i");
+const STRICT_PATTERN = new RegExp(`(${TIME_UNITS_NO_ABBR_PATTERN})\\s{0,5}(?:ago|before|earlier)(?=\\W|$)`, "i");
 
 export default class ENTimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
     constructor(private strictMode: boolean) {

package/src/locales/en/parsers/ENTimeUnitCasualRelativeFormatParser.ts

@@ -1,14 +1,22 @@
-import { TIME_UNITS_PATTERN, parseTimeUnits } from "../constants";
+import { TIME_UNITS_PATTERN, parseTimeUnits, TIME_UNITS_NO_ABBR_PATTERN } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { reverseTimeUnits } from "../../../utils/timeunits";
 
 const PATTERN = new RegExp(`(this|last|past|next|after|\\+|-)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+const PATTERN_NO_ABBR = new RegExp(
+    `(this|last|past|next|after|\\+|-)\\s*(${TIME_UNITS_NO_ABBR_PATTERN})(?=\\W|$)`,
+    "i"
+);
 
 export default class ENTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor(private allowAbbreviations: boolean = true) {
+        super();
+    }
+
     innerPattern(): RegExp {
-        return PATTERN;
+        return this.allowAbbreviations ? PATTERN : PATTERN_NO_ABBR;
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {

package/src/locales/en/parsers/ENTimeUnitLaterFormatParser.ts

@@ -1,5 +1,5 @@
 import { ParsingContext } from "../../../chrono";
-import { parseTimeUnits, TIME_UNITS_PATTERN } from "../constants";
+import { parseTimeUnits, TIME_UNITS_NO_ABBR_PATTERN, TIME_UNITS_PATTERN } from "../constants";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 
@@ -8,7 +8,10 @@ const PATTERN = new RegExp(
     "i"
 );
 
-const STRICT_PATTERN = new RegExp("" + "(" + TIME_UNITS_PATTERN + ")" + "(later|from now)" + "(?=(?:\\W|$))", "i");
+const STRICT_PATTERN = new RegExp(
+    "" + "(" + TIME_UNITS_NO_ABBR_PATTERN + ")" + "(later|from now)" + "(?=(?:\\W|$))",
+    "i"
+);
 const GROUP_NUM_TIMEUNITS = 1;
 
 export default class ENTimeUnitLaterFormatParser extends AbstractParserWithWordBoundaryChecking {

package/src/locales/en/parsers/ENTimeUnitWithinFormatParser.ts

@@ -1,21 +1,34 @@
-import { TIME_UNITS_PATTERN, parseTimeUnits } from "../constants";
+import { TIME_UNITS_PATTERN, parseTimeUnits, TIME_UNITS_NO_ABBR_PATTERN } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 
+const PATTERN_WITHOUT_PREFIX = new RegExp(
+    `(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})(?=\\W|$)`,
+    "i"
+);
+
 const PATTERN_WITH_PREFIX = new RegExp(
     `(?:within|in|for)\\s*` +
         `(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})(?=\\W|$)`,
     "i"
 );
 
-const PATTERN_WITHOUT_PREFIX = new RegExp(
-    `(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})(?=\\W|$)`,
+const PATTERN_WITH_PREFIX_STRICT = new RegExp(
+    `(?:within|in|for)\\s*` +
+        `(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${TIME_UNITS_NO_ABBR_PATTERN})(?=\\W|$)`,
     "i"
 );
 
 export default class ENTimeUnitWithinFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor(private strictMode: boolean) {
+        super();
+    }
+
     innerPattern(context: ParsingContext): RegExp {
+        if (this.strictMode) {
+            return PATTERN_WITH_PREFIX_STRICT;
+        }
         return context.option.forwardDate ? PATTERN_WITHOUT_PREFIX : PATTERN_WITH_PREFIX;
     }
 

package/src/locales/ru/constants.ts

@@ -219,6 +219,9 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } =
     минуток: "minute",
     минутки: "minute",
     минутку: "minute",
+    минуточек: "minute",
+    минуточки: "minute",
+    минуточку: "minute",
     час: "hour",
     часов: "hour",
     часа: "hour",
@@ -284,7 +287,7 @@ export function parseNumberPattern(match: string): number {
 
 export const ORDINAL_NUMBER_PATTERN = `(?:${matchAnyPattern(ORDINAL_WORD_DICTIONARY)}|[0-9]{1,2}(?:го|ого|е|ое)?)`;
 export function parseOrdinalNumberPattern(match: string): number {
-    let num = match.toLowerCase();
+    const num = match.toLowerCase();
     if (ORDINAL_WORD_DICTIONARY[num] !== undefined) {
         return ORDINAL_WORD_DICTIONARY[num];
     }

package/src/results.ts

@@ -16,7 +16,7 @@ export class ReferenceWithTimezone {
             this.instant = input;
         } else {
             this.instant = input.instant ?? new Date();
-            this.timezoneOffset = toTimezoneOffset(input.timezone);
+            this.timezoneOffset = toTimezoneOffset(input.timezone, this.instant);
         }
     }
 
@@ -138,8 +138,8 @@ export class ParsingComponents implements ParsedComponents {
         return this.isCertain("weekday") && !this.isCertain("day") && !this.isCertain("month");
     }
 
-    isOnlyDayMonthComponent(): boolean {
-        return this.isCertain("day") && this.isCertain("month") && !this.isCertain("year");
+    isDateWithUnknownYear(): boolean {
+        return this.isCertain("month") && !this.isCertain("year");
     }
 
     isValidDate(): boolean {

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