art-bd-ui 1.0.21 → 1.0.23

package/dist/esm/node_modules/chrono-node/dist/esm/locales/en/parsers/ENMonthNameLittleEndianParser.js

@@ -0,0 +1,54 @@
+import { findYearClosestToRef } from '../../../calculation/years.js';
+import { MONTH_DICTIONARY, parseOrdinalNumberPattern, parseYear, ORDINAL_NUMBER_PATTERN, YEAR_PATTERN } from '../constants.js';
+import { matchAnyPattern } from '../../../utils/pattern.js';
+import { AbstractParserWithWordBoundaryChecking } from '../../../common/parsers/AbstractParserWithWordBoundary.js';
+
+const PATTERN = new RegExp(`(?:on\\s{0,3})?` +
+    `(${ORDINAL_NUMBER_PATTERN})` +
+    `(?:` +
+    `\\s{0,3}(?:to|\\-|\\–|until|through|till)?\\s{0,3}` +
+    `(${ORDINAL_NUMBER_PATTERN})` +
+    ")?" +
+    `(?:-|/|\\s{0,3}(?:of)?\\s{0,3})` +
+    `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+    "(?:" +
+    `(?:-|/|,?\\s{0,3})` +
+    `(${YEAR_PATTERN}(?!\\w))` +
+    ")?" +
+    "(?=\\W|$)", "i");
+const DATE_GROUP = 1;
+const DATE_TO_GROUP = 2;
+const MONTH_NAME_GROUP = 3;
+const YEAR_GROUP = 4;
+class ENMonthNameLittleEndianParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return PATTERN;
+    }
+    innerExtract(context, match) {
+        const result = context.createParsingResult(match.index, match[0]);
+        const month = MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];
+        const day = 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 = 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 = parseOrdinalNumberPattern(match[DATE_TO_GROUP]);
+            result.end = result.start.clone();
+            result.end.assign("day", endDate);
+        }
+        return result;
+    }
+}
+
+export { ENMonthNameLittleEndianParser as default };

package/dist/esm/node_modules/chrono-node/dist/esm/locales/en/parsers/ENMonthNameMiddleEndianParser.js

@@ -0,0 +1,68 @@
+import { findYearClosestToRef } from '../../../calculation/years.js';
+import { MONTH_DICTIONARY, parseOrdinalNumberPattern, parseYear, ORDINAL_NUMBER_PATTERN, YEAR_PATTERN } from '../constants.js';
+import { matchAnyPattern } from '../../../utils/pattern.js';
+import { AbstractParserWithWordBoundaryChecking } from '../../../common/parsers/AbstractParserWithWordBoundary.js';
+
+const PATTERN = new RegExp(`(${matchAnyPattern(MONTH_DICTIONARY)})` +
+    "(?:-|/|\\s*,?\\s*)" +
+    `(${ORDINAL_NUMBER_PATTERN})(?!\\s*(?:am|pm))\\s*` +
+    "(?:" +
+    "(?:to|\\-)\\s*" +
+    `(${ORDINAL_NUMBER_PATTERN})\\s*` +
+    ")?" +
+    "(?:" +
+    `(?:-|/|\\s*,\\s*|\\s+)` +
+    `(${YEAR_PATTERN})` +
+    ")?" +
+    "(?=\\W|$)(?!\\:\\d)", "i");
+const MONTH_NAME_GROUP = 1;
+const DATE_GROUP = 2;
+const DATE_TO_GROUP = 3;
+const YEAR_GROUP = 4;
+class ENMonthNameMiddleEndianParser extends AbstractParserWithWordBoundaryChecking {
+    shouldSkipYearLikeDate;
+    constructor(shouldSkipYearLikeDate) {
+        super();
+        this.shouldSkipYearLikeDate = shouldSkipYearLikeDate;
+    }
+    innerPattern() {
+        return PATTERN;
+    }
+    innerExtract(context, match) {
+        const month = MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];
+        const day = parseOrdinalNumberPattern(match[DATE_GROUP]);
+        if (day > 31) {
+            return null;
+        }
+        if (this.shouldSkipYearLikeDate) {
+            if (!match[DATE_TO_GROUP] && !match[YEAR_GROUP] && match[DATE_GROUP].match(/^2[0-5]$/)) {
+                return null;
+            }
+        }
+        const components = context
+            .createParsingComponents({
+            day: day,
+            month: month,
+        })
+            .addTag("parser/ENMonthNameMiddleEndianParser");
+        if (match[YEAR_GROUP]) {
+            const year = parseYear(match[YEAR_GROUP]);
+            components.assign("year", year);
+        }
+        else {
+            const year = findYearClosestToRef(context.refDate, day, month);
+            components.imply("year", year);
+        }
+        if (!match[DATE_TO_GROUP]) {
+            return components;
+        }
+        const endDate = parseOrdinalNumberPattern(match[DATE_TO_GROUP]);
+        const result = context.createParsingResult(match.index, match[0]);
+        result.start = components;
+        result.end = components.clone();
+        result.end.assign("day", endDate);
+        return result;
+    }
+}
+
+export { ENMonthNameMiddleEndianParser as default };

package/dist/esm/node_modules/chrono-node/dist/esm/locales/en/parsers/ENMonthNameParser.js

@@ -0,0 +1,42 @@
+import { FULL_MONTH_NAME_DICTIONARY, MONTH_DICTIONARY, parseYear, YEAR_PATTERN } from '../constants.js';
+import { findYearClosestToRef } from '../../../calculation/years.js';
+import { matchAnyPattern } from '../../../utils/pattern.js';
+import { AbstractParserWithWordBoundaryChecking } from '../../../common/parsers/AbstractParserWithWordBoundary.js';
+
+const PATTERN = new RegExp(`((?:in)\\s*)?` +
+    `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+    `\\s*` +
+    `(?:` +
+    `(?:,|-|of)?\\s*(${YEAR_PATTERN})?` +
+    ")?" +
+    "(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)", "i");
+const PREFIX_GROUP = 1;
+const MONTH_NAME_GROUP = 2;
+const YEAR_GROUP = 3;
+class ENMonthNameParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return PATTERN;
+    }
+    innerExtract(context, match) {
+        const monthName = match[MONTH_NAME_GROUP].toLowerCase();
+        if (match[0].length <= 3 && !FULL_MONTH_NAME_DICTIONARY[monthName]) {
+            return null;
+        }
+        const result = context.createParsingResult(match.index + (match[PREFIX_GROUP] || "").length, match.index + match[0].length);
+        result.start.imply("day", 1);
+        result.start.addTag("parser/ENMonthNameParser");
+        const month = MONTH_DICTIONARY[monthName];
+        result.start.assign("month", month);
+        if (match[YEAR_GROUP]) {
+            const year = parseYear(match[YEAR_GROUP]);
+            result.start.assign("year", year);
+        }
+        else {
+            const year = findYearClosestToRef(context.refDate, 1, month);
+            result.start.imply("year", year);
+        }
+        return result;
+    }
+}
+
+export { ENMonthNameParser as default };

