art-bd-ui 1.0.21 → 1.0.23

package/dist/esm/node_modules/chrono-node/dist/esm/common/refiners/ForwardDateRefiner.js

@@ -0,0 +1,74 @@
+import dayjs from '../../../../../../_virtual/dayjs.min.js';
+import { implySimilarDate } from '../../utils/dates.js';
+
+class ForwardDateRefiner {
+    refine(context, results) {
+        if (!context.option.forwardDate) {
+            return results;
+        }
+        results.forEach((result) => {
+            let refMoment = dayjs(context.reference.getDateWithAdjustedTimezone());
+            if (result.start.isOnlyTime() && context.reference.instant > result.start.date()) {
+                const refDate = context.reference.getDateWithAdjustedTimezone();
+                const refFollowingDay = new Date(refDate);
+                refFollowingDay.setDate(refFollowingDay.getDate() + 1);
+                implySimilarDate(result.start, refFollowingDay);
+                context.debug(() => {
+                    console.log(`${this.constructor.name} adjusted ${result} time from the ref date (${refDate}) to the following day (${refFollowingDay})`);
+                });
+                if (result.end && result.end.isOnlyTime()) {
+                    implySimilarDate(result.end, refFollowingDay);
+                    if (result.start.date() > result.end.date()) {
+                        refFollowingDay.setDate(refFollowingDay.getDate() + 1);
+                        implySimilarDate(result.end, refFollowingDay);
+                    }
+                }
+            }
+            if (result.start.isOnlyWeekdayComponent() && refMoment.isAfter(result.start.dayjs())) {
+                if (refMoment.day() >= result.start.get("weekday")) {
+                    refMoment = refMoment.day(result.start.get("weekday") + 7);
+                }
+                else {
+                    refMoment = refMoment.day(result.start.get("weekday"));
+                }
+                result.start.imply("day", refMoment.date());
+                result.start.imply("month", refMoment.month() + 1);
+                result.start.imply("year", refMoment.year());
+                context.debug(() => {
+                    console.log(`${this.constructor.name} adjusted ${result} weekday (${result.start})`);
+                });
+                if (result.end && result.end.isOnlyWeekdayComponent()) {
+                    if (refMoment.day() > result.end.get("weekday")) {
+                        refMoment = refMoment.day(result.end.get("weekday") + 7);
+                    }
+                    else {
+                        refMoment = refMoment.day(result.end.get("weekday"));
+                    }
+                    result.end.imply("day", refMoment.date());
+                    result.end.imply("month", refMoment.month() + 1);
+                    result.end.imply("year", refMoment.year());
+                    context.debug(() => {
+                        console.log(`${this.constructor.name} adjusted ${result} weekday (${result.end})`);
+                    });
+                }
+            }
+            if (result.start.isDateWithUnknownYear() && refMoment.isAfter(result.start.dayjs())) {
+                for (let i = 0; i < 3 && refMoment.isAfter(result.start.dayjs()); i++) {
+                    result.start.imply("year", result.start.get("year") + 1);
+                    context.debug(() => {
+                        console.log(`${this.constructor.name} adjusted ${result} year (${result.start})`);
+                    });
+                    if (result.end && !result.end.isCertain("year")) {
+                        result.end.imply("year", result.end.get("year") + 1);
+                        context.debug(() => {
+                            console.log(`${this.constructor.name} adjusted ${result} month (${result.start})`);
+                        });
+                    }
+                }
+            }
+        });
+        return results;
+    }
+}
+
+export { ForwardDateRefiner as default };

package/dist/esm/node_modules/chrono-node/dist/esm/common/refiners/MergeWeekdayComponentRefiner.js

@@ -0,0 +1,22 @@
+import { MergingRefiner } from '../abstractRefiners.js';
+
+class MergeWeekdayComponentRefiner extends MergingRefiner {
+    mergeResults(textBetween, currentResult, nextResult) {
+        const newResult = nextResult.clone();
+        newResult.index = currentResult.index;
+        newResult.text = currentResult.text + textBetween + newResult.text;
+        newResult.start.assign("weekday", currentResult.start.get("weekday"));
+        if (newResult.end) {
+            newResult.end.assign("weekday", currentResult.start.get("weekday"));
+        }
+        return newResult;
+    }
+    shouldMergeResults(textBetween, currentResult, nextResult) {
+        const weekdayThenNormalDate = currentResult.start.isOnlyWeekdayComponent() &&
+            !currentResult.start.isCertain("hour") &&
+            nextResult.start.isCertain("day");
+        return weekdayThenNormalDate && textBetween.match(/^,?\s*$/) != null;
+    }
+}
+
+export { MergeWeekdayComponentRefiner as default };

