art-bd-ui 1.0.21 → 1.0.23

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

@@ -0,0 +1,334 @@
+import { Meridiem } from '../../types.js';
+
+function primaryTimePattern(leftBoundary, primaryPrefix, primarySuffix, flags) {
+    return new RegExp(`${leftBoundary}` +
+        `${primaryPrefix}` +
+        `(\\d{1,4})` +
+        `(?:` +
+        `(?:\\.|:|：)` +
+        `(\\d{1,2})` +
+        `(?:` +
+        `(?::|：)` +
+        `(\\d{2})` +
+        `(?:\\.(\\d{1,6}))?` +
+        `)?` +
+        `)?` +
+        `(?:\\s*(a\\.m\\.|p\\.m\\.|am?|pm?))?` +
+        `${primarySuffix}`, flags);
+}
+function followingTimePatten(followingPhase, followingSuffix) {
+    return new RegExp(`^(${followingPhase})` +
+        `(\\d{1,4})` +
+        `(?:` +
+        `(?:\\.|\\:|\\：)` +
+        `(\\d{1,2})` +
+        `(?:` +
+        `(?:\\.|\\:|\\：)` +
+        `(\\d{1,2})(?:\\.(\\d{1,6}))?` +
+        `)?` +
+        `)?` +
+        `(?:\\s*(a\\.m\\.|p\\.m\\.|am?|pm?))?` +
+        `${followingSuffix}`, "i");
+}
+const HOUR_GROUP = 2;
+const MINUTE_GROUP = 3;
+const SECOND_GROUP = 4;
+const MILLI_SECOND_GROUP = 5;
+const AM_PM_HOUR_GROUP = 6;
+class AbstractTimeExpressionParser {
+    strictMode;
+    constructor(strictMode = false) {
+        this.strictMode = strictMode;
+    }
+    patternFlags() {
+        return "i";
+    }
+    primaryPatternLeftBoundary() {
+        return `(^|\\s|T|\\b)`;
+    }
+    primarySuffix() {
+        return `(?!/)(?=\\W|$)`;
+    }
+    followingSuffix() {
+        return `(?!/)(?=\\W|$)`;
+    }
+    pattern(context) {
+        return this.getPrimaryTimePatternThroughCache();
+    }
+    extract(context, match) {
+        const startComponents = this.extractPrimaryTimeComponents(context, match);
+        if (!startComponents) {
+            if (match[0].match(/^\d{4}/)) {
+                match.index += 4;
+                return null;
+            }
+            match.index += match[0].length;
+            return null;
+        }
+        const index = match.index + match[1].length;
+        const text = match[0].substring(match[1].length);
+        const result = context.createParsingResult(index, text, startComponents);
+        match.index += match[0].length;
+        const remainingText = context.text.substring(match.index);
+        const followingPattern = this.getFollowingTimePatternThroughCache();
+        const followingMatch = followingPattern.exec(remainingText);
+        if (text.match(/^\d{3,4}/) && followingMatch) {
+            if (followingMatch[0].match(/^\s*([+-])\s*\d{2,4}$/)) {
+                return null;
+            }
+            if (followingMatch[0].match(/^\s*([+-])\s*\d{2}\W\d{2}/)) {
+                return null;
+            }
+        }
+        if (!followingMatch ||
+            followingMatch[0].match(/^\s*([+-])\s*\d{3,4}$/)) {
+            return this.checkAndReturnWithoutFollowingPattern(result);
+        }
+        result.end = this.extractFollowingTimeComponents(context, followingMatch, result);
+        if (result.end) {
+            result.text += followingMatch[0];
+        }
+        return this.checkAndReturnWithFollowingPattern(result);
+    }
+    extractPrimaryTimeComponents(context, match, strict = false) {
+        const components = context.createParsingComponents();
+        let minute = 0;
+        let meridiem = null;
+        let hour = parseInt(match[HOUR_GROUP]);
+        if (hour > 100) {
+            if (this.strictMode || match[MINUTE_GROUP] != null) {
+                return null;
+            }
+            minute = hour % 100;
+            hour = Math.floor(hour / 100);
+        }
+        if (hour > 24) {
+            return null;
+        }
+        if (match[MINUTE_GROUP] != null) {
+            if (match[MINUTE_GROUP].length == 1 && !match[AM_PM_HOUR_GROUP]) {
+                return null;
+            }
+            minute = parseInt(match[MINUTE_GROUP]);
+        }
+        if (minute >= 60) {
+            return null;
+        }
+        if (hour > 12) {
+            meridiem = Meridiem.PM;
+        }
+        if (match[AM_PM_HOUR_GROUP] != null) {
+            if (hour > 12)
+                return null;
+            const ampm = match[AM_PM_HOUR_GROUP][0].toLowerCase();
+            if (ampm == "a") {
+                meridiem = Meridiem.AM;
+                if (hour == 12) {
+                    hour = 0;
+                }
+            }
+            if (ampm == "p") {
+                meridiem = Meridiem.PM;
+                if (hour != 12) {
+                    hour += 12;
+                }
+            }
+        }
+        components.assign("hour", hour);
+        components.assign("minute", minute);
+        if (meridiem !== null) {
+            components.assign("meridiem", meridiem);
+        }
+        else {
+            if (hour < 12) {
+                components.imply("meridiem", Meridiem.AM);
+            }
+            else {
+                components.imply("meridiem", Meridiem.PM);
+            }
+        }
+        if (match[MILLI_SECOND_GROUP] != null) {
+            const millisecond = parseInt(match[MILLI_SECOND_GROUP].substring(0, 3));
+            if (millisecond >= 1000)
+                return null;
+            components.assign("millisecond", millisecond);
+        }
+        if (match[SECOND_GROUP] != null) {
+            const second = parseInt(match[SECOND_GROUP]);
+            if (second >= 60)
+                return null;
+            components.assign("second", second);
+        }
+        return components;
+    }
+    extractFollowingTimeComponents(context, match, result) {
+        const components = context.createParsingComponents();
+        if (match[MILLI_SECOND_GROUP] != null) {
+            const millisecond = parseInt(match[MILLI_SECOND_GROUP].substring(0, 3));
+            if (millisecond >= 1000)
+                return null;
+            components.assign("millisecond", millisecond);
+        }
+        if (match[SECOND_GROUP] != null) {
+            const second = parseInt(match[SECOND_GROUP]);
+            if (second >= 60)
+                return null;
+            components.assign("second", second);
+        }
+        let hour = parseInt(match[HOUR_GROUP]);
+        let minute = 0;
+        let meridiem = -1;
+        if (match[MINUTE_GROUP] != null) {
+            minute = parseInt(match[MINUTE_GROUP]);
+        }
+        else if (hour > 100) {
+            minute = hour % 100;
+            hour = Math.floor(hour / 100);
+        }
+        if (minute >= 60 || hour > 24) {
+            return null;
+        }
+        if (hour >= 12) {
+            meridiem = Meridiem.PM;
+        }
+        if (match[AM_PM_HOUR_GROUP] != null) {
+            if (hour > 12) {
+                return null;
+            }
+            const ampm = match[AM_PM_HOUR_GROUP][0].toLowerCase();
+            if (ampm == "a") {
+                meridiem = Meridiem.AM;
+                if (hour == 12) {
+                    hour = 0;
+                    if (!components.isCertain("day")) {
+                        components.imply("day", components.get("day") + 1);
+                    }
+                }
+            }
+            if (ampm == "p") {
+                meridiem = Meridiem.PM;
+                if (hour != 12)
+                    hour += 12;
+            }
+            if (!result.start.isCertain("meridiem")) {
+                if (meridiem == Meridiem.AM) {
+                    result.start.imply("meridiem", Meridiem.AM);
+                    if (result.start.get("hour") == 12) {
+                        result.start.assign("hour", 0);
+                    }
+                }
+                else {
+                    result.start.imply("meridiem", Meridiem.PM);
+                    if (result.start.get("hour") != 12) {
+                        result.start.assign("hour", result.start.get("hour") + 12);
+                    }
+                }
+            }
+        }
+        components.assign("hour", hour);
+        components.assign("minute", minute);
+        if (meridiem >= 0) {
+            components.assign("meridiem", meridiem);
+        }
+        else {
+            const startAtPM = result.start.isCertain("meridiem") && result.start.get("hour") > 12;
+            if (startAtPM) {
+                if (result.start.get("hour") - 12 > hour) {
+                    components.imply("meridiem", Meridiem.AM);
+                }
+                else if (hour <= 12) {
+                    components.assign("hour", hour + 12);
+                    components.assign("meridiem", Meridiem.PM);
+                }
+            }
+            else if (hour > 12) {
+                components.imply("meridiem", Meridiem.PM);
+            }
+            else if (hour <= 12) {
+                components.imply("meridiem", Meridiem.AM);
+            }
+        }
+        if (components.date().getTime() < result.start.date().getTime()) {
+            components.imply("day", components.get("day") + 1);
+        }
+        return components;
+    }
+    checkAndReturnWithoutFollowingPattern(result) {
+        if (result.text.match(/^\d$/)) {
+            return null;
+        }
+        if (result.text.match(/^\d\d\d+$/)) {
+            return null;
+        }
+        if (result.text.match(/\d[apAP]$/)) {
+            return null;
+        }
+        const endingWithNumbers = result.text.match(/[^\d:.](\d[\d.]+)$/);
+        if (endingWithNumbers) {
+            const endingNumbers = endingWithNumbers[1];
+            if (this.strictMode) {
+                return null;
+            }
+            if (endingNumbers.includes(".") && !endingNumbers.match(/\d(\.\d{2})+$/)) {
+                return null;
+            }
+            const endingNumberVal = parseInt(endingNumbers);
+            if (endingNumberVal > 24) {
+                return null;
+            }
+        }
+        return result;
+    }
+    checkAndReturnWithFollowingPattern(result) {
+        if (result.text.match(/^\d+-\d+$/)) {
+            return null;
+        }
+        const endingWithNumbers = result.text.match(/[^\d:.](\d[\d.]+)\s*-\s*(\d[\d.]+)$/);
+        if (endingWithNumbers) {
+            if (this.strictMode) {
+                return null;
+            }
+            const startingNumbers = endingWithNumbers[1];
+            const endingNumbers = endingWithNumbers[2];
+            if (endingNumbers.includes(".") && !endingNumbers.match(/\d(\.\d{2})+$/)) {
+                return null;
+            }
+            const endingNumberVal = parseInt(endingNumbers);
+            const startingNumberVal = parseInt(startingNumbers);
+            if (endingNumberVal > 24 || startingNumberVal > 24) {
+                return null;
+            }
+        }
+        return result;
+    }
+    cachedPrimaryPrefix = null;
+    cachedPrimarySuffix = null;
+    cachedPrimaryTimePattern = null;
+    getPrimaryTimePatternThroughCache() {
+        const primaryPrefix = this.primaryPrefix();
+        const primarySuffix = this.primarySuffix();
+        if (this.cachedPrimaryPrefix === primaryPrefix && this.cachedPrimarySuffix === primarySuffix) {
+            return this.cachedPrimaryTimePattern;
+        }
+        this.cachedPrimaryTimePattern = primaryTimePattern(this.primaryPatternLeftBoundary(), primaryPrefix, primarySuffix, this.patternFlags());
+        this.cachedPrimaryPrefix = primaryPrefix;
+        this.cachedPrimarySuffix = primarySuffix;
+        return this.cachedPrimaryTimePattern;
+    }
+    cachedFollowingPhase = null;
+    cachedFollowingSuffix = null;
+    cachedFollowingTimePatten = null;
+    getFollowingTimePatternThroughCache() {
+        const followingPhase = this.followingPhase();
+        const followingSuffix = this.followingSuffix();
+        if (this.cachedFollowingPhase === followingPhase && this.cachedFollowingSuffix === followingSuffix) {
+            return this.cachedFollowingTimePatten;
+        }
+        this.cachedFollowingTimePatten = followingTimePatten(followingPhase, followingSuffix);
+        this.cachedFollowingPhase = followingPhase;
+        this.cachedFollowingSuffix = followingSuffix;
+        return this.cachedFollowingTimePatten;
+    }
+}
+
+export { AbstractTimeExpressionParser };

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

