art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,55 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var years = require('../../../calculation/years.js');
+var constants = require('../constants.js');
+var pattern = require('../../../utils/pattern.js');
+var AbstractParserWithWordBoundaryChecking = require('./AbstractParserWithWordBoundaryChecking.js');
+
+const DATE_GROUP = 1;
+const DATE_TO_GROUP = 2;
+const MONTH_NAME_GROUP = 3;
+const YEAR_GROUP = 4;
+class UKMonthNameLittleEndianParser extends AbstractParserWithWordBoundaryChecking.AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context) {
+        return (`(?:з|із)?\\s*(${constants.ORDINAL_NUMBER_PATTERN})` +
+            `(?:` +
+            `\\s{0,3}(?:по|-|–|до)?\\s{0,3}` +
+            `(${constants.ORDINAL_NUMBER_PATTERN})` +
+            `)?` +
+            `(?:-|\\/|\\s{0,3}(?:of)?\\s{0,3})` +
+            `(${pattern.matchAnyPattern(constants.MONTH_DICTIONARY)})` +
+            `(?:` +
+            `(?:-|\\/|,?\\s{0,3})` +
+            `(${constants.YEAR_PATTERN}(?![^\\s]\\d))` +
+            `)?`);
+    }
+    innerExtract(context, match) {
+        const result = context.createParsingResult(match.index, match[0]);
+        const month = constants.MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];
+        const day = constants.parseOrdinalNumberPattern(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 = constants.parseYearPattern(match[YEAR_GROUP]);
+            result.start.assign("year", yearNumber);
+        }
+        else {
+            const year = years.findYearClosestToRef(context.reference.instant, day, month);
+            result.start.imply("year", year);
+        }
+        if (match[DATE_TO_GROUP]) {
+            const endDate = constants.parseOrdinalNumberPattern(match[DATE_TO_GROUP]);
+            result.end = result.start.clone();
+            result.end.assign("day", endDate);
+        }
+        return result;
+    }
+}
+
+exports.default = UKMonthNameLittleEndianParser;

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

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../constants.js');
+var years = require('../../../calculation/years.js');
+var pattern = require('../../../utils/pattern.js');
+var AbstractParserWithWordBoundaryChecking = require('./AbstractParserWithWordBoundaryChecking.js');
+
+const MONTH_NAME_GROUP = 2;
+const YEAR_GROUP = 3;
+class UkMonthNameParser extends AbstractParserWithWordBoundaryChecking.AbstractParserWithLeftBoundaryChecking {
+    innerPatternString(context) {
+        return (`((?:в|у)\\s*)?` +
+            `(${pattern.matchAnyPattern(constants.MONTH_DICTIONARY)})` +
+            `\\s*` +
+            `(?:` +
+            `[,-]?\\s*(${constants.YEAR_PATTERN})?` +
+            `)?` +
+            `(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)`);
+    }
+    innerExtract(context, match) {
+        const monthName = match[MONTH_NAME_GROUP].toLowerCase();
+        if (match[0].length <= 3 && !constants.FULL_MONTH_NAME_DICTIONARY[monthName]) {
+            return null;
+        }
+        const result = context.createParsingResult(match.index, match.index + match[0].length);
+        result.start.imply("day", 1);
+        const month = constants.MONTH_DICTIONARY[monthName];
+        result.start.assign("month", month);
+        if (match[YEAR_GROUP]) {
+            const year = constants.parseYearPattern(match[YEAR_GROUP]);
+            result.start.assign("year", year);
+        }
+        else {
+            const year = years.findYearClosestToRef(context.reference.instant, 1, month);
+            result.start.imply("year", year);
+        }
+        return result;
+    }
+}
+
+exports.default = UkMonthNameParser;

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

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../constants.js');
+var results = require('../../../results.js');
+var dayjs_min = require('../../../../../../../_virtual/dayjs.min.js');
+var pattern = require('../../../utils/pattern.js');
+var AbstractParserWithWordBoundaryChecking = require('./AbstractParserWithWordBoundaryChecking.js');
+
+const MODIFIER_WORD_GROUP = 1;
+const RELATIVE_WORD_GROUP = 2;
+class UKRelativeDateFormatParser extends AbstractParserWithWordBoundaryChecking.AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context) {
+        return (`(в минулому|у минулому|на минулому|минулого|на наступному|в наступному|у наступному|наступного|на цьому|в цьому|у цьому|цього)\\s*` +
+            `(${pattern.matchAnyPattern(constants.TIME_UNIT_DICTIONARY)})(?=\\s*)`);
+    }
+    innerExtract(context, match) {
+        const modifier = match[MODIFIER_WORD_GROUP].toLowerCase();
+        const unitWord = match[RELATIVE_WORD_GROUP].toLowerCase();
+        const timeunit = constants.TIME_UNIT_DICTIONARY[unitWord];
+        if (modifier == "на наступному" ||
+            modifier == "в наступному" ||
+            modifier == "у наступному" ||
+            modifier == "наступного") {
+            const timeUnits = {};
+            timeUnits[timeunit] = 1;
+            return results.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+        }
+        if (modifier == "на минулому" ||
+            modifier == "в минулому" ||
+            modifier == "у минулому" ||
+            modifier == "минулого") {
+            const timeUnits = {};
+            timeUnits[timeunit] = -1;
+            return results.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+        }
+        const components = context.createParsingComponents();
+        let date = dayjs_min.default(context.reference.instant);
+        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());
+        }
+        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);
+        }
+        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());
+        }
+        return components;
+    }
+}
+
+exports.default = UKRelativeDateFormatParser;

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

