art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var AbstractParserWithWordBoundary = require('../../../common/parsers/AbstractParserWithWordBoundary.js');
+var casualReferences = require('../../../common/casualReferences.js');
+
+const PATTERN = /(?:this)?\s{0,3}(morning|afternoon|evening|night|midnight|midday|noon)(?=\W|$)/i;
+class ENCasualTimeParser extends AbstractParserWithWordBoundary.AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return PATTERN;
+    }
+    innerExtract(context, match) {
+        let component = null;
+        switch (match[1].toLowerCase()) {
+            case "afternoon":
+                component = casualReferences.afternoon(context.reference);
+                break;
+            case "evening":
+            case "night":
+                component = casualReferences.evening(context.reference);
+                break;
+            case "midnight":
+                component = casualReferences.midnight(context.reference);
+                break;
+            case "morning":
+                component = casualReferences.morning(context.reference);
+                break;
+            case "noon":
+            case "midday":
+                component = casualReferences.noon(context.reference);
+                break;
+        }
+        if (component) {
+            component.addTag("parser/ENCasualTimeParser");
+        }
+        return component;
+    }
+}
+
+exports.default = ENCasualTimeParser;

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

@@ -0,0 +1,58 @@
+'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 AbstractParserWithWordBoundary = require('../../../common/parsers/AbstractParserWithWordBoundary.js');
+
+const PATTERN = new RegExp(`(?:on\\s{0,3})?` +
+    `(${constants.ORDINAL_NUMBER_PATTERN})` +
+    `(?:` +
+    `\\s{0,3}(?:to|\\-|\\–|until|through|till)?\\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}(?!\\w))` +
+    ")?" +
+    "(?=\\W|$)", "i");
+const DATE_GROUP = 1;
+const DATE_TO_GROUP = 2;
+const MONTH_NAME_GROUP = 3;
+const YEAR_GROUP = 4;
+class ENMonthNameLittleEndianParser extends AbstractParserWithWordBoundary.AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return PATTERN;
+    }
+    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.parseYear(match[YEAR_GROUP]);
+            result.start.assign("year", yearNumber);
+        }
+        else {
+            const year = years.findYearClosestToRef(context.refDate, 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 = ENMonthNameLittleEndianParser;

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

@@ -0,0 +1,72 @@
+'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 AbstractParserWithWordBoundary = require('../../../common/parsers/AbstractParserWithWordBoundary.js');
+
+const PATTERN = new RegExp(`(${pattern.matchAnyPattern(constants.MONTH_DICTIONARY)})` +
+    "(?:-|/|\\s*,?\\s*)" +
+    `(${constants.ORDINAL_NUMBER_PATTERN})(?!\\s*(?:am|pm))\\s*` +
+    "(?:" +
+    "(?:to|\\-)\\s*" +
+    `(${constants.ORDINAL_NUMBER_PATTERN})\\s*` +
+    ")?" +
+    "(?:" +
+    `(?:-|/|\\s*,\\s*|\\s+)` +
+    `(${constants.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 AbstractParserWithWordBoundary.AbstractParserWithWordBoundaryChecking {
+    shouldSkipYearLikeDate;
+    constructor(shouldSkipYearLikeDate) {
+        super();
+        this.shouldSkipYearLikeDate = shouldSkipYearLikeDate;
+    }
+    innerPattern() {
+        return PATTERN;
+    }
+    innerExtract(context, match) {
+        const month = constants.MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];
+        const day = constants.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 = constants.parseYear(match[YEAR_GROUP]);
+            components.assign("year", year);
+        }
+        else {
+            const year = years.findYearClosestToRef(context.refDate, day, month);
+            components.imply("year", year);
+        }
+        if (!match[DATE_TO_GROUP]) {
+            return components;
+        }
+        const endDate = constants.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;
+    }
+}
+
+exports.default = ENMonthNameMiddleEndianParser;

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

@@ -0,0 +1,46 @@
+'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 AbstractParserWithWordBoundary = require('../../../common/parsers/AbstractParserWithWordBoundary.js');
+
+const PATTERN = new RegExp(`((?:in)\\s*)?` +
+    `(${pattern.matchAnyPattern(constants.MONTH_DICTIONARY)})` +
+    `\\s*` +
+    `(?:` +
+    `(?:,|-|of)?\\s*(${constants.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 AbstractParserWithWordBoundary.AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return PATTERN;
+    }
+    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[PREFIX_GROUP] || "").length, match.index + match[0].length);
+        result.start.imply("day", 1);
+        result.start.addTag("parser/ENMonthNameParser");
+        const month = constants.MONTH_DICTIONARY[monthName];
+        result.start.assign("month", month);
+        if (match[YEAR_GROUP]) {
+            const year = constants.parseYear(match[YEAR_GROUP]);
+            result.start.assign("year", year);
+        }
+        else {
+            const year = years.findYearClosestToRef(context.refDate, 1, month);
+            result.start.imply("year", year);
+        }
+        return result;
+    }
+}
+
+exports.default = ENMonthNameParser;

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

@@ -0,0 +1,57 @@
+'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 AbstractParserWithWordBoundary = require('../../../common/parsers/AbstractParserWithWordBoundary.js');
+var pattern = require('../../../utils/pattern.js');
+
+const PATTERN = new RegExp(`(this|last|past|next|after\\s*this)\\s*(${pattern.matchAnyPattern(constants.TIME_UNIT_DICTIONARY)})(?=\\s*)` + "(?=\\W|$)", "i");
+const MODIFIER_WORD_GROUP = 1;
+const RELATIVE_WORD_GROUP = 2;
+class ENRelativeDateFormatParser extends AbstractParserWithWordBoundary.AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return PATTERN;
+    }
+    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 == "next" || modifier.startsWith("after")) {
+            const timeUnits = {};
+            timeUnits[timeunit] = 1;
+            return results.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+        }
+        if (modifier == "last" || modifier == "past") {
+            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 (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;
+    }
+}
+
+exports.default = ENRelativeDateFormatParser;

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

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var AbstractParserWithWordBoundary = require('../../../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 AbstractParserWithWordBoundary.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);
+    }
+}
+
+exports.default = ENSlashMonthFormatParser;

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

