art-bd-ui 1.0.21 → 1.0.23

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

@@ -1,4 +1,4 @@
-import { __exports as es } from '../../../../_virtual/index8.js';
+import { __exports as es } from '../../../../_virtual/index9.js';
 
 var hasRequiredEs;
 

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

@@ -0,0 +1,73 @@
+import { Meridiem } from '../types.js';
+import { assignSimilarDate, implySimilarDate } from '../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")) {
+                assignSimilarDate(endDateTime, nextDayJs);
+            }
+            else {
+                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") == 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;
+}
+
+export { mergeDateTimeComponent, mergeDateTimeResult };

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

@@ -0,0 +1,31 @@
+import dayjs from '../../../../../_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(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();
+}
+
+export { findMostLikelyADYear, findYearClosestToRef };

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

@@ -0,0 +1,110 @@
+import { ParsingResult, ParsingComponents, ReferenceWithTimezone } from './results.js';
+import ENDefaultConfiguration from './locales/en/configuration.js';
+
+class Chrono {
+    parsers;
+    refiners;
+    defaultConfig = new ENDefaultConfiguration();
+    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 = [];
+        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 ParsingResult) {
+                parsedResult = result;
+            }
+            else if (result instanceof 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.push(parsedResult);
+            remainingText = originalText.substring(parsedIndex + parsedText.length);
+            match = pattern.exec(remainingText);
+        }
+        return results;
+    }
+}
+class ParsingContext {
+    text;
+    option;
+    reference;
+    refDate;
+    constructor(text, refDate, option) {
+        this.text = text;
+        this.reference = new ReferenceWithTimezone(refDate);
+        this.option = option ?? {};
+        this.refDate = this.reference.instant;
+    }
+    createParsingComponents(components) {
+        if (components instanceof ParsingComponents) {
+            return components;
+        }
+        return new 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 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);
+            }
+        }
+    }
+}
+
+export { Chrono, ParsingContext };

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

@@ -0,0 +1,38 @@
+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;
+    }
+}
+
+export { Filter, MergingRefiner };

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

@@ -0,0 +1,62 @@
+import { Weekday } from '../../types.js';
+import { ParsingComponents } from '../../results.js';
+import { addImpliedTimeUnits } from '../../utils/timeunits.js';
+
+function createParsingComponentsAtWeekday(reference, weekday, modifier) {
+    const refDate = reference.getDateWithAdjustedTimezone();
+    const daysToWeekday = getDaysToWeekday(refDate, weekday, modifier);
+    let components = new ParsingComponents(reference);
+    components = 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 == Weekday.SUNDAY) {
+                return weekday == Weekday.SUNDAY ? 7 : weekday;
+            }
+            if (refWeekday == Weekday.SATURDAY) {
+                if (weekday == Weekday.SATURDAY)
+                    return 7;
+                if (weekday == Weekday.SUNDAY)
+                    return 8;
+                return 1 + weekday;
+            }
+            if (weekday < refWeekday && weekday != 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;
+}
+
+export { createParsingComponentsAtWeekday, getBackwardDaysToWeekday, getDaysForwardToWeekday, getDaysToWeekday, getDaysToWeekdayClosest };

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

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

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

@@ -0,0 +1,31 @@
+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);
+    }
+}
+
+export { AbstractParserWithWordBoundaryChecking };