@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var types = require('../../../types.js');
+var AbstractTimeExpressionParser = require('../../../common/parsers/AbstractTimeExpressionParser.js');
+var constants = require('../constants.js');
+
+class UKTimeExpressionParser extends AbstractTimeExpressionParser.AbstractTimeExpressionParser {
+    constructor(strictMode) {
+        super(strictMode);
+    }
+    patternFlags() {
+        return constants.REGEX_PARTS.flags;
+    }
+    primaryPatternLeftBoundary() {
+        return `(^|\\s|T|(?:[^\\p{L}\\p{N}_]))`;
+    }
+    followingPhase() {
+        return `\\s*(?:\\-|\\–|\\~|\\〜|до|і|по|\\?)\\s*`;
+    }
+    primaryPrefix() {
+        return `(?:(?:в|у|о|об|з|із|від)\\s*)??`;
+    }
+    primarySuffix() {
+        return `(?:\\s*(?:ранку|вечора|по обіді|після обіду))?(?!\\/)${constants.REGEX_PARTS.rightBoundary}`;
+    }
+    extractPrimaryTimeComponents(context, match) {
+        const components = super.extractPrimaryTimeComponents(context, match);
+        if (components) {
+            if (match[0].endsWith("вечора")) {
+                const hour = components.get("hour");
+                if (hour >= 6 && hour < 12) {
+                    components.assign("hour", components.get("hour") + 12);
+                    components.assign("meridiem", types.Meridiem.PM);
+                }
+                else if (hour < 6) {
+                    components.assign("meridiem", types.Meridiem.AM);
+                }
+            }
+            if (match[0].endsWith("по обіді") || match[0].endsWith("після обіду")) {
+                components.assign("meridiem", types.Meridiem.PM);
+                const hour = components.get("hour");
+                if (hour >= 0 && hour <= 6) {
+                    components.assign("hour", components.get("hour") + 12);
+                }
+            }
+            if (match[0].endsWith("ранку")) {
+                components.assign("meridiem", types.Meridiem.AM);
+                const hour = components.get("hour");
+                if (hour < 12) {
+                    components.assign("hour", components.get("hour"));
+                }
+            }
+        }
+        return components;
+    }
+}
+
+exports.default = UKTimeExpressionParser;

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

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../constants.js');
+var results = require('../../../results.js');
+var timeunits = require('../../../utils/timeunits.js');
+var AbstractParserWithWordBoundaryChecking = require('./AbstractParserWithWordBoundaryChecking.js');
+
+class UKTimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking.AbstractParserWithLeftBoundaryChecking {
+    innerPatternString(context) {
+        return `(${constants.TIME_UNITS_PATTERN})\\s{0,5}тому(?=(?:\\W|$))`;
+    }
+    innerExtract(context, match) {
+        const timeUnits = constants.parseTimeUnits(match[1]);
+        const outputTimeUnits = timeunits.reverseTimeUnits(timeUnits);
+        return results.ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
+    }
+}
+
+exports.default = UKTimeUnitAgoFormatParser;

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

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../constants.js');
+var results = require('../../../results.js');
+var timeunits = require('../../../utils/timeunits.js');
+var AbstractParserWithWordBoundaryChecking = require('./AbstractParserWithWordBoundaryChecking.js');
+
+class UKTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking.AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context) {
+        return `(ці|останні|минулі|майбутні|наступні|після|через|\\+|-)\\s*(${constants.TIME_UNITS_PATTERN})`;
+    }
+    innerExtract(context, match) {
+        const prefix = match[1].toLowerCase();
+        let timeUnits = constants.parseTimeUnits(match[3]);
+        switch (prefix) {
+            case "останні":
+            case "минулі":
+            case "-":
+                timeUnits = timeunits.reverseTimeUnits(timeUnits);
+                break;
+        }
+        return results.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}
+
+exports.default = UKTimeUnitCasualRelativeFormatParser;

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

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../constants.js');
+var results = require('../../../results.js');
+var AbstractParserWithWordBoundary = require('../../../common/parsers/AbstractParserWithWordBoundary.js');
+
+const PATTERN = `(?:(?:приблизно|орієнтовно)\\s*(?:~\\s*)?)?(${constants.TIME_UNITS_PATTERN})${constants.REGEX_PARTS.rightBoundary}`;
+class UKTimeUnitWithinFormatParser extends AbstractParserWithWordBoundary.AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary() {
+        return constants.REGEX_PARTS.leftBoundary;
+    }
+    innerPattern(context) {
+        return context.option.forwardDate
+            ? new RegExp(PATTERN, "i")
+            : new RegExp(`(?:протягом|на протязі|протягом|упродовж|впродовж)\\s*${PATTERN}`, constants.REGEX_PARTS.flags);
+    }
+    innerExtract(context, match) {
+        const timeUnits = constants.parseTimeUnits(match[1]);
+        return results.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}
+
+exports.default = UKTimeUnitWithinFormatParser;

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

