art-bd-ui 1.0.21 → 1.0.23

package/dist/cjs/node_modules/attr-accept/dist/es/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('../../../../_virtual/index8.js');
+var index = require('../../../../_virtual/index9.js');
 
 var hasRequiredEs;
 

package/dist/cjs/node_modules/chrono-node/dist/esm/calculation/mergingCalculation.js

@@ -0,0 +1,76 @@
+'use strict';
+
+var types = require('../types.js');
+var dayjs = require('../utils/dayjs.js');
+
+function mergeDateTimeResult(dateResult, timeResult) {
+    const result = dateResult.clone();
+    const beginDate = dateResult.start;
+    const beginTime = timeResult.start;
+    result.start = mergeDateTimeComponent(beginDate, beginTime);
+    if (dateResult.end != null || timeResult.end != null) {
+        const endDate = dateResult.end == null ? dateResult.start : dateResult.end;
+        const endTime = timeResult.end == null ? timeResult.start : timeResult.end;
+        const endDateTime = mergeDateTimeComponent(endDate, endTime);
+        if (dateResult.end == null && endDateTime.date().getTime() < result.start.date().getTime()) {
+            const nextDayJs = endDateTime.dayjs().add(1, "day");
+            if (endDateTime.isCertain("day")) {
+                dayjs.assignSimilarDate(endDateTime, nextDayJs);
+            }
+            else {
+                dayjs.implySimilarDate(endDateTime, nextDayJs);
+            }
+        }
+        result.end = endDateTime;
+    }
+    return result;
+}
+function mergeDateTimeComponent(dateComponent, timeComponent) {
+    const dateTimeComponent = dateComponent.clone();
+    if (timeComponent.isCertain("hour")) {
+        dateTimeComponent.assign("hour", timeComponent.get("hour"));
+        dateTimeComponent.assign("minute", timeComponent.get("minute"));
+        if (timeComponent.isCertain("second")) {
+            dateTimeComponent.assign("second", timeComponent.get("second"));
+            if (timeComponent.isCertain("millisecond")) {
+                dateTimeComponent.assign("millisecond", timeComponent.get("millisecond"));
+            }
+            else {
+                dateTimeComponent.imply("millisecond", timeComponent.get("millisecond"));
+            }
+        }
+        else {
+            dateTimeComponent.imply("second", timeComponent.get("second"));
+            dateTimeComponent.imply("millisecond", timeComponent.get("millisecond"));
+        }
+    }
+    else {
+        dateTimeComponent.imply("hour", timeComponent.get("hour"));
+        dateTimeComponent.imply("minute", timeComponent.get("minute"));
+        dateTimeComponent.imply("second", timeComponent.get("second"));
+        dateTimeComponent.imply("millisecond", timeComponent.get("millisecond"));
+    }
+    if (timeComponent.isCertain("timezoneOffset")) {
+        dateTimeComponent.assign("timezoneOffset", timeComponent.get("timezoneOffset"));
+    }
+    if (timeComponent.isCertain("meridiem")) {
+        dateTimeComponent.assign("meridiem", timeComponent.get("meridiem"));
+    }
+    else if (timeComponent.get("meridiem") != null && dateTimeComponent.get("meridiem") == null) {
+        dateTimeComponent.imply("meridiem", timeComponent.get("meridiem"));
+    }
+    if (dateTimeComponent.get("meridiem") == types.Meridiem.PM && dateTimeComponent.get("hour") < 12) {
+        if (timeComponent.isCertain("hour")) {
+            dateTimeComponent.assign("hour", dateTimeComponent.get("hour") + 12);
+        }
+        else {
+            dateTimeComponent.imply("hour", dateTimeComponent.get("hour") + 12);
+        }
+    }
+    dateTimeComponent.addTags(dateComponent.tags());
+    dateTimeComponent.addTags(timeComponent.tags());
+    return dateTimeComponent;
+}
+
+exports.mergeDateTimeComponent = mergeDateTimeComponent;
+exports.mergeDateTimeResult = mergeDateTimeResult;

