art-bd-ui 1.0.21 → 1.0.23

package/dist/cjs/node_modules/chrono-node/dist/esm/locales/en/refiners/ENMergeDateRangeRefiner.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var AbstractMergeDateRangeRefiner = require('../../../common/refiners/AbstractMergeDateRangeRefiner.js');
+
+class ENMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner.default {
+    patternBetween() {
+        return /^\s*(to|-|–|until|through|till)\s*$/i;
+    }
+}
+
+exports.default = ENMergeDateRangeRefiner;

package/dist/cjs/node_modules/chrono-node/dist/esm/locales/en/refiners/ENMergeDateTimeRefiner.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var AbstractMergeDateTimeRefiner = require('../../../common/refiners/AbstractMergeDateTimeRefiner.js');
+
+class ENMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner.default {
+    patternBetween() {
+        return new RegExp("^\\s*(T|at|after|before|on|of|,|-|\\.|∙|:)?\\s*$");
+    }
+}
+
+exports.default = ENMergeDateTimeRefiner;

package/dist/cjs/node_modules/chrono-node/dist/esm/locales/en/refiners/ENMergeRelativeAfterDateRefiner.js

@@ -0,0 +1,33 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var abstractRefiners = require('../../../common/abstractRefiners.js');
+var results = require('../../../results.js');
+var constants = require('../constants.js');
+var timeunits = require('../../../utils/timeunits.js');
+
+function IsPositiveFollowingReference(result) {
+    return result.text.match(/^[+-]/i) != null;
+}
+function IsNegativeFollowingReference(result) {
+    return result.text.match(/^-/i) != null;
+}
+class ENMergeRelativeAfterDateRefiner extends abstractRefiners.MergingRefiner {
+    shouldMergeResults(textBetween, currentResult, nextResult) {
+        if (!textBetween.match(/^\s*$/i)) {
+            return false;
+        }
+        return IsPositiveFollowingReference(nextResult) || IsNegativeFollowingReference(nextResult);
+    }
+    mergeResults(textBetween, currentResult, nextResult, context) {
+        let timeUnits = constants.parseTimeUnits(nextResult.text);
+        if (IsNegativeFollowingReference(nextResult)) {
+            timeUnits = timeunits.reverseTimeUnits(timeUnits);
+        }
+        const components = results.ParsingComponents.createRelativeFromReference(new results.ReferenceWithTimezone(currentResult.start.date()), timeUnits);
+        return new results.ParsingResult(currentResult.reference, currentResult.index, `${currentResult.text}${textBetween}${nextResult.text}`, components);
+    }
+}
+
+exports.default = ENMergeRelativeAfterDateRefiner;

package/dist/cjs/node_modules/chrono-node/dist/esm/locales/en/refiners/ENMergeRelativeFollowByDateRefiner.js

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var abstractRefiners = require('../../../common/abstractRefiners.js');
+var results = require('../../../results.js');
+var constants = require('../constants.js');
+var timeunits = require('../../../utils/timeunits.js');
+
+function hasImpliedEarlierReferenceDate(result) {
+    return result.text.match(/\s+(before|from)$/i) != null;
+}
+function hasImpliedLaterReferenceDate(result) {
+    return result.text.match(/\s+(after|since)$/i) != null;
+}
+class ENMergeRelativeFollowByDateRefiner extends abstractRefiners.MergingRefiner {
+    patternBetween() {
+        return /^\s*$/i;
+    }
+    shouldMergeResults(textBetween, currentResult, nextResult) {
+        if (!textBetween.match(this.patternBetween())) {
+            return false;
+        }
+        if (!hasImpliedEarlierReferenceDate(currentResult) && !hasImpliedLaterReferenceDate(currentResult)) {
+            return false;
+        }
+        return !!nextResult.start.get("day") && !!nextResult.start.get("month") && !!nextResult.start.get("year");
+    }
+    mergeResults(textBetween, currentResult, nextResult) {
+        let timeUnits = constants.parseTimeUnits(currentResult.text);
+        if (hasImpliedEarlierReferenceDate(currentResult)) {
+            timeUnits = timeunits.reverseTimeUnits(timeUnits);
+        }
+        const components = results.ParsingComponents.createRelativeFromReference(new results.ReferenceWithTimezone(nextResult.start.date()), timeUnits);
+        return new results.ParsingResult(nextResult.reference, currentResult.index, `${currentResult.text}${textBetween}${nextResult.text}`, components);
+    }
+}
+
+exports.default = ENMergeRelativeFollowByDateRefiner;