@@ -0,0 +1,48 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../constants.js');
+var pattern = require('../../../utils/pattern.js');
+var weekdays = require('../../../common/calculation/weekdays.js');
+var AbstractParserWithWordBoundaryChecking = require('./AbstractParserWithWordBoundaryChecking.js');
+
+const PREFIX_GROUP = 1;
+const WEEKDAY_GROUP = 2;
+const POSTFIX_GROUP = 3;
+class UKWeekdayParser extends AbstractParserWithWordBoundaryChecking.AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context) {
+        return (`(?:(?:,|\\(|（)\\s*)?` +
+            `(?:в\\s*?)?` +
+            `(?:у\\s*?)?` +
+            `(?:(цей|минулого|минулий|попередній|попереднього|наступного|наступний|наступному)\\s*)?` +
+            `(${pattern.matchAnyPattern(constants.WEEKDAY_DICTIONARY)})` +
+            `(?:\\s*(?:,|\\)|）))?` +
+            `(?:\\s*(на|у|в)\\s*(цьому|минулому|наступному)\\s*тижні)?`);
+    }
+    innerExtract(context, match) {
+        const dayOfWeek = match[WEEKDAY_GROUP].toLocaleLowerCase();
+        const weekday = constants.WEEKDAY_DICTIONARY[dayOfWeek];
+        const prefix = match[PREFIX_GROUP];
+        const postfix = match[POSTFIX_GROUP];
+        let modifierWord = prefix || postfix;
+        modifierWord = modifierWord || "";
+        modifierWord = modifierWord.toLocaleLowerCase();
+        let modifier = null;
+        if (modifierWord == "минулого" ||
+            modifierWord == "минулий" ||
+            modifierWord == "попередній" ||
+            modifierWord == "попереднього") {
+            modifier = "last";
+        }
+        else if (modifierWord == "наступного" || modifierWord == "наступний") {
+            modifier = "next";
+        }
+        else if (modifierWord == "цей" || modifierWord == "цього" || modifierWord == "цьому") {
+            modifier = "this";
+        }
+        return weekdays.createParsingComponentsAtWeekday(context.reference, weekday, modifier);
+    }
+}
+
+exports.default = UKWeekdayParser;

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

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var AbstractMergeDateRangeRefiner = require('../../../common/refiners/AbstractMergeDateRangeRefiner.js');
+
+class UKMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner.default {
+    patternBetween() {
+        return /^\s*(і до|і по|до|по|-)\s*$/i;
+    }
+}
+
+exports.default = UKMergeDateRangeRefiner;

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

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var AbstractMergeDateTimeRefiner = require('../../../common/refiners/AbstractMergeDateTimeRefiner.js');
+
+class UKMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner.default {
+    patternBetween() {
+        return new RegExp(`^\\s*(T|в|у|о|,|-)?\\s*$`);
+    }
+}
+
+exports.default = UKMergeDateTimeRefiner;

package/dist/cjs/node_modules/chrono-node/dist/esm/results.js