package/dist/cjs/node_modules/chrono-node/dist/esm/calculation/years.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var dayjs_min = require('../../../../../_virtual/dayjs.min.js');
+
+function findMostLikelyADYear(yearNumber) {
+    if (yearNumber < 100) {
+        if (yearNumber > 50) {
+            yearNumber = yearNumber + 1900;
+        }
+        else {
+            yearNumber = yearNumber + 2000;
+        }
+    }
+    return yearNumber;
+}
+function findYearClosestToRef(refDate, day, month) {
+    const refMoment = dayjs_min.default(refDate);
+    let dateMoment = refMoment;
+    dateMoment = dateMoment.month(month - 1);
+    dateMoment = dateMoment.date(day);
+    dateMoment = dateMoment.year(refMoment.year());
+    const nextYear = dateMoment.add(1, "y");
+    const lastYear = dateMoment.add(-1, "y");
+    if (Math.abs(nextYear.diff(refMoment)) < Math.abs(dateMoment.diff(refMoment))) {
+        dateMoment = nextYear;
+    }
+    else if (Math.abs(lastYear.diff(refMoment)) < Math.abs(dateMoment.diff(refMoment))) {
+        dateMoment = lastYear;
+    }
+    return dateMoment.year();
+}
+
+exports.findMostLikelyADYear = findMostLikelyADYear;
+exports.findYearClosestToRef = findYearClosestToRef;

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

@@ -0,0 +1,113 @@
+'use strict';
+
+var results = require('./results.js');
+var configuration = require('./locales/en/configuration.js');
+
+class Chrono {
+    parsers;
+    refiners;
+    defaultConfig = new configuration.default();
+    constructor(configuration) {
+        configuration = configuration || this.defaultConfig.createCasualConfiguration();
+        this.parsers = [...configuration.parsers];
+        this.refiners = [...configuration.refiners];
+    }
+    clone() {
+        return new Chrono({
+            parsers: [...this.parsers],
+            refiners: [...this.refiners],
+        });
+    }
+    parseDate(text, referenceDate, option) {
+        const results = this.parse(text, referenceDate, option);
+        return results.length > 0 ? results[0].start.date() : null;
+    }
+    parse(text, referenceDate, option) {
+        const context = new ParsingContext(text, referenceDate, option);
+        let results = [];
+        this.parsers.forEach((parser) => {
+            const parsedResults = Chrono.executeParser(context, parser);
+            results = results.concat(parsedResults);
+        });
+        results.sort((a, b) => {
+            return a.index - b.index;
+        });
+        this.refiners.forEach(function (refiner) {
+            results = refiner.refine(context, results);
+        });
+        return results;
+    }
+    static executeParser(context, parser) {
+        const results$1 = [];
+        const pattern = parser.pattern(context);
+        const originalText = context.text;
+        let remainingText = context.text;
+        let match = pattern.exec(remainingText);
+        while (match) {
+            const index = match.index + originalText.length - remainingText.length;
+            match.index = index;
+            const result = parser.extract(context, match);
+            if (!result) {
+                remainingText = originalText.substring(match.index + 1);
+                match = pattern.exec(remainingText);
+                continue;
+            }
+            let parsedResult = null;
+            if (result instanceof results.ParsingResult) {
+                parsedResult = result;
+            }
+            else if (result instanceof results.ParsingComponents) {
+                parsedResult = context.createParsingResult(match.index, match[0]);
+                parsedResult.start = result;
+            }
+            else {
+                parsedResult = context.createParsingResult(match.index, match[0], result);
+            }
+            const parsedIndex = parsedResult.index;
+            const parsedText = parsedResult.text;
+            context.debug(() => console.log(`${parser.constructor.name} extracted (at index=${parsedIndex}) '${parsedText}'`));
+            results$1.push(parsedResult);
+            remainingText = originalText.substring(parsedIndex + parsedText.length);
+            match = pattern.exec(remainingText);
+        }
+        return results$1;
+    }
+}
+class ParsingContext {
+    text;
+    option;
+    reference;
+    refDate;
+    constructor(text, refDate, option) {
+        this.text = text;
+        this.reference = new results.ReferenceWithTimezone(refDate);
+        this.option = option ?? {};
+        this.refDate = this.reference.instant;
+    }
+    createParsingComponents(components) {
+        if (components instanceof results.ParsingComponents) {
+            return components;
+        }
+        return new results.ParsingComponents(this.reference, components);
+    }
+    createParsingResult(index, textOrEndIndex, startComponents, endComponents) {
+        const text = typeof textOrEndIndex === "string" ? textOrEndIndex : this.text.substring(index, textOrEndIndex);
+        const start = startComponents ? this.createParsingComponents(startComponents) : null;
+        const end = endComponents ? this.createParsingComponents(endComponents) : null;
+        return new results.ParsingResult(this.reference, index, text, start, end);
+    }
+    debug(block) {
+        if (this.option.debug) {
+            if (this.option.debug instanceof Function) {
+                this.option.debug(block);
+            }
+            else {
+                const handler = this.option.debug;
+                handler.debug(block);
+            }
+        }
+    }
+}
+
+exports.Chrono = Chrono;
+exports.ParsingContext = ParsingContext;

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

