chrono-node 2.6.3 → 2.6.5

package/src/locales/fr/index.ts

@@ -5,8 +5,9 @@
  */
 
 import { includeCommonConfiguration } from "../../configurations";
-import { ParsedResult, ParsingOption } from "../../index";
-import { Chrono, Configuration } from "../../chrono";
+import { Chrono, Configuration, Parser, Refiner } from "../../chrono";
+import { ParsingResult, ParsingComponents, ReferenceWithTimezone } from "../../results";
+import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday } from "../../types";
 import FRCasualDateParser from "./parsers/FRCasualDateParser";
 import FRCasualTimeParser from "./parsers/FRCasualTimeParser";
 import SlashDateFormatParser from "../../common/parsers/SlashDateFormatParser";
@@ -20,6 +21,9 @@ import FRTimeUnitAgoFormatParser from "./parsers/FRTimeUnitAgoFormatParser";
 import FRTimeUnitWithinFormatParser from "./parsers/FRTimeUnitWithinFormatParser";
 import FRTimeUnitRelativeFormatParser from "./parsers/FRTimeUnitRelativeFormatParser";
 
+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));

package/src/locales/fr/parsers/FRCasualDateParser.ts

@@ -1,7 +1,7 @@
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents, ParsingResult } from "../../../results";
 import dayjs from "dayjs";
-import { Meridiem } from "../../../index";
+import { Meridiem } from "../../../types";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { assignSimilarDate } from "../../../utils/dayjs";
 import * as references from "../../../common/casualReferences";

package/src/locales/fr/parsers/FRCasualTimeParser.ts

@@ -1,6 +1,6 @@
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents, ParsingResult } from "../../../results";
-import { Meridiem } from "../../../index";
+import { Meridiem } from "../../../types";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 
 export default class FRCasualTimeParser extends AbstractParserWithWordBoundaryChecking {

package/src/locales/fr/parsers/FRSpecificTimeExpressionParser.ts

@@ -1,6 +1,6 @@
 import { Parser, ParsingContext } from "../../../chrono";
 import { ParsingComponents, ParsingResult } from "../../../results";
-import { Meridiem } from "../../../index";
+import { Meridiem } from "../../../types";
 
 /**
  * 8h10m00s

package/src/locales/ja/index.ts

@@ -8,8 +8,12 @@ import JPStandardParser from "./parsers/JPStandardParser";
 import JPMergeDateRangeRefiner from "./refiners/JPMergeDateRangeRefiner";
 import JPCasualDateParser from "./parsers/JPCasualDateParser";
 
-import { Chrono, Configuration } from "../../chrono";
-import { ParsedResult, ParsingOption } from "../../index";
+import { Chrono, Configuration, Parser, Refiner } from "../../chrono";
+import { ParsingResult, ParsingComponents, ReferenceWithTimezone } from "../../results";
+import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday } from "../../types";
+
+export { Chrono, Parser, Refiner, ParsingResult, ParsingComponents, ReferenceWithTimezone };
+export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday };
 
 // Shortcuts
 export const casual = new Chrono(createCasualConfiguration());

package/src/locales/ja/parsers/JPCasualDateParser.ts

@@ -1,9 +1,32 @@
 import { Parser, ParsingContext } from "../../../chrono";
 import dayjs from "dayjs";
-import { Meridiem } from "../../../index";
+import { Meridiem } from "../../../types";
 import * as references from "../../../common/casualReferences";
 
-const PATTERN = /今日|当日|昨日|明日|今夜|今夕|今晩|今朝/i;
+const PATTERN = /今日|きょう|当日|とうじつ|昨日|きのう|明日|あした|今夜|こんや|今夕|こんゆう|今晩|こんばん|今朝|けさ/i;
+
+function normalizeTextToKanji(text: string) {
+    switch (text) {
+        case "きょう":
+            return "今日";
+        case "とうじつ":
+            return "当日";
+        case "きのう":
+            return "昨日";
+        case "あした":
+            return "明日";
+        case "こんや":
+            return "今夜";
+        case "こんゆう":
+            return "今夕";
+        case "こんばん":
+            return "今晩";
+        case "けさ":
+            return "今朝";
+        default:
+            return text;
+    }
+}
 
 export default class JPCasualDateParser implements Parser {
     pattern() {
@@ -11,7 +34,7 @@ export default class JPCasualDateParser implements Parser {
     }
 
     extract(context: ParsingContext, match: RegExpMatchArray) {
-        const text = match[0];
+        const text = normalizeTextToKanji(match[0]);
 
         const date = dayjs(context.refDate);
         const components = context.createParsingComponents();

package/src/locales/nl/index.ts

@@ -5,8 +5,9 @@
  */
 
 import { includeCommonConfiguration } from "../../configurations";
-import { ParsedResult, ParsingOption } from "../../index";
-import { Chrono, Configuration } from "../../chrono";
+import { Chrono, Configuration, Parser, Refiner } from "../../chrono";
+import { ParsingResult, ParsingComponents, ReferenceWithTimezone } from "../../results";
+import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday } from "../../types";
 import NLMergeDateRangeRefiner from "./refiners/NLMergeDateRangeRefiner";
 import NLMergeDateTimeRefiner from "./refiners/NLMergeDateTimeRefiner";
 import NLCasualDateParser from "./parsers/NLCasualDateParser";
