chrono-node 2.8.3 → 2.8.5

package/src/locales/ru/constants.ts

@@ -1,7 +1,7 @@
-import { OpUnitType, QUnitType } from "dayjs";
 import { matchAnyPattern, repeatedTimeunitPattern } from "../../utils/pattern";
 import { findMostLikelyADYear } from "../../calculation/years";
-import { TimeUnits } from "../../utils/timeunits";
+import { Duration } from "../../calculation/duration";
+import { Timeunit } from "../../types";
 
 export const REGEX_PARTS = {
     leftBoundary: "([^\\p{L}\\p{N}_]|^)",
@@ -201,7 +201,7 @@ export const ORDINAL_WORD_DICTIONARY: { [word: string]: number } = {
     "тридцать первого": 31,
 };
 
-export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } = {
+export const TIME_UNIT_DICTIONARY: { [word: string]: Timeunit } = {
     сек: "second",
     секунда: "second",
     секунд: "second",
@@ -230,11 +230,11 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } =
     часика: "hour",
     часике: "hour",
     часик: "hour",
-    день: "d",
-    дня: "d",
-    дней: "d",
-    суток: "d",
-    сутки: "d",
+    день: "day",
+    дня: "day",
+    дней: "day",
+    суток: "day",
+    сутки: "day",
     неделя: "week",
     неделе: "week",
     недели: "week",
@@ -326,7 +326,7 @@ const SINGLE_TIME_UNIT_REGEX = new RegExp(SINGLE_TIME_UNIT_PATTERN, "i");
 
 export const TIME_UNITS_PATTERN = repeatedTimeunitPattern(`(?:(?:около|примерно)\\s{0,3})?`, SINGLE_TIME_UNIT_PATTERN);
 
-export function parseTimeUnits(timeunitText): TimeUnits {
+export function parseDuration(timeunitText): Duration {
     const fragments = {};
     let remainingText = timeunitText;
     let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
@@ -335,7 +335,7 @@ export function parseTimeUnits(timeunitText): TimeUnits {
         remainingText = remainingText.substring(match[0].length).trim();
         match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
     }
-    return fragments;
+    return fragments as Duration;
 }
 
 function collectDateTimeFragment(fragments, match) {

package/src/locales/ru/parsers/RUCasualTimeParser.ts

@@ -1,7 +1,6 @@
 import { ParsingContext } from "../../../chrono";
 import * as references from "../../../common/casualReferences";
-import { assignSimilarDate } from "../../../utils/dayjs";
-import dayjs from "dayjs";
+import { assignSimilarDate } from "../../../utils/dates";
 import { AbstractParserWithLeftRightBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
 export default class RUCasualTimeParser extends AbstractParserWithLeftRightBoundaryChecking {
@@ -10,7 +9,7 @@ export default class RUCasualTimeParser extends AbstractParserWithLeftRightBound
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        let targetDate = dayjs(context.refDate);
+        let targetDate = context.refDate;
         const lowerText = match[0].toLowerCase();
         const component = context.createParsingComponents();
 
@@ -33,9 +32,10 @@ export default class RUCasualTimeParser extends AbstractParserWithLeftRightBound
             return references.yesterdayEvening(context.reference);
         }
         if (lowerText.match(/следующей\s*ночью/)) {
-            const daysToAdd = targetDate.hour() < 22 ? 1 : 2;
-            targetDate = targetDate.add(daysToAdd, "day");
-            assignSimilarDate(component, targetDate);
+            const daysToAdd = targetDate.getHours() < 22 ? 1 : 2;
+            const nextDay = new Date(targetDate.getTime());
+            nextDay.setDate(nextDay.getDate() + daysToAdd);
+            assignSimilarDate(component, nextDay);
             component.imply("hour", 0);
         }
         if (lowerText.match(/в\s*полночь/) || lowerText.endsWith("ночью")) {

package/src/locales/ru/parsers/RURelativeDateFormatParser.ts

@@ -1,8 +1,6 @@
-import { REGEX_PARTS, TIME_UNIT_DICTIONARY } from "../constants";
+import { TIME_UNIT_DICTIONARY } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
-import dayjs from "dayjs";
-import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { matchAnyPattern } from "../../../utils/pattern";
 import { AbstractParserWithLeftRightBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
@@ -34,32 +32,31 @@ export default class RURelativeDateFormatParser extends AbstractParserWithLeftRi
         }
 
         const components = context.createParsingComponents();
-        let date = dayjs(context.reference.instant);
+        let date = new Date(context.reference.instant.getTime());
 
         // This week
         if (timeunit.match(/week/i)) {
-            date = date.add(-date.get("d"), "d");
-            components.imply("day", date.date());
-            components.imply("month", date.month() + 1);
-            components.imply("year", date.year());
+            date.setDate(date.getDate() - date.getDay());
+            components.imply("day", date.getDate());
+            components.imply("month", date.getMonth() + 1);
+            components.imply("year", date.getFullYear());
         }
 
         // This month
         else if (timeunit.match(/month/i)) {
-            date = date.add(-date.date() + 1, "d");
-            components.imply("day", date.date());
-            components.assign("year", date.year());
-            components.assign("month", date.month() + 1);
+            date.setDate(1);
+            components.imply("day", date.getDate());
+            components.assign("year", date.getFullYear());
+            components.assign("month", date.getMonth() + 1);
         }
 
         // This year
         else if (timeunit.match(/year/i)) {
-            date = date.add(-date.date() + 1, "d");
-            date = date.add(-date.month(), "month");
-
-            components.imply("day", date.date());
-            components.imply("month", date.month() + 1);
-            components.assign("year", date.year());
+            date.setDate(1);
+            date.setMonth(0);
+            components.imply("day", date.getDate());
+            components.imply("month", date.getMonth() + 1);
+            components.assign("year", date.getFullYear());
         }
 
         return components;

package/src/locales/ru/parsers/RUTimeUnitAgoFormatParser.ts

@@ -1,8 +1,8 @@
 import { ParsingContext } from "../../../chrono";
-import { parseTimeUnits, TIME_UNITS_PATTERN } from "../constants";
+import { parseDuration, TIME_UNITS_PATTERN } from "../constants";
 import { ParsingComponents } from "../../../results";
-import { reverseTimeUnits } from "../../../utils/timeunits";
 import { AbstractParserWithLeftBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
+import { reverseDuration } from "../../../calculation/duration";
 
 export default class RUTimeUnitAgoFormatParser extends AbstractParserWithLeftBoundaryChecking {
     innerPatternString(context: ParsingContext): string {
@@ -10,8 +10,8 @@ export default class RUTimeUnitAgoFormatParser extends AbstractParserWithLeftBou
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        const timeUnits = parseTimeUnits(match[1]);
-        const outputTimeUnits = reverseTimeUnits(timeUnits);
+        const timeUnits = parseDuration(match[1]);
+        const outputTimeUnits = reverseDuration(timeUnits);
 
         return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
     }

package/src/locales/ru/parsers/RUTimeUnitCasualRelativeFormatParser.ts

@@ -1,8 +1,8 @@
-import { TIME_UNITS_PATTERN, parseTimeUnits, REGEX_PARTS } from "../constants";
+import { TIME_UNITS_PATTERN, parseDuration, REGEX_PARTS } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
-import { reverseTimeUnits } from "../../../utils/timeunits";
 import { AbstractParserWithLeftRightBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
+import { reverseDuration } from "../../../calculation/duration";
 
 export default class RUTimeUnitCasualRelativeFormatParser extends AbstractParserWithLeftRightBoundaryChecking {
     innerPatternString(context: ParsingContext): string {
@@ -11,12 +11,12 @@ export default class RUTimeUnitCasualRelativeFormatParser extends AbstractParser
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
         const prefix = match[1].toLowerCase();
-        let timeUnits = parseTimeUnits(match[2]);
+        let timeUnits = parseDuration(match[2]);
         switch (prefix) {
             case "последние":
             case "прошлые":
             case "-":
-                timeUnits = reverseTimeUnits(timeUnits);
+                timeUnits = reverseDuration(timeUnits);
                 break;
         }
 

package/src/locales/ru/parsers/RUTimeUnitWithinFormatParser.ts

@@ -1,4 +1,4 @@
-import { TIME_UNITS_PATTERN, parseTimeUnits, REGEX_PARTS } from "../constants";
+import { TIME_UNITS_PATTERN, parseDuration, REGEX_PARTS } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
@@ -17,7 +17,7 @@ export default class RUTimeUnitWithinFormatParser extends AbstractParserWithWord
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
-        const timeUnits = parseTimeUnits(match[1]);
+        const timeUnits = parseDuration(match[1]);
         return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

package/src/locales/sv/constants.ts

@@ -0,0 +1,237 @@
+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 } = {
+    "söndag": 0,
+    "sön": 0,
+    "so": 0,
+    "måndag": 1,
+    "mån": 1,
+    "må": 1,
+    "tisdag": 2,
+    "tis": 2,
+    "ti": 2,
+    "onsdag": 3,
+    "ons": 3,
+    "on": 3,
+    "torsdag": 4,
+    "tors": 4,
+    "to": 4,
+    "fredag": 5,
+    "fre": 5,
+    "fr": 5,
+    "lördag": 6,
+    "lör": 6,
+    "lö": 6,
+};
+
+export const MONTH_DICTIONARY: { [word: string]: number } = {
+    "januari": 1,
+    "jan": 1,
+    "jan.": 1,
+    "februari": 2,
+    "feb": 2,
+    "feb.": 2,
+    "mars": 3,
+    "mar": 3,
+    "mar.": 3,
+    "april": 4,
+    "apr": 4,
+    "apr.": 4,
+    "maj": 5,
+    "juni": 6,
+    "jun": 6,
+    "jun.": 6,
+    "juli": 7,
+    "jul": 7,
+    "jul.": 7,
+    "augusti": 8,
+    "aug": 8,
+    "aug.": 8,
+    "september": 9,
+    "sep": 9,
+    "sep.": 9,
+    "sept": 9,
+    "oktober": 10,
+    "okt": 10,
+    "okt.": 10,
+    "november": 11,
+    "nov": 11,
+    "nov.": 11,
+    "december": 12,
+    "dec": 12,
+    "dec.": 12,
+};
+
+export const ORDINAL_NUMBER_DICTIONARY: { [word: string]: number } = {
+    "första": 1,
+    "andra": 2,
+    "tredje": 3,
+    "fjärde": 4,
+    "femte": 5,
+    "sjätte": 6,
+    "sjunde": 7,
+    "åttonde": 8,
+    "nionde": 9,
+    "tionde": 10,
+    "elfte": 11,
+    "tolfte": 12,
+    "trettonde": 13,
+    "fjortonde": 14,
+    "femtonde": 15,
+    "sextonde": 16,
+    "sjuttonde": 17,
+    "artonde": 18,
+    "nittonde": 19,
+    "tjugonde": 20,
+    "tjugoförsta": 21,
+    "tjugoandra": 22,
+    "tjugotredje": 23,
+    "tjugofjärde": 24,
+    "tjugofemte": 25,
+    "tjugosjätte": 26,
+    "tjugosjunde": 27,
+    "tjugoåttonde": 28,
+    "tjugonionde": 29,
+    "trettionde": 30,
+    "trettioförsta": 31,
+};
+
+export const INTEGER_WORD_DICTIONARY: { [word: string]: number } = {
+    "en": 1,
+    "ett": 1,
+    "två": 2,
+    "tre": 3,
+    "fyra": 4,
+    "fem": 5,
+    "sex": 6,
+    "sju": 7,
+    "åtta": 8,
+    "nio": 9,
+    "tio": 10,
+    "elva": 11,
+    "tolv": 12,
+    "tretton": 13,
+    "fjorton": 14,
+    "femton": 15,
+    "sexton": 16,
+    "sjutton": 17,
+    "arton": 18,
+    "nitton": 19,
+    "tjugo": 20,
+    "trettiо": 30,
+    "fyrtio": 40,
+    "femtio": 50,
+    "sextio": 60,
+    "sjuttio": 70,
+    "åttio": 80,
+    "nittio": 90,
+    "hundra": 100,
+    "tusen": 1000,
+};
+
+export const TIME_UNIT_DICTIONARY: { [word: string]: Timeunit } = {
+    "sek": "second",
+    "sekund": "second",
+    "sekunder": "second",
+    "min": "minute",
+    "minut": "minute",
+    "minuter": "minute",
+    "tim": "hour",
+    "timme": "hour",
+    "timmar": "hour",
+    "dag": "day",
+    "dagar": "day",
+    "vecka": "week",
+    "veckor": "week",
+    "mån": "month",
+    "månad": "month",
+    "månader": "month",
+    "år": "year",
+    "kvartаl": "quarter",
+    "kvartal": "quarter",
+};
+
+export const TIME_UNIT_NO_ABBR_DICTIONARY: { [word: string]: Timeunit } = {
+    "sekund": "second",
+    "sekunder": "second",
+    "minut": "minute",
+    "minuter": "minute",
+    "timme": "hour",
+    "timmar": "hour",
+    "dag": "day",
+    "dagar": "day",
+    "vecka": "week",
+    "veckor": "week",
+    "månad": "month",
+    "månader": "month",
+    "år": "year",
+    "kvartal": "quarter",
+};
+
+export function parseDuration(timeunitText): Duration {
+    const fragments = {};
+    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, match) {
+    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 ORDINAL_NUMBER_PATTERN = `(?:${matchAnyPattern(ORDINAL_NUMBER_DICTIONARY)}|\\d{1,2}(?:e|:e))`;
+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 parseOrdinalNumberPattern(match: string): number {
+    const num = match.toLowerCase();
+    if (ORDINAL_NUMBER_DICTIONARY[num] !== undefined) {
+        return ORDINAL_NUMBER_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/sv/index.ts

@@ -0,0 +1,47 @@
+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 SVWeekdayParser from "./parsers/SVWeekdayParser";
+import SVMonthNameLittleEndianParser from "./parsers/SVMonthNameLittleEndianParser";
+import SVTimeUnitCasualRelativeFormatParser from "./parsers/SVTimeUnitCasualRelativeFormatParser";
+import SVCasualDateParser from "./parsers/SVCasualDateParser";
+
+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 SVCasualDateParser());
+    return option;
+}
+
+export function createConfiguration(strictMode = true, littleEndian = true): Configuration {
+    return includeCommonConfiguration(
+        {
+            parsers: [
+                new ISOFormatParser(),
+                new SlashDateFormatParser(littleEndian),
+                new SVMonthNameLittleEndianParser(),
+                new SVWeekdayParser(),
+                new SVTimeUnitCasualRelativeFormatParser(),
+            ],
+            refiners: [],
+        },
+        strictMode
+    );
+}

package/src/locales/sv/parsers/SVCasualDateParser.ts

@@ -0,0 +1,118 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents, ParsingResult } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { assignSimilarDate, implySimilarTime } from "../../../utils/dates";
+import * as references from "../../../common/casualReferences";
+
+const PATTERN = new RegExp(
+    `(nu|idag|imorgon|övermorgon|igår|förrgår|i\\s*förrgår)` +
+        `(?:\\s*(?:på\\s*)?(morgonen?|förmiddagen?|middagen?|eftermiddagen?|kvällen?|natten?|midnatt))?` +
+        `(?=\\W|$)`,
+    "i"
+);
+
+const DATE_GROUP = 1;
+const TIME_GROUP = 2;
+
+export default class SVCasualDateParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(context: ParsingContext): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult {
+        const targetDate = context.refDate;
+        const dateKeyword = (match[DATE_GROUP] || "").toLowerCase();
+        const timeKeyword = (match[TIME_GROUP] || "").toLowerCase();
+
+        let component = context.createParsingComponents();
+        switch (dateKeyword) {
+            case "nu":
+                component = references.now(context.reference);
+                break;
+
+            case "idag":
+                component = references.today(context.reference);
+                break;
+
+            case "imorgon":
+            case "imorn":
+                const nextDay = new Date(targetDate.getTime());
+                nextDay.setDate(nextDay.getDate() + 1);
+                assignSimilarDate(component, nextDay);
+                implySimilarTime(component, nextDay);
+                break;
+
+            case "igår":
+                const previousDay = new Date(targetDate.getTime());
+                previousDay.setDate(previousDay.getDate() - 1);
+                assignSimilarDate(component, previousDay);
+                implySimilarTime(component, previousDay);
+                break;
+
+            case "förrgår":
+            case "i förrgår":
+                const twoDaysAgo = new Date(targetDate.getTime());
+                twoDaysAgo.setDate(twoDaysAgo.getDate() - 2);
+                assignSimilarDate(component, twoDaysAgo);
+                implySimilarTime(component, twoDaysAgo);
+                break;
+        }
+
+        switch (timeKeyword) {
+            case "morgon":
+            case "morgonen":
+                component.imply("hour", 6);
+                component.imply("minute", 0);
+                component.imply("second", 0);
+                component.imply("millisecond", 0);
+                break;
+
+            case "förmiddag":
+            case "förmiddagen":
+                component.imply("hour", 9);
+                component.imply("minute", 0);
+                component.imply("second", 0);
+                component.imply("millisecond", 0);
+                break;
+
+            case "middag":
+            case "middagen":
+                component.imply("hour", 12);
+                component.imply("minute", 0);
+                component.imply("second", 0);
+                component.imply("millisecond", 0);
+                break;
+
+            case "eftermiddag":
+            case "eftermiddagen":
+                component.imply("hour", 15);
+                component.imply("minute", 0);
+                component.imply("second", 0);
+                component.imply("millisecond", 0);
+                break;
+
+            case "kväll":
+            case "kvällen":
+                component.imply("hour", 20);
+                component.imply("minute", 0);
+                component.imply("second", 0);
+                component.imply("millisecond", 0);
+                break;
+
+            case "natt":
+            case "natten":
+            case "midnatt":
+                if (timeKeyword === "midnatt") {
+                    component.imply("hour", 0);
+                } else {
+                    component.imply("hour", 2);
+                }
+                component.imply("minute", 0);
+                component.imply("second", 0);
+                component.imply("millisecond", 0);
+                break;
+        }
+
+        return component;
+    }
+}

package/src/locales/sv/parsers/SVMonthNameLittleEndianParser.ts

@@ -0,0 +1,59 @@
+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(
+    "(?:den\\s*?)?" +
+        `([0-9]{1,2})` +
+        `(?:\\s*(?:till|\\-|\\–|\\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 SVMonthNameLittleEndianParser 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) {
+            // 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 = parseInt(match[DATE_TO_GROUP]);
+            result.end = result.start.clone();
+            result.end.assign("day", endDate);
+        }
+
+        return result;
+    }
+}