chrono-node 2.10.0 → 2.10.2

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

@@ -4,7 +4,7 @@ import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/
 import { assignSimilarDate } from "../../../utils/dates";
 import * as references from "../../../common/casualReferences";
 
-const PATTERN = /(ora|oggi|stasera|questa sera|domani|dmn|ieri\s*sera)(?=\W|$)/i;
+const PATTERN = /(adesso|ora|oggi|stasera|stanotte|domani|dopodomani|ieri|ieri\s*sera|ieri\s*notte)(?=\W|$)/i;
 
 export default class ITCasualDateParser extends AbstractParserWithWordBoundaryChecking {
     innerPattern(context: ParsingContext): RegExp {
@@ -14,28 +14,37 @@ export default class ITCasualDateParser extends AbstractParserWithWordBoundaryCh
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult {
         let targetDate = context.refDate;
         const lowerText = match[0].toLowerCase();
-        const component = context.createParsingComponents();
+        let component = context.createParsingComponents();
 
         switch (lowerText) {
+            case "adesso":
             case "ora":
-                return references.now(context.reference);
+                component = references.now(context.reference);
+                break;
 
             case "oggi":
-                return references.today(context.reference);
+                component = references.today(context.reference);
+                break;
 
             case "ieri":
-                return references.yesterday(context.reference);
+                component = references.yesterday(context.reference);
+                break;
 
             case "domani":
-            case "dmn":
-                return references.tomorrow(context.reference);
+                component = references.tomorrow(context.reference);
+                break;
 
             case "stasera":
-            case "questa sera":
-                return references.tonight(context.reference);
+            case "stanotte":
+                component = references.tonight(context.reference);
+                break;
+
+            case "dopodomani":
+                component = references.theDayAfter(context.reference, 2);
+                break;
 
             default:
-                if (lowerText.match(/ieri\s*sera/)) {
+                if (lowerText.match(/ieri\s*sera/) || lowerText.match(/ieri\s*notte/)) {
                     if (targetDate.getHours() > 6) {
                         const previousDay = new Date(targetDate.getTime());
                         previousDay.setDate(previousDay.getDate() - 1);
@@ -45,10 +54,9 @@ export default class ITCasualDateParser extends AbstractParserWithWordBoundaryCh
                     assignSimilarDate(component, targetDate);
                     component.imply("hour", 0);
                 }
-
                 break;
         }
-
+        component.addTag("parser/ITCasualDateParser");
         return component;
     }
 }

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

@@ -1,57 +1,52 @@
 import { ParsingContext } from "../../../chrono";
-import { Meridiem } from "../../../index";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
-import { assignSimilarDate, implySimilarTime } from "../../../utils/dates";
+import * as casualReferences from "../../../common/casualReferences";
 
-const PATTERN = /(?:questo|questa)?\s{0,3}(mattina|pomeriggio|sera|notte|mezzanotte|mezzogiorno)(?=\W|$)/i;
+const PATTERN =
+    /(stamattina|stasera|stanotte|stamani)|(questa\s*)?(mattina|pomeriggio|sera|notte|mezzanotte|mezzogiorno)(?=\W|$)/i;
 
 export default class ITCasualTimeParser extends AbstractParserWithWordBoundaryChecking {
     innerPattern() {
         return PATTERN;
     }
-
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        const targetDate = context.refDate;
-        const component = context.createParsingComponents();
-
-        switch (match[1].toLowerCase()) {
-            case "pomeriggio":
-                component.imply("meridiem", Meridiem.PM);
-                component.imply("hour", 15);
-                component.addTag("casualReference/afternoon");
-                break;
-
-            case "sera":
-            case "notte":
-                component.imply("meridiem", Meridiem.PM);
-                component.imply("hour", 20);
-                component.addTag("casualReference/evening");
-                break;
-
-            case "mezzanotte":
-                const nextDay = new Date(targetDate.getTime());
-                nextDay.setDate(nextDay.getDate() + 1);
-                assignSimilarDate(component, nextDay);
-                implySimilarTime(component, nextDay);
-                component.imply("hour", 0);
-                component.imply("minute", 0);
-                component.imply("second", 0);
-                component.addTag("casualReference/midnight");
-                break;
-
-            case "mattina":
-                component.imply("meridiem", Meridiem.AM);
-                component.imply("hour", 6);
-                component.addTag("casualReference/morning");
-                break;
-
-            case "mezzogiorno":
-                component.imply("meridiem", Meridiem.AM);
-                component.imply("hour", 12);
-                component.addTag("casualReference/noon");
-                break;
+        let component = null;
+
+        // Handle compound words like "stamattina", "stasera", etc.
+        if (match[1]) {
+            switch (match[1].toLowerCase()) {
+                case "stamattina":
+                case "stamani":
+                    component = casualReferences.morning(context.reference);
+                    break;
+                case "stasera":
+                case "stanotte":
+                    component = casualReferences.evening(context.reference);
+                    break;
+            }
+        } else if (match[3]) {
+            switch (match[3].toLowerCase()) {
+                case "pomeriggio":
+                    component = casualReferences.afternoon(context.reference);
+                    break;
+                case "sera":
+                case "notte":
+                    component = casualReferences.evening(context.reference);
+                    break;
+                case "mezzanotte":
+                    component = casualReferences.midnight(context.reference);
+                    break;
+                case "mattina":
+                    component = casualReferences.morning(context.reference);
+                    break;
+                case "mezzogiorno":
+                    component = casualReferences.noon(context.reference);
+                    break;
+            }
+        }
+        if (component) {
+            component.addTag("parser/ITCasualTimeParser");
         }
-
         return component;
     }
 }

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

@@ -9,17 +9,17 @@ import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/
 
 // prettier-ignore
 const PATTERN = new RegExp(
-    `(?:on\\s{0,3})?` +
+    `(?:il\\s{0,3})?` +
         `(${ORDINAL_NUMBER_PATTERN})` +
         `(?:` +
-            `\\s{0,3}(?:al|\\-|\\–|fino|alle|allo)?\\s{0,3}` +
+            `\\s{0,3}(?:al|\\-|\\–|fino\\s*al?)?\\s{0,3}` +
             `(${ORDINAL_NUMBER_PATTERN})` +
         ")?" +
-        `(?:-|/|\\s{0,3}(?:dal)?\\s{0,3})` +
+        `(?:-|/|\\s{0,3}(?:di)?\\s{0,3})` +
         `(${matchAnyPattern(MONTH_DICTIONARY)})` +
         "(?:" +
             `(?:-|/|,?\\s{0,3})` +
-            `(${YEAR_PATTERN}(?![^\\s]\\d))` +
+            `(${YEAR_PATTERN}(?!\\w))` +
         ")?" +
         "(?=\\W|$)",
     "i"
@@ -30,7 +30,7 @@ const DATE_TO_GROUP = 2;
 const MONTH_NAME_GROUP = 3;
 const YEAR_GROUP = 4;
 
-export default class ENMonthNameLittleEndianParser extends AbstractParserWithWordBoundaryChecking {
+export default class ITMonthNameLittleEndianParser extends AbstractParserWithWordBoundaryChecking {
     innerPattern(): RegExp {
         return PATTERN;
     }
@@ -41,7 +41,7 @@ export default class ENMonthNameLittleEndianParser extends AbstractParserWithWor
         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
+            // e.g. "[96 Ago]" => "9[6 Ago]", we need to shift away from the next number
             match.index = match.index + match[DATE_GROUP].length;
             return null;
         }

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

@@ -6,17 +6,18 @@ import { YEAR_PATTERN, parseYear } from "../constants";
 import { matchAnyPattern } from "../../../utils/pattern";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 
+// prettier-ignore
 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*` +
+            "(?:al|\\-)\\s*" +
+            `(${ORDINAL_NUMBER_PATTERN})\\s*` +
         ")?" +
         "(?:" +
-        "(?:-|/|\\s*,?\\s*)" +
-        `(${YEAR_PATTERN})` +
+            `(?:-|/|\\s*,\\s*|\\s+)` +
+            `(${YEAR_PATTERN})` +
         ")?" +
         "(?=\\W|$)(?!\\:\\d)",
     "i"
@@ -28,16 +29,24 @@ 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
+ * The parser for parsing date format that begin with month's name.
+ *  - Gennaio 13
+ *  - Gennaio 13, 2012
+ *  - Gennaio 13 - 15, 2012
  * Note: Watch out for:
- *  - January 12:00
- *  - January 12.44
- *  - January 1222344
+ *  - Gennaio 12:00
+ *  - Gennaio 12.44
+ *  - Gennaio 1222344
+ *  - Gennaio 21 (when shouldSkipYearLikeDate=true)
  */
-export default class ENMonthNameMiddleEndianParser extends AbstractParserWithWordBoundaryChecking {
+export default class ITMonthNameMiddleEndianParser extends AbstractParserWithWordBoundaryChecking {
+    shouldSkipYearLikeDate: boolean;
+
+    constructor(shouldSkipYearLikeDate: boolean) {
+        super();
+        this.shouldSkipYearLikeDate = shouldSkipYearLikeDate;
+    }
+
     innerPattern(): RegExp {
         return PATTERN;
     }
@@ -49,10 +58,18 @@ export default class ENMonthNameMiddleEndianParser extends AbstractParserWithWor
             return null;
         }
 
-        const components = context.createParsingComponents({
-            day: day,
-            month: month,
-        });
+        // Skip the case where the day looks like a year (ex: Gennaio 21)
+        if (this.shouldSkipYearLikeDate) {
+            if (!match[DATE_TO_GROUP] && !match[YEAR_GROUP] && match[DATE_GROUP].match(/^2[0-5]$/)) {
+                return null;
+            }
+        }
+        const components = context
+            .createParsingComponents({
+                day: day,
+                month: month,
+            })
+            .addTag("parser/ITMonthNameMiddleEndianParser");
 
         if (match[YEAR_GROUP]) {
             const year = parseYear(match[YEAR_GROUP]);
@@ -66,7 +83,7 @@ export default class ENMonthNameMiddleEndianParser extends AbstractParserWithWor
             return components;
         }
 
-        // Text can be 'range' value. Such as 'January 12 - 13, 2012'
+        // Text can be 'range' value. Such as 'Gennaio 12 - 13, 2012'
         const endDate = parseOrdinalNumberPattern(match[DATE_TO_GROUP]);
         const result = context.createParsingResult(match.index, match[0]);
         result.start = components;

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

@@ -6,11 +6,11 @@ import { YEAR_PATTERN, parseYear } from "../constants";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 
 const PATTERN = new RegExp(
-    `((?:in)\\s*)?` +
+    `((?:a|in|di|del)\\s*)?` +
         `(${matchAnyPattern(MONTH_DICTIONARY)})` +
         `\\s*` +
         `(?:` +
-        `[,-]?\\s*(${YEAR_PATTERN})?` +
+        `(?:,|-|del)?\\s*(${YEAR_PATTERN})?` +
         ")?" +
         "(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)",
     "i"
@@ -22,12 +22,12 @@ const YEAR_GROUP = 3;
 
 /**
  * The parser for parsing month name and year.
- * - January, 2012
- * - January 2012
- * - January
- * (in) Jan
+ * - Gennaio, 2012
+ * - Gennaio 2012
+ * - Gennaio
+ * (a/in/di/del) Gen
  */
-export default class ENMonthNameParser extends AbstractParserWithWordBoundaryChecking {
+export default class ITMonthNameParser extends AbstractParserWithWordBoundaryChecking {
     innerPattern(): RegExp {
         return PATTERN;
     }
@@ -35,7 +35,7 @@ export default class ENMonthNameParser extends AbstractParserWithWordBoundaryChe
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
         const monthName = match[MONTH_NAME_GROUP].toLowerCase();
 
-        // skip some unlikely words "jan", "mar", ..
+        // skip some unlikely words "gen", "mar", ..
         if (match[0].length <= 3 && !FULL_MONTH_NAME_DICTIONARY[monthName]) {
             return null;
         }
@@ -45,6 +45,7 @@ export default class ENMonthNameParser extends AbstractParserWithWordBoundaryChe
             match.index + match[0].length
         );
         result.start.imply("day", 1);
+        result.start.addTag("parser/ITMonthNameParser");
 
         const month = MONTH_DICTIONARY[monthName];
         result.start.assign("month", month);

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

@@ -4,15 +4,24 @@ import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { matchAnyPattern } from "../../../utils/pattern";
 
+// Italian uses "il mese prossimo" (article + noun + modifier) more commonly than "il prossimo mese"
 const PATTERN = new RegExp(
-    `(questo|ultimo|scorso|prossimo|dopo\\s*questo|questa|ultima|scorsa|prossima\\s*questa)\\s*(${matchAnyPattern(
-        TIME_UNIT_DICTIONARY
-    )})(?=\\s*)` + "(?=\\W|$)",
+    "(?:" +
+        // Pattern 1: "il prossimo mese" / "la prossima settimana" (modifier before noun)
+        `(?:il\\s*|la\\s*|l'\\s*)?(questo|questa|quest'|scorso|scorsa|prossimo|prossima|dopo\\s*questo|dopo\\s*questa)\\s*(${matchAnyPattern(TIME_UNIT_DICTIONARY)})` +
+        "|" +
+        // Pattern 2: "il mese prossimo" / "la settimana scorsa" (modifier after noun)
+        `(?:il\\s*|la\\s*|l'\\s*)(${matchAnyPattern(TIME_UNIT_DICTIONARY)})\\s*(scorso|scorsa|prossimo|prossima)` +
+        ")(?=\\W|$)",
     "i"
 );
 
-const MODIFIER_WORD_GROUP = 1;
-const RELATIVE_WORD_GROUP = 2;
+// Pattern 1 groups
+const MODIFIER_WORD_GROUP_1 = 1;
+const RELATIVE_WORD_GROUP_1 = 2;
+// Pattern 2 groups
+const RELATIVE_WORD_GROUP_2 = 3;
+const MODIFIER_WORD_GROUP_2 = 4;
 
 export default class ITRelativeDateFormatParser extends AbstractParserWithWordBoundaryChecking {
     innerPattern(): RegExp {
@@ -20,17 +29,29 @@ export default class ITRelativeDateFormatParser extends AbstractParserWithWordBo
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
-        const modifier = match[MODIFIER_WORD_GROUP].toLowerCase();
-        const unitWord = match[RELATIVE_WORD_GROUP].toLowerCase();
+        // Determine which pattern matched
+        let modifier: string;
+        let unitWord: string;
+
+        if (match[MODIFIER_WORD_GROUP_1]) {
+            // Pattern 1: "il prossimo mese"
+            modifier = match[MODIFIER_WORD_GROUP_1].toLowerCase();
+            unitWord = match[RELATIVE_WORD_GROUP_1].toLowerCase();
+        } else {
+            // Pattern 2: "il mese prossimo"
+            modifier = match[MODIFIER_WORD_GROUP_2].toLowerCase();
+            unitWord = match[RELATIVE_WORD_GROUP_2].toLowerCase();
+        }
+
         const timeunit = TIME_UNIT_DICTIONARY[unitWord];
 
-        if (modifier == "prossimo" || modifier.startsWith("dopo")) {
+        if (modifier == "prossimo" || modifier == "prossima" || modifier.startsWith("dopo")) {
             const timeUnits = {};
             timeUnits[timeunit] = 1;
             return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
         }
 
-        if (modifier == "prima" || modifier == "precedente") {
+        if (modifier == "scorso" || modifier == "scorsa") {
             const timeUnits = {};
             timeUnits[timeunit] = -1;
             return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
@@ -39,7 +60,7 @@ export default class ITRelativeDateFormatParser extends AbstractParserWithWordBo
         const components = context.createParsingComponents();
         let date = new Date(context.reference.instant.getTime());
 
-        // This week
+        // Questa settimana
         if (unitWord.match(/settimana/i)) {
             date.setDate(date.getDate() - date.getDay());
             components.imply("day", date.getDate());
@@ -47,7 +68,7 @@ export default class ITRelativeDateFormatParser extends AbstractParserWithWordBo
             components.imply("year", date.getFullYear());
         }
 
-        // This month
+        // Questo mese
         else if (unitWord.match(/mese/i)) {
             date.setDate(1);
             components.imply("day", date.getDate());
@@ -55,7 +76,7 @@ export default class ITRelativeDateFormatParser extends AbstractParserWithWordBo
             components.assign("month", date.getMonth() + 1);
         }
 
-        // This year
+        // Quest'anno
         else if (unitWord.match(/anno/i)) {
             date.setDate(1);
             date.setMonth(0);

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

@@ -12,7 +12,7 @@ const YEAR_GROUP = 2;
  * - 11/05
  * - 06/2005
  */
-export default class ENSlashMonthFormatParser extends AbstractParserWithWordBoundaryChecking {
+export default class ITSlashMonthFormatParser extends AbstractParserWithWordBoundaryChecking {
     innerPattern(): RegExp {
         return PATTERN;
     }

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

@@ -1,55 +1,69 @@
 import { ParsingContext } from "../../../chrono";
-import { ParsingComponents } from "../../../results";
-import { Meridiem } from "../../../index";
+import { ParsingComponents, ParsingResult } from "../../../results";
+import { Meridiem } from "../../../types";
 import { AbstractTimeExpressionParser } from "../../../common/parsers/AbstractTimeExpressionParser";
 
-export default class ENTimeExpressionParser extends AbstractTimeExpressionParser {
+export default class ITTimeExpressionParser extends AbstractTimeExpressionParser {
     constructor(strictMode) {
         super(strictMode);
     }
 
     followingPhase(): string {
-        return "\\s*(?:\\-|\\–|\\~|\\〜|to|\\?)\\s*";
+        return "\\s*(?:\\-|\\–|\\~|\\〜|a|fino\\s*a|alle?|\\?)\\s*";
     }
 
     primaryPrefix(): string {
-        return "(?:(?:alle|dalle)\\s*)??";
+        return "(?:(?:alle?|dalle?)\\s*)??";
     }
 
     primarySuffix(): string {
-        return "(?:\\s*(?:in punto|o\\W*in punto|(?:di|del|della|in|al|alla|alle)\\s*(?:mattina|pomeriggio|sera)))?(?!/)(?=\\W|$)";
+        return "(?:\\s*(?:di\\s*(?:sera|notte|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 (!components) {
+            return components;
+        }
 
-            if (match[0].endsWith("pomeriggio")) {
+        if (match[0].match(/di\s*(?:sera|notte)/i)) {
+            const hour = components.get("hour");
+            if (hour >= 6 && hour < 12) {
+                components.assign("hour", components.get("hour") + 12);
                 components.assign("meridiem", Meridiem.PM);
-                const hour = components.get("hour");
-                if (hour >= 0 && hour <= 6) {
-                    components.assign("hour", components.get("hour") + 12);
-                }
+            } else if (hour < 6) {
+                components.assign("meridiem", Meridiem.AM);
             }
+        }
 
-            if (match[0].endsWith("mattina")) {
-                components.assign("meridiem", Meridiem.AM);
-                const hour = components.get("hour");
-                if (hour < 12) {
-                    components.assign("hour", components.get("hour"));
-                }
+        if (match[0].match(/di\s*pomeriggio/i)) {
+            components.assign("meridiem", Meridiem.PM);
+            const hour = components.get("hour");
+            if (hour >= 0 && hour <= 6) {
+                components.assign("hour", components.get("hour") + 12);
             }
         }
 
-        return components;
+        if (match[0].match(/di\s*mattina/i)) {
+            components.assign("meridiem", Meridiem.AM);
+            const hour = components.get("hour");
+            if (hour < 12) {
+                components.assign("hour", components.get("hour"));
+            }
+        }
+
+        return components.addTag("parser/ITTimeExpressionParser");
+    }
+
+    extractFollowingTimeComponents(
+        context: ParsingContext,
+        match: RegExpMatchArray,
+        result: ParsingResult
+    ): ParsingComponents | null {
+        const followingComponents = super.extractFollowingTimeComponents(context, match, result);
+        if (followingComponents) {
+            followingComponents.addTag("parser/ITTimeExpressionParser");
+        }
+        return followingComponents;
     }
 }

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

@@ -1,13 +1,13 @@
 import { ParsingContext } from "../../../chrono";
-import { parseDuration, TIME_UNITS_PATTERN } from "../constants";
+import { parseDuration, TIME_UNITS_NO_ABBR_PATTERN, TIME_UNITS_PATTERN } from "../constants";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { reverseDuration } from "../../../calculation/duration";
 
-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");
+const PATTERN = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}(?:fa|prima)(?=\\W|$)`, "i");
+const STRICT_PATTERN = new RegExp(`(${TIME_UNITS_NO_ABBR_PATTERN})\\s{0,5}(?:fa|prima)(?=\\W|$)`, "i");
 
-export default class ENTimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
+export default class ITTimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
     constructor(private strictMode: boolean) {
         super();
     }
@@ -17,9 +17,10 @@ export default class ENTimeUnitAgoFormatParser extends AbstractParserWithWordBou
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        const timeUnits = parseDuration(match[1]);
-        const outputTimeUnits = reverseDuration(timeUnits);
-
-        return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
+        const duration = parseDuration(match[1]);
+        if (!duration) {
+            return null;
+        }
+        return ParsingComponents.createRelativeFromReference(context.reference, reverseDuration(duration));
     }
 }

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

@@ -1,30 +1,40 @@
-import { TIME_UNITS_PATTERN, parseDuration } from "../constants";
+import { TIME_UNITS_PATTERN, parseDuration, TIME_UNITS_NO_ABBR_PATTERN } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { reverseDuration } from "../../../calculation/duration";
 
 const PATTERN = new RegExp(
-    `(questo|ultimo|passato|prossimo|dopo|questa|ultima|passata|prossima|\\+|-)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`,
+    `(?:il\\s*|la\\s*|l'\\s*)?(questo|questa|quest'|scorso|scorsa|prossimo|prossima|dopo|\\+|-)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`,
     "i"
 );
+const PATTERN_NO_ABBR = new RegExp(
+    `(?:il\\s*|la\\s*|l'\\s*)?(questo|questa|quest'|scorso|scorsa|prossimo|prossima|dopo|\\+|-)\\s*(${TIME_UNITS_NO_ABBR_PATTERN})(?=\\W|$)`,
+    "i"
+);
+
+export default class ITTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor(private allowAbbreviations: boolean = true) {
+        super();
+    }
 
-export default class ENTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
     innerPattern(): RegExp {
-        return PATTERN;
+        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 = parseDuration(match[2]);
+        let duration = parseDuration(match[2]);
+        if (!duration) {
+            return null;
+        }
         switch (prefix) {
-            case "last":
-            case "past":
+            case "scorso":
+            case "scorsa":
             case "-":
-                timeUnits = reverseDuration(timeUnits);
+                duration = reverseDuration(duration);
                 break;
         }
-
-        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, duration);
     }
 }