chrono-node 2.3.2 → 2.3.6

package/dist/locales/zh/hans/refiners/ZHHansMergeDateTimeRefiner.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMergeDateTimeRefiner_1 = __importDefault(require("../../../../common/refiners/AbstractMergeDateTimeRefiner"));
+class ZHHansMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner_1.default {
+    patternBetween() {
+        return /^\s*$/i;
+    }
+}
+exports.default = ZHHansMergeDateTimeRefiner;

package/dist/locales/zh/hant/constants.d.ts

@@ -0,0 +1,28 @@
+export declare const NUMBER: {
+    零: number;
+    一: number;
+    二: number;
+    兩: number;
+    三: number;
+    四: number;
+    五: number;
+    六: number;
+    七: number;
+    八: number;
+    九: number;
+    十: number;
+    廿: number;
+    卅: number;
+};
+export declare const WEEKDAY_OFFSET: {
+    天: number;
+    日: number;
+    一: number;
+    二: number;
+    三: number;
+    四: number;
+    五: number;
+    六: number;
+};
+export declare function zhStringToNumber(text: string): number;
+export declare function zhStringToYear(text: string): number;

package/dist/locales/zh/hant/constants.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zhStringToYear = exports.zhStringToNumber = exports.WEEKDAY_OFFSET = exports.NUMBER = void 0;
+exports.NUMBER = {
+    "零": 0,
+    "一": 1,
+    "二": 2,
+    "兩": 2,
+    "三": 3,
+    "四": 4,
+    "五": 5,
+    "六": 6,
+    "七": 7,
+    "八": 8,
+    "九": 9,
+    "十": 10,
+    "廿": 20,
+    "卅": 30,
+};
+exports.WEEKDAY_OFFSET = {
+    "天": 0,
+    "日": 0,
+    "一": 1,
+    "二": 2,
+    "三": 3,
+    "四": 4,
+    "五": 5,
+    "六": 6,
+};
+function zhStringToNumber(text) {
+    let number = 0;
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (char === "十") {
+            number = number === 0 ? exports.NUMBER[char] : number * exports.NUMBER[char];
+        }
+        else {
+            number += exports.NUMBER[char];
+        }
+    }
+    return number;
+}
+exports.zhStringToNumber = zhStringToNumber;
+function zhStringToYear(text) {
+    let string = "";
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        string = string + exports.NUMBER[char];
+    }
+    return parseInt(string);
+}
+exports.zhStringToYear = zhStringToYear;

package/dist/locales/zh/hant/index.d.ts

@@ -0,0 +1,9 @@
+import { Chrono, Configuration } from "../../../chrono";
+import { ParsedResult, ParsingOption } from "../../../index";
+export declare const hant: Chrono;
+export declare const casual: Chrono;
+export declare const strict: Chrono;
+export declare function parse(text: string, ref?: Date, option?: ParsingOption): ParsedResult[];
+export declare function parseDate(text: string, ref?: Date, option?: ParsingOption): Date;
+export declare function createCasualConfiguration(): Configuration;
+export declare function createConfiguration(): Configuration;