@@ -0,0 +1,41 @@
+'use strict';
+
+class Filter {
+    refine(context, results) {
+        return results.filter((r) => this.isValid(context, r));
+    }
+}
+class MergingRefiner {
+    refine(context, results) {
+        if (results.length < 2) {
+            return results;
+        }
+        const mergedResults = [];
+        let curResult = results[0];
+        let nextResult = null;
+        for (let i = 1; i < results.length; i++) {
+            nextResult = results[i];
+            const textBetween = context.text.substring(curResult.index + curResult.text.length, nextResult.index);
+            if (!this.shouldMergeResults(textBetween, curResult, nextResult, context)) {
+                mergedResults.push(curResult);
+                curResult = nextResult;
+            }
+            else {
+                const left = curResult;
+                const right = nextResult;
+                const mergedResult = this.mergeResults(textBetween, left, right, context);
+                context.debug(() => {
+                    console.log(`${this.constructor.name} merged ${left} and ${right} into ${mergedResult}`);
+                });
+                curResult = mergedResult;
+            }
+        }
+        if (curResult != null) {
+            mergedResults.push(curResult);
+        }
+        return mergedResults;
+    }
+}
+
+exports.Filter = Filter;
+exports.MergingRefiner = MergingRefiner;

package/dist/cjs/node_modules/chrono-node/dist/esm/common/calculation/weekdays.js

@@ -0,0 +1,68 @@
+'use strict';
+
+var types = require('../../types.js');
+var results = require('../../results.js');
+var timeunits = require('../../utils/timeunits.js');
+
+function createParsingComponentsAtWeekday(reference, weekday, modifier) {
+    const refDate = reference.getDateWithAdjustedTimezone();
+    const daysToWeekday = getDaysToWeekday(refDate, weekday, modifier);
+    let components = new results.ParsingComponents(reference);
+    components = timeunits.addImpliedTimeUnits(components, { "day": daysToWeekday });
+    components.assign("weekday", weekday);
+    return components;
+}
+function getDaysToWeekday(refDate, weekday, modifier) {
+    const refWeekday = refDate.getDay();
+    switch (modifier) {
+        case "this":
+            return getDaysForwardToWeekday(refDate, weekday);
+        case "last":
+            return getBackwardDaysToWeekday(refDate, weekday);
+        case "next":
+            if (refWeekday == types.Weekday.SUNDAY) {
+                return weekday == types.Weekday.SUNDAY ? 7 : weekday;
+            }
+            if (refWeekday == types.Weekday.SATURDAY) {
+                if (weekday == types.Weekday.SATURDAY)
+                    return 7;
+                if (weekday == types.Weekday.SUNDAY)
+                    return 8;
+                return 1 + weekday;
+            }
+            if (weekday < refWeekday && weekday != types.Weekday.SUNDAY) {
+                return getDaysForwardToWeekday(refDate, weekday);
+            }
+            else {
+                return getDaysForwardToWeekday(refDate, weekday) + 7;
+            }
+    }
+    return getDaysToWeekdayClosest(refDate, weekday);
+}
+function getDaysToWeekdayClosest(refDate, weekday) {
+    const backward = getBackwardDaysToWeekday(refDate, weekday);
+    const forward = getDaysForwardToWeekday(refDate, weekday);
+    return forward < -backward ? forward : backward;
+}
+function getDaysForwardToWeekday(refDate, weekday) {
+    const refWeekday = refDate.getDay();
+    let forwardCount = weekday - refWeekday;
+    if (forwardCount < 0) {
+        forwardCount += 7;
+    }
+    return forwardCount;
+}
+function getBackwardDaysToWeekday(refDate, weekday) {
+    const refWeekday = refDate.getDay();
+    let backwardCount = weekday - refWeekday;
+    if (backwardCount >= 0) {
+        backwardCount -= 7;
+    }
+    return backwardCount;
+}
+
+exports.createParsingComponentsAtWeekday = createParsingComponentsAtWeekday;
+exports.getBackwardDaysToWeekday = getBackwardDaysToWeekday;
+exports.getDaysForwardToWeekday = getDaysForwardToWeekday;
+exports.getDaysToWeekday = getDaysToWeekday;
+exports.getDaysToWeekdayClosest = getDaysToWeekdayClosest;

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