package/dist/esm/node_modules/chrono-node/dist/esm/common/refiners/OverlapRemovalRefiner.js

@@ -0,0 +1,37 @@
+class OverlapRemovalRefiner {
+    refine(context, results) {
+        if (results.length < 2) {
+            return results;
+        }
+        const filteredResults = [];
+        let prevResult = results[0];
+        for (let i = 1; i < results.length; i++) {
+            const result = results[i];
+            if (result.index >= prevResult.index + prevResult.text.length) {
+                filteredResults.push(prevResult);
+                prevResult = result;
+                continue;
+            }
+            let kept = null;
+            let removed = null;
+            if (result.text.length > prevResult.text.length) {
+                kept = result;
+                removed = prevResult;
+            }
+            else {
+                kept = prevResult;
+                removed = result;
+            }
+            context.debug(() => {
+                console.log(`${this.constructor.name} remove ${removed} by ${kept}`);
+            });
+            prevResult = kept;
+        }
+        if (prevResult != null) {
+            filteredResults.push(prevResult);
+        }
+        return filteredResults;
+    }
+}
+
+export { OverlapRemovalRefiner as default };

package/dist/esm/node_modules/chrono-node/dist/esm/common/refiners/UnlikelyFormatFilter.js

@@ -0,0 +1,50 @@
+import { Filter } from '../abstractRefiners.js';
+
+class UnlikelyFormatFilter extends Filter {
+    strictMode;
+    constructor(strictMode) {
+        super();
+        this.strictMode = strictMode;
+    }
+    isValid(context, result) {
+        if (result.text.replace(" ", "").match(/^\d*(\.\d*)?$/)) {
+            context.debug(() => {
+                console.log(`Removing unlikely result '${result.text}'`);
+            });
+            return false;
+        }
+        if (!result.start.isValidDate()) {
+            context.debug(() => {
+                console.log(`Removing invalid result: ${result} (${result.start})`);
+            });
+            return false;
+        }
+        if (result.end && !result.end.isValidDate()) {
+            context.debug(() => {
+                console.log(`Removing invalid result: ${result} (${result.end})`);
+            });
+            return false;
+        }
+        if (this.strictMode) {
+            return this.isStrictModeValid(context, result);
+        }
+        return true;
+    }
+    isStrictModeValid(context, result) {
+        if (result.start.isOnlyWeekdayComponent()) {
+            context.debug(() => {
+                console.log(`(Strict) Removing weekday only component: ${result} (${result.end})`);
+            });
+            return false;
+        }
+        if (result.start.isOnlyTime() && (!result.start.isCertain("hour") || !result.start.isCertain("minute"))) {
+            context.debug(() => {
+                console.log(`(Strict) Removing uncertain time component: ${result} (${result.end})`);
+            });
+            return false;
+        }
+        return true;
+    }
+}
+
+export { UnlikelyFormatFilter as default };

package/dist/esm/node_modules/chrono-node/dist/esm/configurations.js

@@ -0,0 +1,21 @@
+import ExtractTimezoneAbbrRefiner from './common/refiners/ExtractTimezoneAbbrRefiner.js';
+import ExtractTimezoneOffsetRefiner from './common/refiners/ExtractTimezoneOffsetRefiner.js';
+import OverlapRemovalRefiner from './common/refiners/OverlapRemovalRefiner.js';
+import ForwardDateRefiner from './common/refiners/ForwardDateRefiner.js';
+import UnlikelyFormatFilter from './common/refiners/UnlikelyFormatFilter.js';
+import ISOFormatParser from './common/parsers/ISOFormatParser.js';
+import MergeWeekdayComponentRefiner from './common/refiners/MergeWeekdayComponentRefiner.js';
+
+function includeCommonConfiguration(configuration, strictMode = false) {
+    configuration.parsers.unshift(new ISOFormatParser());
+    configuration.refiners.unshift(new MergeWeekdayComponentRefiner());
+    configuration.refiners.unshift(new ExtractTimezoneOffsetRefiner());
+    configuration.refiners.unshift(new OverlapRemovalRefiner());
+    configuration.refiners.push(new ExtractTimezoneAbbrRefiner());
+    configuration.refiners.push(new OverlapRemovalRefiner());
+    configuration.refiners.push(new ForwardDateRefiner());
+    configuration.refiners.push(new UnlikelyFormatFilter(strictMode));
+    return configuration;
+}
+
+export { includeCommonConfiguration };

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