package/dist/locales/zh/hant/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfiguration = exports.createCasualConfiguration = exports.parseDate = exports.parse = exports.strict = exports.casual = exports.hant = void 0;
+const chrono_1 = require("../../../chrono");
+const ExtractTimezoneOffsetRefiner_1 = __importDefault(require("../../../common/refiners/ExtractTimezoneOffsetRefiner"));
+const configurations_1 = require("../../../configurations");
+const ZHHantCasualDateParser_1 = __importDefault(require("./parsers/ZHHantCasualDateParser"));
+const ZHHantDateParser_1 = __importDefault(require("./parsers/ZHHantDateParser"));
+const ZHHantDeadlineFormatParser_1 = __importDefault(require("./parsers/ZHHantDeadlineFormatParser"));
+const ZHHantRelationWeekdayParser_1 = __importDefault(require("./parsers/ZHHantRelationWeekdayParser"));
+const ZHHantTimeExpressionParser_1 = __importDefault(require("./parsers/ZHHantTimeExpressionParser"));
+const ZHHantWeekdayParser_1 = __importDefault(require("./parsers/ZHHantWeekdayParser"));
+const ZHHantMergeDateRangeRefiner_1 = __importDefault(require("./refiners/ZHHantMergeDateRangeRefiner"));
+const ZHHantMergeDateTimeRefiner_1 = __importDefault(require("./refiners/ZHHantMergeDateTimeRefiner"));
+exports.hant = new chrono_1.Chrono(createCasualConfiguration());
+exports.casual = new chrono_1.Chrono(createCasualConfiguration());
+exports.strict = new chrono_1.Chrono(createConfiguration());
+function parse(text, ref, option) {
+    return exports.casual.parse(text, ref, option);
+}
+exports.parse = parse;
+function parseDate(text, ref, option) {
+    return exports.casual.parseDate(text, ref, option);
+}
+exports.parseDate = parseDate;
+function createCasualConfiguration() {
+    const option = createConfiguration();
+    option.parsers.unshift(new ZHHantCasualDateParser_1.default());
+    return option;
+}
+exports.createCasualConfiguration = createCasualConfiguration;
+function createConfiguration() {
+    const configuration = configurations_1.includeCommonConfiguration({
+        parsers: [
+            new ZHHantDateParser_1.default(),
+            new ZHHantRelationWeekdayParser_1.default(),
+            new ZHHantWeekdayParser_1.default(),
+            new ZHHantTimeExpressionParser_1.default(),
+            new ZHHantDeadlineFormatParser_1.default(),
+        ],
+        refiners: [new ZHHantMergeDateRangeRefiner_1.default(), new ZHHantMergeDateTimeRefiner_1.default()],
+    });
+    configuration.refiners = configuration.refiners.filter((refiner) => !(refiner instanceof ExtractTimezoneOffsetRefiner_1.default));
+    return configuration;
+}
+exports.createConfiguration = createConfiguration;

package/dist/locales/zh/hant/parsers/ZHHantCasualDateParser.d.ts

@@ -0,0 +1,7 @@
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+import { ParsingComponents, ParsingResult } from "../../../../results";
+export default class ZHHantCasualDateParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(context: ParsingContext): RegExp;
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult;
+}