@@ -0,0 +1,136 @@
+'use strict';
+
+var results = require('../results.js');
+var dayjs_min = require('../../../../../_virtual/dayjs.min.js');
+var dayjs = require('../utils/dayjs.js');
+var types = require('../types.js');
+
+function now(reference) {
+    const targetDate = dayjs_min.default(reference.getDateWithAdjustedTimezone());
+    const component = new results.ParsingComponents(reference, {});
+    dayjs.assignSimilarDate(component, targetDate);
+    dayjs.assignSimilarTime(component, targetDate);
+    component.assign("timezoneOffset", reference.getTimezoneOffset());
+    component.addTag("casualReference/now");
+    return component;
+}
+function today(reference) {
+    const targetDate = dayjs_min.default(reference.getDateWithAdjustedTimezone());
+    const component = new results.ParsingComponents(reference, {});
+    dayjs.assignSimilarDate(component, targetDate);
+    dayjs.implySimilarTime(component, targetDate);
+    component.addTag("casualReference/today");
+    return component;
+}
+function yesterday(reference) {
+    return theDayBefore(reference, 1).addTag("casualReference/yesterday");
+}
+function theDayBefore(reference, numDay) {
+    return theDayAfter(reference, -numDay);
+}
+function tomorrow(reference) {
+    return theDayAfter(reference, 1).addTag("casualReference/tomorrow");
+}
+function theDayAfter(reference, nDays) {
+    let targetDate = dayjs_min.default(reference.getDateWithAdjustedTimezone());
+    const component = new results.ParsingComponents(reference, {});
+    targetDate = targetDate.add(nDays, "day");
+    dayjs.assignSimilarDate(component, targetDate);
+    dayjs.implySimilarTime(component, targetDate);
+    return component;
+}
+function tonight(reference, implyHour = 22) {
+    const targetDate = dayjs_min.default(reference.getDateWithAdjustedTimezone());
+    const component = new results.ParsingComponents(reference, {});
+    dayjs.assignSimilarDate(component, targetDate);
+    component.imply("hour", implyHour);
+    component.imply("meridiem", types.Meridiem.PM);
+    component.addTag("casualReference/tonight");
+    return component;
+}
+function lastNight(reference, implyHour = 0) {
+    let targetDate = dayjs_min.default(reference.getDateWithAdjustedTimezone());
+    const component = new results.ParsingComponents(reference, {});
+    if (targetDate.hour() < 6) {
+        targetDate = targetDate.add(-1, "day");
+    }
+    dayjs.assignSimilarDate(component, targetDate);
+    component.imply("hour", implyHour);
+    return component;
+}
+function evening(reference, implyHour = 20) {
+    const component = new results.ParsingComponents(reference, {});
+    component.imply("meridiem", types.Meridiem.PM);
+    component.imply("hour", implyHour);
+    component.addTag("casualReference/evening");
+    return component;
+}
+function yesterdayEvening(reference, implyHour = 20) {
+    let targetDate = dayjs_min.default(reference.getDateWithAdjustedTimezone());
+    const component = new results.ParsingComponents(reference, {});
+    targetDate = targetDate.add(-1, "day");
+    dayjs.assignSimilarDate(component, targetDate);
+    component.imply("hour", implyHour);
+    component.imply("meridiem", types.Meridiem.PM);
+    component.addTag("casualReference/yesterday");
+    component.addTag("casualReference/evening");
+    return component;
+}
+function midnight(reference) {
+    const component = new results.ParsingComponents(reference, {});
+    const targetDate = dayjs_min.default(reference.getDateWithAdjustedTimezone());
+    if (targetDate.hour() > 2) {
+        dayjs.implyTheNextDay(component, targetDate);
+    }
+    component.assign("hour", 0);
+    component.imply("minute", 0);
+    component.imply("second", 0);
+    component.imply("millisecond", 0);
+    component.addTag("casualReference/midnight");
+    return component;
+}
+function morning(reference, implyHour = 6) {
+    const component = new results.ParsingComponents(reference, {});
+    component.imply("meridiem", types.Meridiem.AM);
+    component.imply("hour", implyHour);
+    component.imply("minute", 0);
+    component.imply("second", 0);
+    component.imply("millisecond", 0);
+    component.addTag("casualReference/morning");
+    return component;
+}
+function afternoon(reference, implyHour = 15) {
+    const component = new results.ParsingComponents(reference, {});
+    component.imply("meridiem", types.Meridiem.PM);
+    component.imply("hour", implyHour);
+    component.imply("minute", 0);
+    component.imply("second", 0);
+    component.imply("millisecond", 0);
+    component.addTag("casualReference/afternoon");
+    return component;
+}
+function noon(reference) {
+    const component = new results.ParsingComponents(reference, {});
+    component.imply("meridiem", types.Meridiem.AM);
+    component.imply("hour", 12);
+    component.imply("minute", 0);
+    component.imply("second", 0);
+    component.imply("millisecond", 0);
+    component.addTag("casualReference/noon");
+    return component;
+}
+
+exports.afternoon = afternoon;
+exports.evening = evening;
+exports.lastNight = lastNight;
+exports.midnight = midnight;
+exports.morning = morning;
+exports.noon = noon;
+exports.now = now;
+exports.theDayAfter = theDayAfter;
+exports.theDayBefore = theDayBefore;
+exports.today = today;
+exports.tomorrow = tomorrow;
+exports.tonight = tonight;
+exports.yesterday = yesterday;
+exports.yesterdayEvening = yesterdayEvening;