package/dist/esm/node_modules/chrono-node/dist/esm/locales/en/parsers/ENRelativeDateFormatParser.js

@@ -0,0 +1,53 @@
+import { TIME_UNIT_DICTIONARY } from '../constants.js';
+import { ParsingComponents } from '../../../results.js';
+import dayjs from '../../../../../../../_virtual/dayjs.min.js';
+import { AbstractParserWithWordBoundaryChecking } from '../../../common/parsers/AbstractParserWithWordBoundary.js';
+import { matchAnyPattern } from '../../../utils/pattern.js';
+
+const PATTERN = new RegExp(`(this|last|past|next|after\\s*this)\\s*(${matchAnyPattern(TIME_UNIT_DICTIONARY)})(?=\\s*)` + "(?=\\W|$)", "i");
+const MODIFIER_WORD_GROUP = 1;
+const RELATIVE_WORD_GROUP = 2;
+class ENRelativeDateFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return PATTERN;
+    }
+    innerExtract(context, match) {
+        const modifier = match[MODIFIER_WORD_GROUP].toLowerCase();
+        const unitWord = match[RELATIVE_WORD_GROUP].toLowerCase();
+        const timeunit = TIME_UNIT_DICTIONARY[unitWord];
+        if (modifier == "next" || modifier.startsWith("after")) {
+            const timeUnits = {};
+            timeUnits[timeunit] = 1;
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+        }
+        if (modifier == "last" || modifier == "past") {
+            const timeUnits = {};
+            timeUnits[timeunit] = -1;
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+        }
+        const components = context.createParsingComponents();
+        let date = dayjs(context.reference.instant);
+        if (unitWord.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 (unitWord.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 (unitWord.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;
+    }
+}
+
+export { ENRelativeDateFormatParser as default };

package/dist/esm/node_modules/chrono-node/dist/esm/locales/en/parsers/ENSlashMonthFormatParser.js

@@ -0,0 +1,17 @@
+import { AbstractParserWithWordBoundaryChecking } from '../../../common/parsers/AbstractParserWithWordBoundary.js';
+
+const PATTERN = new RegExp("([0-9]|0[1-9]|1[012])/([0-9]{4})" + "", "i");
+const MONTH_GROUP = 1;
+const YEAR_GROUP = 2;
+class ENSlashMonthFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return PATTERN;
+    }
+    innerExtract(context, match) {
+        const year = parseInt(match[YEAR_GROUP]);
+        const month = parseInt(match[MONTH_GROUP]);
+        return context.createParsingComponents().imply("day", 1).assign("month", month).assign("year", year);
+    }
+}
+
+export { ENSlashMonthFormatParser as default };

