chrono-node 2.7.8 → 2.8.0

package/src/locales/it/parsers/ITCasualYearMonthDayParser.ts

@@ -0,0 +1,49 @@
+import { ParsingContext } from "../../../chrono";
+import { MONTH_DICTIONARY } from "../constants";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+/*
+    Date format with slash "/" between numbers like ENSlashDateFormatParser,
+    but this parser expect year before month and date.
+    - YYYY/MM/DD
+    - YYYY-MM-DD
+    - YYYY.MM.DD
+*/
+const PATTERN = new RegExp(
+    `([0-9]{4})[\\.\\/\\s]` +
+        `(?:(${matchAnyPattern(MONTH_DICTIONARY)})|([0-9]{1,2}))[\\.\\/\\s]` +
+        `([0-9]{1,2})` +
+        "(?=\\W|$)",
+    "i"
+);
+
+const YEAR_NUMBER_GROUP = 1;
+const MONTH_NAME_GROUP = 2;
+const MONTH_NUMBER_GROUP = 3;
+const DATE_NUMBER_GROUP = 4;
+
+export default class ENCasualYearMonthDayParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const month = match[MONTH_NUMBER_GROUP]
+            ? parseInt(match[MONTH_NUMBER_GROUP])
+            : MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];
+
+        if (month < 1 || month > 12) {
+            return null;
+        }
+
+        const year = parseInt(match[YEAR_NUMBER_GROUP]);
+        const day = parseInt(match[DATE_NUMBER_GROUP]);
+
+        return {
+            day: day,
+            month: month,
+            year: year,
+        };
+    }
+}

package/src/locales/it/parsers/ITMonthNameLittleEndianParser.ts

@@ -0,0 +1,69 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingResult } from "../../../results";
+import { findYearClosestToRef } from "../../../calculation/years";
+import { MONTH_DICTIONARY } from "../constants";
+import { YEAR_PATTERN, parseYear } from "../constants";
+import { ORDINAL_NUMBER_PATTERN, parseOrdinalNumberPattern } from "../constants";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+// prettier-ignore
+const PATTERN = new RegExp(
+    `(?:on\\s{0,3})?` +
+        `(${ORDINAL_NUMBER_PATTERN})` +
+        `(?:` +
+            `\\s{0,3}(?:al|\\-|\\–|fino|alle|allo)?\\s{0,3}` +
+            `(${ORDINAL_NUMBER_PATTERN})` +
+        ")?" +
+        `(?:-|/|\\s{0,3}(?:dal)?\\s{0,3})` +
+        `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+        "(?:" +
+            `(?:-|/|,?\\s{0,3})` +
+            `(${YEAR_PATTERN}(?![^\\s]\\d))` +
+        ")?" +
+        "(?=\\W|$)",
+    "i"
+);
+
+const DATE_GROUP = 1;
+const DATE_TO_GROUP = 2;
+const MONTH_NAME_GROUP = 3;
+const YEAR_GROUP = 4;
+
+export default class ENMonthNameLittleEndianParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingResult {
+        const result = context.createParsingResult(match.index, match[0]);
+
+        const month = MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];
+        const day = parseOrdinalNumberPattern(match[DATE_GROUP]);
+        if (day > 31) {
+            // e.g. "[96 Aug]" => "9[6 Aug]", we need to shift away from the next number
+            match.index = match.index + match[DATE_GROUP].length;
+            return null;
+        }
+
+        result.start.assign("month", month);
+        result.start.assign("day", day);
+
+        if (match[YEAR_GROUP]) {
+            const yearNumber = parseYear(match[YEAR_GROUP]);
+            result.start.assign("year", yearNumber);
+        } else {
+            const year = findYearClosestToRef(context.refDate, day, month);
+            result.start.imply("year", year);
+        }
+
+        if (match[DATE_TO_GROUP]) {
+            const endDate = parseOrdinalNumberPattern(match[DATE_TO_GROUP]);
+
+            result.end = result.start.clone();
+            result.end.assign("day", endDate);
+        }
+
+        return result;
+    }
+}

package/src/locales/it/parsers/ITMonthNameMiddleEndianParser.ts

@@ -0,0 +1,78 @@
+import { ParsingContext } from "../../../chrono";
+import { findYearClosestToRef } from "../../../calculation/years";
+import { MONTH_DICTIONARY } from "../constants";
+import { ORDINAL_NUMBER_PATTERN, parseOrdinalNumberPattern } from "../constants";
+import { YEAR_PATTERN, parseYear } from "../constants";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const PATTERN = new RegExp(
+    `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+        "(?:-|/|\\s*,?\\s*)" +
+        `(${ORDINAL_NUMBER_PATTERN})(?!\\s*(?:am|pm))\\s*` +
+        "(?:" +
+        "(?:al|\\-|\\alle|\\del|\\s)\\s*" +
+        `(${ORDINAL_NUMBER_PATTERN})\\s*` +
+        ")?" +
+        "(?:" +
+        "(?:-|/|\\s*,?\\s*)" +
+        `(${YEAR_PATTERN})` +
+        ")?" +
+        "(?=\\W|$)(?!\\:\\d)",
+    "i"
+);
+
+const MONTH_NAME_GROUP = 1;
+const DATE_GROUP = 2;
+const DATE_TO_GROUP = 3;
+const YEAR_GROUP = 4;
+
+/**
+ * The parser for parsing US's date format that begin with month's name.
+ *  - January 13
+ *  - January 13, 2012
+ *  - January 13 - 15, 2012
+ * Note: Watch out for:
+ *  - January 12:00
+ *  - January 12.44
+ *  - January 1222344
+ */
+export default class ENMonthNameMiddleEndianParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const month = MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];
+        const day = parseOrdinalNumberPattern(match[DATE_GROUP]);
+        if (day > 31) {
+            return null;
+        }
+
+        const components = context.createParsingComponents({
+            day: day,
+            month: month,
+        });
+
+        if (match[YEAR_GROUP]) {
+            const year = parseYear(match[YEAR_GROUP]);
+            components.assign("year", year);
+        } else {
+            const year = findYearClosestToRef(context.refDate, day, month);
+            components.imply("year", year);
+        }
+
+        if (!match[DATE_TO_GROUP]) {
+            return components;
+        }
+
+        // Text can be 'range' value. Such as 'January 12 - 13, 2012'
+        const endDate = parseOrdinalNumberPattern(match[DATE_TO_GROUP]);
+        const result = context.createParsingResult(match.index, match[0]);
+        result.start = components;
+        result.end = components.clone();
+        result.end.assign("day", endDate);
+
+        return result;
+    }
+}

