art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,78 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dayjs_min = require('../../../../../../_virtual/dayjs.min.js');
+var dates = require('../../utils/dates.js');
+
+class ForwardDateRefiner {
+    refine(context, results) {
+        if (!context.option.forwardDate) {
+            return results;
+        }
+        results.forEach((result) => {
+            let refMoment = dayjs_min.default(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);
+                dates.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()) {
+                    dates.implySimilarDate(result.end, refFollowingDay);
+                    if (result.start.date() > result.end.date()) {
+                        refFollowingDay.setDate(refFollowingDay.getDate() + 1);
+                        dates.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;
+    }
+}
+
+exports.default = ForwardDateRefiner;

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

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var abstractRefiners = require('../abstractRefiners.js');
+
+class MergeWeekdayComponentRefiner extends abstractRefiners.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;
+    }
+}
+
+exports.default = MergeWeekdayComponentRefiner;

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

@@ -0,0 +1,41 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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;
+    }
+}
+
+exports.default = OverlapRemovalRefiner;

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

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var abstractRefiners = require('../abstractRefiners.js');
+
+class UnlikelyFormatFilter extends abstractRefiners.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;
+    }
+}
+
+exports.default = UnlikelyFormatFilter;

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

@@ -0,0 +1,23 @@
+'use strict';
+
+var ExtractTimezoneAbbrRefiner = require('./common/refiners/ExtractTimezoneAbbrRefiner.js');
+var ExtractTimezoneOffsetRefiner = require('./common/refiners/ExtractTimezoneOffsetRefiner.js');
+var OverlapRemovalRefiner = require('./common/refiners/OverlapRemovalRefiner.js');
+var ForwardDateRefiner = require('./common/refiners/ForwardDateRefiner.js');
+var UnlikelyFormatFilter = require('./common/refiners/UnlikelyFormatFilter.js');
+var ISOFormatParser = require('./common/parsers/ISOFormatParser.js');
+var MergeWeekdayComponentRefiner = require('./common/refiners/MergeWeekdayComponentRefiner.js');
+
+function includeCommonConfiguration(configuration, strictMode = false) {
+    configuration.parsers.unshift(new ISOFormatParser.default());
+    configuration.refiners.unshift(new MergeWeekdayComponentRefiner.default());
+    configuration.refiners.unshift(new ExtractTimezoneOffsetRefiner.default());
+    configuration.refiners.unshift(new OverlapRemovalRefiner.default());
+    configuration.refiners.push(new ExtractTimezoneAbbrRefiner.default());
+    configuration.refiners.push(new OverlapRemovalRefiner.default());
+    configuration.refiners.push(new ForwardDateRefiner.default());
+    configuration.refiners.push(new UnlikelyFormatFilter.default(strictMode));
+    return configuration;
+}
+
+exports.includeCommonConfiguration = includeCommonConfiguration;

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

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

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

@@ -0,0 +1,277 @@
+'use strict';
+
+var pattern = require('../../utils/pattern.js');
+var years = require('../../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 = `(?:${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 = `(?:${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 years.findMostLikelyADYear(rawYearNumber);
+}
+const SINGLE_TIME_UNIT_PATTERN = `(${NUMBER_PATTERN})\\s{0,3}(${pattern.matchAnyPattern(TIME_UNIT_DICTIONARY)})`;
+const SINGLE_TIME_UNIT_REGEX = new RegExp(SINGLE_TIME_UNIT_PATTERN, "i");
+const SINGLE_TIME_UNIT_NO_ABBR_PATTERN = `(${NUMBER_PATTERN})\\s{0,3}(${pattern.matchAnyPattern(TIME_UNIT_DICTIONARY_NO_ABBR)})`;
+const TIME_UNIT_CONNECTOR_PATTERN = `\\s{0,5},?(?:\\s*and)?\\s{0,5}`;
+const TIME_UNITS_PATTERN = pattern.repeatedTimeunitPattern(`(?:(?:about|around)\\s{0,3})?`, SINGLE_TIME_UNIT_PATTERN, TIME_UNIT_CONNECTOR_PATTERN);
+const TIME_UNITS_NO_ABBR_PATTERN = 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;
+}
+
+exports.FULL_MONTH_NAME_DICTIONARY = FULL_MONTH_NAME_DICTIONARY;
+exports.INTEGER_WORD_DICTIONARY = INTEGER_WORD_DICTIONARY;
+exports.MONTH_DICTIONARY = MONTH_DICTIONARY;
+exports.NUMBER_PATTERN = NUMBER_PATTERN;
+exports.ORDINAL_NUMBER_PATTERN = ORDINAL_NUMBER_PATTERN;
+exports.ORDINAL_WORD_DICTIONARY = ORDINAL_WORD_DICTIONARY;
+exports.TIME_UNITS_NO_ABBR_PATTERN = TIME_UNITS_NO_ABBR_PATTERN;
+exports.TIME_UNITS_PATTERN = TIME_UNITS_PATTERN;
+exports.TIME_UNIT_DICTIONARY = TIME_UNIT_DICTIONARY;
+exports.TIME_UNIT_DICTIONARY_NO_ABBR = TIME_UNIT_DICTIONARY_NO_ABBR;
+exports.WEEKDAY_DICTIONARY = WEEKDAY_DICTIONARY;
+exports.YEAR_PATTERN = YEAR_PATTERN;
+exports.parseNumberPattern = parseNumberPattern;
+exports.parseOrdinalNumberPattern = parseOrdinalNumberPattern;
+exports.parseTimeUnits = parseTimeUnits;
+exports.parseYear = parseYear;

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

@@ -0,0 +1,36 @@
+'use strict';
+
+var chrono = require('../../chrono.js');
+var results = require('../../results.js');
+var types = require('../../types.js');
+var configuration$1 = require('./configuration.js');
+
+const configuration = new configuration$1.default();
+const casual = new chrono.Chrono(configuration.createCasualConfiguration(false));
+const strict = new chrono.Chrono(configuration.createConfiguration(true, false));
+const GB = new chrono.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);
+}
+
+exports.Chrono = chrono.Chrono;
+exports.ParsingComponents = results.ParsingComponents;
+exports.ParsingResult = results.ParsingResult;
+exports.ReferenceWithTimezone = results.ReferenceWithTimezone;
+Object.defineProperty(exports, "Meridiem", {
+    enumerable: true,
+    get: function () { return types.Meridiem; }
+});
+Object.defineProperty(exports, "Weekday", {
+    enumerable: true,
+    get: function () { return types.Weekday; }
+});
+exports.GB = GB;
+exports.casual = casual;
+exports.configuration = configuration;
+exports.parse = parse;
+exports.parseDate = parseDate;
+exports.strict = strict;

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

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