@@ -0,0 +1,61 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var types = require('../../../types.js');
+var AbstractTimeExpressionParser = require('../../../common/parsers/AbstractTimeExpressionParser.js');
+
+class ENTimeExpressionParser extends AbstractTimeExpressionParser.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", types.Meridiem.PM);
+            }
+            else if (hour < 6) {
+                components.assign("meridiem", types.Meridiem.AM);
+            }
+        }
+        if (match[0].endsWith("afternoon")) {
+            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("morning")) {
+            components.assign("meridiem", types.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;
+    }
+}
+
+exports.default = ENTimeExpressionParser;

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

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

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

@@ -0,0 +1,38 @@
+'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');
+var timeunits = require('../../../utils/timeunits.js');
+
+const PATTERN = new RegExp(`(this|last|past|next|after|\\+|-)\\s*(${constants.TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+const PATTERN_NO_ABBR = new RegExp(`(this|last|past|next|after|\\+|-)\\s*(${constants.TIME_UNITS_NO_ABBR_PATTERN})(?=\\W|$)`, "i");
+class ENTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundary.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 = constants.parseTimeUnits(match[2]);
+        if (!timeUnits) {
+            return null;
+        }
+        switch (prefix) {
+            case "last":
+            case "past":
+            case "-":
+                timeUnits = timeunits.reverseTimeUnits(timeUnits);
+                break;
+        }
+        return results.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}
+
+exports.default = ENTimeUnitCasualRelativeFormatParser;

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

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

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

@@ -0,0 +1,39 @@
+'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_WITH_OPTIONAL_PREFIX = new RegExp(`(?:(?:within|in|for)\\s*)?` +
+    `(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${constants.TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+const PATTERN_WITH_PREFIX = new RegExp(`(?:within|in|for)\\s*` +
+    `(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${constants.TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+const PATTERN_WITH_PREFIX_STRICT = new RegExp(`(?:within|in|for)\\s*` +
+    `(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${constants.TIME_UNITS_NO_ABBR_PATTERN})(?=\\W|$)`, "i");
+class ENTimeUnitWithinFormatParser extends AbstractParserWithWordBoundary.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 = constants.parseTimeUnits(match[1]);
+        if (!timeUnits) {
+            return null;
+        }
+        return results.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}
+
+exports.default = ENTimeUnitWithinFormatParser;

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

@@ -0,0 +1,67 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../constants.js');
+var pattern = require('../../../utils/pattern.js');
+var AbstractParserWithWordBoundary = require('../../../common/parsers/AbstractParserWithWordBoundary.js');
+var weekdays = require('../../../common/calculation/weekdays.js');
+var types = require('../../../types.js');
+
+const PATTERN = new RegExp("(?:(?:\\,|\\(|\\（)\\s*)?" +
+    "(?:on\\s*?)?" +
+    "(?:(this|last|past|next)\\s*)?" +
+    `(${pattern.matchAnyPattern(constants.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 AbstractParserWithWordBoundary.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 (constants.WEEKDAY_DICTIONARY[weekday_word] !== undefined) {
+            weekday = constants.WEEKDAY_DICTIONARY[weekday_word];
+        }
+        else if (weekday_word == "weekend") {
+            weekday = modifier == "last" ? types.Weekday.SUNDAY : types.Weekday.SATURDAY;
+        }
+        else if (weekday_word == "weekday") {
+            const refWeekday = context.reference.getDateWithAdjustedTimezone().getDay();
+            if (refWeekday == types.Weekday.SUNDAY || refWeekday == types.Weekday.SATURDAY) {
+                weekday = modifier == "last" ? types.Weekday.FRIDAY : types.Weekday.MONDAY;
+            }
+            else {
+                weekday = refWeekday - 1;
+                weekday = modifier == "last" ? weekday - 1 : weekday + 1;
+                weekday = (weekday % 5) + 1;
+            }
+        }
+        else {
+            return null;
+        }
+        return weekdays.createParsingComponentsAtWeekday(context.reference, weekday, modifier);
+    }
+}
+
+exports.default = ENWeekdayParser;

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

@@ -0,0 +1,51 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../constants.js');
+var pattern = require('../../../utils/pattern.js');
+var AbstractParserWithWordBoundary = require('../../../common/parsers/AbstractParserWithWordBoundary.js');
+
+const PATTERN = new RegExp(`([0-9]{4})[-\\.\\/\\s]` +
+    `(?:(${pattern.matchAnyPattern(constants.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 AbstractParserWithWordBoundary.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])
+            : constants.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,
+        };
+    }
+}
+
+exports.default = ENYearMonthDayParser;

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

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../constants.js');
+
+const YEAR_SUFFIX_PATTERN = new RegExp(`^\\s*(${constants.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 = constants.parseYear(match[YEAR_GROUP]);
+            if (result.end != null) {
+                result.end.assign("year", year);
+            }
+            result.start.assign("year", year);
+            result.text += match[0];
+        });
+        return results;
+    }
+}
+
+exports.default = ENExtractYearSuffixRefiner;