@@ -25,6 +26,9 @@ import NLRelativeDateFormatParser from "./parsers/NLRelativeDateFormatParser";
 import NLTimeUnitAgoFormatParser from "./parsers/NLTimeUnitAgoFormatParser";
 import NLTimeUnitLaterFormatParser from "./parsers/NLTimeUnitLaterFormatParser";
 
+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));

package/src/locales/nl/parsers/NLCasualDateTimeParser.ts

@@ -1,7 +1,7 @@
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents, ParsingResult } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
-import { Meridiem } from "../../../index";
+import { Meridiem } from "../../../types";
 import { assignSimilarDate, assignTheNextDay } from "../../../utils/dayjs";
 import dayjs from "dayjs";
 

package/src/locales/nl/parsers/NLCasualTimeParser.ts

@@ -1,5 +1,5 @@
 import { ParsingContext } from "../../../chrono";
-import { Meridiem } from "../../../index";
+import { Meridiem } from "../../../types";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import dayjs from "dayjs";
 import { assignTheNextDay } from "../../../utils/dayjs";

package/src/locales/pt/index.ts

@@ -5,8 +5,9 @@
  */
 
 import { includeCommonConfiguration } from "../../configurations";
-import { ParsedResult, ParsingOption } from "../../index";
-import { Chrono, Configuration } from "../../chrono";
+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 PTWeekdayParser from "./parsers/PTWeekdayParser";
 import PTTimeExpressionParser from "./parsers/PTTimeExpressionParser";
@@ -16,6 +17,9 @@ import PTMonthNameLittleEndianParser from "./parsers/PTMonthNameLittleEndianPars
 import PTCasualDateParser from "./parsers/PTCasualDateParser";
 import PTCasualTimeParser from "./parsers/PTCasualTimeParser";
 
+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));

package/src/locales/pt/parsers/PTCasualTimeParser.ts

@@ -1,5 +1,5 @@
 import { ParsingContext } from "../../../chrono";
-import { Meridiem } from "../../../index";
+import { Meridiem } from "../../../types";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { assignTheNextDay } from "../../../utils/dayjs";
 import dayjs from "dayjs";

package/src/locales/ru/index.ts

@@ -18,11 +18,15 @@ import RUCasualTimeParser from "./parsers/RUCasualTimeParser";
 import RUWeekdayParser from "./parsers/RUWeekdayParser";
 import RURelativeDateFormatParser from "./parsers/RURelativeDateFormatParser";
 
-import { ParsedResult, ParsingOption } from "../../index";
-import { Chrono, Configuration } from "../../chrono";
+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 RUTimeUnitCasualRelativeFormatParser from "./parsers/RUTimeUnitCasualRelativeFormatParser";
 
+export { Chrono, Parser, Refiner, ParsingResult, ParsingComponents, ReferenceWithTimezone };
+export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday };
+
 /**
  * Chrono object configured for parsing *casual* Russian
  */

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

@@ -1,6 +1,6 @@
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
-import { Meridiem } from "../../../index";
+import { Meridiem } from "../../../types";
 import { AbstractTimeExpressionParser } from "../../../common/parsers/AbstractTimeExpressionParser";
 import { REGEX_PARTS } from "../constants";
 

package/src/locales/uk/constants.ts