package/dist/cjs/node_modules/chrono-node/dist/esm/locales/en/refiners/ENUnlikelyFormatFilter.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var abstractRefiners = require('../../../common/abstractRefiners.js');
+
+class ENUnlikelyFormatFilter extends abstractRefiners.Filter {
+    constructor() {
+        super();
+    }
+    isValid(context, result) {
+        const text = result.text.trim();
+        if (text === context.text.trim()) {
+            return true;
+        }
+        if (text.toLowerCase() === "may") {
+            const textBefore = context.text.substring(0, result.index).trim();
+            if (!textBefore.match(/\b(in)$/i)) {
+                context.debug(() => {
+                    console.log(`Removing unlikely result: ${result}`);
+                });
+                return false;
+            }
+        }
+        if (text.toLowerCase().endsWith("the second")) {
+            const textAfter = context.text.substring(result.index + result.text.length).trim();
+            if (textAfter.length > 0) {
+                context.debug(() => {
+                    console.log(`Removing unlikely result: ${result}`);
+                });
+            }
+            return false;
+        }
+        return true;
+    }
+}
+
+exports.default = ENUnlikelyFormatFilter;

package/dist/cjs/node_modules/chrono-node/dist/esm/locales/uk/constants.js

@@ -0,0 +1,342 @@
+'use strict';
+
+var pattern = require('../../utils/pattern.js');
+var years = require('../../calculation/years.js');
+
+const REGEX_PARTS = {
+    leftBoundary: "([^\\p{L}\\p{N}_]|^)",
+    rightBoundary: "(?=[^\\p{L}\\p{N}_]|$)",
+    flags: "iu",
+};
+const WEEKDAY_DICTIONARY = {
+    "неділя": 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,
+};
+const FULL_MONTH_NAME_DICTIONARY = {
+    "січень": 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,
+};
+const MONTH_DICTIONARY = {
+    ...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,
+};
+const INTEGER_WORD_DICTIONARY = {
+    "один": 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,
+};
+const ORDINAL_WORD_DICTIONARY = {
+    "перше": 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,
+};
+const TIME_UNIT_DICTIONARY = {
+    сек: "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",
+};
+const NUMBER_PATTERN = `(?:${pattern.matchAnyPattern(INTEGER_WORD_DICTIONARY)}|[0-9]+|[0-9]+\\.[0-9]+|пів|декілька|пар(?:у)|\\s{0,3})`;
+function parseNumberPattern(match) {
+    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);
+}
+const ORDINAL_NUMBER_PATTERN = `(?:${pattern.matchAnyPattern(ORDINAL_WORD_DICTIONARY)}|[0-9]{1,2}(?:го|ого|е)?)`;
+function parseOrdinalNumberPattern(match) {
+    const num = match.toLowerCase();
+    if (ORDINAL_WORD_DICTIONARY[num] !== undefined) {
+        return ORDINAL_WORD_DICTIONARY[num];
+    }
+    return parseInt(num);
+}
+const year = "(?:\\s+(?:року|рік|р|р.))?";
+const YEAR_PATTERN = `(?:[1-9][0-9]{0,3}${year}\\s*(?:н.е.|до н.е.|н. е.|до н. е.)|[1-2][0-9]{3}${year}|[5-9][0-9]${year})`;
+function parseYearPattern(match) {
+    if (/(рік|року|р|р.)/i.test(match)) {
+        match = match.replace(/(рік|року|р|р.)/i, "");
+    }
+    if (/(до н.е.|до н. е.)/i.test(match)) {
+        match = match.replace(/(до н.е.|до н. е.)/i, "");
+        return -parseInt(match);
+    }
+    if (/(н. е.|н.е.)/i.test(match)) {
+        match = match.replace(/(н. е.|н.е.)/i, "");
+        return parseInt(match);
+    }
+    const rawYearNumber = parseInt(match);
+    return years.findMostLikelyADYear(rawYearNumber);
+}
+const SINGLE_TIME_UNIT_PATTERN = `(${NUMBER_PATTERN})\\s{0,3}(${pattern.matchAnyPattern(TIME_UNIT_DICTIONARY)})`;
+const SINGLE_TIME_UNIT_REGEX = new RegExp(SINGLE_TIME_UNIT_PATTERN, "i");
+const TIME_UNITS_PATTERN = pattern.repeatedTimeunitPattern(`(?:(?:близько|приблизно)\\s{0,3})?`, SINGLE_TIME_UNIT_PATTERN);
+function parseTimeUnits(timeunitText) {
+    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;
+}
+
+exports.FULL_MONTH_NAME_DICTIONARY = FULL_MONTH_NAME_DICTIONARY;
+exports.INTEGER_WORD_DICTIONARY = INTEGER_WORD_DICTIONARY;
+exports.MONTH_DICTIONARY = MONTH_DICTIONARY;
+exports.NUMBER_PATTERN = NUMBER_PATTERN;
+exports.ORDINAL_NUMBER_PATTERN = ORDINAL_NUMBER_PATTERN;
+exports.ORDINAL_WORD_DICTIONARY = ORDINAL_WORD_DICTIONARY;
+exports.REGEX_PARTS = REGEX_PARTS;
+exports.TIME_UNITS_PATTERN = TIME_UNITS_PATTERN;
+exports.TIME_UNIT_DICTIONARY = TIME_UNIT_DICTIONARY;
+exports.WEEKDAY_DICTIONARY = WEEKDAY_DICTIONARY;
+exports.YEAR_PATTERN = YEAR_PATTERN;
+exports.parseNumberPattern = parseNumberPattern;
+exports.parseOrdinalNumberPattern = parseOrdinalNumberPattern;
+exports.parseTimeUnits = parseTimeUnits;
+exports.parseYearPattern = parseYearPattern;