package/dist/locales/zh/hant/parsers/ZHHantCasualDateParser.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dayjs_1 = __importDefault(require("dayjs"));
+const AbstractParserWithWordBoundary_1 = require("../../../../common/parsers/AbstractParserWithWordBoundary");
+const NOW_GROUP = 1;
+const DAY_GROUP_1 = 2;
+const TIME_GROUP_1 = 3;
+const TIME_GROUP_2 = 4;
+const DAY_GROUP_3 = 5;
+const TIME_GROUP_3 = 6;
+class ZHHantCasualDateParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {
+    innerPattern(context) {
+        return new RegExp("(而家|立(?:刻|即)|即刻)|" +
+            "(今|明|前|大前|後|大後|聽|昨|尋|琴)(早|朝|晚)|" +
+            "(上(?:午|晝)|朝(?:早)|早(?:上)|下(?:午|晝)|晏(?:晝)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨))|" +
+            "(今|明|前|大前|後|大後|聽|昨|尋|琴)(?:日|天)" +
+            "(?:[\\s|,|，]*)" +
+            "(?:(上(?:午|晝)|朝(?:早)|早(?:上)|下(?:午|晝)|晏(?:晝)|晚(?:上)|夜(?:晚)?|中(?:午)|凌(?:晨)))?", "i");
+    }
+    innerExtract(context, match) {
+        const index = match.index;
+        const result = context.createParsingResult(index, match[0]);
+        const refMoment = dayjs_1.default(context.refDate);
+        let startMoment = refMoment;
+        if (match[NOW_GROUP]) {
+            result.start.imply("hour", refMoment.hour());
+            result.start.imply("minute", refMoment.minute());
+            result.start.imply("second", refMoment.second());
+            result.start.imply("millisecond", refMoment.millisecond());
+        }
+        else if (match[DAY_GROUP_1]) {
+            const day1 = match[DAY_GROUP_1];
+            const time1 = match[TIME_GROUP_1];
+            if (day1 == "明" || day1 == "聽") {
+                if (refMoment.hour() > 1) {
+                    startMoment = startMoment.add(1, "day");
+                }
+            }
+            else if (day1 == "昨" || day1 == "尋" || day1 == "琴") {
+                startMoment = startMoment.add(-1, "day");
+            }
+            else if (day1 == "前") {
+                startMoment = startMoment.add(-2, "day");
+            }
+            else if (day1 == "大前") {
+                startMoment = startMoment.add(-3, "day");
+            }
+            else if (day1 == "後") {
+                startMoment = startMoment.add(2, "day");
+            }
+            else if (day1 == "大後") {
+                startMoment = startMoment.add(3, "day");
+            }
+            if (time1 == "早" || time1 == "朝") {
+                result.start.imply("hour", 6);
+            }
+            else if (time1 == "晚") {
+                result.start.imply("hour", 22);
+                result.start.imply("meridiem", 1);
+            }
+        }
+        else if (match[TIME_GROUP_2]) {
+            const timeString2 = match[TIME_GROUP_2];
+            const time2 = timeString2[0];
+            if (time2 == "早" || time2 == "朝" || time2 == "上") {
+                result.start.imply("hour", 6);
+            }
+            else if (time2 == "下" || time2 == "晏") {
+                result.start.imply("hour", 15);
+                result.start.imply("meridiem", 1);
+            }
+            else if (time2 == "中") {
+                result.start.imply("hour", 12);
+                result.start.imply("meridiem", 1);
+            }
+            else if (time2 == "夜" || time2 == "晚") {
+                result.start.imply("hour", 22);
+                result.start.imply("meridiem", 1);
+            }
+            else if (time2 == "凌") {
+                result.start.imply("hour", 0);
+            }
+        }
+        else if (match[DAY_GROUP_3]) {
+            const day3 = match[DAY_GROUP_3];
+            if (day3 == "明" || day3 == "聽") {
+                if (refMoment.hour() > 1) {
+                    startMoment = startMoment.add(1, "day");
+                }
+            }
+            else if (day3 == "昨" || day3 == "尋" || day3 == "琴") {
+                startMoment = startMoment.add(-1, "day");
+            }
+            else if (day3 == "前") {
+                startMoment = startMoment.add(-2, "day");
+            }
+            else if (day3 == "大前") {
+                startMoment = startMoment.add(-3, "day");
+            }
+            else if (day3 == "後") {
+                startMoment = startMoment.add(2, "day");
+            }
+            else if (day3 == "大後") {
+                startMoment = startMoment.add(3, "day");
+            }
+            const timeString3 = match[TIME_GROUP_3];
+            if (timeString3) {
+                const time3 = timeString3[0];
+                if (time3 == "早" || time3 == "朝" || time3 == "上") {
+                    result.start.imply("hour", 6);
+                }
+                else if (time3 == "下" || time3 == "晏") {
+                    result.start.imply("hour", 15);
+                    result.start.imply("meridiem", 1);
+                }
+                else if (time3 == "中") {
+                    result.start.imply("hour", 12);
+                    result.start.imply("meridiem", 1);
+                }
+                else if (time3 == "夜" || time3 == "晚") {
+                    result.start.imply("hour", 22);
+                    result.start.imply("meridiem", 1);
+                }
+                else if (time3 == "凌") {
+                    result.start.imply("hour", 0);
+                }
+            }
+        }
+        result.start.assign("day", startMoment.date());
+        result.start.assign("month", startMoment.month() + 1);
+        result.start.assign("year", startMoment.year());
+        return result;
+    }
+}
+exports.default = ZHHantCasualDateParser;

package/dist/locales/zh/hant/parsers/ZHHantDateParser.d.ts

@@ -0,0 +1,6 @@
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+export default class ZHHantDateParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp;
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): import("../../../../results").ParsingResult;
+}