package/dist/cjs/node_modules/chrono-node/dist/esm/common/parsers/AbstractParserWithWordBoundary.js

@@ -0,0 +1,33 @@
+'use strict';
+
+class AbstractParserWithWordBoundaryChecking {
+    innerPatternHasChange(context, currentInnerPattern) {
+        return this.innerPattern(context) !== currentInnerPattern;
+    }
+    patternLeftBoundary() {
+        return `(\\W|^)`;
+    }
+    cachedInnerPattern = null;
+    cachedPattern = null;
+    pattern(context) {
+        if (this.cachedInnerPattern) {
+            if (!this.innerPatternHasChange(context, this.cachedInnerPattern)) {
+                return this.cachedPattern;
+            }
+        }
+        this.cachedInnerPattern = this.innerPattern(context);
+        this.cachedPattern = new RegExp(`${this.patternLeftBoundary()}${this.cachedInnerPattern.source}`, this.cachedInnerPattern.flags);
+        return this.cachedPattern;
+    }
+    extract(context, match) {
+        const header = match[1] ?? "";
+        match.index = match.index + header.length;
+        match[0] = match[0].substring(header.length);
+        for (let i = 2; i < match.length; i++) {
+            match[i - 1] = match[i];
+        }
+        return this.innerExtract(context, match);
+    }
+}
+
+exports.AbstractParserWithWordBoundaryChecking = AbstractParserWithWordBoundaryChecking;