package/dist/cjs/node_modules/chrono-node/dist/esm/locales/uk/index.js

@@ -0,0 +1,71 @@
+'use strict';
+
+var UKTimeUnitWithinFormatParser = require('./parsers/UKTimeUnitWithinFormatParser.js');
+var UKMonthNameLittleEndianParser = require('./parsers/UKMonthNameLittleEndianParser.js');
+var UKMonthNameParser = require('./parsers/UKMonthNameParser.js');
+var UKTimeExpressionParser = require('./parsers/UKTimeExpressionParser.js');
+var UKTimeUnitAgoFormatParser = require('./parsers/UKTimeUnitAgoFormatParser.js');
+var UKMergeDateRangeRefiner = require('./refiners/UKMergeDateRangeRefiner.js');
+var UKMergeDateTimeRefiner = require('./refiners/UKMergeDateTimeRefiner.js');
+var configurations = require('../../configurations.js');
+var UKCasualDateParser = require('./parsers/UKCasualDateParser.js');
+var UKCasualTimeParser = require('./parsers/UKCasualTimeParser.js');
+var UKWeekdayParser = require('./parsers/UKWeekdayParser.js');
+var UKRelativeDateFormatParser = require('./parsers/UKRelativeDateFormatParser.js');
+var chrono = require('../../chrono.js');
+var results = require('../../results.js');
+var types = require('../../types.js');
+var SlashDateFormatParser = require('../../common/parsers/SlashDateFormatParser.js');
+var UKTimeUnitCasualRelativeFormatParser = require('./parsers/UKTimeUnitCasualRelativeFormatParser.js');
+var ISOFormatParser = require('../../common/parsers/ISOFormatParser.js');
+
+const casual = new chrono.Chrono(createCasualConfiguration());
+const strict = new chrono.Chrono(createConfiguration(true));
+function createCasualConfiguration() {
+    const option = createConfiguration(false);
+    option.parsers.unshift(new UKCasualDateParser.default());
+    option.parsers.unshift(new UKCasualTimeParser.default());
+    option.parsers.unshift(new UKMonthNameParser.default());
+    option.parsers.unshift(new UKRelativeDateFormatParser.default());
+    option.parsers.unshift(new UKTimeUnitCasualRelativeFormatParser.default());
+    return option;
+}
+function createConfiguration(strictMode) {
+    return configurations.includeCommonConfiguration({
+        parsers: [
+            new ISOFormatParser.default(),
+            new SlashDateFormatParser.default(true),
+            new UKTimeUnitWithinFormatParser.default(),
+            new UKMonthNameLittleEndianParser.default(),
+            new UKWeekdayParser.default(),
+            new UKTimeExpressionParser.default(strictMode),
+            new UKTimeUnitAgoFormatParser.default(),
+        ],
+        refiners: [new UKMergeDateTimeRefiner.default(), new UKMergeDateRangeRefiner.default()],
+    }, strictMode);
+}
+function parse(text, ref, option) {
+    return casual.parse(text, ref, option);
+}
+function parseDate(text, ref, option) {
+    return casual.parseDate(text, ref, option);
+}
+
+exports.Chrono = chrono.Chrono;
+exports.ParsingComponents = results.ParsingComponents;
+exports.ParsingResult = results.ParsingResult;
+exports.ReferenceWithTimezone = results.ReferenceWithTimezone;
+Object.defineProperty(exports, "Meridiem", {
+    enumerable: true,
+    get: function () { return types.Meridiem; }
+});
+Object.defineProperty(exports, "Weekday", {
+    enumerable: true,
+    get: function () { return types.Weekday; }
+});
+exports.casual = casual;
+exports.createCasualConfiguration = createCasualConfiguration;
+exports.createConfiguration = createConfiguration;
+exports.parse = parse;
+exports.parseDate = parseDate;
+exports.strict = strict;

