chrono-node 2.6.3 → 2.6.5

package/src/locales/uk/parsers/UKCasualDateParser.ts

@@ -0,0 +1,50 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents, ParsingResult } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import * as references from "../../../common/casualReferences";
+import { REGEX_PARTS } from "../constants";
+
+const PATTERN = new RegExp(
+    `(?:з|із|від)?\\s*(сьогодні|вчора|завтра|післязавтра|післяпіслязавтра|позапозавчора|позавчора)${REGEX_PARTS.rightBoundary}`,
+    REGEX_PARTS.flags
+);
+
+export default class UKCasualDateParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(context: ParsingContext): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult {
+        const lowerText = match[1].toLowerCase();
+        const component = context.createParsingComponents();
+
+        switch (lowerText) {
+            case "сьогодні":
+                return references.today(context.reference);
+
+            case "вчора":
+                return references.yesterday(context.reference);
+
+            case "завтра":
+                return references.tomorrow(context.reference);
+
+            case "післязавтра":
+                return references.theDayAfter(context.reference, 2);
+
+            case "післяпіслязавтра":
+                return references.theDayAfter(context.reference, 3);
+
+            case "позавчора":
+                return references.theDayBefore(context.reference, 2);
+
+            case "позапозавчора":
+                return references.theDayBefore(context.reference, 3);
+        }
+
+        return component;
+    }
+}

package/src/locales/uk/parsers/UKCasualTimeParser.ts

@@ -0,0 +1,59 @@
+import { ParsingContext } from "../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import * as references from "../../../common/casualReferences";
+import { assignSimilarDate } from "../../../utils/dayjs";
+import dayjs from "dayjs";
+import { REGEX_PARTS } from "../constants";
+
+const PATTERN = new RegExp(
+    `(зараз|минулого\\s*вечора|минулої\\s*ночі|наступної\\s*ночі|сьогодні\\s*вночі|цієї\\s*ночі|цього ранку|вранці|ранку|зранку|опівдні|ввечері|вечора|опівночі|вночі)` +
+        `${REGEX_PARTS.rightBoundary}`,
+    REGEX_PARTS.flags
+);
+export default class UKCasualTimeParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern() {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        let targetDate = dayjs(context.reference.instant);
+        const lowerText = match[0].toLowerCase();
+        const component = context.createParsingComponents();
+
+        if (lowerText === "зараз") {
+            return references.now(context.reference);
+        }
+        if (lowerText === "ввечері" || lowerText === "вечора") {
+            return references.evening(context.reference);
+        }
+        if (lowerText.endsWith("вранці") || lowerText.endsWith("ранку") || lowerText.endsWith("зранку")) {
+            return references.morning(context.reference);
+        }
+        if (lowerText.endsWith("опівдні")) {
+            return references.noon(context.reference);
+        }
+        if (lowerText.match(/минулої\s*ночі/)) {
+            return references.lastNight(context.reference);
+        }
+        if (lowerText.match(/минулого\s*вечора/)) {
+            return references.yesterdayEvening(context.reference);
+        }
+        if (lowerText.match(/наступної\s*ночі/)) {
+            const daysToAdd = targetDate.hour() < 22 ? 1 : 2;
+            targetDate = targetDate.add(daysToAdd, "day");
+            assignSimilarDate(component, targetDate);
+            component.imply("hour", 1);
+        }
+        if (lowerText.match(/цієї\s*ночі/)) {
+            return references.midnight(context.reference);
+        }
+        if (lowerText.endsWith("опівночі") || lowerText.endsWith("вночі")) {
+            return references.midnight(context.reference);
+        }
+        return component;
+    }
+}

package/src/locales/uk/parsers/UKMonthNameLittleEndianParser.ts