@@ -0,0 +1,66 @@
+import { AbstractParserWithWordBoundaryChecking } from './AbstractParserWithWordBoundary.js';
+
+const PATTERN = new RegExp("([0-9]{4})\\-([0-9]{1,2})\\-([0-9]{1,2})" +
+    "(?:T" +
+    "([0-9]{1,2}):([0-9]{1,2})" +
+    "(?:" +
+    ":([0-9]{1,2})(?:\\.(\\d{1,4}))?" +
+    ")?" +
+    "(" +
+    "Z|([+-]\\d{2}):?(\\d{2})?" +
+    ")?" +
+    ")?" +
+    "(?=\\W|$)", "i");
+const YEAR_NUMBER_GROUP = 1;
+const MONTH_NUMBER_GROUP = 2;
+const DATE_NUMBER_GROUP = 3;
+const HOUR_NUMBER_GROUP = 4;
+const MINUTE_NUMBER_GROUP = 5;
+const SECOND_NUMBER_GROUP = 6;
+const MILLISECOND_NUMBER_GROUP = 7;
+const TZD_GROUP = 8;
+const TZD_HOUR_OFFSET_GROUP = 9;
+const TZD_MINUTE_OFFSET_GROUP = 10;
+class ISOFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return PATTERN;
+    }
+    innerExtract(context, match) {
+        const components = context.createParsingComponents({
+            "year": parseInt(match[YEAR_NUMBER_GROUP]),
+            "month": parseInt(match[MONTH_NUMBER_GROUP]),
+            "day": parseInt(match[DATE_NUMBER_GROUP]),
+        });
+        if (match[HOUR_NUMBER_GROUP] != null) {
+            components.assign("hour", parseInt(match[HOUR_NUMBER_GROUP]));
+            components.assign("minute", parseInt(match[MINUTE_NUMBER_GROUP]));
+            if (match[SECOND_NUMBER_GROUP] != null) {
+                components.assign("second", parseInt(match[SECOND_NUMBER_GROUP]));
+            }
+            if (match[MILLISECOND_NUMBER_GROUP] != null) {
+                components.assign("millisecond", parseInt(match[MILLISECOND_NUMBER_GROUP]));
+            }
+            if (match[TZD_GROUP] != null) {
+                let offset = 0;
+                if (match[TZD_HOUR_OFFSET_GROUP]) {
+                    const hourOffset = parseInt(match[TZD_HOUR_OFFSET_GROUP]);
+                    let minuteOffset = 0;
+                    if (match[TZD_MINUTE_OFFSET_GROUP] != null) {
+                        minuteOffset = parseInt(match[TZD_MINUTE_OFFSET_GROUP]);
+                    }
+                    offset = hourOffset * 60;
+                    if (offset < 0) {
+                        offset -= minuteOffset;
+                    }
+                    else {
+                        offset += minuteOffset;
+                    }
+                }
+                components.assign("timezoneOffset", offset);
+            }
+        }
+        return components.addTag("parser/ISOFormatParser");
+    }
+}
+
+export { ISOFormatParser as default };

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