@@ -0,0 +1,269 @@
+'use strict';
+
+var quarterOfYear = require('../../../../_virtual/quarterOfYear.js');
+var dayjs_min = require('../../../../_virtual/dayjs.min.js');
+var dayjs = require('./utils/dayjs.js');
+var timezone = require('./timezone.js');
+
+dayjs_min.default.extend(quarterOfYear.default);
+class ReferenceWithTimezone {
+    instant;
+    timezoneOffset;
+    constructor(input) {
+        input = input ?? new Date();
+        if (input instanceof Date) {
+            this.instant = input;
+            this.timezoneOffset = null;
+        }
+        else {
+            this.instant = input.instant ?? new Date();
+            this.timezoneOffset = timezone.toTimezoneOffset(input.timezone, this.instant);
+        }
+    }
+    getDateWithAdjustedTimezone() {
+        const date = new Date(this.instant);
+        if (this.timezoneOffset !== null) {
+            date.setMinutes(date.getMinutes() - this.getSystemTimezoneAdjustmentMinute(this.instant));
+        }
+        return date;
+    }
+    getSystemTimezoneAdjustmentMinute(date, overrideTimezoneOffset) {
+        if (!date || date.getTime() < 0) {
+            date = new Date();
+        }
+        const currentTimezoneOffset = -date.getTimezoneOffset();
+        const targetTimezoneOffset = overrideTimezoneOffset ?? this.timezoneOffset ?? currentTimezoneOffset;
+        return currentTimezoneOffset - targetTimezoneOffset;
+    }
+    getTimezoneOffset() {
+        return this.timezoneOffset ?? -this.instant.getTimezoneOffset();
+    }
+}
+class ParsingComponents {
+    knownValues;
+    impliedValues;
+    reference;
+    _tags = new Set();
+    constructor(reference, knownComponents) {
+        this.reference = reference;
+        this.knownValues = {};
+        this.impliedValues = {};
+        if (knownComponents) {
+            for (const key in knownComponents) {
+                this.knownValues[key] = knownComponents[key];
+            }
+        }
+        const refDayJs = reference.getDateWithAdjustedTimezone();
+        this.imply("day", refDayJs.getDate());
+        this.imply("month", refDayJs.getMonth() + 1);
+        this.imply("year", refDayJs.getFullYear());
+        this.imply("hour", 12);
+        this.imply("minute", 0);
+        this.imply("second", 0);
+        this.imply("millisecond", 0);
+    }
+    get(component) {
+        if (component in this.knownValues) {
+            return this.knownValues[component];
+        }
+        if (component in this.impliedValues) {
+            return this.impliedValues[component];
+        }
+        return null;
+    }
+    isCertain(component) {
+        return component in this.knownValues;
+    }
+    getCertainComponents() {
+        return Object.keys(this.knownValues);
+    }
+    imply(component, value) {
+        if (component in this.knownValues) {
+            return this;
+        }
+        this.impliedValues[component] = value;
+        return this;
+    }
+    assign(component, value) {
+        this.knownValues[component] = value;
+        delete this.impliedValues[component];
+        return this;
+    }
+    delete(component) {
+        delete this.knownValues[component];
+        delete this.impliedValues[component];
+    }
+    clone() {
+        const component = new ParsingComponents(this.reference);
+        component.knownValues = {};
+        component.impliedValues = {};
+        for (const key in this.knownValues) {
+            component.knownValues[key] = this.knownValues[key];
+        }
+        for (const key in this.impliedValues) {
+            component.impliedValues[key] = this.impliedValues[key];
+        }
+        return component;
+    }
+    isOnlyDate() {
+        return !this.isCertain("hour") && !this.isCertain("minute") && !this.isCertain("second");
+    }
+    isOnlyTime() {
+        return (!this.isCertain("weekday") && !this.isCertain("day") && !this.isCertain("month") && !this.isCertain("year"));
+    }
+    isOnlyWeekdayComponent() {
+        return this.isCertain("weekday") && !this.isCertain("day") && !this.isCertain("month");
+    }
+    isDateWithUnknownYear() {
+        return this.isCertain("month") && !this.isCertain("year");
+    }
+    isValidDate() {
+        const date = this.dateWithoutTimezoneAdjustment();
+        if (date.getFullYear() !== this.get("year"))
+            return false;
+        if (date.getMonth() !== this.get("month") - 1)
+            return false;
+        if (date.getDate() !== this.get("day"))
+            return false;
+        if (this.get("hour") != null && date.getHours() != this.get("hour"))
+            return false;
+        if (this.get("minute") != null && date.getMinutes() != this.get("minute"))
+            return false;
+        return true;
+    }
+    toString() {
+        return `[ParsingComponents {
+            tags: ${JSON.stringify(Array.from(this._tags).sort())}, 
+            knownValues: ${JSON.stringify(this.knownValues)}, 
+            impliedValues: ${JSON.stringify(this.impliedValues)}}, 
+            reference: ${JSON.stringify(this.reference)}]`;
+    }
+    dayjs() {
+        return dayjs_min.default(this.dateWithoutTimezoneAdjustment());
+    }
+    date() {
+        const date = this.dateWithoutTimezoneAdjustment();
+        const timezoneAdjustment = this.reference.getSystemTimezoneAdjustmentMinute(date, this.get("timezoneOffset"));
+        return new Date(date.getTime() + timezoneAdjustment * 60000);
+    }
+    addTag(tag) {
+        this._tags.add(tag);
+        return this;
+    }
+    addTags(tags) {
+        for (const tag of tags) {
+            this._tags.add(tag);
+        }
+        return this;
+    }
+    tags() {
+        return new Set(this._tags);
+    }
+    dateWithoutTimezoneAdjustment() {
+        const date = new Date(this.get("year"), this.get("month") - 1, this.get("day"), this.get("hour"), this.get("minute"), this.get("second"), this.get("millisecond"));
+        date.setFullYear(this.get("year"));
+        return date;
+    }
+    static createRelativeFromReference(reference, fragments) {
+        let date = dayjs_min.default(reference.getDateWithAdjustedTimezone());
+        for (const key in fragments) {
+            date = date.add(fragments[key], key);
+        }
+        const components = new ParsingComponents(reference);
+        components.addTag("result/relativeDate");
+        if (fragments["hour"] || fragments["minute"] || fragments["second"]) {
+            components.addTag("result/relativeDateAndTime");
+            dayjs.assignSimilarTime(components, date);
+            dayjs.assignSimilarDate(components, date);
+            components.assign("timezoneOffset", reference.getTimezoneOffset());
+        }
+        else {
+            dayjs.implySimilarTime(components, date);
+            components.imply("timezoneOffset", reference.getTimezoneOffset());
+            if (fragments["d"]) {
+                components.assign("day", date.date());
+                components.assign("month", date.month() + 1);
+                components.assign("year", date.year());
+            }
+            else if (fragments["week"]) {
+                components.assign("day", date.date());
+                components.assign("month", date.month() + 1);
+                components.assign("year", date.year());
+                components.imply("weekday", date.day());
+            }
+            else {
+                components.imply("day", date.date());
+                if (fragments["month"]) {
+                    components.assign("month", date.month() + 1);
+                    components.assign("year", date.year());
+                }
+                else {
+                    components.imply("month", date.month() + 1);
+                    if (fragments["year"]) {
+                        components.assign("year", date.year());
+                    }
+                    else {
+                        components.imply("year", date.year());
+                    }
+                }
+            }
+        }
+        return components;
+    }
+}
+class ParsingResult {
+    refDate;
+    index;
+    text;
+    reference;
+    start;
+    end;
+    constructor(reference, index, text, start, end) {
+        this.reference = reference;
+        this.refDate = reference.instant;
+        this.index = index;
+        this.text = text;
+        this.start = start || new ParsingComponents(reference);
+        this.end = end;
+    }
+    clone() {
+        const result = new ParsingResult(this.reference, this.index, this.text);
+        result.start = this.start ? this.start.clone() : null;
+        result.end = this.end ? this.end.clone() : null;
+        return result;
+    }
+    date() {
+        return this.start.date();
+    }
+    addTag(tag) {
+        this.start.addTag(tag);
+        if (this.end) {
+            this.end.addTag(tag);
+        }
+        return this;
+    }
+    addTags(tags) {
+        this.start.addTags(tags);
+        if (this.end) {
+            this.end.addTags(tags);
+        }
+        return this;
+    }
+    tags() {
+        const combinedTags = new Set(this.start.tags());
+        if (this.end) {
+            for (const tag of this.end.tags()) {
+                combinedTags.add(tag);
+            }
+        }
+        return combinedTags;
+    }
+    toString() {
+        const tags = Array.from(this.tags()).sort();
+        return `[ParsingResult {index: ${this.index}, text: '${this.text}', tags: ${JSON.stringify(tags)} ...}]`;
+    }
+}
+
+exports.ParsingComponents = ParsingComponents;
+exports.ParsingResult = ParsingResult;
+exports.ReferenceWithTimezone = ReferenceWithTimezone;