chrono-node 2.9.0 → 2.9.2

package/src/locales/de/parsers/DECasualTimeParser.ts

@@ -24,6 +24,7 @@ export default class DECasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/morning");
                 break;
 
             case "vormittag":
@@ -31,6 +32,7 @@ export default class DECasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/morning");
                 break;
 
             case "mittag":
@@ -39,6 +41,7 @@ export default class DECasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/noon");
                 break;
 
             case "nachmittag":
@@ -46,6 +49,7 @@ export default class DECasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.PM);
+                component.addTag("casualReference/afternoon");
                 break;
 
             case "abend":
@@ -53,6 +57,7 @@ export default class DECasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.PM);
+                component.addTag("casualReference/evening");
                 break;
 
             case "nacht":
@@ -60,6 +65,7 @@ export default class DECasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.PM);
+                component.addTag("casualReference/evening");
                 break;
 
             case "mitternacht":
@@ -71,6 +77,7 @@ export default class DECasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("minute", 0);
                 component.imply("second", 0);
                 component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/midnight");
                 break;
         }
         return component;

package/src/locales/de/parsers/DETimeUnitRelativeFormatParser.ts

@@ -15,7 +15,7 @@ export default class DETimeUnitAgoFormatParser extends AbstractParserWithWordBou
             `(?:\\s*((?:nächste|kommende|folgende|letzte|vergangene|vorige|vor(?:her|an)gegangene)(?:s|n|m|r)?|vor|in)\\s*)?` +
                 `(${NUMBER_PATTERN})?` +
                 `(?:\\s*(nächste|kommende|folgende|letzte|vergangene|vorige|vor(?:her|an)gegangene)(?:s|n|m|r)?)?` +
-                `\\s*(${matchAnyPattern(TIME_UNIT_DICTIONARY)})`,
+                `\\s*(${matchAnyPattern(TIME_UNIT_DICTIONARY)})(?=\\W|$)`,
             "i"
         );
     }

package/src/locales/en/configuration.ts

@@ -5,6 +5,7 @@ import ENMonthNameLittleEndianParser from "./parsers/ENMonthNameLittleEndianPars
 import ENMonthNameMiddleEndianParser from "./parsers/ENMonthNameMiddleEndianParser";
 import ENMonthNameParser from "./parsers/ENMonthNameParser";
 import ENYearMonthDayParser from "./parsers/ENYearMonthDayParser";
+import ENYearMonthNameParser from "./parsers/ENYearMonthNameParser";
 import ENSlashMonthFormatParser from "./parsers/ENSlashMonthFormatParser";
 import ENTimeExpressionParser from "./parsers/ENTimeExpressionParser";
 import ENTimeUnitAgoFormatParser from "./parsers/ENTimeUnitAgoFormatParser";
@@ -61,6 +62,7 @@ export default class ENDefaultConfiguration {
                     new ENTimeExpressionParser(strictMode),
                     new ENTimeUnitAgoFormatParser(strictMode),
                     new ENTimeUnitLaterFormatParser(strictMode),
+                    new ENYearMonthNameParser(),
                 ],
                 refiners: [new ENMergeDateTimeRefiner()],
             },

package/src/locales/en/constants.ts