@@ -0,0 +1,75 @@
+import { findMostLikelyADYear, findYearClosestToRef } from '../../calculation/years.js';
+
+const PATTERN = new RegExp("([^\\d]|^)" +
+    "([0-3]{0,1}[0-9]{1})[\\/\\.\\-]([0-3]{0,1}[0-9]{1})" +
+    "(?:[\\/\\.\\-]([0-9]{4}|[0-9]{2}))?" +
+    "(\\W|$)", "i");
+const OPENING_GROUP = 1;
+const ENDING_GROUP = 5;
+const FIRST_NUMBERS_GROUP = 2;
+const SECOND_NUMBERS_GROUP = 3;
+const YEAR_GROUP = 4;
+class SlashDateFormatParser {
+    groupNumberMonth;
+    groupNumberDay;
+    constructor(littleEndian) {
+        this.groupNumberMonth = littleEndian ? SECOND_NUMBERS_GROUP : FIRST_NUMBERS_GROUP;
+        this.groupNumberDay = littleEndian ? FIRST_NUMBERS_GROUP : SECOND_NUMBERS_GROUP;
+    }
+    pattern() {
+        return PATTERN;
+    }
+    extract(context, match) {
+        const index = match.index + match[OPENING_GROUP].length;
+        const indexEnd = match.index + match[0].length - match[ENDING_GROUP].length;
+        if (index > 0) {
+            const textBefore = context.text.substring(0, index);
+            if (textBefore.match("\\d/?$")) {
+                return;
+            }
+        }
+        if (indexEnd < context.text.length) {
+            const textAfter = context.text.substring(indexEnd);
+            if (textAfter.match("^/?\\d")) {
+                return;
+            }
+        }
+        const text = context.text.substring(index, indexEnd);
+        if (text.match(/^\d\.\d$/) || text.match(/^\d\.\d{1,2}\.\d{1,2}\s*$/)) {
+            return;
+        }
+        if (!match[YEAR_GROUP] && text.indexOf("/") < 0) {
+            return;
+        }
+        const result = context.createParsingResult(index, text);
+        let month = parseInt(match[this.groupNumberMonth]);
+        let day = parseInt(match[this.groupNumberDay]);
+        if (month < 1 || month > 12) {
+            if (month > 12) {
+                if (day >= 1 && day <= 12 && month <= 31) {
+                    [day, month] = [month, day];
+                }
+                else {
+                    return null;
+                }
+            }
+        }
+        if (day < 1 || day > 31) {
+            return null;
+        }
+        result.start.assign("day", day);
+        result.start.assign("month", month);
+        if (match[YEAR_GROUP]) {
+            const rawYearNumber = parseInt(match[YEAR_GROUP]);
+            const year = findMostLikelyADYear(rawYearNumber);
+            result.start.assign("year", year);
+        }
+        else {
+            const year = findYearClosestToRef(context.refDate, day, month);
+            result.start.imply("year", year);
+        }
+        return result.addTag("parser/SlashDateFormatParser");
+    }
+}
+
+export { SlashDateFormatParser as default };

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