@@ -0,0 +1,72 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingResult } from "../../../results";
+import { findYearClosestToRef } from "../../../calculation/years";
+import { MONTH_DICTIONARY, REGEX_PARTS } from "../constants";
+import { YEAR_PATTERN, parseYearPattern } from "../constants";
+import { ORDINAL_NUMBER_PATTERN, parseOrdinalNumberPattern } from "../constants";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+// prettier-ignore
+const PATTERN = new RegExp(
+    `(?:з|із)?\\s*(${ORDINAL_NUMBER_PATTERN})` +
+    `(?:` +
+    `\\s{0,3}(?:по|-|–|до)?\\s{0,3}` +
+    `(${ORDINAL_NUMBER_PATTERN})` +
+    `)?` +
+    `(?:-|\\/|\\s{0,3}(?:of)?\\s{0,3})` +
+    `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+    `(?:` +
+    `(?:-|\\/|,?\\s{0,3})` +
+    `(${YEAR_PATTERN}(?![^\\s]\\d))` +
+    `)?` +
+    `${REGEX_PARTS.rightBoundary}`,
+    REGEX_PARTS.flags
+);
+
+const DATE_GROUP = 1;
+const DATE_TO_GROUP = 2;
+const MONTH_NAME_GROUP = 3;
+const YEAR_GROUP = 4;
+
+export default class UKMonthNameLittleEndianParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingResult {
+        const result = context.createParsingResult(match.index, match[0]);
+
+        const month = MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];
+        const day = parseOrdinalNumberPattern(match[DATE_GROUP]);
+        if (day > 31) {
+            // e.g. "[96 Aug]" => "9[6 Aug]", we need to shift away from the next number
+            match.index = match.index + match[DATE_GROUP].length;
+            return null;
+        }
+
+        result.start.assign("month", month);
+        result.start.assign("day", day);
+
+        if (match[YEAR_GROUP]) {
+            const yearNumber = parseYearPattern(match[YEAR_GROUP]);
+            result.start.assign("year", yearNumber);
+        } else {
+            const year = findYearClosestToRef(context.reference.instant, day, month);
+            result.start.imply("year", year);
+        }
+
+        if (match[DATE_TO_GROUP]) {
+            const endDate = parseOrdinalNumberPattern(match[DATE_TO_GROUP]);
+
+            result.end = result.start.clone();
+            result.end.assign("day", endDate);
+        }
+
+        return result;
+    }
+}

package/src/locales/uk/parsers/UKMonthNameParser.ts

@@ -0,0 +1,61 @@
+import { FULL_MONTH_NAME_DICTIONARY, MONTH_DICTIONARY, REGEX_PARTS } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { findYearClosestToRef } from "../../../calculation/years";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { YEAR_PATTERN, parseYearPattern } from "../constants";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const PATTERN = new RegExp(
+    `((?:в|у)\\s*)?` +
+        `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+        `\\s*` +
+        `(?:` +
+        `[,-]?\\s*(${YEAR_PATTERN})?` +
+        `)?` +
+        `(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)`,
+    REGEX_PARTS.flags
+);
+
+const MONTH_NAME_GROUP = 2;
+const YEAR_GROUP = 3;
+
+/**
+ * The parser for parsing month name and year.
+ * - Cічень, 2012
+ * - Січень 2012
+ * - Січень
+ */
+export default class UkMonthNameParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const monthName = match[MONTH_NAME_GROUP].toLowerCase();
+
+        // skip some unlikely words "січ", "лют", ..
+        if (match[0].length <= 3 && !FULL_MONTH_NAME_DICTIONARY[monthName]) {
+            return null;
+        }
+
+        const result = context.createParsingResult(match.index, match.index + match[0].length);
+        result.start.imply("day", 1);
+
+        const month = MONTH_DICTIONARY[monthName];
+        result.start.assign("month", month);
+
+        if (match[YEAR_GROUP]) {
+            const year = parseYearPattern(match[YEAR_GROUP]);
+            result.start.assign("year", year);
+        } else {
+            const year = findYearClosestToRef(context.reference.instant, 1, month);
+            result.start.imply("year", year);
+        }
+
+        return result;
+    }
+}

package/src/locales/uk/parsers/UKRelativeDateFormatParser.ts