package/dist/locales/zh/hant/parsers/ZHHantDateParser.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dayjs_1 = __importDefault(require("dayjs"));
+const AbstractParserWithWordBoundary_1 = require("../../../../common/parsers/AbstractParserWithWordBoundary");
+const constants_1 = require("../constants");
+const YEAR_GROUP = 1;
+const MONTH_GROUP = 2;
+const DAY_GROUP = 3;
+class ZHHantDateParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return new RegExp("(" +
+            "\\d{2,4}|" +
+            "[" + Object.keys(constants_1.NUMBER).join("") + "]{4}|" +
+            "[" + Object.keys(constants_1.NUMBER).join("") + "]{2}" +
+            ")?" +
+            "(?:\\s*)" +
+            "(?:年)?" +
+            "(?:[\\s|,|，]*)" +
+            "(" +
+            "\\d{1,2}|" +
+            "[" + Object.keys(constants_1.NUMBER).join("") + "]{1,2}" +
+            ")" +
+            "(?:\\s*)" +
+            "(?:月)" +
+            "(?:\\s*)" +
+            "(" +
+            "\\d{1,2}|" +
+            "[" + Object.keys(constants_1.NUMBER).join("") + "]{1,2}" +
+            ")?" +
+            "(?:\\s*)" +
+            "(?:日|號)?");
+    }
+    innerExtract(context, match) {
+        const startMoment = dayjs_1.default(context.refDate);
+        const result = context.createParsingResult(match.index, match[0]);
+        let month = parseInt(match[MONTH_GROUP]);
+        if (isNaN(month))
+            month = constants_1.zhStringToNumber(match[MONTH_GROUP]);
+        result.start.assign("month", month);
+        if (match[DAY_GROUP]) {
+            let day = parseInt(match[DAY_GROUP]);
+            if (isNaN(day))
+                day = constants_1.zhStringToNumber(match[DAY_GROUP]);
+            result.start.assign("day", day);
+        }
+        else {
+            result.start.imply("day", startMoment.date());
+        }
+        if (match[YEAR_GROUP]) {
+            let year = parseInt(match[YEAR_GROUP]);
+            if (isNaN(year))
+                year = constants_1.zhStringToYear(match[YEAR_GROUP]);
+            result.start.assign("year", year);
+        }
+        else {
+            result.start.imply("year", startMoment.year());
+        }
+        return result;
+    }
+}
+exports.default = ZHHantDateParser;

package/dist/locales/zh/hant/parsers/ZHHantDeadlineFormatParser.d.ts

@@ -0,0 +1,6 @@
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+export default class ZHHantDeadlineFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp;
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): import("../../../../results").ParsingResult;
+}

package/dist/locales/zh/hant/parsers/ZHHantDeadlineFormatParser.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dayjs_1 = __importDefault(require("dayjs"));
+const AbstractParserWithWordBoundary_1 = require("../../../../common/parsers/AbstractParserWithWordBoundary");
+const constants_1 = require("../constants");
+const PATTERN = new RegExp("(\\d+|[" +
+    Object.keys(constants_1.NUMBER).join("") +
+    "]+|半|幾)(?:\\s*)" +
+    "(?:個)?" +
+    "(秒(?:鐘)?|分鐘|小時|鐘|日|天|星期|禮拜|月|年)" +
+    "(?:(?:之|過)?後|(?:之)?內)", "i");
+const NUMBER_GROUP = 1;
+const UNIT_GROUP = 2;
+class ZHHantDeadlineFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return PATTERN;
+    }
+    innerExtract(context, match) {
+        const result = context.createParsingResult(match.index, match[0]);
+        let number = parseInt(match[NUMBER_GROUP]);
+        if (isNaN(number)) {
+            number = constants_1.zhStringToNumber(match[NUMBER_GROUP]);
+        }
+        if (isNaN(number)) {
+            const string = match[NUMBER_GROUP];
+            if (string === "幾") {
+                number = 3;
+            }
+            else if (string === "半") {
+                number = 0.5;
+            }
+            else {
+                return null;
+            }
+        }
+        let date = dayjs_1.default(context.refDate);
+        const unit = match[UNIT_GROUP];
+        const unitAbbr = unit[0];
+        if (unitAbbr.match(/[日天星禮月年]/)) {
+            if (unitAbbr == "日" || unitAbbr == "天") {
+                date = date.add(number, "d");
+            }
+            else if (unitAbbr == "星" || unitAbbr == "禮") {
+                date = date.add(number * 7, "d");
+            }
+            else if (unitAbbr == "月") {
+                date = date.add(number, "month");
+            }
+            else if (unitAbbr == "年") {
+                date = date.add(number, "year");
+            }
+            result.start.assign("year", date.year());
+            result.start.assign("month", date.month() + 1);
+            result.start.assign("day", date.date());
+            return result;
+        }
+        if (unitAbbr == "秒") {
+            date = date.add(number, "second");
+        }
+        else if (unitAbbr == "分") {
+            date = date.add(number, "minute");
+        }
+        else if (unitAbbr == "小" || unitAbbr == "鐘") {
+            date = date.add(number, "hour");
+        }
+        result.start.imply("year", date.year());
+        result.start.imply("month", date.month() + 1);
+        result.start.imply("day", date.date());
+        result.start.assign("hour", date.hour());
+        result.start.assign("minute", date.minute());
+        result.start.assign("second", date.second());
+        return result;
+    }
+}
+exports.default = ZHHantDeadlineFormatParser;

