chrono-node 2.10.0 → 2.10.2

package/src/locales/it/configuration.ts

@@ -0,0 +1,85 @@
+import { Configuration } from "../../chrono";
+
+import ITTimeUnitWithinFormatParser from "./parsers/ITTimeUnitWithinFormatParser";
+import ITMonthNameLittleEndianParser from "./parsers/ITMonthNameLittleEndianParser";
+import ITMonthNameMiddleEndianParser from "./parsers/ITMonthNameMiddleEndianParser";
+import ITMonthNameParser from "./parsers/ITMonthNameParser";
+import ITYearMonthDayParser from "./parsers/ITYearMonthDayParser";
+import ITSlashMonthFormatParser from "./parsers/ITSlashMonthFormatParser";
+import ITTimeExpressionParser from "./parsers/ITTimeExpressionParser";
+import ITTimeUnitAgoFormatParser from "./parsers/ITTimeUnitAgoFormatParser";
+import ITTimeUnitLaterFormatParser from "./parsers/ITTimeUnitLaterFormatParser";
+import ITMergeDateRangeRefiner from "./refiners/ITMergeDateRangeRefiner";
+import ITMergeDateTimeRefiner from "./refiners/ITMergeDateTimeRefiner";
+
+import { includeCommonConfiguration } from "../../configurations";
+import ITCasualDateParser from "./parsers/ITCasualDateParser";
+import ITCasualTimeParser from "./parsers/ITCasualTimeParser";
+import ITWeekdayParser from "./parsers/ITWeekdayParser";
+import ITRelativeDateFormatParser from "./parsers/ITRelativeDateFormatParser";
+
+import SlashDateFormatParser from "../../common/parsers/SlashDateFormatParser";
+import ITTimeUnitCasualRelativeFormatParser from "./parsers/ITTimeUnitCasualRelativeFormatParser";
+import ITMergeRelativeAfterDateRefiner from "./refiners/ITMergeRelativeAfterDateRefiner";
+import ITMergeRelativeFollowByDateRefiner from "./refiners/ITMergeRelativeFollowByDateRefiner";
+import OverlapRemovalRefiner from "../../common/refiners/OverlapRemovalRefiner";
+import ITExtractYearSuffixRefiner from "./refiners/ITExtractYearSuffixRefiner";
+import ITUnlikelyFormatFilter from "./refiners/ITUnlikelyFormatFilter";
+
+export default class ITDefaultConfiguration {
+    /**
+     * Create a default *casual* {@link Configuration} for Italian chrono.
+     * It calls {@link createConfiguration} and includes additional parsers.
+     */
+    createCasualConfiguration(): Configuration {
+        const option = this.createConfiguration(false);
+        option.parsers.push(new ITCasualDateParser());
+        option.parsers.push(new ITCasualTimeParser());
+        option.parsers.push(new ITMonthNameParser());
+        option.parsers.push(new ITRelativeDateFormatParser());
+        option.parsers.push(new ITTimeUnitCasualRelativeFormatParser());
+        option.refiners.push(new ITUnlikelyFormatFilter());
+        return option;
+    }
+
+    /**
+     * Create a default {@link Configuration} for Italian chrono
+     *
+     * @param strictMode If the timeunit mentioning should be strict, not casual
+     */
+    createConfiguration(strictMode = true): Configuration {
+        const options = includeCommonConfiguration(
+            {
+                parsers: [
+                    new SlashDateFormatParser(true), // Italian uses day/month/year format (littleEndian)
+                    new ITTimeUnitWithinFormatParser(strictMode),
+                    new ITMonthNameLittleEndianParser(),
+                    new ITMonthNameMiddleEndianParser(/*shouldSkipYearLikeDate=*/ true),
+                    new ITWeekdayParser(),
+                    new ITSlashMonthFormatParser(),
+                    new ITTimeExpressionParser(strictMode),
+                    new ITTimeUnitAgoFormatParser(strictMode),
+                    new ITTimeUnitLaterFormatParser(strictMode),
+                ],
+                refiners: [new ITMergeDateTimeRefiner()],
+            },
+            strictMode
+        );
+        options.parsers.unshift(new ITYearMonthDayParser(/*strictMonthDateOrder=*/ strictMode));
+
+        // These relative-dates consideration should be done before other common refiners.
+        options.refiners.unshift(new ITMergeRelativeFollowByDateRefiner());
+        options.refiners.unshift(new ITMergeRelativeAfterDateRefiner());
+        options.refiners.unshift(new OverlapRemovalRefiner());
+
+        // Re-apply the date time refiner again after the timezone refinement and exclusion in common refiners.
+        options.refiners.push(new ITMergeDateTimeRefiner());
+
+        // Extract year after merging date and time
+        options.refiners.push(new ITExtractYearSuffixRefiner());
+
+        // Keep the date range refiner at the end (after all other refinements).
+        options.refiners.push(new ITMergeDateRangeRefiner());
+        return options;
+    }
+}