package/dist/esm/node_modules/chrono-node/dist/esm/locales/en/parsers/ENTimeExpressionParser.js

@@ -0,0 +1,57 @@
+import { Meridiem } from '../../../types.js';
+import { AbstractTimeExpressionParser } from '../../../common/parsers/AbstractTimeExpressionParser.js';
+
+class ENTimeExpressionParser extends AbstractTimeExpressionParser {
+    constructor(strictMode) {
+        super(strictMode);
+    }
+    followingPhase() {
+        return "\\s*(?:\\-|\\–|\\~|\\〜|to|until|through|till|\\?)\\s*";
+    }
+    primaryPrefix() {
+        return "(?:(?:at|from)\\s*)??";
+    }
+    primarySuffix() {
+        return "(?:\\s*(?:o\\W*clock|at\\s*night|in\\s*the\\s*(?:morning|afternoon)))?(?!/)(?=\\W|$)";
+    }
+    extractPrimaryTimeComponents(context, match) {
+        const components = super.extractPrimaryTimeComponents(context, match);
+        if (!components) {
+            return components;
+        }
+        if (match[0].endsWith("night")) {
+            const hour = components.get("hour");
+            if (hour >= 6 && hour < 12) {
+                components.assign("hour", components.get("hour") + 12);
+                components.assign("meridiem", Meridiem.PM);
+            }
+            else if (hour < 6) {
+                components.assign("meridiem", Meridiem.AM);
+            }
+        }
+        if (match[0].endsWith("afternoon")) {
+            components.assign("meridiem", Meridiem.PM);
+            const hour = components.get("hour");
+            if (hour >= 0 && hour <= 6) {
+                components.assign("hour", components.get("hour") + 12);
+            }
+        }
+        if (match[0].endsWith("morning")) {
+            components.assign("meridiem", Meridiem.AM);
+            const hour = components.get("hour");
+            if (hour < 12) {
+                components.assign("hour", components.get("hour"));
+            }
+        }
+        return components.addTag("parser/ENTimeExpressionParser");
+    }
+    extractFollowingTimeComponents(context, match, result) {
+        const followingComponents = super.extractFollowingTimeComponents(context, match, result);
+        if (followingComponents) {
+            followingComponents.addTag("parser/ENTimeExpressionParser");
+        }
+        return followingComponents;
+    }
+}
+
+export { ENTimeExpressionParser as default };

package/dist/esm/node_modules/chrono-node/dist/esm/locales/en/parsers/ENTimeUnitAgoFormatParser.js