package/dist/cjs/node_modules/chrono-node/dist/esm/locales/uk/parsers/AbstractParserWithWordBoundaryChecking.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var AbstractParserWithWordBoundary = require('../../../common/parsers/AbstractParserWithWordBoundary.js');
+var constants = require('../constants.js');
+
+class AbstractParserWithLeftBoundaryChecking extends AbstractParserWithWordBoundary.AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary() {
+        return constants.REGEX_PARTS.leftBoundary;
+    }
+    innerPattern(context) {
+        return new RegExp(this.innerPatternString(context), constants.REGEX_PARTS.flags);
+    }
+    innerPatternHasChange(context, currentInnerPattern) {
+        return false;
+    }
+}
+class AbstractParserWithLeftRightBoundaryChecking extends AbstractParserWithLeftBoundaryChecking {
+    innerPattern(context) {
+        return new RegExp(`${this.innerPatternString(context)}${constants.REGEX_PARTS.rightBoundary}`, constants.REGEX_PARTS.flags);
+    }
+}
+
+exports.AbstractParserWithLeftBoundaryChecking = AbstractParserWithLeftBoundaryChecking;
+exports.AbstractParserWithLeftRightBoundaryChecking = AbstractParserWithLeftRightBoundaryChecking;

package/dist/cjs/node_modules/chrono-node/dist/esm/locales/uk/parsers/UKCasualDateParser.js

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var casualReferences = require('../../../common/casualReferences.js');
+var AbstractParserWithWordBoundaryChecking = require('./AbstractParserWithWordBoundaryChecking.js');
+
+class UKCasualDateParser extends AbstractParserWithWordBoundaryChecking.AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context) {
+        return `(?:з|із|від)?\\s*(сьогодні|вчора|завтра|післязавтра|післяпіслязавтра|позапозавчора|позавчора)`;
+    }
+    innerExtract(context, match) {
+        const lowerText = match[1].toLowerCase();
+        const component = context.createParsingComponents();
+        switch (lowerText) {
+            case "сьогодні":
+                return casualReferences.today(context.reference);
+            case "вчора":
+                return casualReferences.yesterday(context.reference);
+            case "завтра":
+                return casualReferences.tomorrow(context.reference);
+            case "післязавтра":
+                return casualReferences.theDayAfter(context.reference, 2);
+            case "післяпіслязавтра":
+                return casualReferences.theDayAfter(context.reference, 3);
+            case "позавчора":
+                return casualReferences.theDayBefore(context.reference, 2);
+            case "позапозавчора":
+                return casualReferences.theDayBefore(context.reference, 3);
+        }
+        return component;
+    }
+}
+
+exports.default = UKCasualDateParser;

package/dist/cjs/node_modules/chrono-node/dist/esm/locales/uk/parsers/UKCasualTimeParser.js

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var casualReferences = require('../../../common/casualReferences.js');
+var dayjs = require('../../../utils/dayjs.js');
+var dayjs_min = require('../../../../../../../_virtual/dayjs.min.js');
+var AbstractParserWithWordBoundaryChecking = require('./AbstractParserWithWordBoundaryChecking.js');
+
+class UKCasualTimeParser extends AbstractParserWithWordBoundaryChecking.AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context) {
+        return `(зараз|минулого\\s*вечора|минулої\\s*ночі|наступної\\s*ночі|сьогодні\\s*вночі|цієї\\s*ночі|цього ранку|вранці|ранку|зранку|опівдні|ввечері|вечора|опівночі|вночі)`;
+    }
+    innerExtract(context, match) {
+        let targetDate = dayjs_min.default(context.reference.instant);
+        const lowerText = match[0].toLowerCase();
+        const component = context.createParsingComponents();
+        if (lowerText === "зараз") {
+            return casualReferences.now(context.reference);
+        }
+        if (lowerText === "ввечері" || lowerText === "вечора") {
+            return casualReferences.evening(context.reference);
+        }
+        if (lowerText.endsWith("вранці") || lowerText.endsWith("ранку") || lowerText.endsWith("зранку")) {
+            return casualReferences.morning(context.reference);
+        }
+        if (lowerText.endsWith("опівдні")) {
+            return casualReferences.noon(context.reference);
+        }
+        if (lowerText.match(/минулої\s*ночі/)) {
+            return casualReferences.lastNight(context.reference);
+        }
+        if (lowerText.match(/минулого\s*вечора/)) {
+            return casualReferences.yesterdayEvening(context.reference);
+        }
+        if (lowerText.match(/наступної\s*ночі/)) {
+            const daysToAdd = targetDate.hour() < 22 ? 1 : 2;
+            targetDate = targetDate.add(daysToAdd, "day");
+            dayjs.assignSimilarDate(component, targetDate);
+            component.imply("hour", 1);
+        }
+        if (lowerText.match(/цієї\s*ночі/)) {
+            return casualReferences.midnight(context.reference);
+        }
+        if (lowerText.endsWith("опівночі") || lowerText.endsWith("вночі")) {
+            return casualReferences.midnight(context.reference);
+        }
+        return component;
+    }
+}
+
+exports.default = UKCasualTimeParser;