chrono-node 2.7.6 → 2.7.8

package/src/common/parsers/ISOFormatParser.ts

@@ -18,7 +18,7 @@ const PATTERN = new RegExp(
         "(?:" +
             ":([0-9]{1,2})(?:\\.(\\d{1,4}))?" +
         ")?" + // :ss.s
-        "(?:" +
+        "(" +
             "Z|([+-]\\d{2}):?(\\d{2})?" +
         ")?" + // TZD (Z or ±hh:mm or ±hhmm or ±hh)
     ")?" +
@@ -33,8 +33,9 @@ const HOUR_NUMBER_GROUP = 4;
 const MINUTE_NUMBER_GROUP = 5;
 const SECOND_NUMBER_GROUP = 6;
 const MILLISECOND_NUMBER_GROUP = 7;
-const TZD_HOUR_OFFSET_GROUP = 8;
-const TZD_MINUTE_OFFSET_GROUP = 9;
+const TZD_GROUP = 8;
+const TZD_HOUR_OFFSET_GROUP = 9;
+const TZD_MINUTE_OFFSET_GROUP = 10;
 
 export default class ISOFormatParser extends AbstractParserWithWordBoundaryChecking {
     innerPattern(): RegExp {
@@ -42,44 +43,41 @@ export default class ISOFormatParser extends AbstractParserWithWordBoundaryCheck
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        const components: { [component in Component]?: number } = {};
-        components["year"] = parseInt(match[YEAR_NUMBER_GROUP]);
-        components["month"] = parseInt(match[MONTH_NUMBER_GROUP]);
-        components["day"] = parseInt(match[DATE_NUMBER_GROUP]);
-
+        const components = context.createParsingComponents({
+            "year": parseInt(match[YEAR_NUMBER_GROUP]),
+            "month": parseInt(match[MONTH_NUMBER_GROUP]),
+            "day": parseInt(match[DATE_NUMBER_GROUP]),
+        });
         if (match[HOUR_NUMBER_GROUP] != null) {
-            components["hour"] = parseInt(match[HOUR_NUMBER_GROUP]);
-            components["minute"] = parseInt(match[MINUTE_NUMBER_GROUP]);
+            components.assign("hour", parseInt(match[HOUR_NUMBER_GROUP]));
+            components.assign("minute", parseInt(match[MINUTE_NUMBER_GROUP]));
 
             if (match[SECOND_NUMBER_GROUP] != null) {
-                components["second"] = parseInt(match[SECOND_NUMBER_GROUP]);
+                components.assign("second", parseInt(match[SECOND_NUMBER_GROUP]));
             }
 
             if (match[MILLISECOND_NUMBER_GROUP] != null) {
-                components["millisecond"] = parseInt(match[MILLISECOND_NUMBER_GROUP]);
+                components.assign("millisecond", parseInt(match[MILLISECOND_NUMBER_GROUP]));
             }
-
-            if (match[TZD_HOUR_OFFSET_GROUP] == null) {
-                components["timezoneOffset"] = 0;
-            } else {
-                const hourOffset = parseInt(match[TZD_HOUR_OFFSET_GROUP]);
-
-                let minuteOffset = 0;
-                if (match[TZD_MINUTE_OFFSET_GROUP] != null) {
-                    minuteOffset = parseInt(match[TZD_MINUTE_OFFSET_GROUP]);
+            if (match[TZD_GROUP] != null) {
+                // The Zulu time zone (Z) is equivalent to UTC
+                let offset = 0;
+                if (match[TZD_HOUR_OFFSET_GROUP]) {
+                    const hourOffset = parseInt(match[TZD_HOUR_OFFSET_GROUP]);
+                    let minuteOffset = 0;
+                    if (match[TZD_MINUTE_OFFSET_GROUP] != null) {
+                        minuteOffset = parseInt(match[TZD_MINUTE_OFFSET_GROUP]);
+                    }
+                    offset = hourOffset * 60;
+                    if (offset < 0) {
+                        offset -= minuteOffset;
+                    } else {
+                        offset += minuteOffset;
+                    }
                 }
-
-                let offset = hourOffset * 60;
-                if (offset < 0) {
-                    offset -= minuteOffset;
-                } else {
-                    offset += minuteOffset;
-                }
-
-                components["timezoneOffset"] = offset;
+                components.assign("timezoneOffset", offset);
             }
         }
-
-        return components;
+        return components.addTag("parser/ISOFormatParser");
     }
 }

package/src/common/parsers/SlashDateFormatParser.ts

@@ -41,18 +41,22 @@ export default class SlashDateFormatParser implements Parser {
     extract(context: ParsingContext, match: RegExpMatchArray): ParsingResult {
         // Because of how pattern is executed on remaining text in `chrono.ts`, the character before the match could
         // still be a number (e.g. X[X/YY/ZZ] or XX[/YY/ZZ] or [XX/YY/]ZZ). We want to check and skip them.
-        if (match[OPENING_GROUP].length == 0 && match.index > 0 && match.index < context.text.length) {
-            const previousChar = context.text[match.index - 1];
-            if (previousChar >= "0" && previousChar <= "9") {
+        const index = match.index + match[OPENING_GROUP].length;
+        const indexEnd = match.index + match[0].length - match[ENDING_GROUP].length;
+        if (index > 0) {
+            const textBefore = context.text.substring(0, index);
+            if (textBefore.match("\\d/?$")) {
+                return;
+            }
+        }
+        if (indexEnd < context.text.length) {
+            const textAfter = context.text.substring(indexEnd);
+            if (textAfter.match("^/?\\d")) {
                 return;
             }
         }
 
-        const index = match.index + match[OPENING_GROUP].length;
-        const text = match[0].substr(
-            match[OPENING_GROUP].length,
-            match[0].length - match[OPENING_GROUP].length - match[ENDING_GROUP].length
-        );
+        const text = context.text.substring(index, indexEnd);
 
         // '1.12', '1.12.12' is more like a version numbers
         if (text.match(/^\d\.\d$/) || text.match(/^\d\.\d{1,2}\.\d{1,2}\s*$/)) {
@@ -61,14 +65,13 @@ export default class SlashDateFormatParser implements Parser {
 
         // MM/dd -> OK
         // MM.dd -> NG
-        if (!match[YEAR_GROUP] && match[0].indexOf("/") < 0) {
+        if (!match[YEAR_GROUP] && text.indexOf("/") < 0) {
             return;
         }
 
         const result = context.createParsingResult(index, text);
         let month = parseInt(match[this.groupNumberMonth]);
         let day = parseInt(match[this.groupNumberDay]);
-
         if (month < 1 || month > 12) {
             if (month > 12) {
                 if (day >= 1 && day <= 12 && month <= 31) {
@@ -95,6 +98,6 @@ export default class SlashDateFormatParser implements Parser {
             result.start.imply("year", year);
         }
 
-        return result;
+        return result.addTag("parser/SlashDateFormatParser");
     }
 }

package/src/common/refiners/ForwardDateRefiner.ts

@@ -15,7 +15,7 @@ export default class ForwardDateRefiner implements Refiner {
             return results;
         }
 
-        results.forEach(function (result) {
+        results.forEach((result) => {
             let refMoment = dayjs(context.refDate);
 
             if (result.start.isOnlyTime() && refMoment.isAfter(result.start.dayjs())) {
@@ -28,6 +28,9 @@ export default class ForwardDateRefiner implements Refiner {
                         implySimilarDate(result.end, refMoment);
                     }
                 }
+                context.debug(() => {
+                    console.log(`${this.constructor.name} adjusted ${result} time result (${result.start})`);
+                });
             }
 
             if (result.start.isOnlyWeekdayComponent() && refMoment.isAfter(result.start.dayjs())) {
@@ -41,7 +44,7 @@ export default class ForwardDateRefiner implements Refiner {
                 result.start.imply("month", refMoment.month() + 1);
                 result.start.imply("year", refMoment.year());
                 context.debug(() => {
-                    console.log(`Forward weekly adjusted for ${result} (${result.start})`);
+                    console.log(`${this.constructor.name} adjusted ${result} weekday (${result.start})`);
                 });
 
                 if (result.end && result.end.isOnlyWeekdayComponent()) {
@@ -56,7 +59,7 @@ export default class ForwardDateRefiner implements Refiner {
                     result.end.imply("month", refMoment.month() + 1);
                     result.end.imply("year", refMoment.year());
                     context.debug(() => {
-                        console.log(`Forward weekly adjusted for ${result} (${result.end})`);
+                        console.log(`${this.constructor.name} adjusted ${result} weekday (${result.end})`);
                     });
                 }
             }
@@ -67,13 +70,13 @@ export default class ForwardDateRefiner implements Refiner {
                 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})`);
+                        console.log(`${this.constructor.name} adjusted ${result} year (${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})`);
+                            console.log(`${this.constructor.name} adjusted ${result} month (${result.start})`);
                         });
                     }
                 }

package/src/locales/en/configuration.ts

@@ -4,7 +4,7 @@ import ENTimeUnitWithinFormatParser from "./parsers/ENTimeUnitWithinFormatParser
 import ENMonthNameLittleEndianParser from "./parsers/ENMonthNameLittleEndianParser";
 import ENMonthNameMiddleEndianParser from "./parsers/ENMonthNameMiddleEndianParser";
 import ENMonthNameParser from "./parsers/ENMonthNameParser";
-import ENCasualYearMonthDayParser from "./parsers/ENCasualYearMonthDayParser";
+import ENYearMonthDayParser from "./parsers/ENYearMonthDayParser";
 import ENSlashMonthFormatParser from "./parsers/ENSlashMonthFormatParser";
 import ENTimeExpressionParser from "./parsers/ENTimeExpressionParser";
 import ENTimeUnitAgoFormatParser from "./parsers/ENTimeUnitAgoFormatParser";
@@ -23,6 +23,8 @@ import ENTimeUnitCasualRelativeFormatParser from "./parsers/ENTimeUnitCasualRela
 import ENMergeRelativeAfterDateRefiner from "./refiners/ENMergeRelativeAfterDateRefiner";
 import ENMergeRelativeFollowByDateRefiner from "./refiners/ENMergeRelativeFollowByDateRefiner";
 import OverlapRemovalRefiner from "../../common/refiners/OverlapRemovalRefiner";
+import ENExtractYearSuffixRefiner from "./refiners/ENExtractYearSuffixRefiner";
+import ENUnlikelyFormatFilter from "./refiners/ENUnlikelyFormatFilter";
 
 export default class ENDefaultConfiguration {
     /**
@@ -36,6 +38,7 @@ export default class ENDefaultConfiguration {
         option.parsers.push(new ENMonthNameParser());
         option.parsers.push(new ENRelativeDateFormatParser());
         option.parsers.push(new ENTimeUnitCasualRelativeFormatParser());
+        option.refiners.push(new ENUnlikelyFormatFilter());
         return option;
     }
 
@@ -54,7 +57,6 @@ export default class ENDefaultConfiguration {
                     new ENMonthNameLittleEndianParser(),
                     new ENMonthNameMiddleEndianParser(/*shouldSkipYearLikeDate=*/ littleEndian),
                     new ENWeekdayParser(),
-                    new ENCasualYearMonthDayParser(),
                     new ENSlashMonthFormatParser(),
                     new ENTimeExpressionParser(strictMode),
                     new ENTimeUnitAgoFormatParser(strictMode),
@@ -64,6 +66,8 @@ export default class ENDefaultConfiguration {
             },
             strictMode
         );
+        options.parsers.unshift(new ENYearMonthDayParser(/*strictMonthDateOrder=*/ strictMode));
+
         // These relative-dates consideration should be done before other common refiners.
         options.refiners.unshift(new ENMergeRelativeFollowByDateRefiner());
         options.refiners.unshift(new ENMergeRelativeAfterDateRefiner());
@@ -71,6 +75,10 @@ export default class ENDefaultConfiguration {
 
         // Re-apply the date time refiner again after the timezone refinement and exclusion in common refiners.
         options.refiners.push(new ENMergeDateTimeRefiner());
+
+        // Extract year after merging date and time
+        options.refiners.push(new ENExtractYearSuffixRefiner());
+
         // Keep the date range refiner at the end (after all other refinements).
         options.refiners.push(new ENMergeDateRangeRefiner());
         return options;

package/src/locales/en/constants.ts

@@ -277,7 +277,7 @@ export const TIME_UNITS_NO_ABBR_PATTERN = repeatedTimeunitPattern(
     TIME_UNIT_CONNECTOR_PATTERN
 );
 
-export function parseTimeUnits(timeunitText): TimeUnits {
+export function parseTimeUnits(timeunitText): null | TimeUnits {
     const fragments = {};
     let remainingText = timeunitText;
     let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
@@ -286,10 +286,16 @@ export function parseTimeUnits(timeunitText): TimeUnits {
         remainingText = remainingText.substring(match[0].length).trim();
         match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
     }
+    if (Object.keys(fragments).length == 0) {
+        return null;
+    }
     return fragments;
 }
 
 function collectDateTimeFragment(fragments, match) {
+    if (match[0].match(/^[a-zA-Z]+$/)) {
+        return;
+    }
     const num = parseNumberPattern(match[1]);
     const unit = TIME_UNIT_DICTIONARY[match[2].toLowerCase()];
     fragments[unit] = num;

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

@@ -10,7 +10,7 @@ const PATTERN = new RegExp(
         `(${matchAnyPattern(MONTH_DICTIONARY)})` +
         `\\s*` +
         `(?:` +
-        `[,-]?\\s*(${YEAR_PATTERN})?` +
+        `(?:,|-|of)?\\s*(${YEAR_PATTERN})?` +
         ")?" +
         "(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)",
     "i"

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

@@ -1,5 +1,5 @@
 import { ParsingContext } from "../../../chrono";
-import { ParsingComponents } from "../../../results";
+import { ParsingComponents, ParsingResult } from "../../../results";
 import { Meridiem } from "../../../types";
 import { AbstractTimeExpressionParser } from "../../../common/parsers/AbstractTimeExpressionParser";
 
@@ -54,4 +54,16 @@ export default class ENTimeExpressionParser extends AbstractTimeExpressionParser
 
         return components.addTag("parser/ENTimeExpressionParser");
     }
+
+    extractFollowingTimeComponents(
+        context: ParsingContext,
+        match: RegExpMatchArray,
+        result: ParsingResult
+    ): ParsingComponents | null {
+        const followingComponents = super.extractFollowingTimeComponents(context, match, result);
+        if (followingComponents) {
+            followingComponents.addTag("parser/ENTimeExpressionParser");
+        }
+        return followingComponents;
+    }
 }

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

@@ -18,8 +18,10 @@ export default class ENTimeUnitAgoFormatParser extends AbstractParserWithWordBou
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
         const timeUnits = parseTimeUnits(match[1]);
+        if (!timeUnits) {
+            return null;
+        }
         const outputTimeUnits = reverseTimeUnits(timeUnits);
-
         return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
     }
 }

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

@@ -19,9 +19,12 @@ export default class ENTimeUnitCasualRelativeFormatParser extends AbstractParser
         return this.allowAbbreviations ? PATTERN : PATTERN_NO_ABBR;
     }
 
-    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
         const prefix = match[1].toLowerCase();
         let timeUnits = parseTimeUnits(match[2]);
+        if (!timeUnits) {
+            return null;
+        }
         switch (prefix) {
             case "last":
             case "past":
@@ -29,7 +32,6 @@ export default class ENTimeUnitCasualRelativeFormatParser extends AbstractParser
                 timeUnits = reverseTimeUnits(timeUnits);
                 break;
         }
-
         return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

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

@@ -21,7 +21,10 @@ export default class ENTimeUnitLaterFormatParser extends AbstractParserWithWordB
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        const fragments = parseTimeUnits(match[GROUP_NUM_TIMEUNITS]);
-        return ParsingComponents.createRelativeFromReference(context.reference, fragments);
+        const timeUnits = parseTimeUnits(match[GROUP_NUM_TIMEUNITS]);
+        if (!timeUnits) {
+            return null;
+        }
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

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

@@ -33,13 +33,15 @@ export default class ENTimeUnitWithinFormatParser extends AbstractParserWithWord
         return context.option.forwardDate ? PATTERN_WITH_OPTIONAL_PREFIX : PATTERN_WITH_PREFIX;
     }
 
-    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
         // Exclude "for the unit" phases, e.g. "for the year"
         if (match[0].match(/^for\s*the\s*\w+/)) {
             return null;
         }
-
         const timeUnits = parseTimeUnits(match[1]);
+        if (!timeUnits) {
+            return null;
+        }
         return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

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

@@ -4,12 +4,13 @@ import { WEEKDAY_DICTIONARY } from "../constants";
 import { matchAnyPattern } from "../../../utils/pattern";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { createParsingComponentsAtWeekday } from "../../../common/calculation/weekdays";
+import { Weekday } from "../../../types";
 
 const PATTERN = new RegExp(
     "(?:(?:\\,|\\(|\\（)\\s*)?" +
         "(?:on\\s*?)?" +
         "(?:(this|last|past|next)\\s*)?" +
-        `(${matchAnyPattern(WEEKDAY_DICTIONARY)})` +
+        `(${matchAnyPattern(WEEKDAY_DICTIONARY)}|weekend|weekday)` +
         "(?:\\s*(?:\\,|\\)|\\）))?" +
         "(?:\\s*(this|last|past|next)\\s*week)?" +
         "(?=\\W|$)",
@@ -25,9 +26,7 @@ export default class ENWeekdayParser extends AbstractParserWithWordBoundaryCheck
         return PATTERN;
     }
 
-    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
-        const dayOfWeek = match[WEEKDAY_GROUP].toLowerCase();
-        const weekday = WEEKDAY_DICTIONARY[dayOfWeek];
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | null {
         const prefix = match[PREFIX_GROUP];
         const postfix = match[POSTFIX_GROUP];
         let modifierWord = prefix || postfix;
@@ -43,6 +42,31 @@ export default class ENWeekdayParser extends AbstractParserWithWordBoundaryCheck
             modifier = "this";
         }
 
+        const weekday_word = match[WEEKDAY_GROUP].toLowerCase();
+        let weekday;
+        if (WEEKDAY_DICTIONARY[weekday_word] !== undefined) {
+            weekday = WEEKDAY_DICTIONARY[weekday_word];
+        } else if (weekday_word == "weekend") {
+            // This depends on what days are weekend setting, but typically:
+            // 'This/next weekend' means the coming Saturday, 'last weekend' means last Sunday.
+            weekday = modifier == "last" ? Weekday.SUNDAY : Weekday.SATURDAY;
+        } else if (weekday_word == "weekday") {
+            // In English, the "weekday" means any day of the week except weekend.
+            // This also depends on what days are weekend setting, but typically:
+            // - On weekend ref, this means the coming Monday or last Friday.
+            // - On weekday ref, this means the next/last working day.
+            const refWeekday = context.reference.getDateWithAdjustedTimezone().getDay();
+            if (refWeekday == Weekday.SUNDAY || refWeekday == Weekday.SATURDAY) {
+                weekday = modifier == "last" ? Weekday.FRIDAY : Weekday.MONDAY;
+            } else {
+                weekday = refWeekday - 1;
+                weekday = modifier == "last" ? weekday - 1 : weekday + 1;
+                weekday = (weekday % 5) + 1;
+            }
+        } else {
+            return null;
+        }
+
         return createParsingComponentsAtWeekday(context.reference, weekday, modifier);
     }
 }

package/src/locales/en/parsers/{ENCasualYearMonthDayParser.ts → ENYearMonthDayParser.ts}

@@ -11,8 +11,8 @@ import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/
     - YYYY.MM.DD
 */
 const PATTERN = new RegExp(
-    `([0-9]{4})[\\.\\/\\s]` +
-        `(?:(${matchAnyPattern(MONTH_DICTIONARY)})|([0-9]{1,2}))[\\.\\/\\s]` +
+    `([0-9]{4})[-\\.\\/\\s]` +
+        `(?:(${matchAnyPattern(MONTH_DICTIONARY)})|([0-9]{1,2}))[-\\.\\/\\s]` +
         `([0-9]{1,2})` +
         "(?=\\W|$)",
     "i"
@@ -23,23 +23,34 @@ const MONTH_NAME_GROUP = 2;
 const MONTH_NUMBER_GROUP = 3;
 const DATE_NUMBER_GROUP = 4;
 
-export default class ENCasualYearMonthDayParser extends AbstractParserWithWordBoundaryChecking {
+export default class ENYearMonthDayParser extends AbstractParserWithWordBoundaryChecking {
+    constructor(private strictMonthDateOrder: boolean) {
+        super();
+    }
+
     innerPattern(): RegExp {
         return PATTERN;
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        const month = match[MONTH_NUMBER_GROUP]
+        const year = parseInt(match[YEAR_NUMBER_GROUP]);
+        let day = parseInt(match[DATE_NUMBER_GROUP]);
+        let month = match[MONTH_NUMBER_GROUP]
             ? parseInt(match[MONTH_NUMBER_GROUP])
             : MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];
 
         if (month < 1 || month > 12) {
+            if (this.strictMonthDateOrder) {
+                return null;
+            }
+            if (day >= 1 && day <= 12) {
+                [month, day] = [day, month];
+            }
+        }
+        if (day < 1 || day > 31) {
             return null;
         }
 
-        const year = parseInt(match[YEAR_NUMBER_GROUP]);
-        const day = parseInt(match[DATE_NUMBER_GROUP]);
-
         return {
             day: day,
             month: month,

package/src/locales/en/refiners/ENExtractYearSuffixRefiner.ts

@@ -0,0 +1,34 @@
+import { ParsingContext, Refiner } from "../../../chrono";
+import { ParsingResult } from "../../../results";
+import { YEAR_PATTERN, parseYear } from "../constants";
+
+const YEAR_SUFFIX_PATTERN = new RegExp(`^\\s*(${YEAR_PATTERN})`, "i");
+const YEAR_GROUP = 1;
+export default class ENExtractYearSuffixRefiner implements Refiner {
+    refine(context: ParsingContext, results: ParsingResult[]): ParsingResult[] {
+        results.forEach(function (result) {
+            if (!result.start.isDateWithUnknownYear()) {
+                return;
+            }
+
+            const suffix = context.text.substring(result.index + result.text.length);
+            const match = YEAR_SUFFIX_PATTERN.exec(suffix);
+            if (!match) {
+                return;
+            }
+
+            context.debug(() => {
+                console.log(`Extracting year: '${match[0]}' into : ${result}`);
+            });
+
+            const year = parseYear(match[YEAR_GROUP]);
+            if (result.end != null) {
+                result.end.assign("year", year);
+            }
+            result.start.assign("year", year);
+            result.text += match[0];
+        });
+
+        return results;
+    }
+}

package/src/locales/en/refiners/ENMergeDateTimeRefiner.ts

@@ -8,6 +8,6 @@ import AbstractMergeDateTimeRefiner from "../../../common/refiners/AbstractMerge
  */
 export default class ENMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner {
     patternBetween(): RegExp {
-        return new RegExp("^\\s*(T|at|after|before|on|of|,|-|\\.|:)?\\s*$");
+        return new RegExp("^\\s*(T|at|after|before|on|of|,|-|\\.|∙|:)?\\s*$");
     }
 }

package/src/locales/en/refiners/ENUnlikelyFormatFilter.ts

@@ -0,0 +1,44 @@
+import { Filter } from "../../../common/abstractRefiners";
+import { ParsingResult } from "../../../results";
+
+export default class ENUnlikelyFormatFilter extends Filter {
+    constructor() {
+        super();
+    }
+
+    isValid(context, result: ParsingResult): boolean {
+        const text = result.text.trim();
+
+        // If the result is consists of the whole text (e.g. "2024", "May", etc),
+        // then it is unlikely to be a date.
+        if (text === context.text.trim()) {
+            return true;
+        }
+
+        // In English, the word "may" is a month name, but it is also a modal verb.
+        // Check if the text before "may" follows some allowed patterns.
+        if (text.toLowerCase() === "may") {
+            const textBefore = context.text.substring(0, result.index).trim();
+            if (!textBefore.match(/\b(in)$/i)) {
+                context.debug(() => {
+                    console.log(`Removing unlikely result: ${result}`);
+                });
+
+                return false;
+            }
+        }
+
+        // In English, "the second" could refer to the ordinal number or timeunit.
+        if (text.toLowerCase().endsWith("the second")) {
+            const textAfter = context.text.substring(result.index + result.text.length).trim();
+            if (textAfter.length > 0) {
+                context.debug(() => {
+                    console.log(`Removing unlikely result: ${result}`);
+                });
+            }
+            return false;
+        }
+
+        return true;
+    }
+}

package/src/results.ts

@@ -132,7 +132,9 @@ export class ParsingComponents implements ParsedComponents {
     }
 
     isOnlyTime(): boolean {
-        return !this.isCertain("weekday") && !this.isCertain("day") && !this.isCertain("month");
+        return (
+            !this.isCertain("weekday") && !this.isCertain("day") && !this.isCertain("month") && !this.isCertain("year")
+        );
     }
 
     isOnlyWeekdayComponent(): boolean {
@@ -214,7 +216,9 @@ export class ParsingComponents implements ParsedComponents {
         }
 
         const components = new ParsingComponents(reference);
+        components.addTag("result/relativeDate");
         if (fragments["hour"] || fragments["minute"] || fragments["second"]) {
+            components.addTag("result/relativeDateAndTime");
             assignSimilarTime(components, date);
             assignSimilarDate(components, date);
             if (reference.timezoneOffset !== null) {
@@ -230,11 +234,12 @@ export class ParsingComponents implements ParsedComponents {
                 components.assign("day", date.date());
                 components.assign("month", date.month() + 1);
                 components.assign("year", date.year());
+            } else if (fragments["week"]) {
+                components.assign("day", date.date());
+                components.assign("month", date.month() + 1);
+                components.assign("year", date.year());
+                components.imply("weekday", date.day());
             } else {
-                if (fragments["week"]) {
-                    components.imply("weekday", date.day());
-                }
-
                 components.imply("day", date.date());
                 if (fragments["month"]) {
                     components.assign("month", date.month() + 1);
@@ -290,6 +295,22 @@ export class ParsingResult implements ParsedResult {
         return this.start.date();
     }
 
+    addTag(tag: string): ParsingResult {
+        this.start.addTag(tag);
+        if (this.end) {
+            this.end.addTag(tag);
+        }
+        return this;
+    }
+
+    addTags(tags: string[] | Set<string>): ParsingResult {
+        this.start.addTags(tags);
+        if (this.end) {
+            this.end.addTags(tags);
+        }
+        return this;
+    }
+
     tags(): Set<string> {
         const combinedTags: Set<string> = new Set(this.start.tags());
         if (this.end) {

package/test/en/en_casual.test.ts

@@ -412,6 +412,10 @@ test("Test - Random negative text", () => {
 
     testUnexpectedResult(chrono, "do I have the money");
 
+    testUnexpectedResult(chrono, "I may by here. May the force be with you. Theresa may become PM soon.");
+
+    testUnexpectedResult(chrono, "XXX is set to be released in the second half of 2025");
+
     testUnexpectedResult(chrono.casual, "do I have the money");
 
     testUnexpectedResult(chrono.en.GB, "do I have the money");