@@ -0,0 +1,62 @@
+import ENTimeUnitWithinFormatParser from './parsers/ENTimeUnitWithinFormatParser.js';
+import ENMonthNameLittleEndianParser from './parsers/ENMonthNameLittleEndianParser.js';
+import ENMonthNameMiddleEndianParser from './parsers/ENMonthNameMiddleEndianParser.js';
+import ENMonthNameParser from './parsers/ENMonthNameParser.js';
+import ENYearMonthDayParser from './parsers/ENYearMonthDayParser.js';
+import ENSlashMonthFormatParser from './parsers/ENSlashMonthFormatParser.js';
+import ENTimeExpressionParser from './parsers/ENTimeExpressionParser.js';
+import ENTimeUnitAgoFormatParser from './parsers/ENTimeUnitAgoFormatParser.js';
+import ENTimeUnitLaterFormatParser from './parsers/ENTimeUnitLaterFormatParser.js';
+import ENMergeDateRangeRefiner from './refiners/ENMergeDateRangeRefiner.js';
+import ENMergeDateTimeRefiner from './refiners/ENMergeDateTimeRefiner.js';
+import { includeCommonConfiguration } from '../../configurations.js';
+import ENCasualDateParser from './parsers/ENCasualDateParser.js';
+import ENCasualTimeParser from './parsers/ENCasualTimeParser.js';
+import ENWeekdayParser from './parsers/ENWeekdayParser.js';
+import ENRelativeDateFormatParser from './parsers/ENRelativeDateFormatParser.js';
+import SlashDateFormatParser from '../../common/parsers/SlashDateFormatParser.js';
+import ENTimeUnitCasualRelativeFormatParser from './parsers/ENTimeUnitCasualRelativeFormatParser.js';
+import ENMergeRelativeAfterDateRefiner from './refiners/ENMergeRelativeAfterDateRefiner.js';
+import ENMergeRelativeFollowByDateRefiner from './refiners/ENMergeRelativeFollowByDateRefiner.js';
+import OverlapRemovalRefiner from '../../common/refiners/OverlapRemovalRefiner.js';
+import ENExtractYearSuffixRefiner from './refiners/ENExtractYearSuffixRefiner.js';
+import ENUnlikelyFormatFilter from './refiners/ENUnlikelyFormatFilter.js';
+
+class ENDefaultConfiguration {
+    createCasualConfiguration(littleEndian = false) {
+        const option = this.createConfiguration(false, littleEndian);
+        option.parsers.push(new ENCasualDateParser());
+        option.parsers.push(new ENCasualTimeParser());
+        option.parsers.push(new ENMonthNameParser());
+        option.parsers.push(new ENRelativeDateFormatParser());
+        option.parsers.push(new ENTimeUnitCasualRelativeFormatParser());
+        option.refiners.push(new ENUnlikelyFormatFilter());
+        return option;
+    }
+    createConfiguration(strictMode = true, littleEndian = false) {
+        const options = includeCommonConfiguration({
+            parsers: [
+                new SlashDateFormatParser(littleEndian),
+                new ENTimeUnitWithinFormatParser(strictMode),
+                new ENMonthNameLittleEndianParser(),
+                new ENMonthNameMiddleEndianParser(littleEndian),
+                new ENWeekdayParser(),
+                new ENSlashMonthFormatParser(),
+                new ENTimeExpressionParser(strictMode),
+                new ENTimeUnitAgoFormatParser(strictMode),
+                new ENTimeUnitLaterFormatParser(strictMode),
+            ],
+            refiners: [new ENMergeDateTimeRefiner()],
+        }, strictMode);
+        options.parsers.unshift(new ENYearMonthDayParser(strictMode));
+        options.refiners.unshift(new ENMergeRelativeFollowByDateRefiner());
+        options.refiners.unshift(new ENMergeRelativeAfterDateRefiner());
+        options.refiners.unshift(new OverlapRemovalRefiner());
+        options.refiners.push(new ENMergeDateTimeRefiner());
+        options.refiners.push(new ENExtractYearSuffixRefiner());
+        options.refiners.push(new ENMergeDateRangeRefiner());
+        return options;
+    }
+}
+
+export { ENDefaultConfiguration as default };

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