@@ -0,0 +1,349 @@
+import { OpUnitType, QUnitType } from "dayjs";
+import { matchAnyPattern, repeatedTimeunitPattern } from "../../utils/pattern";
+import { findMostLikelyADYear } from "../../calculation/years";
+import { TimeUnits } from "../../utils/timeunits";
+
+export const REGEX_PARTS = {
+    leftBoundary: "([^\\p{L}\\p{N}_]|^)",
+    rightBoundary: "(?=[^\\p{L}\\p{N}_]|$)",
+    flags: "iu",
+};
+
+export const WEEKDAY_DICTIONARY: { [word: string]: number } = {
+    "неділя": 0,
+    "неділі": 0,
+    "неділю": 0,
+    "нд": 0,
+    "нд.": 0,
+    "понеділок": 1,
+    "понеділка": 1,
+    "пн": 1,
+    "пн.": 1,
+    "вівторок": 2,
+    "вівторка": 2,
+    "вт": 2,
+    "вт.": 2,
+    "середа": 3,
+    "середи": 3,
+    "середу": 3,
+    "ср": 3,
+    "ср.": 3,
+    "четвер": 4,
+    "четверга": 4,
+    "четвергу": 4,
+    "чт": 4,
+    "чт.": 4,
+    "п'ятниця": 5,
+    "п'ятниці": 5,
+    "п'ятницю": 5,
+    "пт": 5,
+    "пт.": 5,
+    "субота": 6,
+    "суботи": 6,
+    "суботу": 6,
+    "сб": 6,
+    "сб.": 6,
+};
+
+export const FULL_MONTH_NAME_DICTIONARY: { [word: string]: number } = {
+    "січень": 1,
+    "січня": 1,
+    "січні": 1,
+    "лютий": 2,
+    "лютого": 2,
+    "лютому": 2,
+    "березень": 3,
+    "березня": 3,
+    "березні": 3,
+    "квітень": 4,
+    "квітня": 4,
+    "квітні": 4,
+    "травень": 5,
+    "травня": 5,
+    "травні": 5,
+    "червень": 6,
+    "червня": 6,
+    "червні": 6,
+    "липень": 7,
+    "липня": 7,
+    "липні": 7,
+    "серпень": 8,
+    "серпня": 8,
+    "серпні": 8,
+    "вересень": 9,
+    "вересня": 9,
+    "вересні": 9,
+    "жовтень": 10,
+    "жовтня": 10,
+    "жовтні": 10,
+    "листопад": 11,
+    "листопада": 11,
+    "листопаду": 11,
+    "грудень": 12,
+    "грудня": 12,
+    "грудні": 12,
+};
+
+export const MONTH_DICTIONARY: { [word: string]: number } = {
+    ...FULL_MONTH_NAME_DICTIONARY,
+    "січ": 1,
+    "січ.": 1,
+    "лют": 2,
+    "лют.": 2,
+    "бер": 3,
+    "бер.": 3,
+    "квіт": 4,
+    "квіт.": 4,
+    "трав": 5,
+    "трав.": 5,
+    "черв": 6,
+    "черв.": 6,
+    "лип": 7,
+    "лип.": 7,
+    "серп": 8,
+    "серп.": 8,
+    "сер": 8,
+    "cер.": 8,
+    "вер": 9,
+    "вер.": 9,
+    "верес": 9,
+    "верес.": 9,
+    "жовт": 10,
+    "жовт.": 10,
+    "листоп": 11,
+    "листоп.": 11,
+    "груд": 12,
+    "груд.": 12,
+};
+
+export const INTEGER_WORD_DICTIONARY: { [word: string]: number } = {
+    "один": 1,
+    "одна": 1,
+    "одної": 1,
+    "одну": 1,
+    "дві": 2,
+    "два": 2,
+    "двох": 2,
+    "три": 3,
+    "трьох": 3,
+    "чотири": 4,
+    "чотирьох": 4,
+    "п'ять": 5,
+    "п'яти": 5,
+    "шість": 6,
+    "шести": 6,
+    "сім": 7,
+    "семи": 7,
+    "вісім": 8,
+    "восьми": 8,
+    "дев'ять": 9,
+    "дев'яти": 9,
+    "десять": 10,
+    "десяти": 10,
+    "одинадцять": 11,
+    "одинадцяти": 11,
+    "дванадцять": 12,
+    "дванадцяти": 12,
+};
+
+export const ORDINAL_WORD_DICTIONARY: { [word: string]: number } = {
+    "перше": 1,
+    "першого": 1,
+    "друге": 2,
+    "другого": 2,
+    "третє": 3,
+    "третього": 3,
+    "четверте": 4,
+    "четвертого": 4,
+    "п'яте": 5,
+    "п'ятого": 5,
+    "шосте": 6,
+    "шостого": 6,
+    "сьоме": 7,
+    "сьомого": 7,
+    "восьме": 8,
+    "восьмого": 8,
+    "дев'яте": 9,
+    "дев'ятого": 9,
+    "десяте": 10,
+    "десятого": 10,
+    "одинадцяте": 11,
+    "одинадцятого": 11,
+    "дванадцяте": 12,
+    "дванадцятого": 12,
+    "тринадцяте": 13,
+    "тринадцятого": 13,
+    "чотирнадцяте": 14,
+    "чотинрнадцятого": 14,
+    "п'ятнадцяте": 15,
+    "п'ятнадцятого": 15,
+    "шістнадцяте": 16,
+    "шістнадцятого": 16,
+    "сімнадцяте": 17,
+    "сімнадцятого": 17,
+    "вісімнадцяте": 18,
+    "вісімнадцятого": 18,
+    "дев'ятнадцяте": 19,
+    "дев'ятнадцятого": 19,
+    "двадцяте": 20,
+    "двадцятого": 20,
+    "двадцять перше": 21,
+    "двадцять першого": 21,
+    "двадцять друге": 22,
+    "двадцять другого": 22,
+    "двадцять третє": 23,
+    "двадцять третього": 23,
+    "двадцять четверте": 24,
+    "двадцять четвертого": 24,
+    "двадцять п'яте": 25,
+    "двадцять п'ятого": 25,
+    "двадцять шосте": 26,
+    "двадцять шостого": 26,
+    "двадцять сьоме": 27,
+    "двадцять сьомого": 27,
+    "двадцять восьме": 28,
+    "двадцять восьмого": 28,
+    "двадцять дев'яте": 29,
+    "двадцять дев'ятого": 29,
+    "тридцяте": 30,
+    "тридцятого": 30,
+    "тридцять перше": 31,
+    "тридцять першого": 31,
+};
+
+export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } = {
+    сек: "second",
+    секунда: "second",
+    секунд: "second",
+    секунди: "second",
+    секунду: "second",
+    секундочок: "second",
+    секундочки: "second",
+    секундочку: "second",
+    хв: "minute",
+    хвилина: "minute",
+    хвилин: "minute",
+    хвилини: "minute",
+    хвилину: "minute",
+    хвилинок: "minute",
+    хвилинки: "minute",
+    хвилинку: "minute",
+    хвилиночок: "minute",
+    хвилиночки: "minute",
+    хвилиночку: "minute",
+    год: "hour",
+    година: "hour",
+    годин: "hour",
+    години: "hour",
+    годину: "hour",
+    годинка: "hour",
+    годинок: "hour",
+    годинки: "hour",
+    годинку: "hour",
+    день: "d",
+    дня: "d",
+    днів: "d",
+    дні: "d",
+    доба: "d",
+    добу: "d",
+    тиждень: "week",
+    тижню: "week",
+    тижня: "week",
+    тижні: "week",
+    тижнів: "week",
+    місяць: "month",
+    місяців: "month",
+    місяці: "month",
+    місяця: "month",
+    квартал: "quarter",
+    кварталу: "quarter",
+    квартала: "quarter",
+    кварталів: "quarter",
+    кварталі: "quarter",
+    рік: "year",
+    року: "year",
+    році: "year",
+    років: "year",
+    роки: "year",
+};
+
+//--------------------------------
+
+export const NUMBER_PATTERN = `(?:${matchAnyPattern(
+    INTEGER_WORD_DICTIONARY
+)}|[0-9]+|[0-9]+\\.[0-9]+|пів|декілька|пар(?:у)|\\s{0,3})`;
+
+export function parseNumberPattern(match: string): number {
+    const num = match.toLowerCase();
+    if (INTEGER_WORD_DICTIONARY[num] !== undefined) {
+        return INTEGER_WORD_DICTIONARY[num];
+    }
+    if (num.match(/декілька/)) {
+        return 2;
+    } else if (num.match(/пів/)) {
+        return 0.5;
+    } else if (num.match(/пар/)) {
+        return 2;
+    } else if (num === "") {
+        return 1;
+    }
+    return parseFloat(num);
+}
+
+export const ORDINAL_NUMBER_PATTERN = `(?:${matchAnyPattern(ORDINAL_WORD_DICTIONARY)}|[0-9]{1,2}(?:го|ого|е)?)`;
+export function parseOrdinalNumberPattern(match: string): number {
+    const num = match.toLowerCase();
+    if (ORDINAL_WORD_DICTIONARY[num] !== undefined) {
+        return ORDINAL_WORD_DICTIONARY[num];
+    }
+    return parseInt(num);
+}
+
+const year = "(?:\\s+(?:року|рік|р|р.))?";
+export const YEAR_PATTERN = `(?:[1-9][0-9]{0,3}${year}\\s*(?:н.е.|до н.е.|н. е.|до н. е.)|[1-2][0-9]{3}${year}|[5-9][0-9]${year})`;
+export function parseYearPattern(match: string): number {
+    if (/(рік|року|р|р.)/i.test(match)) {
+        match = match.replace(/(рік|року|р|р.)/i, "");
+    }
+
+    if (/(до н.е.|до н. е.)/i.test(match)) {
+        //Before Common Era
+        match = match.replace(/(до н.е.|до н. е.)/i, "");
+        return -parseInt(match);
+    }
+
+    if (/(н. е.|н.е.)/i.test(match)) {
+        //Common Era
+        match = match.replace(/(н. е.|н.е.)/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(
+    `(?:(?:близько|приблизно)\\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/uk/index.ts

@@ -0,0 +1,90 @@
+/**
+ * Chrono components for Ukrainian support (*parsers*, *refiners*, and *configuration*)
+ *
+ * @module
+ */
+
+import UKTimeUnitWithinFormatParser from "./parsers/UKTimeUnitWithinFormatParser";
+import UKMonthNameLittleEndianParser from "./parsers/UKMonthNameLittleEndianParser";
+import UkMonthNameParser from "./parsers/UKMonthNameParser";
+import UKTimeExpressionParser from "./parsers/UKTimeExpressionParser";
+import UKTimeUnitAgoFormatParser from "./parsers/UKTimeUnitAgoFormatParser";
+import UKMergeDateRangeRefiner from "./refiners/UKMergeDateRangeRefiner";
+import UKMergeDateTimeRefiner from "./refiners/UKMergeDateTimeRefiner";
+
+import { includeCommonConfiguration } from "../../configurations";
+import UKCasualDateParser from "./parsers/UKCasualDateParser";
+import UKCasualTimeParser from "./parsers/UKCasualTimeParser";
+import UKWeekdayParser from "./parsers/UKWeekdayParser";
+import UKRelativeDateFormatParser from "./parsers/UKRelativeDateFormatParser";
+
+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 UKTimeUnitCasualRelativeFormatParser from "./parsers/UKTimeUnitCasualRelativeFormatParser";
+import ISOFormatParser from "../../common/parsers/ISOFormatParser";
+
+export { Chrono, Parser, Refiner, ParsingResult, ParsingComponents, ReferenceWithTimezone };
+export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday };
+
+/**
+ * Chrono object configured for parsing *casual* Ukrainian
+ */
+export const casual = new Chrono(createCasualConfiguration());
+
+/**
+ * Chrono object configured for parsing *strict* Ukrainian
+ */
+export const strict = new Chrono(createConfiguration(true));
+
+/**
+ * Create a default *casual* {@Link Configuration} for Ukrainian chrono.
+ * It calls {@Link createConfiguration} and includes additional parsers.
+ */
+export function createCasualConfiguration(): Configuration {
+    const option = createConfiguration(false);
+    option.parsers.unshift(new UKCasualDateParser());
+    option.parsers.unshift(new UKCasualTimeParser());
+    option.parsers.unshift(new UkMonthNameParser());
+    option.parsers.unshift(new UKRelativeDateFormatParser());
+    option.parsers.unshift(new UKTimeUnitCasualRelativeFormatParser());
+    return option;
+}
+
+/**
+ * Create a default {@Link Configuration} for Ukrainian chrono
+ *
+ * @param strictMode If the timeunit mentioning should be strict, not casual
+ */
+export function createConfiguration(strictMode: boolean): Configuration {
+    return includeCommonConfiguration(
+        {
+            parsers: [
+                new ISOFormatParser(),
+                new SlashDateFormatParser(true),
+                new UKTimeUnitWithinFormatParser(),
+                new UKMonthNameLittleEndianParser(),
+                new UKWeekdayParser(),
+                new UKTimeExpressionParser(strictMode),
+                new UKTimeUnitAgoFormatParser(),
+            ],
+            refiners: [new UKMergeDateTimeRefiner(), new UKMergeDateRangeRefiner()],
+        },
+        strictMode
+    );
+}
+
+/**
+ * A shortcut for uk.casual.parse()
+ */
+export function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[] {
+    return casual.parse(text, ref, option);
+}
+
+/**
+ * A shortcut for uk.casual.parseDate()
+ */
+export function parseDate(text: string, ref?: Date, option?: ParsingOption): Date {
+    return casual.parseDate(text, ref, option);
+}