@@ -0,0 +1,27 @@
+import { parseTimeUnits, TIME_UNITS_NO_ABBR_PATTERN, TIME_UNITS_PATTERN } from '../constants.js';
+import { ParsingComponents } from '../../../results.js';
+import { AbstractParserWithWordBoundaryChecking } from '../../../common/parsers/AbstractParserWithWordBoundary.js';
+import { reverseTimeUnits } from '../../../utils/timeunits.js';
+
+const PATTERN = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}(?:ago|before|earlier)(?=\\W|$)`, "i");
+const STRICT_PATTERN = new RegExp(`(${TIME_UNITS_NO_ABBR_PATTERN})\\s{0,5}(?:ago|before|earlier)(?=\\W|$)`, "i");
+class ENTimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
+    strictMode;
+    constructor(strictMode) {
+        super();
+        this.strictMode = strictMode;
+    }
+    innerPattern() {
+        return this.strictMode ? STRICT_PATTERN : PATTERN;
+    }
+    innerExtract(context, match) {
+        const timeUnits = parseTimeUnits(match[1]);
+        if (!timeUnits) {
+            return null;
+        }
+        const outputTimeUnits = reverseTimeUnits(timeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
+    }
+}
+
+export { ENTimeUnitAgoFormatParser as default };

package/dist/esm/node_modules/chrono-node/dist/esm/locales/en/parsers/ENTimeUnitCasualRelativeFormatParser.js

@@ -0,0 +1,34 @@
+import { parseTimeUnits, TIME_UNITS_PATTERN, TIME_UNITS_NO_ABBR_PATTERN } from '../constants.js';
+import { ParsingComponents } from '../../../results.js';
+import { AbstractParserWithWordBoundaryChecking } from '../../../common/parsers/AbstractParserWithWordBoundary.js';
+import { reverseTimeUnits } from '../../../utils/timeunits.js';
+
+const PATTERN = new RegExp(`(this|last|past|next|after|\\+|-)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+const PATTERN_NO_ABBR = new RegExp(`(this|last|past|next|after|\\+|-)\\s*(${TIME_UNITS_NO_ABBR_PATTERN})(?=\\W|$)`, "i");
+class ENTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
+    allowAbbreviations;
+    constructor(allowAbbreviations = true) {
+        super();
+        this.allowAbbreviations = allowAbbreviations;
+    }
+    innerPattern() {
+        return this.allowAbbreviations ? PATTERN : PATTERN_NO_ABBR;
+    }
+    innerExtract(context, match) {
+        const prefix = match[1].toLowerCase();
+        let timeUnits = parseTimeUnits(match[2]);
+        if (!timeUnits) {
+            return null;
+        }
+        switch (prefix) {
+            case "last":
+            case "past":
+            case "-":
+                timeUnits = reverseTimeUnits(timeUnits);
+                break;
+        }
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}
+
+export { ENTimeUnitCasualRelativeFormatParser as default };

package/dist/esm/node_modules/chrono-node/dist/esm/locales/en/parsers/ENTimeUnitLaterFormatParser.js