package/src/locales/it/constants.ts

@@ -1,162 +1,293 @@
 import { matchAnyPattern, repeatedTimeunitPattern } from "../../utils/pattern";
 import { findMostLikelyADYear } from "../../calculation/years";
 import { Duration } from "../../calculation/duration";
-import { Timeunit } from "../../types";
-
-export const WEEKDAY_DICTIONARY: { [word: string]: number } = {
-    "domenica": 0,
-    "dom": 0,
-    "lunedì": 1,
-    "lun": 1,
-    "martedì": 2,
-    "mar": 2,
-    "mercoledì": 3,
-    "merc": 3,
-    "giovedì": 4,
-    "giov": 4,
-    "venerdì": 5,
-    "ven": 5,
-    "sabato": 6,
-    "sab": 6,
+import { Timeunit, Weekday } from "../../types";
+
+export const WEEKDAY_DICTIONARY: { [word: string]: Weekday } = {
+    domenica: 0,
+    dom: 0,
+    "dom.": 0,
+    lunedì: 1,
+    lunedi: 1,
+    lun: 1,
+    "lun.": 1,
+    martedì: 2,
+    martedi: 2,
+    mar: 2,
+    "mar.": 2,
+    mercoledì: 3,
+    mercoledi: 3,
+    mer: 3,
+    "mer.": 3,
+    giovedì: 4,
+    giovedi: 4,
+    gio: 4,
+    "gio.": 4,
+    venerdì: 5,
+    venerdi: 5,
+    ven: 5,
+    "ven.": 5,
+    sabato: 6,
+    sab: 6,
+    "sab.": 6,
 };
 
-export const FULL_MONTH_NAME_DICTIONARY: { [word: string]: number } = {};
+export const FULL_MONTH_NAME_DICTIONARY: { [word: string]: number } = {
+    gennaio: 1,
+    febbraio: 2,
+    marzo: 3,
+    aprile: 4,
+    maggio: 5,
+    giugno: 6,
+    luglio: 7,
+    agosto: 8,
+    settembre: 9,
+    ottobre: 10,
+    novembre: 11,
+    dicembre: 12,
+};
 
 export const MONTH_DICTIONARY: { [word: string]: number } = {
     ...FULL_MONTH_NAME_DICTIONARY,
-    "gennaio": 1,
-    "gen": 1,
+    gen: 1,
     "gen.": 1,
-    "febbraio": 2,
-    "feb": 2,
+    feb: 2,
     "feb.": 2,
-    "febraio": 2,
-    "febb": 2,
-    "febb.": 2,
-    "marzo": 3,
-    "mar": 3,
+    mar: 3,
     "mar.": 3,
-    "aprile": 4,
-    "apr": 4,
+    apr: 4,
     "apr.": 4,
-    "maggio": 5,
-    "mag": 5,
-    "giugno": 6,
-    "giu": 6,
-    "luglio": 7,
-    "lug": 7,
-    "lugl": 7,
+    mag: 5,
+    "mag.": 5,
+    giu: 6,
+    "giu.": 6,
+    lug: 7,
     "lug.": 7,
-    "agosto": 8,
-    "ago": 8,
-    "settembre": 9,
-    "set": 9,
+    ago: 8,
+    "ago.": 8,
+    set: 9,
     "set.": 9,
-    "sett": 9,
+    sett: 9,
     "sett.": 9,
-    "ottobre": 10,
-    "ott": 10,
+    ott: 10,
     "ott.": 10,
-    "novembre": 11,
-    "nov": 11,
+    nov: 11,
     "nov.": 11,
-    "dicembre": 12,
-    "dic": 12,
-    "dice": 12,
+    dic: 12,
     "dic.": 12,
 };
 
 export const INTEGER_WORD_DICTIONARY: { [word: string]: number } = {
-    "uno": 1,
-    "due": 2,
-    "tre": 3,
-    "quattro": 4,
-    "cinque": 5,
-    "sei": 6,
-    "sette": 7,
-    "otto": 8,
-    "nove": 9,
-    "dieci": 10,
-    "undici": 11,
-    "dodici": 12,
+    uno: 1,
+    una: 1,
+    un: 1,
+    due: 2,
+    tre: 3,
+    quattro: 4,
+    cinque: 5,
+    sei: 6,
+    sette: 7,
+    otto: 8,
+    nove: 9,
+    dieci: 10,
+    undici: 11,
+    dodici: 12,
 };
 
 export const ORDINAL_WORD_DICTIONARY: { [word: string]: number } = {
-    "primo": 1,
-    "secondo": 2,
-    "terzo": 3,
-    "quarto": 4,
-    "quinto": 5,
-    "sesto": 6,
-    "settimo": 7,
-    "ottavo": 8,
-    "nono": 9,
-    "decimo": 10,
-    "undicesimo": 11,
-    "dodicesimo": 12,
-    "tredicesimo": 13,
-    "quattordicesimo": 14,
-    "quindicesimo": 15,
-    "sedicesimo": 16,
-    "diciassettesimo": 17,
-    "diciottesimo": 18,
-    "diciannovesimo": 19,
-    "ventesimo": 20,
-    "ventunesimo": 21,
-    "ventiduesimo": 22,
-    "ventitreesimo": 23,
-    "ventiquattresimo": 24,
-    "venticinquesimo": 25,
-    "ventiseiesimo": 26,
-    "ventisettesimo": 27,
-    "ventottesimo": 28,
-    "ventinovesimo": 29,
-    "trentesimo": 30,
-    "trentunesimo": 31,
+    primo: 1,
+    prima: 1,
+    "1°": 1,
+    "1ª": 1,
+    secondo: 2,
+    seconda: 2,
+    "2°": 2,
+    "2ª": 2,
+    terzo: 3,
+    terza: 3,
+    "3°": 3,
+    "3ª": 3,
+    quarto: 4,
+    quarta: 4,
+    "4°": 4,
+    "4ª": 4,
+    quinto: 5,
+    quinta: 5,
+    "5°": 5,
+    "5ª": 5,
+    sesto: 6,
+    sesta: 6,
+    "6°": 6,
+    "6ª": 6,
+    settimo: 7,
+    settima: 7,
+    "7°": 7,
+    "7ª": 7,
+    ottavo: 8,
+    ottava: 8,
+    "8°": 8,
+    "8ª": 8,
+    nono: 9,
+    nona: 9,
+    "9°": 9,
+    "9ª": 9,
+    decimo: 10,
+    decima: 10,
+    "10°": 10,
+    "10ª": 10,
+    undicesimo: 11,
+    undicesima: 11,
+    "11°": 11,
+    "11ª": 11,
+    dodicesimo: 12,
+    dodicesima: 12,
+    "12°": 12,
+    "12ª": 12,
+    tredicesimo: 13,
+    tredicesima: 13,
+    "13°": 13,
+    "13ª": 13,
+    quattordicesimo: 14,
+    quattordicesima: 14,
+    "14°": 14,
+    "14ª": 14,
+    quindicesimo: 15,
+    quindicesima: 15,
+    "15°": 15,
+    "15ª": 15,
+    sedicesimo: 16,
+    sedicesima: 16,
+    "16°": 16,
+    "16ª": 16,
+    diciassettesimo: 17,
+    diciassettesima: 17,
+    "17°": 17,
+    "17ª": 17,
+    diciottesimo: 18,
+    diciottesima: 18,
+    "18°": 18,
+    "18ª": 18,
+    diciannovesimo: 19,
+    diciannovesima: 19,
+    "19°": 19,
+    "19ª": 19,
+    ventesimo: 20,
+    ventesima: 20,
+    "20°": 20,
+    "20ª": 20,
+    ventunesimo: 21,
+    ventunesima: 21,
+    "21°": 21,
+    "21ª": 21,
+    ventiduesimo: 22,
+    ventiduesima: 22,
+    "22°": 22,
+    "22ª": 22,
+    ventitreesimo: 23,
+    ventitreesima: 23,
+    "23°": 23,
+    "23ª": 23,
+    ventiquattresimo: 24,
+    ventiquattresima: 24,
+    "24°": 24,
+    "24ª": 24,
+    venticinquesimo: 25,
+    venticinquesima: 25,
+    "25°": 25,
+    "25ª": 25,
+    ventiseiesimo: 26,
+    ventiseiesima: 26,
+    "26°": 26,
+    "26ª": 26,
+    ventisettesimo: 27,
+    ventisettesima: 27,
+    "27°": 27,
+    "27ª": 27,
+    ventottesimo: 28,
+    ventottesima: 28,
+    "28°": 28,
+    "28ª": 28,
+    ventinovesimo: 29,
+    ventinovesima: 29,
+    "29°": 29,
+    "29ª": 29,
+    trentesimo: 30,
+    trentesima: 30,
+    "30°": 30,
+    "30ª": 30,
+    trentunesimo: 31,
+    trentunesima: 31,
+    "31°": 31,
+    "31ª": 31,
+};
+
+export const TIME_UNIT_DICTIONARY_NO_ABBR: { [word: string]: Timeunit } = {
+    secondo: "second",
+    secondi: "second",
+    minuto: "minute",
+    minuti: "minute",
+    ora: "hour",
+    ore: "hour",
+    giorno: "day",
+    giorni: "day",
+    settimana: "week",
+    settimane: "week",
+    mese: "month",
+    mesi: "month",
+    trimestre: "quarter",
+    trimestri: "quarter",
+    anno: "year",
+    anni: "year",
 };
 
 export const TIME_UNIT_DICTIONARY: { [word: string]: Timeunit } = {
-    "sec": "second",
-    "secondo": "second",
-    "secondi": "second",
-    "min": "minute",
-    "mins": "minute",
-    "minuti": "minute",
-    "h": "hour",
-    "hr": "hour",
-    "o": "hour",
-    "ora": "hour",
-    "ore": "hour",
-    "giorno": "day",
-    "giorni": "day",
-    "settimana": "week",
-    "settimane": "week",
-    "mese": "month",
-    "trimestre": "quarter",
-    "trimestri": "quarter",
-    "anni": "year",
-    "anno": "year",
+    s: "second",
+    sec: "second",
+    secondo: "second",
+    secondi: "second",
+    m: "minute",
+    min: "minute",
+    minuto: "minute",
+    minuti: "minute",
+    h: "hour",
+    ora: "hour",
+    ore: "hour",
+    g: "day",
+    gg: "day",
+    giorno: "day",
+    giorni: "day",
+    sett: "week",
+    settimana: "week",
+    settimane: "week",
+    mese: "month",
+    mesi: "month",
+    trim: "quarter",
+    trimestre: "quarter",
+    trimestri: "quarter",
+    anno: "year",
+    anni: "year",
+    ...TIME_UNIT_DICTIONARY_NO_ABBR,
 };
 
 //-----------------------------
 
 export const NUMBER_PATTERN = `(?:${matchAnyPattern(
     INTEGER_WORD_DICTIONARY
-)}|[0-9]+|[0-9]+\\.[0-9]+|half(?:\\s{0,2}un?)?|un?\\b(?:\\s{0,2}qualcuno)?|qualcuno|molti|a?\\s{0,2}alcuni\\s{0,2}(?:of)?)`;
+)}|[0-9]+|[0-9]+\\.[0-9]+|mezz[oa]?(?:\\s{0,2})?|un(?:'|\\s{0,2})?|qualche|alcuni|paio\\s{0,2}(?:di)?)`;
 
 export function parseNumberPattern(match: string): number {
     const num = match.toLowerCase();
     if (INTEGER_WORD_DICTIONARY[num] !== undefined) {
         return INTEGER_WORD_DICTIONARY[num];
-    } else if (num === "un" || num === "una") {
+    } else if (num === "un" || num === "un'" || num === "una" || num === "uno") {
         return 1;
-    } else if (num.match(/alcuni/)) {
+    } else if (num.match(/qualche/)) {
         return 3;
-    } else if (num.match(/metá/)) {
+    } else if (num.match(/mezz/)) {
         return 0.5;
     } else if (num.match(/paio/)) {
         return 2;
-    } else if (num.match(/molti/)) {
+    } else if (num.match(/alcuni/)) {
         return 7;
     }
 
@@ -165,22 +296,20 @@ export function parseNumberPattern(match: string): number {
 
 //-----------------------------
 
-export const ORDINAL_NUMBER_PATTERN = `(?:${matchAnyPattern(
-    ORDINAL_WORD_DICTIONARY
-)}|[0-9]{1,2}(?:mo|ndo|rzo|simo|esimo)?)`;
+export const ORDINAL_NUMBER_PATTERN = `(?:${matchAnyPattern(ORDINAL_WORD_DICTIONARY)}|[0-9]{1,2}(?:°|ª|º)?)`;
 export function parseOrdinalNumberPattern(match: string): number {
     let num = match.toLowerCase();
     if (ORDINAL_WORD_DICTIONARY[num] !== undefined) {
         return ORDINAL_WORD_DICTIONARY[num];
     }
 
-    num = num.replace(/(?:imo|ndo|rzo|rto|nto|sto|tavo|nono|cimo|timo|esimo)$/i, "");
+    num = num.replace(/(?:°|ª|º)$/i, "");
     return parseInt(num);
 }
 
 //-----------------------------
 
-export const YEAR_PATTERN = `(?:[1-9][0-9]{0,3}\\s{0,2}(?:BE|AD|BC|BCE|CE)|[1-2][0-9]{3}|[5-9][0-9])`;
+export const YEAR_PATTERN = `(?:[1-9][0-9]{0,3}\\s{0,2}(?:BE|AD|BC|BCE|CE)|[1-2][0-9]{3}|[5-9][0-9]|2[0-5])`;
 export function parseYear(match: string): number {
     if (/BE/i.test(match)) {
         // Buddhist Era
@@ -209,9 +338,24 @@ 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");
 
-export const TIME_UNITS_PATTERN = repeatedTimeunitPattern(`(?:(?:about|around)\\s{0,3})?`, SINGLE_TIME_UNIT_PATTERN);
+const SINGLE_TIME_UNIT_NO_ABBR_PATTERN = `(${NUMBER_PATTERN})\\s{0,3}(${matchAnyPattern(
+    TIME_UNIT_DICTIONARY_NO_ABBR
+)})`;
+
+const TIME_UNIT_CONNECTOR_PATTERN = `\\s{0,5},?(?:\\s*e)?\\s{0,5}`;
+
+export const TIME_UNITS_PATTERN = repeatedTimeunitPattern(
+    `(?:(?:circa|approssimativamente)\\s{0,3})?`,
+    SINGLE_TIME_UNIT_PATTERN,
+    TIME_UNIT_CONNECTOR_PATTERN
+);
+export const TIME_UNITS_NO_ABBR_PATTERN = repeatedTimeunitPattern(
+    `(?:(?:circa|approssimativamente)\\s{0,3})?`,
+    SINGLE_TIME_UNIT_NO_ABBR_PATTERN,
+    TIME_UNIT_CONNECTOR_PATTERN
+);
 
-export function parseDuration(timeunitText): Duration {
+export function parseDuration(timeunitText): null | Duration {
     const fragments = {};
     let remainingText = timeunitText;
     let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
@@ -220,10 +364,16 @@ export function parseDuration(timeunitText): Duration {
         remainingText = remainingText.substring(match[0].length).trim();
         match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
     }
+    if (Object.keys(fragments).length == 0) {
+        return null;
+    }
     return fragments as Duration;
 }
 
 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/it/index.ts

@@ -4,96 +4,37 @@
  * @module
  */
 
-import ENTimeUnitWithinFormatParser from "./parsers/ITTimeUnitWithinFormatParser";
-import ENMonthNameLittleEndianParser from "./parsers/ITMonthNameLittleEndianParser";
-import ENMonthNameMiddleEndianParser from "./parsers/ITMonthNameMiddleEndianParser";
-import ENMonthNameParser from "./parsers/ITMonthNameParser";
-import ENCasualYearMonthDayParser from "./parsers/ITCasualYearMonthDayParser";
-import ENSlashMonthFormatParser from "./parsers/ITSlashMonthFormatParser";
-import ENTimeExpressionParser from "./parsers/ITTimeExpressionParser";
-import ENTimeUnitAgoFormatParser from "./parsers/ITTimeUnitAgoFormatParser";
-import ENTimeUnitLaterFormatParser from "./parsers/ITTimeUnitLaterFormatParser";
-import ENMergeDateRangeRefiner from "./refiners/ITMergeDateRangeRefiner";
-import ENMergeDateTimeRefiner from "./refiners/ITMergeDateTimeRefiner";
+import { Chrono, Parser, Refiner } from "../../chrono";
+import { ParsingResult, ParsingComponents, ReferenceWithTimezone } from "../../results";
+import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday } from "../../types";
 
-import { includeCommonConfiguration } from "../../configurations";
-import ENCasualDateParser from "./parsers/ITCasualDateParser";
-import ENCasualTimeParser from "./parsers/ITCasualTimeParser";
-import ENWeekdayParser from "./parsers/ITWeekdayParser";
-import ITRelativeDateFormatParser from "./parsers/ITRelativeDateFormatParser";
+import ITDefaultConfiguration from "./configuration";
 
-import { ParsedResult, ParsingOption } from "../../index";
-import { Chrono, Configuration } from "../../chrono";
-import SlashDateFormatParser from "../../common/parsers/SlashDateFormatParser";
-import ENTimeUnitCasualRelativeFormatParser from "./parsers/ITTimeUnitCasualRelativeFormatParser";
-import ENMergeRelativeDateRefiner from "./refiners/ITMergeRelativeDateRefiner";
+export { Chrono, Parser, Refiner, ParsingResult, ParsingComponents, ReferenceWithTimezone };
+export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday };
+
+export const configuration = new ITDefaultConfiguration();
 
 /**
  * Chrono object configured for parsing *casual* Italian
  */
-export const casual = new Chrono(createCasualConfiguration(false));
+export const casual = new Chrono(configuration.createCasualConfiguration());
 
 /**
  * Chrono object configured for parsing *strict* Italian
  */
-export const strict = new Chrono(createConfiguration(true, false));
-
-/**
- * Chrono object configured for parsing Italian
- */
-export const GB = new Chrono(createConfiguration(false, true));
+export const strict = new Chrono(configuration.createConfiguration(true));
 
 /**
- * A shortcut for en.casual.parse()
+ * A shortcut for it.casual.parse()
  */
-export function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[] {
+export function parse(text: string, ref?: ParsingReference | Date, option?: ParsingOption): ParsedResult[] {
     return casual.parse(text, ref, option);
 }
 
 /**
- * A shortcut for en.casual.parseDate()
+ * A shortcut for it.casual.parseDate()
  */
-export function parseDate(text: string, ref?: Date, option?: ParsingOption): Date {
+export function parseDate(text: string, ref?: ParsingReference | Date, option?: ParsingOption): Date {
     return casual.parseDate(text, ref, option);
 }
-
-/**
- * Create a default *casual* {@Link Configuration} for Italian chrono.
- * It calls {@Link createConfiguration} and includes additional parsers.
- */
-export function createCasualConfiguration(littleEndian = false): Configuration {
-    const option = createConfiguration(false, littleEndian);
-    option.parsers.unshift(new ENCasualDateParser());
-    option.parsers.unshift(new ENCasualTimeParser());
-    option.parsers.unshift(new ENMonthNameParser());
-    option.parsers.unshift(new ITRelativeDateFormatParser());
-    option.parsers.unshift(new ENTimeUnitCasualRelativeFormatParser());
-    return option;
-}
-
-/**
- * Create a default {@Link Configuration} for Italian chrono
- *
- * @param strictMode If the timeunit mentioning should be strict, not casual
- * @param littleEndian If format should be date-first/littleEndian (e.g. en_UK), not month-first/middleEndian (e.g. en_US)
- */
-export function createConfiguration(strictMode = true, littleEndian = false): Configuration {
-    return includeCommonConfiguration(
-        {
-            parsers: [
-                new SlashDateFormatParser(littleEndian),
-                new ENTimeUnitWithinFormatParser(),
-                new ENMonthNameLittleEndianParser(),
-                new ENMonthNameMiddleEndianParser(),
-                new ENWeekdayParser(),
-                new ENCasualYearMonthDayParser(),
-                new ENSlashMonthFormatParser(),
-                new ENTimeExpressionParser(strictMode),
-                new ENTimeUnitAgoFormatParser(strictMode),
-                new ENTimeUnitLaterFormatParser(strictMode),
-            ],
-            refiners: [new ENMergeRelativeDateRefiner(), new ENMergeDateTimeRefiner(), new ENMergeDateRangeRefiner()],
-        },
-        strictMode
-    );
-}