@@ -0,0 +1,85 @@
+import { REGEX_PARTS, TIME_UNIT_DICTIONARY } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import dayjs from "dayjs";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { matchAnyPattern } from "../../../utils/pattern";
+
+const PATTERN = new RegExp(
+    `(в минулому|у минулому|на минулому|минулого|на наступному|в наступному|у наступному|наступного|на цьому|в цьому|у цьому|цього)\\s*(${matchAnyPattern(
+        TIME_UNIT_DICTIONARY
+    )})(?=\\s*)${REGEX_PARTS.rightBoundary}`,
+    REGEX_PARTS.flags
+);
+
+const MODIFIER_WORD_GROUP = 1;
+const RELATIVE_WORD_GROUP = 2;
+
+export default class UKRelativeDateFormatParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const modifier = match[MODIFIER_WORD_GROUP].toLowerCase();
+        const unitWord = match[RELATIVE_WORD_GROUP].toLowerCase();
+        const timeunit = TIME_UNIT_DICTIONARY[unitWord];
+
+        if (
+            modifier == "на наступному" ||
+            modifier == "в наступному" ||
+            modifier == "у наступному" ||
+            modifier == "наступного"
+        ) {
+            const timeUnits = {};
+            timeUnits[timeunit] = 1;
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+        }
+
+        if (
+            modifier == "на минулому" ||
+            modifier == "в минулому" ||
+            modifier == "у минулому" ||
+            modifier == "минулого"
+        ) {
+            const timeUnits = {};
+            timeUnits[timeunit] = -1;
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+        }
+
+        const components = context.createParsingComponents();
+        let date = dayjs(context.reference.instant);
+
+        // This week
+        if (timeunit.match(/week/i)) {
+            date = date.add(-date.get("d"), "d");
+            components.imply("day", date.date());
+            components.imply("month", date.month() + 1);
+            components.imply("year", date.year());
+        }
+
+        // This month
+        else if (timeunit.match(/month/i)) {
+            date = date.add(-date.date() + 1, "d");
+            components.imply("day", date.date());
+            components.assign("year", date.year());
+            components.assign("month", date.month() + 1);
+        }
+
+        // This year
+        else if (timeunit.match(/year/i)) {
+            date = date.add(-date.date() + 1, "d");
+            date = date.add(-date.month(), "month");
+
+            components.imply("day", date.date());
+            components.imply("month", date.month() + 1);
+            components.assign("year", date.year());
+        }
+
+        return components;
+    }
+}

package/src/locales/uk/parsers/UKTimeExpressionParser.ts

@@ -0,0 +1,64 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { Meridiem } from "../../../types";
+import { AbstractTimeExpressionParser } from "../../../common/parsers/AbstractTimeExpressionParser";
+import { REGEX_PARTS } from "../constants";
+
+export default class UKTimeExpressionParser extends AbstractTimeExpressionParser {
+    constructor(strictMode) {
+        super(strictMode);
+    }
+
+    patternFlags(): string {
+        return REGEX_PARTS.flags;
+    }
+
+    primaryPatternLeftBoundary(): string {
+        return `(^|\\s|T|(?:[^\\p{L}\\p{N}_]))`;
+    }
+
+    followingPhase(): string {
+        return `\\s*(?:\\-|\\–|\\~|\\〜|до|і|по|\\?)\\s*`;
+    }
+
+    primaryPrefix(): string {
+        return `(?:(?:в|у|о|об|з|із|від)\\s*)??`;
+    }
+
+    primarySuffix(): string {
+        return `(?:\\s*(?:ранку|вечора|по обіді|після обіду))?(?!\\/)${REGEX_PARTS.rightBoundary}`;
+    }
+
+    extractPrimaryTimeComponents(context: ParsingContext, match: RegExpMatchArray): null | ParsingComponents {
+        const components = super.extractPrimaryTimeComponents(context, match);
+        if (components) {
+            if (match[0].endsWith("вечора")) {
+                const hour = components.get("hour");
+                if (hour >= 6 && hour < 12) {
+                    components.assign("hour", components.get("hour") + 12);
+                    components.assign("meridiem", Meridiem.PM);
+                } else if (hour < 6) {
+                    components.assign("meridiem", Meridiem.AM);
+                }
+            }
+
+            if (match[0].endsWith("по обіді") || match[0].endsWith("після обіду")) {
+                components.assign("meridiem", Meridiem.PM);
+                const hour = components.get("hour");
+                if (hour >= 0 && hour <= 6) {
+                    components.assign("hour", components.get("hour") + 12);
+                }
+            }
+
+            if (match[0].endsWith("ранку")) {
+                components.assign("meridiem", Meridiem.AM);
+                const hour = components.get("hour");
+                if (hour < 12) {
+                    components.assign("hour", components.get("hour"));
+                }
+            }
+        }
+
+        return components;
+    }
+}

package/src/locales/uk/parsers/UKTimeUnitAgoFormatParser.ts