package/dist/locales/zh/hant/parsers/ZHHantRelationWeekdayParser.d.ts

@@ -0,0 +1,7 @@
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+import { ParsingResult } from "../../../../results";
+export default class ZHHantRelationWeekdayParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp;
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingResult;
+}

package/dist/locales/zh/hant/parsers/ZHHantRelationWeekdayParser.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dayjs_1 = __importDefault(require("dayjs"));
+const AbstractParserWithWordBoundary_1 = require("../../../../common/parsers/AbstractParserWithWordBoundary");
+const constants_1 = require("../constants");
+const PATTERN = new RegExp("(?<prefix>上|今|下|這|呢)(?:個)?(?:星期|禮拜|週)(?<weekday>" + Object.keys(constants_1.WEEKDAY_OFFSET).join("|") + ")");
+class ZHHantRelationWeekdayParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return PATTERN;
+    }
+    innerExtract(context, match) {
+        const result = context.createParsingResult(match.index, match[0]);
+        const dayOfWeek = match.groups.weekday;
+        const offset = constants_1.WEEKDAY_OFFSET[dayOfWeek];
+        if (offset === undefined)
+            return null;
+        let modifier = null;
+        const prefix = match.groups.prefix;
+        if (prefix == "上") {
+            modifier = "last";
+        }
+        else if (prefix == "下") {
+            modifier = "next";
+        }
+        else if (prefix == "今" || prefix == "這" || prefix == "呢") {
+            modifier = "this";
+        }
+        let startMoment = dayjs_1.default(context.refDate);
+        let startMomentFixed = false;
+        const refOffset = startMoment.day();
+        if (modifier == "last" || modifier == "past") {
+            startMoment = startMoment.day(offset - 7);
+            startMomentFixed = true;
+        }
+        else if (modifier == "next") {
+            startMoment = startMoment.day(offset + 7);
+            startMomentFixed = true;
+        }
+        else if (modifier == "this") {
+            startMoment = startMoment.day(offset);
+        }
+        else {
+            if (Math.abs(offset - 7 - refOffset) < Math.abs(offset - refOffset)) {
+                startMoment = startMoment.day(offset - 7);
+            }
+            else if (Math.abs(offset + 7 - refOffset) < Math.abs(offset - refOffset)) {
+                startMoment = startMoment.day(offset + 7);
+            }
+            else {
+                startMoment = startMoment.day(offset);
+            }
+        }
+        result.start.assign("weekday", offset);
+        if (startMomentFixed) {
+            result.start.assign("day", startMoment.date());
+            result.start.assign("month", startMoment.month() + 1);
+            result.start.assign("year", startMoment.year());
+        }
+        else {
+            result.start.imply("day", startMoment.date());
+            result.start.imply("month", startMoment.month() + 1);
+            result.start.imply("year", startMoment.year());
+        }
+        return result;
+    }
+}
+exports.default = ZHHantRelationWeekdayParser;

package/dist/locales/zh/hant/parsers/ZHHantTimeExpressionParser.d.ts

@@ -0,0 +1,6 @@
+import { ParsingContext } from "../../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../../common/parsers/AbstractParserWithWordBoundary";
+export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp;
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): import("../../../../results").ParsingResult;
+}