@@ -0,0 +1,26 @@
+import { parseTimeUnits, TIME_UNITS_NO_ABBR_PATTERN, TIME_UNITS_PATTERN } from '../constants.js';
+import { ParsingComponents } from '../../../results.js';
+import { AbstractParserWithWordBoundaryChecking } from '../../../common/parsers/AbstractParserWithWordBoundary.js';
+
+const PATTERN = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}(?:later|after|from now|henceforth|forward|out)` + "(?=(?:\\W|$))", "i");
+const STRICT_PATTERN = new RegExp(`(${TIME_UNITS_NO_ABBR_PATTERN})\\s{0,5}(later|after|from now)(?=\\W|$)`, "i");
+const GROUP_NUM_TIMEUNITS = 1;
+class ENTimeUnitLaterFormatParser extends AbstractParserWithWordBoundaryChecking {
+    strictMode;
+    constructor(strictMode) {
+        super();
+        this.strictMode = strictMode;
+    }
+    innerPattern() {
+        return this.strictMode ? STRICT_PATTERN : PATTERN;
+    }
+    innerExtract(context, match) {
+        const timeUnits = parseTimeUnits(match[GROUP_NUM_TIMEUNITS]);
+        if (!timeUnits) {
+            return null;
+        }
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}
+
+export { ENTimeUnitLaterFormatParser as default };

package/dist/esm/node_modules/chrono-node/dist/esm/locales/en/parsers/ENTimeUnitWithinFormatParser.js

@@ -0,0 +1,35 @@
+import { parseTimeUnits, TIME_UNITS_NO_ABBR_PATTERN, TIME_UNITS_PATTERN } from '../constants.js';
+import { ParsingComponents } from '../../../results.js';
+import { AbstractParserWithWordBoundaryChecking } from '../../../common/parsers/AbstractParserWithWordBoundary.js';
+
+const PATTERN_WITH_OPTIONAL_PREFIX = new RegExp(`(?:(?:within|in|for)\\s*)?` +
+    `(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+const PATTERN_WITH_PREFIX = new RegExp(`(?:within|in|for)\\s*` +
+    `(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+const PATTERN_WITH_PREFIX_STRICT = new RegExp(`(?:within|in|for)\\s*` +
+    `(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${TIME_UNITS_NO_ABBR_PATTERN})(?=\\W|$)`, "i");
+class ENTimeUnitWithinFormatParser extends AbstractParserWithWordBoundaryChecking {
+    strictMode;
+    constructor(strictMode) {
+        super();
+        this.strictMode = strictMode;
+    }
+    innerPattern(context) {
+        if (this.strictMode) {
+            return PATTERN_WITH_PREFIX_STRICT;
+        }
+        return context.option.forwardDate ? PATTERN_WITH_OPTIONAL_PREFIX : PATTERN_WITH_PREFIX;
+    }
+    innerExtract(context, match) {
+        if (match[0].match(/^for\s*the\s*\w+/)) {
+            return null;
+        }
+        const timeUnits = parseTimeUnits(match[1]);
+        if (!timeUnits) {
+            return null;
+        }
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}
+
+export { ENTimeUnitWithinFormatParser as default };

package/dist/esm/node_modules/chrono-node/dist/esm/locales/en/parsers/ENWeekdayParser.js

@@ -0,0 +1,63 @@
+import { WEEKDAY_DICTIONARY } from '../constants.js';
+import { matchAnyPattern } from '../../../utils/pattern.js';
+import { AbstractParserWithWordBoundaryChecking } from '../../../common/parsers/AbstractParserWithWordBoundary.js';
+import { createParsingComponentsAtWeekday } from '../../../common/calculation/weekdays.js';
+import { Weekday } from '../../../types.js';
+
+const PATTERN = new RegExp("(?:(?:\\,|\\(|\\（)\\s*)?" +
+    "(?:on\\s*?)?" +
+    "(?:(this|last|past|next)\\s*)?" +
+    `(${matchAnyPattern(WEEKDAY_DICTIONARY)}|weekend|weekday)` +
+    "(?:\\s*(?:\\,|\\)|\\）))?" +
+    "(?:\\s*(this|last|past|next)\\s*week)?" +
+    "(?=\\W|$)", "i");
+const PREFIX_GROUP = 1;
+const WEEKDAY_GROUP = 2;
+const POSTFIX_GROUP = 3;
+class ENWeekdayParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return PATTERN;
+    }
+    innerExtract(context, match) {
+        const prefix = match[PREFIX_GROUP];
+        const postfix = match[POSTFIX_GROUP];
+        let modifierWord = prefix || postfix;
+        modifierWord = modifierWord || "";
+        modifierWord = modifierWord.toLowerCase();
+        let modifier = null;
+        if (modifierWord == "last" || modifierWord == "past") {
+            modifier = "last";
+        }
+        else if (modifierWord == "next") {
+            modifier = "next";
+        }
+        else if (modifierWord == "this") {
+            modifier = "this";
+        }
+        const weekday_word = match[WEEKDAY_GROUP].toLowerCase();
+        let weekday;
+        if (WEEKDAY_DICTIONARY[weekday_word] !== undefined) {
+            weekday = WEEKDAY_DICTIONARY[weekday_word];
+        }
+        else if (weekday_word == "weekend") {
+            weekday = modifier == "last" ? Weekday.SUNDAY : Weekday.SATURDAY;
+        }
+        else if (weekday_word == "weekday") {
+            const refWeekday = context.reference.getDateWithAdjustedTimezone().getDay();
+            if (refWeekday == Weekday.SUNDAY || refWeekday == Weekday.SATURDAY) {
+                weekday = modifier == "last" ? Weekday.FRIDAY : Weekday.MONDAY;
+            }
+            else {
+                weekday = refWeekday - 1;
+                weekday = modifier == "last" ? weekday - 1 : weekday + 1;
+                weekday = (weekday % 5) + 1;
+            }
+        }
+        else {
+            return null;
+        }
+        return createParsingComponentsAtWeekday(context.reference, weekday, modifier);
+    }
+}
+
+export { ENWeekdayParser as default };

package/dist/esm/node_modules/chrono-node/dist/esm/locales/en/parsers/ENYearMonthDayParser.js

@@ -0,0 +1,47 @@
+import { MONTH_DICTIONARY } from '../constants.js';
+import { matchAnyPattern } from '../../../utils/pattern.js';
+import { AbstractParserWithWordBoundaryChecking } from '../../../common/parsers/AbstractParserWithWordBoundary.js';
+
+const PATTERN = new RegExp(`([0-9]{4})[-\\.\\/\\s]` +
+    `(?:(${matchAnyPattern(MONTH_DICTIONARY)})|([0-9]{1,2}))[-\\.\\/\\s]` +
+    `([0-9]{1,2})` +
+    "(?=\\W|$)", "i");
+const YEAR_NUMBER_GROUP = 1;
+const MONTH_NAME_GROUP = 2;
+const MONTH_NUMBER_GROUP = 3;
+const DATE_NUMBER_GROUP = 4;
+class ENYearMonthDayParser extends AbstractParserWithWordBoundaryChecking {
+    strictMonthDateOrder;
+    constructor(strictMonthDateOrder) {
+        super();
+        this.strictMonthDateOrder = strictMonthDateOrder;
+    }
+    innerPattern() {
+        return PATTERN;
+    }
+    innerExtract(context, match) {
+        const year = parseInt(match[YEAR_NUMBER_GROUP]);
+        let day = parseInt(match[DATE_NUMBER_GROUP]);
+        let month = match[MONTH_NUMBER_GROUP]
+            ? parseInt(match[MONTH_NUMBER_GROUP])
+            : MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];
+        if (month < 1 || month > 12) {
+            if (this.strictMonthDateOrder) {
+                return null;
+            }
+            if (day >= 1 && day <= 12) {
+                [month, day] = [day, month];
+            }
+        }
+        if (day < 1 || day > 31) {
+            return null;
+        }
+        return {
+            day: day,
+            month: month,
+            year: year,
+        };
+    }
+}
+
+export { ENYearMonthDayParser as default };

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

@@ -0,0 +1,33 @@
+import { parseYear, YEAR_PATTERN } from '../constants.js';
+
+const YEAR_SUFFIX_PATTERN = new RegExp(`^\\s*(${YEAR_PATTERN})`, "i");
+const YEAR_GROUP = 1;
+class ENExtractYearSuffixRefiner {
+    refine(context, results) {
+        results.forEach(function (result) {
+            if (!result.start.isDateWithUnknownYear()) {
+                return;
+            }
+            const suffix = context.text.substring(result.index + result.text.length);
+            const match = YEAR_SUFFIX_PATTERN.exec(suffix);
+            if (!match) {
+                return;
+            }
+            if (match[0].trim().length <= 3) {
+                return;
+            }
+            context.debug(() => {
+                console.log(`Extracting year: '${match[0]}' into : ${result}`);
+            });
+            const year = parseYear(match[YEAR_GROUP]);
+            if (result.end != null) {
+                result.end.assign("year", year);
+            }
+            result.start.assign("year", year);
+            result.text += match[0];
+        });
+        return results;
+    }
+}
+
+export { ENExtractYearSuffixRefiner as default };

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

@@ -0,0 +1,9 @@
+import AbstractMergeDateRangeRefiner from '../../../common/refiners/AbstractMergeDateRangeRefiner.js';
+
+class ENMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner {
+    patternBetween() {
+        return /^\s*(to|-|–|until|through|till)\s*$/i;
+    }
+}
+
+export { ENMergeDateRangeRefiner as default };

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

@@ -0,0 +1,9 @@
+import AbstractMergeDateTimeRefiner from '../../../common/refiners/AbstractMergeDateTimeRefiner.js';
+
+class ENMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner {
+    patternBetween() {
+        return new RegExp("^\\s*(T|at|after|before|on|of|,|-|\\.|∙|:)?\\s*$");
+    }
+}
+
+export { ENMergeDateTimeRefiner as default };

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

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

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

@@ -0,0 +1,35 @@
+import { MergingRefiner } from '../../../common/abstractRefiners.js';
+import { ParsingComponents, ReferenceWithTimezone, ParsingResult } from '../../../results.js';
+import { parseTimeUnits } from '../constants.js';
+import { reverseTimeUnits } from '../../../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 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 = parseTimeUnits(currentResult.text);
+        if (hasImpliedEarlierReferenceDate(currentResult)) {
+            timeUnits = reverseTimeUnits(timeUnits);
+        }
+        const components = ParsingComponents.createRelativeFromReference(new ReferenceWithTimezone(nextResult.start.date()), timeUnits);
+        return new ParsingResult(nextResult.reference, currentResult.index, `${currentResult.text}${textBetween}${nextResult.text}`, components);
+    }
+}
+
+export { ENMergeRelativeFollowByDateRefiner as default };