@@ -0,0 +1,61 @@
+import { MergingRefiner } from '../abstractRefiners.js';
+
+class AbstractMergeDateRangeRefiner extends MergingRefiner {
+    shouldMergeResults(textBetween, currentResult, nextResult) {
+        return !currentResult.end && !nextResult.end && textBetween.match(this.patternBetween()) != null;
+    }
+    mergeResults(textBetween, fromResult, toResult) {
+        if (!fromResult.start.isOnlyWeekdayComponent() && !toResult.start.isOnlyWeekdayComponent()) {
+            toResult.start.getCertainComponents().forEach((key) => {
+                if (!fromResult.start.isCertain(key)) {
+                    fromResult.start.imply(key, toResult.start.get(key));
+                }
+            });
+            fromResult.start.getCertainComponents().forEach((key) => {
+                if (!toResult.start.isCertain(key)) {
+                    toResult.start.imply(key, fromResult.start.get(key));
+                }
+            });
+        }
+        if (fromResult.start.date().getTime() > toResult.start.date().getTime()) {
+            let fromMoment = fromResult.start.dayjs();
+            let toMoment = toResult.start.dayjs();
+            if (toResult.start.isOnlyWeekdayComponent() && toMoment.add(7, "days").isAfter(fromMoment)) {
+                toMoment = toMoment.add(7, "days");
+                toResult.start.imply("day", toMoment.date());
+                toResult.start.imply("month", toMoment.month() + 1);
+                toResult.start.imply("year", toMoment.year());
+            }
+            else if (fromResult.start.isOnlyWeekdayComponent() && fromMoment.add(-7, "days").isBefore(toMoment)) {
+                fromMoment = fromMoment.add(-7, "days");
+                fromResult.start.imply("day", fromMoment.date());
+                fromResult.start.imply("month", fromMoment.month() + 1);
+                fromResult.start.imply("year", fromMoment.year());
+            }
+            else if (toResult.start.isDateWithUnknownYear() && toMoment.add(1, "years").isAfter(fromMoment)) {
+                toMoment = toMoment.add(1, "years");
+                toResult.start.imply("year", toMoment.year());
+            }
+            else if (fromResult.start.isDateWithUnknownYear() && fromMoment.add(-1, "years").isBefore(toMoment)) {
+                fromMoment = fromMoment.add(-1, "years");
+                fromResult.start.imply("year", fromMoment.year());
+            }
+            else {
+                [toResult, fromResult] = [fromResult, toResult];
+            }
+        }
+        const result = fromResult.clone();
+        result.start = fromResult.start;
+        result.end = toResult.start;
+        result.index = Math.min(fromResult.index, toResult.index);
+        if (fromResult.index < toResult.index) {
+            result.text = fromResult.text + textBetween + toResult.text;
+        }
+        else {
+            result.text = toResult.text + textBetween + fromResult.text;
+        }
+        return result;
+    }
+}
+
+export { AbstractMergeDateRangeRefiner as default };

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

