chrono-node 2.7.8 → 2.7.9

package/package.json

@@ -15,7 +15,7 @@
     "preset": "ts-jest"
   },
   "license": "MIT",
-  "version": "2.7.8",
+  "version": "2.7.9",
   "directories": {
     "source": "./src",
     "test": "./test"

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

@@ -5,7 +5,7 @@ import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/
 import { assignSimilarDate } from "../../../utils/dayjs";
 import * as references from "../../../common/casualReferences";
 
-const PATTERN = /(now|today|tonight|tomorrow|tmr|tmrw|yesterday|last\s*night)(?=\W|$)/i;
+const PATTERN = /(now|today|tonight|tomorrow|overmorrow|tmr|tmrw|yesterday|last\s*night)(?=\W|$)/i;
 
 export default class ENCasualDateParser extends AbstractParserWithWordBoundaryChecking {
     innerPattern(context: ParsingContext): RegExp {
@@ -40,6 +40,10 @@ export default class ENCasualDateParser extends AbstractParserWithWordBoundaryCh
                 component = references.tonight(context.reference);
                 break;
 
+            case "overmorrow":
+                component = references.theDayAfter(context.reference, 2);
+                break;
+
             default:
                 if (lowerText.match(/last\s*night/)) {
                     if (targetDate.hour() > 6) {

package/src/locales/it/constants.ts

@@ -0,0 +1,230 @@
+import { OpUnitType, QUnitType } from "dayjs";
+import { matchAnyPattern, repeatedTimeunitPattern } from "../../utils/pattern";
+import { findMostLikelyADYear } from "../../calculation/years";
+import { TimeUnits } from "../../utils/timeunits";
+
+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,
+};
+
+export const FULL_MONTH_NAME_DICTIONARY: { [word: string]: number } = {};
+
+export const MONTH_DICTIONARY: { [word: string]: number } = {
+    ...FULL_MONTH_NAME_DICTIONARY,
+    "gennaio": 1,
+    "gen": 1,
+    "gen.": 1,
+    "febbraio": 2,
+    "feb": 2,
+    "feb.": 2,
+    "febraio": 2,
+    "febb": 2,
+    "febb.": 2,
+    "marzo": 3,
+    "mar": 3,
+    "mar.": 3,
+    "aprile": 4,
+    "apr": 4,
+    "apr.": 4,
+    "maggio": 5,
+    "mag": 5,
+    "giugno": 6,
+    "giu": 6,
+    "luglio": 7,
+    "lug": 7,
+    "lugl": 7,
+    "lug.": 7,
+    "agosto": 8,
+    "ago": 8,
+    "settembre": 9,
+    "set": 9,
+    "set.": 9,
+    "sett": 9,
+    "sett.": 9,
+    "ottobre": 10,
+    "ott": 10,
+    "ott.": 10,
+    "novembre": 11,
+    "nov": 11,
+    "nov.": 11,
+    "dicembre": 12,
+    "dic": 12,
+    "dice": 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,
+};
+
+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,
+};
+
+export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } = {
+    "sec": "second",
+    "secondo": "second",
+    "secondi": "second",
+    "min": "minute",
+    "mins": "minute",
+    "minuti": "minute",
+    "h": "hour",
+    "hr": "hour",
+    "o": "hour",
+    "ora": "hour",
+    "ore": "hour",
+    "giorno": "d",
+    "giorni": "d",
+    "settimana": "week",
+    "settimane": "week",
+    "mese": "month",
+    "trimestre": "quarter",
+    "trimestri": "quarter",
+    "anni": "year",
+    "anno": "year",
+};
+
+//-----------------------------
+
+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)?)`;
+
+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") {
+        return 1;
+    } else if (num.match(/alcuni/)) {
+        return 3;
+    } else if (num.match(/metá/)) {
+        return 0.5;
+    } else if (num.match(/paio/)) {
+        return 2;
+    } else if (num.match(/molti/)) {
+        return 7;
+    }
+
+    return parseFloat(num);
+}
+
+//-----------------------------
+
+export const ORDINAL_NUMBER_PATTERN = `(?:${matchAnyPattern(
+    ORDINAL_WORD_DICTIONARY
+)}|[0-9]{1,2}(?:mo|ndo|rzo|simo|esimo)?)`;
+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, "");
+    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 function parseYear(match: string): number {
+    if (/BE/i.test(match)) {
+        // Buddhist Era
+        match = match.replace(/BE/i, "");
+        return parseInt(match) - 543;
+    }
+
+    if (/BCE?/i.test(match)) {
+        // Before Christ, Before Common Era
+        match = match.replace(/BCE?/i, "");
+        return -parseInt(match);
+    }
+
+    if (/(AD|CE)/i.test(match)) {
+        // Anno Domini, Common Era
+        match = match.replace(/(AD|CE)/i, "");
+        return parseInt(match);
+    }
+
+    const rawYearNumber = parseInt(match);
+    return findMostLikelyADYear(rawYearNumber);
+}
+
+//-----------------------------
+
+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);
+
+export function parseTimeUnits(timeunitText): TimeUnits {
+    const fragments = {};
+    let remainingText = timeunitText;
+    let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
+    while (match) {
+        collectDateTimeFragment(fragments, match);
+        remainingText = remainingText.substring(match[0].length).trim();
+        match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
+    }
+    return fragments;
+}
+
+function collectDateTimeFragment(fragments, match) {
+    const num = parseNumberPattern(match[1]);
+    const unit = TIME_UNIT_DICTIONARY[match[2].toLowerCase()];
+    fragments[unit] = num;
+}

package/src/locales/it/index.ts

@@ -0,0 +1,99 @@
+/**
+ * Chrono components for Italian support (*parsers*, *refiners*, and *configuration*)
+ *
+ * @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 { includeCommonConfiguration } from "../../configurations";
+import ENCasualDateParser from "./parsers/ITCasualDateParser";
+import ENCasualTimeParser from "./parsers/ITCasualTimeParser";
+import ENWeekdayParser from "./parsers/ITWeekdayParser";
+import ENRelativeDateFormatParser from "./parsers/ITRelativeDateFormatParser";
+
+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";
+
+/**
+ * Chrono object configured for parsing *casual* Italian
+ */
+export const casual = new Chrono(createCasualConfiguration(false));
+
+/**
+ * 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));
+
+/**
+ * A shortcut for en.casual.parse()
+ */
+export function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[] {
+    return casual.parse(text, ref, option);
+}
+
+/**
+ * A shortcut for en.casual.parseDate()
+ */
+export function parseDate(text: string, ref?: 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 ENRelativeDateFormatParser());
+    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
+    );
+}

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

@@ -0,0 +1,53 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents, ParsingResult } from "../../../results";
+import dayjs from "dayjs";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { assignSimilarDate } from "../../../utils/dayjs";
+import * as references from "../../../common/casualReferences";
+
+const PATTERN = /(ora|oggi|stasera|questa sera|domani|dmn|ieri\s*sera)(?=\W|$)/i;
+
+export default class ENCasualDateParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(context: ParsingContext): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult {
+        let targetDate = dayjs(context.refDate);
+        const lowerText = match[0].toLowerCase();
+        const component = context.createParsingComponents();
+
+        switch (lowerText) {
+            case "ora":
+                return references.now(context.reference);
+
+            case "oggi":
+                return references.today(context.reference);
+
+            case "ieri":
+                return references.yesterday(context.reference);
+
+            case "domani":
+            case "dmn":
+                return references.tomorrow(context.reference);
+
+            case "stasera":
+            case "questa sera":
+                return references.tonight(context.reference);
+
+            default:
+                if (lowerText.match(/ieri\s*sera/)) {
+                    if (targetDate.hour() > 6) {
+                        targetDate = targetDate.add(-1, "day");
+                    }
+
+                    assignSimilarDate(component, targetDate);
+                    component.imply("hour", 0);
+                }
+
+                break;
+        }
+
+        return component;
+    }
+}

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

@@ -0,0 +1,50 @@
+import { ParsingContext } from "../../../chrono";
+import { Meridiem } from "../../../index";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import dayjs from "dayjs";
+import { assignTheNextDay } from "../../../utils/dayjs";
+
+const PATTERN = /(?:questo|questa)?\s{0,3}(mattina|pomeriggio|sera|notte|mezzanotte|mezzogiorno)(?=\W|$)/i;
+
+export default class ENCasualTimeParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const targetDate = dayjs(context.refDate);
+        const component = context.createParsingComponents();
+
+        switch (match[1].toLowerCase()) {
+            case "pomeriggio":
+                component.imply("meridiem", Meridiem.PM);
+                component.imply("hour", 15);
+                break;
+
+            case "sera":
+            case "notte":
+                component.imply("meridiem", Meridiem.PM);
+                component.imply("hour", 20);
+                break;
+
+            case "mezzanotte":
+                assignTheNextDay(component, targetDate);
+                component.imply("hour", 0);
+                component.imply("minute", 0);
+                component.imply("second", 0);
+                break;
+
+            case "mattina":
+                component.imply("meridiem", Meridiem.AM);
+                component.imply("hour", 6);
+                break;
+
+            case "mezzogiorno":
+                component.imply("meridiem", Meridiem.AM);
+                component.imply("hour", 12);
+                break;
+        }
+
+        return component;
+    }
+}

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;
+    }
+}