@@ -0,0 +1,260 @@
+import { repeatedTimeunitPattern, matchAnyPattern } from '../../utils/pattern.js';
+import { findMostLikelyADYear } from '../../calculation/years.js';
+
+const WEEKDAY_DICTIONARY = {
+    sunday: 0,
+    sun: 0,
+    "sun.": 0,
+    monday: 1,
+    mon: 1,
+    "mon.": 1,
+    tuesday: 2,
+    tue: 2,
+    "tue.": 2,
+    wednesday: 3,
+    wed: 3,
+    "wed.": 3,
+    thursday: 4,
+    thurs: 4,
+    "thurs.": 4,
+    thur: 4,
+    "thur.": 4,
+    thu: 4,
+    "thu.": 4,
+    friday: 5,
+    fri: 5,
+    "fri.": 5,
+    saturday: 6,
+    sat: 6,
+    "sat.": 6,
+};
+const FULL_MONTH_NAME_DICTIONARY = {
+    january: 1,
+    february: 2,
+    march: 3,
+    april: 4,
+    may: 5,
+    june: 6,
+    july: 7,
+    august: 8,
+    september: 9,
+    october: 10,
+    november: 11,
+    december: 12,
+};
+const MONTH_DICTIONARY = {
+    ...FULL_MONTH_NAME_DICTIONARY,
+    jan: 1,
+    "jan.": 1,
+    feb: 2,
+    "feb.": 2,
+    mar: 3,
+    "mar.": 3,
+    apr: 4,
+    "apr.": 4,
+    jun: 6,
+    "jun.": 6,
+    jul: 7,
+    "jul.": 7,
+    aug: 8,
+    "aug.": 8,
+    sep: 9,
+    "sep.": 9,
+    sept: 9,
+    "sept.": 9,
+    oct: 10,
+    "oct.": 10,
+    nov: 11,
+    "nov.": 11,
+    dec: 12,
+    "dec.": 12,
+};
+const INTEGER_WORD_DICTIONARY = {
+    one: 1,
+    two: 2,
+    three: 3,
+    four: 4,
+    five: 5,
+    six: 6,
+    seven: 7,
+    eight: 8,
+    nine: 9,
+    ten: 10,
+    eleven: 11,
+    twelve: 12,
+};
+const ORDINAL_WORD_DICTIONARY = {
+    first: 1,
+    second: 2,
+    third: 3,
+    fourth: 4,
+    fifth: 5,
+    sixth: 6,
+    seventh: 7,
+    eighth: 8,
+    ninth: 9,
+    tenth: 10,
+    eleventh: 11,
+    twelfth: 12,
+    thirteenth: 13,
+    fourteenth: 14,
+    fifteenth: 15,
+    sixteenth: 16,
+    seventeenth: 17,
+    eighteenth: 18,
+    nineteenth: 19,
+    twentieth: 20,
+    "twenty first": 21,
+    "twenty-first": 21,
+    "twenty second": 22,
+    "twenty-second": 22,
+    "twenty third": 23,
+    "twenty-third": 23,
+    "twenty fourth": 24,
+    "twenty-fourth": 24,
+    "twenty fifth": 25,
+    "twenty-fifth": 25,
+    "twenty sixth": 26,
+    "twenty-sixth": 26,
+    "twenty seventh": 27,
+    "twenty-seventh": 27,
+    "twenty eighth": 28,
+    "twenty-eighth": 28,
+    "twenty ninth": 29,
+    "twenty-ninth": 29,
+    "thirtieth": 30,
+    "thirty first": 31,
+    "thirty-first": 31,
+};
+const TIME_UNIT_DICTIONARY_NO_ABBR = {
+    second: "second",
+    seconds: "second",
+    minute: "minute",
+    minutes: "minute",
+    hour: "hour",
+    hours: "hour",
+    day: "d",
+    days: "d",
+    week: "week",
+    weeks: "week",
+    month: "month",
+    months: "month",
+    quarter: "quarter",
+    quarters: "quarter",
+    year: "year",
+    years: "year",
+};
+const TIME_UNIT_DICTIONARY = {
+    s: "second",
+    sec: "second",
+    second: "second",
+    seconds: "second",
+    m: "minute",
+    min: "minute",
+    mins: "minute",
+    minute: "minute",
+    minutes: "minute",
+    h: "hour",
+    hr: "hour",
+    hrs: "hour",
+    hour: "hour",
+    hours: "hour",
+    d: "d",
+    day: "d",
+    days: "d",
+    w: "w",
+    week: "week",
+    weeks: "week",
+    mo: "month",
+    mon: "month",
+    mos: "month",
+    month: "month",
+    months: "month",
+    qtr: "quarter",
+    quarter: "quarter",
+    quarters: "quarter",
+    y: "year",
+    yr: "year",
+    year: "year",
+    years: "year",
+    ...TIME_UNIT_DICTIONARY_NO_ABBR,
+};
+const NUMBER_PATTERN = `(?:${matchAnyPattern(INTEGER_WORD_DICTIONARY)}|[0-9]+|[0-9]+\\.[0-9]+|half(?:\\s{0,2}an?)?|an?\\b(?:\\s{0,2}few)?|few|several|the|a?\\s{0,2}couple\\s{0,2}(?:of)?)`;
+function parseNumberPattern(match) {
+    const num = match.toLowerCase();
+    if (INTEGER_WORD_DICTIONARY[num] !== undefined) {
+        return INTEGER_WORD_DICTIONARY[num];
+    }
+    else if (num === "a" || num === "an" || num == "the") {
+        return 1;
+    }
+    else if (num.match(/few/)) {
+        return 3;
+    }
+    else if (num.match(/half/)) {
+        return 0.5;
+    }
+    else if (num.match(/couple/)) {
+        return 2;
+    }
+    else if (num.match(/several/)) {
+        return 7;
+    }
+    return parseFloat(num);
+}
+const ORDINAL_NUMBER_PATTERN = `(?:${matchAnyPattern(ORDINAL_WORD_DICTIONARY)}|[0-9]{1,2}(?:st|nd|rd|th)?)`;
+function parseOrdinalNumberPattern(match) {
+    let num = match.toLowerCase();
+    if (ORDINAL_WORD_DICTIONARY[num] !== undefined) {
+        return ORDINAL_WORD_DICTIONARY[num];
+    }
+    num = num.replace(/(?:st|nd|rd|th)$/i, "");
+    return parseInt(num);
+}
+const YEAR_PATTERN = `(?:[1-9][0-9]{0,3}\\s{0,2}(?:BE|AD|BC|BCE|CE)|[1-2][0-9]{3}|[5-9][0-9]|2[0-5])`;
+function parseYear(match) {
+    if (/BE/i.test(match)) {
+        match = match.replace(/BE/i, "");
+        return parseInt(match) - 543;
+    }
+    if (/BCE?/i.test(match)) {
+        match = match.replace(/BCE?/i, "");
+        return -parseInt(match);
+    }
+    if (/(AD|CE)/i.test(match)) {
+        match = match.replace(/(AD|CE)/i, "");
+        return parseInt(match);
+    }
+    const rawYearNumber = parseInt(match);
+    return findMostLikelyADYear(rawYearNumber);
+}
+const SINGLE_TIME_UNIT_PATTERN = `(${NUMBER_PATTERN})\\s{0,3}(${matchAnyPattern(TIME_UNIT_DICTIONARY)})`;
+const SINGLE_TIME_UNIT_REGEX = new RegExp(SINGLE_TIME_UNIT_PATTERN, "i");
+const SINGLE_TIME_UNIT_NO_ABBR_PATTERN = `(${NUMBER_PATTERN})\\s{0,3}(${matchAnyPattern(TIME_UNIT_DICTIONARY_NO_ABBR)})`;
+const TIME_UNIT_CONNECTOR_PATTERN = `\\s{0,5},?(?:\\s*and)?\\s{0,5}`;
+const TIME_UNITS_PATTERN = repeatedTimeunitPattern(`(?:(?:about|around)\\s{0,3})?`, SINGLE_TIME_UNIT_PATTERN, TIME_UNIT_CONNECTOR_PATTERN);
+const TIME_UNITS_NO_ABBR_PATTERN = repeatedTimeunitPattern(`(?:(?:about|around)\\s{0,3})?`, SINGLE_TIME_UNIT_NO_ABBR_PATTERN, TIME_UNIT_CONNECTOR_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);
+    }
+    if (Object.keys(fragments).length == 0) {
+        return null;
+    }
+    return fragments;
+}
+function collectDateTimeFragment(fragments, match) {
+    if (match[0].match(/^[a-zA-Z]+$/)) {
+        return;
+    }
+    const num = parseNumberPattern(match[1]);
+    const unit = TIME_UNIT_DICTIONARY[match[2].toLowerCase()];
+    fragments[unit] = num;
+}
+
+export { FULL_MONTH_NAME_DICTIONARY, INTEGER_WORD_DICTIONARY, MONTH_DICTIONARY, NUMBER_PATTERN, ORDINAL_NUMBER_PATTERN, ORDINAL_WORD_DICTIONARY, TIME_UNITS_NO_ABBR_PATTERN, TIME_UNITS_PATTERN, TIME_UNIT_DICTIONARY, TIME_UNIT_DICTIONARY_NO_ABBR, WEEKDAY_DICTIONARY, YEAR_PATTERN, parseNumberPattern, parseOrdinalNumberPattern, parseTimeUnits, parseYear };

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