@@ -230,7 +230,7 @@ export function parseOrdinalNumberPattern(match: string): number {
 
 //-----------------------------
 
-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 const YEAR_PATTERN = `(?:[1-9][0-9]{0,3}\\s{0,2}(?:BE|AD|BC|BCE|CE)|[1-9][0-9]{3}|[5-9][0-9]|2[0-5])`;
 export function parseYear(match: string): number {
     if (/BE/i.test(match)) {
         // Buddhist Era

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

@@ -12,7 +12,7 @@ const PATTERN = new RegExp(
     `(?:on\\s{0,3})?` +
         `(${ORDINAL_NUMBER_PATTERN})` +
         `(?:` +
-            `\\s{0,3}(?:to|\\-|\\–|until|through|till)?\\s{0,3}` +
+            `\\s{0,3}(?:to|\\-|\\–|until|through|till)\\s{0,3}` +
             `(${ORDINAL_NUMBER_PATTERN})` +
         ")?" +
         `(?:-|/|\\s{0,3}(?:of)?\\s{0,3})` +

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

@@ -12,7 +12,7 @@ const PATTERN = new RegExp(
         "(?:(this|last|past|next)\\s*)?" +
         `(${matchAnyPattern(WEEKDAY_DICTIONARY)}|weekend|weekday)` +
         "(?:\\s*(?:\\,|\\)|\\）))?" +
-        "(?:\\s*(this|last|past|next)\\s*week)?" +
+        "(?:\\s*(?:of\\s*)?(this|last|past|next)\\s*week)?" +
         "(?=\\W|$)",
     "i"
 );

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

@@ -0,0 +1,38 @@
+import { MONTH_DICTIONARY } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { parseYear } from "../constants";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const YEAR_PATTERN = `(?:[1-9][0-9]{0,3}\\s{0,2}(?:BE|AD|BC|BCE|CE)|[1-9][0-9]{3})`;
+
+const PATTERN = new RegExp(
+    `(${YEAR_PATTERN})` +
+        `(?:\\s*[-.\\/,]?\\s*|\\s+of\\s+)` +
+        `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+        `(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)`,
+    "i"
+);
+
+const YEAR_GROUP = 1;
+const MONTH_NAME_GROUP = 2;
+
+export default class ENYearMonthNameParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const year = parseYear(match[YEAR_GROUP]);
+        const monthName = match[MONTH_NAME_GROUP].toLowerCase();
+        const month = MONTH_DICTIONARY[monthName];
+
+        const result = context.createParsingResult(match.index, match[0]);
+        result.start.imply("day", 1);
+        result.start.assign("month", month);
+        result.start.assign("year", year);
+        result.start.addTag("parser/ENYearMonthNameParser");
+
+        return result;
+    }
+}

package/src/locales/es/parsers/ESCasualTimeParser.ts

@@ -15,16 +15,19 @@ export default class ESCasualTimeParser extends AbstractParserWithWordBoundaryCh
             case "tarde":
                 component.imply("meridiem", Meridiem.PM);
                 component.imply("hour", 15);
+                component.addTag("casualReference/afternoon");
                 break;
 
             case "noche":
                 component.imply("meridiem", Meridiem.PM);
                 component.imply("hour", 22);
+                component.addTag("casualReference/evening");
                 break;
 
             case "mañana":
                 component.imply("meridiem", Meridiem.AM);
                 component.imply("hour", 6);
+                component.addTag("casualReference/morning");
                 break;
 
             case "medianoche":
@@ -35,12 +38,14 @@ export default class ESCasualTimeParser extends AbstractParserWithWordBoundaryCh
                 component.imply("hour", 0);
                 component.imply("minute", 0);
                 component.imply("second", 0);
+                component.addTag("casualReference/midnight");
                 break;
 
             case "mediodia":
             case "mediodía":
                 component.imply("meridiem", Meridiem.AM);
                 component.imply("hour", 12);
+                component.addTag("casualReference/noon");
                 break;
         }
 

package/src/locales/fi/constants.ts

@@ -0,0 +1,209 @@
+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 } = {
+    "sunnuntai": 0,
+    "sunnuntaina": 0,
+    "su": 0,
+    "maanantai": 1,
+    "maanantaina": 1,
+    "ma": 1,
+    "tiistai": 2,
+    "tiistaina": 2,
+    "ti": 2,
+    "keskiviikko": 3,
+    "keskiviikkona": 3,
+    "ke": 3,
+    "torstai": 4,
+    "torstaina": 4,
+    "to": 4,
+    "perjantai": 5,
+    "perjantaina": 5,
+    "pe": 5,
+    "lauantai": 6,
+    "lauantaina": 6,
+    "la": 6,
+};
+
+export const MONTH_DICTIONARY: { [word: string]: number } = {
+    "tammikuu": 1,
+    "tammikuuta": 1,
+    "tammikuun": 1,
+    "tammi": 1,
+    "helmikuu": 2,
+    "helmikuuta": 2,
+    "helmikuun": 2,
+    "helmi": 2,
+    "maaliskuu": 3,
+    "maaliskuuta": 3,
+    "maaliskuun": 3,
+    "maalis": 3,
+    "huhtikuu": 4,
+    "huhtikuuta": 4,
+    "huhtikuun": 4,
+    "huhti": 4,
+    "toukokuu": 5,
+    "toukokuuta": 5,
+    "toukokuun": 5,
+    "touko": 5,
+    "kesäkuu": 6,
+    "kesäkuuta": 6,
+    "kesäkuun": 6,
+    "kesä": 6,
+    "heinäkuu": 7,
+    "heinäkuuta": 7,
+    "heinäkuun": 7,
+    "heinä": 7,
+    "elokuu": 8,
+    "elokuuta": 8,
+    "elokuun": 8,
+    "elo": 8,
+    "syyskuu": 9,
+    "syyskuuta": 9,
+    "syyskuun": 9,
+    "syys": 9,
+    "lokakuu": 10,
+    "lokakuuta": 10,
+    "lokakuun": 10,
+    "loka": 10,
+    "marraskuu": 11,
+    "marraskuuta": 11,
+    "marraskuun": 11,
+    "marras": 11,
+    "joulukuu": 12,
+    "joulukuuta": 12,
+    "joulukuun": 12,
+    "joulu": 12,
+};
+
+export const INTEGER_WORD_DICTIONARY: { [word: string]: number } = {
+    "yksi": 1,
+    "yhden": 1,
+    "kaksi": 2,
+    "kahden": 2,
+    "kolme": 3,
+    "kolmen": 3,
+    "neljä": 4,
+    "neljän": 4,
+    "viisi": 5,
+    "viiden": 5,
+    "kuusi": 6,
+    "kuuden": 6,
+    "seitsemän": 7,
+    "kahdeksan": 8,
+    "yhdeksän": 9,
+    "kymmenen": 10,
+};
+
+export const TIME_UNIT_DICTIONARY: { [word: string]: Timeunit } = {
+    "s": "second",
+    "sek": "second",
+    "sekunti": "second",
+    "sekuntia": "second",
+    "sekunnin": "second",
+    "min": "minute",
+    "minuutti": "minute",
+    "minuuttia": "minute",
+    "minuutin": "minute",
+    "t": "hour",
+    "tunti": "hour",
+    "tuntia": "hour",
+    "tunnin": "hour",
+    "pv": "day",
+    "päivä": "day",
+    "päivää": "day",
+    "päivän": "day",
+    "vk": "week",
+    "viikko": "week",
+    "viikkoa": "week",
+    "viikon": "week",
+    "kk": "month",
+    "kuukausi": "month",
+    "kuukautta": "month",
+    "kuukauden": "month",
+    "vuosi": "year",
+    "vuotta": "year",
+    "vuoden": "year",
+};
+
+export const TIME_UNIT_NO_ABBR_DICTIONARY: { [word: string]: Timeunit } = {
+    "sekunti": "second",
+    "sekuntia": "second",
+    "sekunnin": "second",
+    "minuutti": "minute",
+    "minuuttia": "minute",
+    "minuutin": "minute",
+    "tunti": "hour",
+    "tuntia": "hour",
+    "tunnin": "hour",
+    "päivä": "day",
+    "päivää": "day",
+    "päivän": "day",
+    "viikko": "week",
+    "viikkoa": "week",
+    "viikon": "week",
+    "kuukausi": "month",
+    "kuukautta": "month",
+    "kuukauden": "month",
+    "vuosi": "year",
+    "vuotta": "year",
+    "vuoden": "year",
+};
+
+export function parseDuration(timeunitText: string): Duration {
+    const fragments: { [key: string]: number } = {};
+    let remainingText = timeunitText;
+    let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
+    while (match) {
+        collectDateTimeFragment(fragments, match);
+        remainingText = remainingText.substring(match[0].length);
+        match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
+    }
+    return fragments as Duration;
+}
+
+function collectDateTimeFragment(fragments: { [key: string]: number }, match: RegExpMatchArray) {
+    const num = parseNumberPattern(match[1]);
+    const unit = TIME_UNIT_DICTIONARY[match[2].toLowerCase()];
+    fragments[unit] = num;
+}
+
+export const NUMBER_PATTERN = `(?:${matchAnyPattern(INTEGER_WORD_DICTIONARY)}|\\d+)`;
+export const TIME_UNIT_PATTERN = `(?:${matchAnyPattern(TIME_UNIT_DICTIONARY)})`;
+
+const SINGLE_TIME_UNIT_PATTERN = `(${NUMBER_PATTERN})\\s{0,5}(${matchAnyPattern(TIME_UNIT_DICTIONARY)})\\s{0,5}`;
+const SINGLE_TIME_UNIT_REGEX = new RegExp(SINGLE_TIME_UNIT_PATTERN, "i");
+
+const SINGLE_TIME_UNIT_NO_ABBR_PATTERN = `(${NUMBER_PATTERN})\\s{0,5}(${matchAnyPattern(
+    TIME_UNIT_NO_ABBR_DICTIONARY
+)})\\s{0,5}`;
+
+export const TIME_UNITS_PATTERN = repeatedTimeunitPattern("", SINGLE_TIME_UNIT_PATTERN);
+export const TIME_UNITS_NO_ABBR_PATTERN = repeatedTimeunitPattern("", SINGLE_TIME_UNIT_NO_ABBR_PATTERN);
+
+export function parseNumberPattern(match: string): number {
+    const num = match.toLowerCase();
+    if (INTEGER_WORD_DICTIONARY[num] !== undefined) {
+        return INTEGER_WORD_DICTIONARY[num];
+    }
+    return parseInt(num);
+}
+
+export function parseYear(match: string): number {
+    if (/\d+/.test(match)) {
+        let yearNumber = parseInt(match);
+        if (yearNumber < 100) {
+            yearNumber = findMostLikelyADYear(yearNumber);
+        }
+        return yearNumber;
+    }
+
+    const num = match.toLowerCase();
+    if (INTEGER_WORD_DICTIONARY[num] !== undefined) {
+        return INTEGER_WORD_DICTIONARY[num];
+    }
+
+    return parseInt(match);
+}

package/src/locales/fi/index.ts

@@ -0,0 +1,57 @@
+import { includeCommonConfiguration } from "../../configurations";
+import { Chrono, Configuration, Parser, Refiner } from "../../chrono";
+import { ParsingResult, ParsingComponents, ReferenceWithTimezone } from "../../results";
+import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday } from "../../types";
+import SlashDateFormatParser from "../../common/parsers/SlashDateFormatParser";
+import ISOFormatParser from "../../common/parsers/ISOFormatParser";
+import FITimeExpressionParser from "./parsers/FITimeExpressionParser";
+import FIWeekdayParser from "./parsers/FIWeekdayParser";
+import FIMonthNameLittleEndianParser from "./parsers/FIMonthNameLittleEndianParser";
+import FITimeUnitCasualRelativeFormatParser from "./parsers/FITimeUnitCasualRelativeFormatParser";
+import FITimeUnitAgoFormatParser from "./parsers/FITimeUnitAgoFormatParser";
+import FITimeUnitWithinFormatParser from "./parsers/FITimeUnitWithinFormatParser";
+import FICasualDateParser from "./parsers/FICasualDateParser";
+import FICasualTimeParser from "./parsers/FICasualTimeParser";
+import FIMergeDateRangeRefiner from "./refiners/FIMergeDateRangeRefiner";
+import FIMergeDateTimeRefiner from "./refiners/FIMergeDateTimeRefiner";
+
+export { Chrono, Parser, Refiner, ParsingResult, ParsingComponents, ReferenceWithTimezone };
+export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday };
+
+// Shortcuts
+export const casual = new Chrono(createCasualConfiguration());
+export const strict = new Chrono(createConfiguration(true));
+
+export function parse(text: string, ref?: ParsingReference | Date, option?: ParsingOption): ParsedResult[] {
+    return casual.parse(text, ref, option);
+}
+
+export function parseDate(text: string, ref?: ParsingReference | Date, option?: ParsingOption): Date {
+    return casual.parseDate(text, ref, option);
+}
+
+export function createCasualConfiguration(littleEndian = true): Configuration {
+    const option = createConfiguration(false, littleEndian);
+    option.parsers.unshift(new FICasualTimeParser());
+    option.parsers.unshift(new FICasualDateParser());
+    option.parsers.unshift(new FITimeUnitCasualRelativeFormatParser());
+    return option;
+}
+
+export function createConfiguration(strictMode = true, littleEndian = true): Configuration {
+    return includeCommonConfiguration(
+        {
+            parsers: [
+                new ISOFormatParser(),
+                new SlashDateFormatParser(littleEndian),
+                new FITimeExpressionParser(),
+                new FIMonthNameLittleEndianParser(),
+                new FIWeekdayParser(),
+                new FITimeUnitWithinFormatParser(),
+                new FITimeUnitAgoFormatParser(),
+            ],
+            refiners: [new FIMergeDateRangeRefiner(), new FIMergeDateTimeRefiner()],
+        },
+        strictMode
+    );
+}

package/src/locales/fi/parsers/FICasualDateParser.ts

@@ -0,0 +1,82 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents, ParsingResult } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { assignSimilarDate, implySimilarTime } from "../../../utils/dates";
+import FICasualTimeParser from "./FICasualTimeParser";
+import * as references from "../../../common/casualReferences";
+import { addDuration } from "../../../calculation/duration";
+
+const PATTERN = new RegExp(
+    `(nyt|tänään|huomenna|ylihuomenna|eilen|toissapäivänä|viime\\s*yönä)` +
+        `(?:\\s*(aamulla|aamuna|aamupäivällä|päivällä|iltapäivällä|illalla|yöllä|keskiyöllä))?` +
+        `(?=\\W|$)`,
+    "i"
+);
+
+const DATE_GROUP = 1;
+const TIME_GROUP = 2;
+
+export default class FICasualDateParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(context: ParsingContext): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult {
+        let targetDate = context.reference.getDateWithAdjustedTimezone();
+        const dateKeyword = (match[DATE_GROUP] || "").toLowerCase();
+        const timeKeyword = (match[TIME_GROUP] || "").toLowerCase();
+
+        let component = context.createParsingComponents();
+        switch (dateKeyword) {
+            case "nyt":
+                component = references.now(context.reference);
+                break;
+
+            case "tänään":
+                component = references.today(context.reference);
+                break;
+
+            case "huomenna":
+                targetDate = addDuration(targetDate, { day: 1 });
+                assignSimilarDate(component, targetDate);
+                implySimilarTime(component, targetDate);
+                break;
+
+            case "ylihuomenna":
+                targetDate = addDuration(targetDate, { day: 2 });
+                assignSimilarDate(component, targetDate);
+                implySimilarTime(component, targetDate);
+                break;
+
+            case "eilen":
+                targetDate = addDuration(targetDate, { day: -1 });
+                assignSimilarDate(component, targetDate);
+                implySimilarTime(component, targetDate);
+                break;
+
+            case "toissapäivänä":
+                targetDate = addDuration(targetDate, { day: -2 });
+                assignSimilarDate(component, targetDate);
+                implySimilarTime(component, targetDate);
+                break;
+
+            default:
+                if (dateKeyword.match(/viime\s*yönä/)) {
+                    if (targetDate.getHours() > 6) {
+                        targetDate = addDuration(targetDate, { day: -1 });
+                    }
+
+                    assignSimilarDate(component, targetDate);
+                    component.imply("hour", 0);
+                }
+
+                break;
+        }
+
+        if (timeKeyword) {
+            component = FICasualTimeParser.extractTimeComponents(component, timeKeyword);
+        }
+
+        return component;
+    }
+}

package/src/locales/fi/parsers/FICasualTimeParser.ts

@@ -0,0 +1,85 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents, ParsingResult } from "../../../results";
+import { Meridiem } from "../../../types";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { implySimilarTime } from "../../../utils/dates";
+
+export default class FICasualTimeParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(context: ParsingContext): RegExp {
+        return /(tänä\s*)?(aamulla|aamuna|aamupäivällä|päivällä|iltapäivällä|illalla|yöllä|keskiyöllä)(?=\W|$)/i;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult {
+        const targetDate = context.refDate;
+        const timeKeywordPattern = match[2].toLowerCase();
+        const component = context.createParsingComponents();
+        implySimilarTime(component, targetDate);
+        return FICasualTimeParser.extractTimeComponents(component, timeKeywordPattern);
+    }
+
+    static extractTimeComponents(component: ParsingComponents, timeKeywordPattern: string): ParsingComponents {
+        switch (timeKeywordPattern) {
+            case "aamulla":
+            case "aamuna":
+                component.imply("hour", 6);
+                component.imply("minute", 0);
+                component.imply("second", 0);
+                component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/morning");
+                break;
+
+            case "aamupäivällä":
+                component.imply("hour", 9);
+                component.imply("minute", 0);
+                component.imply("second", 0);
+                component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/morning");
+                break;
+
+            case "päivällä":
+                component.imply("hour", 12);
+                component.imply("minute", 0);
+                component.imply("second", 0);
+                component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/noon");
+                break;
+
+            case "iltapäivällä":
+                component.imply("hour", 15);
+                component.imply("minute", 0);
+                component.imply("second", 0);
+                component.imply("meridiem", Meridiem.PM);
+                component.addTag("casualReference/afternoon");
+                break;
+
+            case "illalla":
+                component.imply("hour", 18);
+                component.imply("minute", 0);
+                component.imply("second", 0);
+                component.imply("meridiem", Meridiem.PM);
+                component.addTag("casualReference/evening");
+                break;
+
+            case "yöllä":
+                component.imply("hour", 22);
+                component.imply("minute", 0);
+                component.imply("second", 0);
+                component.imply("meridiem", Meridiem.PM);
+                component.addTag("casualReference/evening");
+                break;
+
+            case "keskiyöllä":
+                if (component.get("hour") > 1) {
+                    component.addDurationAsImplied({ "day": 1 });
+                }
+
+                component.imply("hour", 0);
+                component.imply("minute", 0);
+                component.imply("second", 0);
+                component.imply("meridiem", Meridiem.AM);
+                component.addTag("casualReference/midnight");
+                break;
+        }
+        return component;
+    }
+}

package/src/locales/fi/parsers/FIMonthNameLittleEndianParser.ts

@@ -0,0 +1,57 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingResult } from "../../../results";
+import { findYearClosestToRef } from "../../../calculation/years";
+import { MONTH_DICTIONARY } from "../constants";
+import { parseYear } from "../constants";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const PATTERN = new RegExp(
+    `([0-9]{1,2})\\.?` +
+        `(?:\\s*(?:\\-|\\–|\\s)\\s*([0-9]{1,2})\\.?)?\\s*` +
+        `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+        `(?:(?:-|/|,?\\s*)([0-9]{4}(?![^\\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 FIMonthNameLittleEndianParser 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 = parseInt(match[DATE_GROUP]);
+        if (day > 31) {
+            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 = parseInt(match[DATE_TO_GROUP]);
+            result.end = result.start.clone();
+            result.end.assign("day", endDate);
+        }
+
+        return result;
+    }
+}