@@ -0,0 +1,20 @@
+import { MergingRefiner } from '../abstractRefiners.js';
+import { mergeDateTimeResult } from '../../calculation/mergingCalculation.js';
+
+class AbstractMergeDateTimeRefiner extends MergingRefiner {
+    shouldMergeResults(textBetween, currentResult, nextResult) {
+        return (((currentResult.start.isOnlyDate() && nextResult.start.isOnlyTime()) ||
+            (nextResult.start.isOnlyDate() && currentResult.start.isOnlyTime())) &&
+            textBetween.match(this.patternBetween()) != null);
+    }
+    mergeResults(textBetween, currentResult, nextResult) {
+        const result = currentResult.start.isOnlyDate()
+            ? mergeDateTimeResult(currentResult, nextResult)
+            : mergeDateTimeResult(nextResult, currentResult);
+        result.index = currentResult.index;
+        result.text = currentResult.text + textBetween + nextResult.text;
+        return result;
+    }
+}
+
+export { AbstractMergeDateTimeRefiner as default };

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

@@ -0,0 +1,53 @@
+import { toTimezoneOffset } from '../../timezone.js';
+
+const TIMEZONE_NAME_PATTERN = new RegExp("^\\s*,?\\s*\\(?([A-Z]{2,4})\\)?(?=\\W|$)", "i");
+class ExtractTimezoneAbbrRefiner {
+    timezoneOverrides;
+    constructor(timezoneOverrides) {
+        this.timezoneOverrides = timezoneOverrides;
+    }
+    refine(context, results) {
+        const timezoneOverrides = context.option.timezones ?? {};
+        results.forEach((result) => {
+            const suffix = context.text.substring(result.index + result.text.length);
+            const match = TIMEZONE_NAME_PATTERN.exec(suffix);
+            if (!match) {
+                return;
+            }
+            const timezoneAbbr = match[1].toUpperCase();
+            const refDate = result.start.date() ?? result.refDate ?? new Date();
+            const tzOverrides = { ...this.timezoneOverrides, ...timezoneOverrides };
+            const extractedTimezoneOffset = toTimezoneOffset(timezoneAbbr, refDate, tzOverrides);
+            if (extractedTimezoneOffset == null) {
+                return;
+            }
+            context.debug(() => {
+                console.log(`Extracting timezone: '${timezoneAbbr}' into: ${extractedTimezoneOffset} for: ${result.start}`);
+            });
+            const currentTimezoneOffset = result.start.get("timezoneOffset");
+            if (currentTimezoneOffset !== null && extractedTimezoneOffset != currentTimezoneOffset) {
+                if (result.start.isCertain("timezoneOffset")) {
+                    return;
+                }
+                if (timezoneAbbr != match[1]) {
+                    return;
+                }
+            }
+            if (result.start.isOnlyDate()) {
+                if (timezoneAbbr != match[1]) {
+                    return;
+                }
+            }
+            result.text += match[0];
+            if (!result.start.isCertain("timezoneOffset")) {
+                result.start.assign("timezoneOffset", extractedTimezoneOffset);
+            }
+            if (result.end != null && !result.end.isCertain("timezoneOffset")) {
+                result.end.assign("timezoneOffset", extractedTimezoneOffset);
+            }
+        });
+        return results;
+    }
+}
+
+export { ExtractTimezoneAbbrRefiner as default };

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