package/src/locales/it/parsers/ITMonthNameParser.ts

@@ -0,0 +1,62 @@
+import { FULL_MONTH_NAME_DICTIONARY, MONTH_DICTIONARY } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { findYearClosestToRef } from "../../../calculation/years";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { YEAR_PATTERN, parseYear } from "../constants";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const PATTERN = new RegExp(
+    `((?:in)\\s*)?` +
+        `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+        `\\s*` +
+        `(?:` +
+        `[,-]?\\s*(${YEAR_PATTERN})?` +
+        ")?" +
+        "(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)",
+    "i"
+);
+
+const PREFIX_GROUP = 1;
+const MONTH_NAME_GROUP = 2;
+const YEAR_GROUP = 3;
+
+/**
+ * The parser for parsing month name and year.
+ * - January, 2012
+ * - January 2012
+ * - January
+ * (in) Jan
+ */
+export default class ENMonthNameParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const monthName = match[MONTH_NAME_GROUP].toLowerCase();
+
+        // skip some unlikely words "jan", "mar", ..
+        if (match[0].length <= 3 && !FULL_MONTH_NAME_DICTIONARY[monthName]) {
+            return null;
+        }
+
+        const result = context.createParsingResult(
+            match.index + (match[PREFIX_GROUP] || "").length,
+            match.index + match[0].length
+        );
+        result.start.imply("day", 1);
+
+        const month = MONTH_DICTIONARY[monthName];
+        result.start.assign("month", month);
+
+        if (match[YEAR_GROUP]) {
+            const year = parseYear(match[YEAR_GROUP]);
+            result.start.assign("year", year);
+        } else {
+            const year = findYearClosestToRef(context.refDate, 1, month);
+            result.start.imply("year", year);
+        }
+
+        return result;
+    }
+}

package/src/locales/it/parsers/ITRelativeDateFormatParser.ts

@@ -0,0 +1,71 @@
+import { TIME_UNIT_DICTIONARY } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import dayjs from "dayjs";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { matchAnyPattern } from "../../../utils/pattern";
+
+const PATTERN = new RegExp(
+    `(questo|ultimo|scorso|prossimo|dopo\\s*questo|questa|ultima|scorsa|prossima\\s*questa)\\s*(${matchAnyPattern(
+        TIME_UNIT_DICTIONARY
+    )})(?=\\s*)` + "(?=\\W|$)",
+    "i"
+);
+
+const MODIFIER_WORD_GROUP = 1;
+const RELATIVE_WORD_GROUP = 2;
+
+export default class ENRelativeDateFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const modifier = match[MODIFIER_WORD_GROUP].toLowerCase();
+        const unitWord = match[RELATIVE_WORD_GROUP].toLowerCase();
+        const timeunit = TIME_UNIT_DICTIONARY[unitWord];
+
+        if (modifier == "prossimo" || modifier.startsWith("dopo")) {
+            const timeUnits = {};
+            timeUnits[timeunit] = 1;
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+        }
+
+        if (modifier == "prima" || modifier == "precedente") {
+            const timeUnits = {};
+            timeUnits[timeunit] = -1;
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+        }
+
+        const components = context.createParsingComponents();
+        let date = dayjs(context.reference.instant);
+
+        // This week
+        if (unitWord.match(/settimana/i)) {
+            date = date.add(-date.get("d"), "d");
+            components.imply("day", date.date());
+            components.imply("month", date.month() + 1);
+            components.imply("year", date.year());
+        }
+
+        // This month
+        else if (unitWord.match(/mese/i)) {
+            date = date.add(-date.date() + 1, "d");
+            components.imply("day", date.date());
+            components.assign("year", date.year());
+            components.assign("month", date.month() + 1);
+        }
+
+        // This year
+        else if (unitWord.match(/anno/i)) {
+            date = date.add(-date.date() + 1, "d");
+            date = date.add(-date.month(), "month");
+
+            components.imply("day", date.date());
+            components.imply("month", date.month() + 1);
+            components.assign("year", date.year());
+        }
+
+        return components;
+    }
+}

package/src/locales/it/parsers/ITSlashMonthFormatParser.ts

@@ -0,0 +1,26 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const PATTERN = new RegExp("([0-9]|0[1-9]|1[012])/([0-9]{4})" + "", "i");
+
+const MONTH_GROUP = 1;
+const YEAR_GROUP = 2;
+
+/**
+ * Month/Year date format with slash "/" (also "-" and ".") between numbers
+ * - 11/05
+ * - 06/2005
+ */
+export default class ENSlashMonthFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const year = parseInt(match[YEAR_GROUP]);
+        const month = parseInt(match[MONTH_GROUP]);
+
+        return context.createParsingComponents().imply("day", 1).assign("month", month).assign("year", year);
+    }
+}

package/src/locales/it/parsers/ITTimeExpressionParser.ts

@@ -0,0 +1,55 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { Meridiem } from "../../../index";
+import { AbstractTimeExpressionParser } from "../../../common/parsers/AbstractTimeExpressionParser";
+
+export default class ENTimeExpressionParser extends AbstractTimeExpressionParser {
+    constructor(strictMode) {
+        super(strictMode);
+    }
+
+    followingPhase(): string {
+        return "\\s*(?:\\-|\\–|\\~|\\〜|to|\\?)\\s*";
+    }
+
+    primaryPrefix(): string {
+        return "(?:(?:alle|dalle)\\s*)??";
+    }
+
+    primarySuffix(): string {
+        return "(?:\\s*(?:o\\W*in punto|alle\\s*sera|in\\s*del\\s*(?:mattina|pomeriggio)))?(?!/)(?=\\W|$)";
+    }
+
+    extractPrimaryTimeComponents(context: ParsingContext, match: RegExpMatchArray): null | ParsingComponents {
+        const components = super.extractPrimaryTimeComponents(context, match);
+        if (components) {
+            if (match[0].endsWith("sera")) {
+                const hour = components.get("hour");
+                if (hour >= 6 && hour < 12) {
+                    components.assign("hour", components.get("hour") + 12);
+                    components.assign("meridiem", Meridiem.PM);
+                } else if (hour < 6) {
+                    components.assign("meridiem", Meridiem.AM);
+                }
+            }
+
+            if (match[0].endsWith("pomeriggio")) {
+                components.assign("meridiem", Meridiem.PM);
+                const hour = components.get("hour");
+                if (hour >= 0 && hour <= 6) {
+                    components.assign("hour", components.get("hour") + 12);
+                }
+            }
+
+            if (match[0].endsWith("mattina")) {
+                components.assign("meridiem", Meridiem.AM);
+                const hour = components.get("hour");
+                if (hour < 12) {
+                    components.assign("hour", components.get("hour"));
+                }
+            }
+        }
+
+        return components;
+    }
+}

package/src/locales/it/parsers/ITTimeUnitAgoFormatParser.ts

@@ -0,0 +1,25 @@
+import { ParsingContext } from "../../../chrono";
+import { parseTimeUnits, 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}(?:fa|prima|precedente)(?=(?:\\W|$))`, "i");
+const STRICT_PATTERN = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}fa(?=(?:\\W|$))`, "i");
+
+export default class ENTimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor(private strictMode: boolean) {
+        super();
+    }
+
+    innerPattern(): RegExp {
+        return this.strictMode ? STRICT_PATTERN : PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const timeUnits = parseTimeUnits(match[1]);
+        const outputTimeUnits = reverseTimeUnits(timeUnits);
+
+        return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
+    }
+}

package/src/locales/it/parsers/ITTimeUnitCasualRelativeFormatParser.ts

@@ -0,0 +1,30 @@
+import { TIME_UNITS_PATTERN, parseTimeUnits } 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(
+    `(questo|ultimo|passato|prossimo|dopo|questa|ultima|passata|prossima|\\+|-)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`,
+    "i"
+);
+
+export default class ENTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const prefix = match[1].toLowerCase();
+        let timeUnits = parseTimeUnits(match[2]);
+        switch (prefix) {
+            case "last":
+            case "past":
+            case "-":
+                timeUnits = reverseTimeUnits(timeUnits);
+                break;
+        }
+
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}

package/src/locales/it/parsers/ITTimeUnitLaterFormatParser.ts

@@ -0,0 +1,27 @@
+import { ParsingContext } from "../../../chrono";
+import { parseTimeUnits, TIME_UNITS_PATTERN } from "../constants";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const PATTERN = new RegExp(
+    `(${TIME_UNITS_PATTERN})\\s{0,5}(?:dopo|più tardi|da adesso|avanti|oltre|a seguire)` + "(?=(?:\\W|$))",
+    "i"
+);
+
+const STRICT_PATTERN = new RegExp("" + "(" + TIME_UNITS_PATTERN + ")" + "(dopo|più tardi)" + "(?=(?:\\W|$))", "i");
+const GROUP_NUM_TIMEUNITS = 1;
+
+export default class ENTimeUnitLaterFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor(private strictMode: boolean) {
+        super();
+    }
+
+    innerPattern(): RegExp {
+        return this.strictMode ? STRICT_PATTERN : PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const fragments = parseTimeUnits(match[GROUP_NUM_TIMEUNITS]);
+        return ParsingComponents.createRelativeFromReference(context.reference, fragments);
+    }
+}

package/src/locales/it/parsers/ITTimeUnitWithinFormatParser.ts

@@ -0,0 +1,26 @@
+import { TIME_UNITS_PATTERN, parseTimeUnits } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const PATTERN_WITH_PREFIX = new RegExp(
+    `(?:within|in|for)\\s*` +
+        `(?:(?:più o meno|intorno|approssimativamente|verso|verso le)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})(?=\\W|$)`,
+    "i"
+);
+
+const PATTERN_WITHOUT_PREFIX = new RegExp(
+    `(?:(?:più o meno|intorno|approssimativamente|verso|verso le)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})(?=\\W|$)`,
+    "i"
+);
+
+export default class ENTimeUnitWithinFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(context: ParsingContext): RegExp {
+        return context.option.forwardDate ? PATTERN_WITHOUT_PREFIX : PATTERN_WITH_PREFIX;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const timeUnits = parseTimeUnits(match[1]);
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}

package/src/locales/it/parsers/ITWeekdayParser.ts

@@ -0,0 +1,47 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { WEEKDAY_DICTIONARY } from "../constants";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { createParsingComponentsAtWeekday } from "../../../common/calculation/weekdays";
+
+const PATTERN = new RegExp(
+    "(?:(?:\\,|\\(|\\（)\\s*)?" +
+        "(?:il\\s*?)?" +
+        "(?:(questa|l'ultima|scorsa|prossima)\\s*)?" +
+        `(${matchAnyPattern(WEEKDAY_DICTIONARY)})` +
+        "(?:\\s*(?:\\,|\\)|\\）))?" +
+        "(?:\\s*(questa|l'ultima|scorsa|prossima)\\s*settimana)?" +
+        "(?=\\W|$)",
+    "i"
+);
+
+const PREFIX_GROUP = 1;
+const WEEKDAY_GROUP = 2;
+const POSTFIX_GROUP = 3;
+
+export default class ITWeekdayParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const dayOfWeek = match[WEEKDAY_GROUP].toLowerCase();
+        const weekday = WEEKDAY_DICTIONARY[dayOfWeek];
+        const prefix = match[PREFIX_GROUP];
+        const postfix = match[POSTFIX_GROUP];
+        let modifierWord = prefix || postfix;
+        modifierWord = modifierWord || "";
+        modifierWord = modifierWord.toLowerCase();
+
+        let modifier = null;
+        if (modifierWord == "ultima" || modifierWord == "scorsa") {
+            modifier = "ultima";
+        } else if (modifierWord == "prossima") {
+            modifier = "prossima";
+        } else if (modifierWord == "questa") {
+            modifier = "questa";
+        }
+        return createParsingComponentsAtWeekday(context.reference, weekday, modifier);
+    }
+}

package/src/locales/it/refiners/ITMergeDateRangeRefiner.ts

@@ -0,0 +1,17 @@
+/*
+  
+*/
+
+import AbstractMergeDateRangeRefiner from "../../../common/refiners/AbstractMergeDateRangeRefiner";
+
+/**
+ * Merging before and after results (see. AbstractMergeDateRangeRefiner)
+ * This implementation should provide English connecting phases
+ * - 2020-02-13 [to] 2020-02-13
+ * - Wednesday [-] Friday
+ */
+export default class ENMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner {
+    patternBetween(): RegExp {
+        return /^\s*(to|-)\s*$/i;
+    }
+}

package/src/locales/it/refiners/ITMergeDateTimeRefiner.ts

@@ -0,0 +1,13 @@
+import AbstractMergeDateTimeRefiner from "../../../common/refiners/AbstractMergeDateTimeRefiner";
+
+/**
+ * Merging date-only result and time-only result (see. AbstractMergeDateTimeRefiner).
+ * This implementation should provide English connecting phases
+ * - 2020-02-13 [at] 6pm
+ * - Tomorrow [after] 7am
+ */
+export default class ENMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner {
+    patternBetween(): RegExp {
+        return new RegExp("^\\s*(T|alle|dopo|prima|il|di|del|delle|,|-)?\\s*$");
+    }
+}

package/src/locales/it/refiners/ITMergeRelativeDateRefiner.ts

@@ -0,0 +1,58 @@
+import { MergingRefiner } from "../../../common/abstractRefiners";
+import { ParsingComponents, ParsingResult, ReferenceWithTimezone } from "../../../results";
+import { parseTimeUnits } from "../constants";
+import { reverseTimeUnits } from "../../../utils/timeunits";
+
+function hasImpliedEarlierReferenceDate(result: ParsingResult): boolean {
+    return result.text.match(/\s+(prima|dal)$/i) != null;
+}
+
+function hasImpliedLaterReferenceDate(result: ParsingResult): boolean {
+    return result.text.match(/\s+(dopo|dal|fino)$/i) != null;
+}
+
+/**
+ * Merges an absolute date with a relative date.
+ * - 2 weeks before 2020-02-13
+ * - 2 days after next Friday
+ */
+export default class ENMergeRelativeDateRefiner extends MergingRefiner {
+    patternBetween(): RegExp {
+        return /^\s*$/i;
+    }
+
+    shouldMergeResults(textBetween: string, currentResult: ParsingResult, nextResult: ParsingResult): boolean {
+        // Dates need to be next to each other to get merged
+        if (!textBetween.match(this.patternBetween())) {
+            return false;
+        }
+
+        // Check if any relative tokens were swallowed by the first date.
+        // E.g. [<relative_date1> from] [<date2>]
+        if (!hasImpliedEarlierReferenceDate(currentResult) && !hasImpliedLaterReferenceDate(currentResult)) {
+            return false;
+        }
+
+        // make sure that <date2> implies an absolute date
+        return !!nextResult.start.get("day") && !!nextResult.start.get("month") && !!nextResult.start.get("year");
+    }
+
+    mergeResults(textBetween: string, currentResult: ParsingResult, nextResult: ParsingResult): ParsingResult {
+        let timeUnits = parseTimeUnits(currentResult.text);
+        if (hasImpliedEarlierReferenceDate(currentResult)) {
+            timeUnits = reverseTimeUnits(timeUnits);
+        }
+
+        const components = ParsingComponents.createRelativeFromReference(
+            new ReferenceWithTimezone(nextResult.start.date()),
+            timeUnits
+        );
+
+        return new ParsingResult(
+            nextResult.reference,
+            currentResult.index,
+            `${currentResult.text}${textBetween}${nextResult.text}`,
+            components
+        );
+    }
+}