@@ -0,0 +1,17 @@
+import { Chrono } from '../../chrono.js';
+export { ParsingComponents, ParsingResult, ReferenceWithTimezone } from '../../results.js';
+export { Meridiem, Weekday } from '../../types.js';
+import ENDefaultConfiguration from './configuration.js';
+
+const configuration = new ENDefaultConfiguration();
+const casual = new Chrono(configuration.createCasualConfiguration(false));
+const strict = new Chrono(configuration.createConfiguration(true, false));
+const GB = new Chrono(configuration.createCasualConfiguration(true));
+function parse(text, ref, option) {
+    return casual.parse(text, ref, option);
+}
+function parseDate(text, ref, option) {
+    return casual.parseDate(text, ref, option);
+}
+
+export { Chrono, GB, casual, configuration, parse, parseDate, strict };

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

@@ -0,0 +1,51 @@
+import dayjs from '../../../../../../../_virtual/dayjs.min.js';
+import { AbstractParserWithWordBoundaryChecking } from '../../../common/parsers/AbstractParserWithWordBoundary.js';
+import { assignSimilarDate } from '../../../utils/dayjs.js';
+import { theDayAfter, tonight, tomorrow, yesterday, today, now } from '../../../common/casualReferences.js';
+
+const PATTERN = /(now|today|tonight|tomorrow|overmorrow|tmr|tmrw|yesterday|last\s*night)(?=\W|$)/i;
+class ENCasualDateParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(context) {
+        return PATTERN;
+    }
+    innerExtract(context, match) {
+        let targetDate = dayjs(context.refDate);
+        const lowerText = match[0].toLowerCase();
+        let component = context.createParsingComponents();
+        switch (lowerText) {
+            case "now":
+                component = now(context.reference);
+                break;
+            case "today":
+                component = today(context.reference);
+                break;
+            case "yesterday":
+                component = yesterday(context.reference);
+                break;
+            case "tomorrow":
+            case "tmr":
+            case "tmrw":
+                component = tomorrow(context.reference);
+                break;
+            case "tonight":
+                component = tonight(context.reference);
+                break;
+            case "overmorrow":
+                component = theDayAfter(context.reference, 2);
+                break;
+            default:
+                if (lowerText.match(/last\s*night/)) {
+                    if (targetDate.hour() > 6) {
+                        targetDate = targetDate.add(-1, "day");
+                    }
+                    assignSimilarDate(component, targetDate);
+                    component.imply("hour", 0);
+                }
+                break;
+        }
+        component.addTag("parser/ENCasualDateParser");
+        return component;
+    }
+}
+
+export { ENCasualDateParser as default };

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

@@ -0,0 +1,37 @@
+import { AbstractParserWithWordBoundaryChecking } from '../../../common/parsers/AbstractParserWithWordBoundary.js';
+import { noon, morning, midnight, evening, afternoon } from '../../../common/casualReferences.js';
+
+const PATTERN = /(?:this)?\s{0,3}(morning|afternoon|evening|night|midnight|midday|noon)(?=\W|$)/i;
+class ENCasualTimeParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return PATTERN;
+    }
+    innerExtract(context, match) {
+        let component = null;
+        switch (match[1].toLowerCase()) {
+            case "afternoon":
+                component = afternoon(context.reference);
+                break;
+            case "evening":
+            case "night":
+                component = evening(context.reference);
+                break;
+            case "midnight":
+                component = midnight(context.reference);
+                break;
+            case "morning":
+                component = morning(context.reference);
+                break;
+            case "noon":
+            case "midday":
+                component = noon(context.reference);
+                break;
+        }
+        if (component) {
+            component.addTag("parser/ENCasualTimeParser");
+        }
+        return component;
+    }
+}
+
+export { ENCasualTimeParser as default };