@@ -0,0 +1,24 @@
+import { ParsingContext } from "../../../chrono";
+import { parseTimeUnits, REGEX_PARTS, TIME_UNITS_PATTERN } from "../constants";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { reverseTimeUnits } from "../../../utils/timeunits";
+
+const PATTERN = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}тому(?=(?:\\W|$))`, REGEX_PARTS.flags);
+
+export default class UKTimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const timeUnits = parseTimeUnits(match[1]);
+        const outputTimeUnits = reverseTimeUnits(timeUnits);
+
+        return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
+    }
+}

package/src/locales/uk/parsers/UKTimeUnitCasualRelativeFormatParser.ts

@@ -0,0 +1,34 @@
+import { TIME_UNITS_PATTERN, parseTimeUnits, REGEX_PARTS } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { reverseTimeUnits } from "../../../utils/timeunits";
+
+const PATTERN = new RegExp(
+    `(ці|останні|минулі|майбутні|наступні|після|через|\\+|-)\\s*(${TIME_UNITS_PATTERN})${REGEX_PARTS.rightBoundary}`,
+    REGEX_PARTS.flags
+);
+
+export default class UKTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const prefix = match[1].toLowerCase();
+        let timeUnits = parseTimeUnits(match[3]);
+        switch (prefix) {
+            case "останні":
+            case "минулі":
+            case "-":
+                timeUnits = reverseTimeUnits(timeUnits);
+                break;
+        }
+
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}

package/src/locales/uk/parsers/UKTimeUnitWithinFormatParser.ts

@@ -0,0 +1,27 @@
+import { TIME_UNITS_PATTERN, parseTimeUnits, REGEX_PARTS } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const PATTERN = `(?:(?:приблизно|орієнтовно)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})${REGEX_PARTS.rightBoundary}`;
+const PATTERN_WITH_PREFIX = new RegExp(
+    `(?:протягом|на протязі|протягом|упродовж|впродовж)\\s*${PATTERN}`,
+    REGEX_PARTS.flags
+);
+
+const PATTERN_WITHOUT_PREFIX = new RegExp(PATTERN, "i");
+
+export default class UKTimeUnitWithinFormatParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(context: ParsingContext): RegExp {
+        return context.option.forwardDate ? PATTERN_WITHOUT_PREFIX : PATTERN_WITH_PREFIX;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const timeUnits = parseTimeUnits(match[1]);
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}

package/src/locales/uk/parsers/UKWeekdayParser.ts

@@ -0,0 +1,59 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+// TODO: ADD REGEX_PARTS below
+import { REGEX_PARTS, WEEKDAY_DICTIONARY } from "../constants";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { createParsingComponentsAtWeekday } from "../../../common/calculation/weekdays";
+
+const PATTERN = new RegExp(
+    `(?:(?:,|\\(|（)\\s*)?` +
+        `(?:в\\s*?)?` +
+        `(?:у\\s*?)?` +
+        `(?:(цей|минулого|минулий|попередній|попереднього|наступного|наступний|наступному)\\s*)?` +
+        `(${matchAnyPattern(WEEKDAY_DICTIONARY)})` +
+        `(?:\\s*(?:,|\\)|）))?` +
+        `(?:\\s*(на|у|в)\\s*(цьому|минулому|наступному)\\s*тижні)?` +
+        `${REGEX_PARTS.rightBoundary}`,
+    REGEX_PARTS.flags
+);
+
+const PREFIX_GROUP = 1;
+const WEEKDAY_GROUP = 2;
+const POSTFIX_GROUP = 3;
+
+export default class UKWeekdayParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const dayOfWeek = match[WEEKDAY_GROUP].toLocaleLowerCase();
+        const weekday = WEEKDAY_DICTIONARY[dayOfWeek];
+        const prefix = match[PREFIX_GROUP];
+        const postfix = match[POSTFIX_GROUP];
+        let modifierWord = prefix || postfix;
+        modifierWord = modifierWord || "";
+        modifierWord = modifierWord.toLocaleLowerCase();
+
+        let modifier = null;
+        if (
+            modifierWord == "минулого" ||
+            modifierWord == "минулий" ||
+            modifierWord == "попередній" ||
+            modifierWord == "попереднього"
+        ) {
+            modifier = "last";
+        } else if (modifierWord == "наступного" || modifierWord == "наступний") {
+            modifier = "next";
+        } else if (modifierWord == "цей" || modifierWord == "цього" || modifierWord == "цьому") {
+            modifier = "this";
+        }
+
+        return createParsingComponentsAtWeekday(context.reference, weekday, modifier);
+    }
+}

package/src/locales/uk/refiners/UKMergeDateRangeRefiner.ts

@@ -0,0 +1,13 @@
+import AbstractMergeDateRangeRefiner from "../../../common/refiners/AbstractMergeDateRangeRefiner";
+
+/**
+ * Merging before and after results (see. AbstractMergeDateRangeRefiner)
+ * This implementation should provide Russian connecting phases
+ * - [з|із] 06.09.1989 [до|по] 11.12.1996
+ * - [з|із] п'ятниці і до середи
+ */
+export default class UKMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner {
+    patternBetween(): RegExp {
+        return /^\s*(і до|і по|до|по|-)\s*$/i;
+    }
+}

package/src/locales/uk/refiners/UKMergeDateTimeRefiner.ts

@@ -0,0 +1,13 @@
+import AbstractMergeDateTimeRefiner from "../../../common/refiners/AbstractMergeDateTimeRefiner";
+
+/**
+ * Merging date-only result and time-only result (see. AbstractMergeDateTimeRefiner).
+ * This implementation should provide Ukrainian connecting phases
+ * - 2020-02-13 [в/у/о] 6:00
+ * - Завтра [,] 7:00
+ */
+export default class UKMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner {
+    patternBetween(): RegExp {
+        return new RegExp(`^\\s*(T|в|у|о|,|-)?\\s*$`);
+    }
+}

package/src/locales/zh/hans/index.ts

@@ -2,10 +2,11 @@
  * Chrono components for zh support
  */
 
-import { Chrono, Configuration } from "../../../chrono";
 import ExtractTimezoneOffsetRefiner from "../../../common/refiners/ExtractTimezoneOffsetRefiner";
 import { includeCommonConfiguration } from "../../../configurations";
-import { ParsedResult, ParsingOption } from "../../../index";
+import { Chrono, Configuration, Parser, Refiner } from "../../../chrono";
+import { ParsingResult, ParsingComponents, ReferenceWithTimezone } from "../../../results";
+import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday } from "../../../types";
 import ZHHansCasualDateParser from "./parsers/ZHHansCasualDateParser";
 import ZHHansDateParser from "./parsers/ZHHansDateParser";
 import ZHHansDeadlineFormatParser from "./parsers/ZHHansDeadlineFormatParser";
@@ -15,6 +16,9 @@ import ZHHansWeekdayParser from "./parsers/ZHHansWeekdayParser";
 import ZHHansMergeDateRangeRefiner from "./refiners/ZHHansMergeDateRangeRefiner";
 import ZHHansMergeDateTimeRefiner from "./refiners/ZHHansMergeDateTimeRefiner";
 
+export { Chrono, Parser, Refiner, ParsingResult, ParsingComponents, ReferenceWithTimezone };
+export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday };
+
 // Shortcuts
 export const hans = new Chrono(createCasualConfiguration());
 

package/src/locales/zh/hant/index.ts

@@ -3,10 +3,11 @@
  * TODO: Complete general zh support (current support only zh-Hant)
  */
 
-import { Chrono, Configuration } from "../../../chrono";
 import ExtractTimezoneOffsetRefiner from "../../../common/refiners/ExtractTimezoneOffsetRefiner";
 import { includeCommonConfiguration } from "../../../configurations";
-import { ParsedResult, ParsingOption } from "../../../index";
+import { Chrono, Configuration, Parser, Refiner } from "../../../chrono";
+import { ParsingResult, ParsingComponents, ReferenceWithTimezone } from "../../../results";
+import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday } from "../../../types";
 import ZHHantCasualDateParser from "./parsers/ZHHantCasualDateParser";
 import ZHHantDateParser from "./parsers/ZHHantDateParser";
 import ZHHantDeadlineFormatParser from "./parsers/ZHHantDeadlineFormatParser";
@@ -16,6 +17,9 @@ import ZHHantWeekdayParser from "./parsers/ZHHantWeekdayParser";
 import ZHHantMergeDateRangeRefiner from "./refiners/ZHHantMergeDateRangeRefiner";
 import ZHHantMergeDateTimeRefiner from "./refiners/ZHHantMergeDateTimeRefiner";
 
+export { Chrono, Parser, Refiner, ParsingResult, ParsingComponents, ReferenceWithTimezone };
+export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday };
+
 // Shortcuts
 export const hant = new Chrono(createCasualConfiguration());
 

package/src/results.ts

@@ -1,4 +1,4 @@
-import { Component, ParsedComponents, ParsedResult, ParsingReference } from "./index";
+import { Component, ParsedComponents, ParsedResult, ParsingReference } from "./types";
 
 import quarterOfYear from "dayjs/plugin/quarterOfYear";
 import dayjs, { QUnitType } from "dayjs";

package/src/timezone.ts

@@ -1,5 +1,5 @@
 import dayjs from "dayjs";
-import { TimezoneAbbrMap, Weekday, Month } from "./index";
+import { TimezoneAbbrMap, Weekday, Month } from "./types";
 
 export const TIMEZONE_ABBR_MAP: TimezoneAbbrMap = {
     ACDT: 630,