@@ -0,0 +1,38 @@
+const TIMEZONE_OFFSET_PATTERN = new RegExp("^\\s*(?:\\(?(?:GMT|UTC)\\s?)?([+-])(\\d{1,2})(?::?(\\d{2}))?\\)?", "i");
+const TIMEZONE_OFFSET_SIGN_GROUP = 1;
+const TIMEZONE_OFFSET_HOUR_OFFSET_GROUP = 2;
+const TIMEZONE_OFFSET_MINUTE_OFFSET_GROUP = 3;
+class ExtractTimezoneOffsetRefiner {
+    refine(context, results) {
+        results.forEach(function (result) {
+            if (result.start.isCertain("timezoneOffset")) {
+                return;
+            }
+            const suffix = context.text.substring(result.index + result.text.length);
+            const match = TIMEZONE_OFFSET_PATTERN.exec(suffix);
+            if (!match) {
+                return;
+            }
+            context.debug(() => {
+                console.log(`Extracting timezone: '${match[0]}' into : ${result}`);
+            });
+            const hourOffset = parseInt(match[TIMEZONE_OFFSET_HOUR_OFFSET_GROUP]);
+            const minuteOffset = parseInt(match[TIMEZONE_OFFSET_MINUTE_OFFSET_GROUP] || "0");
+            let timezoneOffset = hourOffset * 60 + minuteOffset;
+            if (timezoneOffset > 14 * 60) {
+                return;
+            }
+            if (match[TIMEZONE_OFFSET_SIGN_GROUP] === "-") {
+                timezoneOffset = -timezoneOffset;
+            }
+            if (result.end != null) {
+                result.end.assign("timezoneOffset", timezoneOffset);
+            }
+            result.start.assign("timezoneOffset", timezoneOffset);
+            result.text += match[0];
+        });
+        return results;
+    }
+}
+
+export { ExtractTimezoneOffsetRefiner as default };