chrono-node 2.6.2 → 2.6.4

package/dist/esm/utils/dayjs.js

@@ -1,4 +1,4 @@
-import { Meridiem } from "../index.js";
+import { Meridiem } from "../types.js";
 export function assignTheNextDay(component, targetDayJs) {
     targetDayJs = targetDayJs.add(1, "day");
     assignSimilarDate(component, targetDayJs);

package/package.json

@@ -15,7 +15,7 @@
     "preset": "ts-jest"
   },
   "license": "MIT",
-  "version": "2.6.2",
+  "version": "2.6.4",
   "directories": {
     "source": "./src",
     "test": "./test"
@@ -26,6 +26,14 @@
     ".": {
       "require": "./dist/cjs/index.js",
       "import": "./dist/esm/index.js"
+    },
+    "./*": {
+      "require": "./dist/cjs/locales/*/index.js",
+      "import": "./dist/esm/locales/*/index.js"
+    },
+    "./*/*": {
+      "require": "./dist/cjs/locales/*/*/index.js",
+      "import": "./dist/esm/locales/*/*/index.js"
     }
   },
   "engines": {
@@ -43,12 +51,12 @@
     "husky": "^4.2.5",
     "jest": "^26.1.0",
     "prettier": "^2.0.5",
+    "rimraf": "^3.0.2",
     "run-script-os": "^1.1.6",
     "ts-jest": "^26.1.1",
     "tsc-esm-fix": "^2.12.4",
     "typedoc": "^0.20.36",
-    "typescript": "~4.2.4",
-    "rimraf": "^3.0.2"
+    "typescript": "~4.2.4"
   },
   "husky": {
     "hooks": {
@@ -71,8 +79,7 @@
     "prettier:test": "prettier --write test --loglevel=warn",
     "watch": "jest --watch",
     "test": "jest --coverage",
-    "test:silent": "jest --silent",
-    "coveralls": "npm run test && cat coverage/lcov.info | coveralls"
+    "test:silent": "jest --silent"
   },
   "dependencies": {
     "dayjs": "^1.10.0"

package/src/calculation/mergingCalculation.ts

@@ -1,5 +1,5 @@
 import { ParsingComponents, ParsingResult } from "../results";
-import { Meridiem } from "../index";
+import { Meridiem } from "../types";
 import { assignSimilarDate, implySimilarDate } from "../utils/dayjs";
 
 export function mergeDateTimeResult(dateResult: ParsingResult, timeResult: ParsingResult): ParsingResult {

package/src/chrono.ts

@@ -1,7 +1,7 @@
 import { ReferenceWithTimezone, ParsingComponents, ParsingResult } from "./results";
-import { Component, ParsedResult, ParsingOption, ParsingReference } from "./index";
+import { Component, ParsedResult, ParsingOption, ParsingReference } from "./types";
 import { AsyncDebugBlock, DebugHandler } from "./debugging";
-import { createCasualConfiguration } from "./locales/en";
+import ENDefaultConfiguration from "./locales/en/configuration";
 
 /**
  * Chrono configuration.
@@ -13,7 +13,7 @@ export interface Configuration {
 }
 
 /**
- * A abstraction for Chrono *Parser*.
+ * An abstraction for Chrono *Parser*.
  *
  * Each parser should recognize and handle a certain date format.
  * Chrono uses multiple parses (and refiners) together for parsing the input.
@@ -48,8 +48,10 @@ export class Chrono {
     parsers: Array<Parser>;
     refiners: Array<Refiner>;
 
+    defaultConfig = new ENDefaultConfiguration();
+
     constructor(configuration?: Configuration) {
-        configuration = configuration || createCasualConfiguration();
+        configuration = configuration || this.defaultConfig.createCasualConfiguration();
         this.parsers = [...configuration.parsers];
         this.refiners = [...configuration.refiners];
     }
@@ -108,7 +110,7 @@ export class Chrono {
 
             const result = parser.extract(context, match);
             if (!result) {
-                // If fail, move on by 1
+                // If fails, move on by 1
                 remainingText = originalText.substring(match.index + 1);
                 match = pattern.exec(remainingText);
                 continue;
@@ -124,10 +126,14 @@ export class Chrono {
                 parsedResult = context.createParsingResult(match.index, match[0], result);
             }
 
-            context.debug(() => console.log(`${parser.constructor.name} extracted result ${parsedResult}`));
+            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(index + parsedResult.text.length);
+            remainingText = originalText.substring(parsedIndex + parsedText.length);
             match = pattern.exec(remainingText);
         }
 
@@ -141,7 +147,7 @@ export class ParsingContext implements DebugHandler {
     readonly reference: ReferenceWithTimezone;
 
     /**
-     * @deprecated. Use reference.instant instead.
+     * @deprecated. Use `reference.instant` instead.
      */
     readonly refDate: Date;
 

package/src/common/calculation/weekdays.ts

@@ -1,4 +1,4 @@
-import { Weekday } from "../../index";
+import { Weekday } from "../../types";
 import { ParsingComponents, ReferenceWithTimezone } from "../../results";
 import { addImpliedTimeUnits } from "../../utils/timeunits";
 

package/src/common/casualReferences.ts

@@ -7,7 +7,7 @@ import {
     implySimilarTime,
     implyTheNextDay,
 } from "../utils/dayjs";
-import { Meridiem } from "../index";
+import { Meridiem } from "../types";
 
 export function now(reference: ReferenceWithTimezone): ParsingComponents {
     const targetDate = dayjs(reference.instant);

package/src/common/parsers/AbstractParserWithWordBoundary.ts

@@ -1,6 +1,6 @@
 import { Parser, ParsingContext } from "../../chrono";
 import { ParsingComponents, ParsingResult } from "../../results";
-import { Component } from "../../index";
+import { Component } from "../../types";
 
 /**
  *

package/src/common/parsers/AbstractTimeExpressionParser.ts

@@ -1,6 +1,6 @@
 import { Parser, ParsingContext } from "../../chrono";
 import { ParsingComponents, ParsingResult } from "../../results";
-import { Meridiem } from "../../index";
+import { Meridiem } from "../../types";
 
 // prettier-ignore
 function primaryTimePattern(leftBoundary: string, primaryPrefix: string, primarySuffix: string, flags: string) {

package/src/common/parsers/ISOFormatParser.ts

@@ -1,5 +1,5 @@
 import { ParsingContext } from "../../chrono";
-import { Component } from "../../index";
+import { Component } from "../../types";
 import { AbstractParserWithWordBoundaryChecking } from "./AbstractParserWithWordBoundary";
 
 // ISO 8601

package/src/common/refiners/AbstractMergeDateRangeRefiner.ts

@@ -16,13 +16,13 @@ export default abstract class AbstractMergeDateRangeRefiner extends MergingRefin
         if (!fromResult.start.isOnlyWeekdayComponent() && !toResult.start.isOnlyWeekdayComponent()) {
             toResult.start.getCertainComponents().forEach((key) => {
                 if (!fromResult.start.isCertain(key)) {
-                    fromResult.start.assign(key, toResult.start.get(key));
+                    fromResult.start.imply(key, toResult.start.get(key));
                 }
             });
 
             fromResult.start.getCertainComponents().forEach((key) => {
                 if (!toResult.start.isCertain(key)) {
-                    toResult.start.assign(key, fromResult.start.get(key));
+                    toResult.start.imply(key, fromResult.start.get(key));
                 }
             });
         }
@@ -30,17 +30,22 @@ export default abstract class AbstractMergeDateRangeRefiner extends MergingRefin
         if (fromResult.start.date().getTime() > toResult.start.date().getTime()) {
             let fromMoment = fromResult.start.dayjs();
             let toMoment = toResult.start.dayjs();
-
-            if (fromResult.start.isOnlyWeekdayComponent() && fromMoment.add(-7, "days").isBefore(toMoment)) {
+            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.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);
+            } 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];
             }

package/src/common/refiners/ExtractTimezoneAbbrRefiner.ts

@@ -1,208 +1,13 @@
 // Map ABBR -> Offset in minute
 import { ParsingContext, Refiner } from "../../chrono";
+import { TimezoneAbbrMap } from "../../types";
 import { ParsingResult } from "../../results";
+import { toTimezoneOffset } from "../../timezone";
 
 const TIMEZONE_NAME_PATTERN = new RegExp("^\\s*,?\\s*\\(?([A-Z]{2,4})\\)?(?=\\W|$)", "i");
-const DEFAULT_TIMEZONE_ABBR_MAP = {
-    ACDT: 630,
-    ACST: 570,
-    ADT: -180,
-    AEDT: 660,
-    AEST: 600,
-    AFT: 270,
-    AKDT: -480,
-    AKST: -540,
-    ALMT: 360,
-    AMST: -180,
-    AMT: -240,
-    ANAST: 720,
-    ANAT: 720,
-    AQTT: 300,
-    ART: -180,
-    AST: -240,
-    AWDT: 540,
-    AWST: 480,
-    AZOST: 0,
-    AZOT: -60,
-    AZST: 300,
-    AZT: 240,
-    BNT: 480,
-    BOT: -240,
-    BRST: -120,
-    BRT: -180,
-    BST: 60,
-    BTT: 360,
-    CAST: 480,
-    CAT: 120,
-    CCT: 390,
-    CDT: -300,
-    CEST: 120,
-    CET: 60,
-    CHADT: 825,
-    CHAST: 765,
-    CKT: -600,
-    CLST: -180,
-    CLT: -240,
-    COT: -300,
-    CST: -360,
-    CVT: -60,
-    CXT: 420,
-    ChST: 600,
-    DAVT: 420,
-    EASST: -300,
-    EAST: -360,
-    EAT: 180,
-    ECT: -300,
-    EDT: -240,
-    EEST: 180,
-    EET: 120,
-    EGST: 0,
-    EGT: -60,
-    EST: -300,
-    ET: -300,
-    FJST: 780,
-    FJT: 720,
-    FKST: -180,
-    FKT: -240,
-    FNT: -120,
-    GALT: -360,
-    GAMT: -540,
-    GET: 240,
-    GFT: -180,
-    GILT: 720,
-    GMT: 0,
-    GST: 240,
-    GYT: -240,
-    HAA: -180,
-    HAC: -300,
-    HADT: -540,
-    HAE: -240,
-    HAP: -420,
-    HAR: -360,
-    HAST: -600,
-    HAT: -90,
-    HAY: -480,
-    HKT: 480,
-    HLV: -210,
-    HNA: -240,
-    HNC: -360,
-    HNE: -300,
-    HNP: -480,
-    HNR: -420,
-    HNT: -150,
-    HNY: -540,
-    HOVT: 420,
-    ICT: 420,
-    IDT: 180,
-    IOT: 360,
-    IRDT: 270,
-    IRKST: 540,
-    IRKT: 540,
-    IRST: 210,
-    IST: 330,
-    JST: 540,
-    KGT: 360,
-    KRAST: 480,
-    KRAT: 480,
-    KST: 540,
-    KUYT: 240,
-    LHDT: 660,
-    LHST: 630,
-    LINT: 840,
-    MAGST: 720,
-    MAGT: 720,
-    MART: -510,
-    MAWT: 300,
-    MDT: -360,
-    MESZ: 120,
-    MEZ: 60,
-    MHT: 720,
-    MMT: 390,
-    MSD: 240,
-    MSK: 240,
-    MST: -420,
-    MUT: 240,
-    MVT: 300,
-    MYT: 480,
-    NCT: 660,
-    NDT: -90,
-    NFT: 690,
-    NOVST: 420,
-    NOVT: 360,
-    NPT: 345,
-    NST: -150,
-    NUT: -660,
-    NZDT: 780,
-    NZST: 720,
-    OMSST: 420,
-    OMST: 420,
-    PDT: -420,
-    PET: -300,
-    PETST: 720,
-    PETT: 720,
-    PGT: 600,
-    PHOT: 780,
-    PHT: 480,
-    PKT: 300,
-    PMDT: -120,
-    PMST: -180,
-    PONT: 660,
-    PST: -480,
-    PT: -480,
-    PWT: 540,
-    PYST: -180,
-    PYT: -240,
-    RET: 240,
-    SAMT: 240,
-    SAST: 120,
-    SBT: 660,
-    SCT: 240,
-    SGT: 480,
-    SRT: -180,
-    SST: -660,
-    TAHT: -600,
-    TFT: 300,
-    TJT: 300,
-    TKT: 780,
-    TLT: 540,
-    TMT: 300,
-    TVT: 720,
-    ULAT: 480,
-    UTC: 0,
-    UYST: -120,
-    UYT: -180,
-    UZT: 300,
-    VET: -210,
-    VLAST: 660,
-    VLAT: 660,
-    VUT: 660,
-    WAST: 120,
-    WAT: 60,
-    WEST: 60,
-    WESZ: 60,
-    WET: 0,
-    WEZ: 0,
-    WFT: 720,
-    WGST: -120,
-    WGT: -180,
-    WIB: 420,
-    WIT: 540,
-    WITA: 480,
-    WST: 780,
-    WT: 0,
-    YAKST: 600,
-    YAKT: 600,
-    YAPT: 600,
-    YEKST: 360,
-    YEKT: 360,
-};
 
 export default class ExtractTimezoneAbbrRefiner implements Refiner {
-    private readonly timezone: { string: number };
-
-    constructor(timezoneOverrides?: { string: number }) {
-        this.timezone = { ...DEFAULT_TIMEZONE_ABBR_MAP, ...timezoneOverrides };
-    }
+    constructor(private readonly timezoneOverrides?: TimezoneAbbrMap) {}
 
     refine(context: ParsingContext, results: ParsingResult[]): ParsingResult[] {
         const timezoneOverrides = context.option.timezones ?? {};
@@ -215,11 +20,12 @@ export default class ExtractTimezoneAbbrRefiner implements Refiner {
             }
 
             const timezoneAbbr = match[1].toUpperCase();
-            const extractedTimezoneOffset = timezoneOverrides[timezoneAbbr] ?? this.timezone[timezoneAbbr] ?? null;
-            if (extractedTimezoneOffset === null) {
+            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}`

package/src/common/refiners/ForwardDateRefiner.ts

@@ -30,22 +30,6 @@ export default class ForwardDateRefiner implements Refiner {
                 }
             }
 
-            if (result.start.isOnlyDayMonthComponent() && refMoment.isAfter(result.start.dayjs())) {
-                for (let i = 0; i < 3 && refMoment.isAfter(result.start.dayjs()); i++) {
-                    result.start.imply("year", result.start.get("year") + 1);
-                    context.debug(() => {
-                        console.log(`Forward yearly adjusted for ${result} (${result.start})`);
-                    });
-
-                    if (result.end && !result.end.isCertain("year")) {
-                        result.end.imply("year", result.end.get("year") + 1);
-                        context.debug(() => {
-                            console.log(`Forward yearly adjusted for ${result} (${result.end})`);
-                        });
-                    }
-                }
-            }
-
             if (result.start.isOnlyWeekdayComponent() && refMoment.isAfter(result.start.dayjs())) {
                 if (refMoment.day() >= result.start.get("weekday")) {
                     refMoment = refMoment.day(result.start.get("weekday") + 7);
@@ -76,6 +60,24 @@ export default class ForwardDateRefiner implements Refiner {
                     });
                 }
             }
+
+            // In case where we know the month, but not which year (e.g. "in December", "25th December"),
+            // try move to another year
+            if (result.start.isDateWithUnknownYear() && refMoment.isAfter(result.start.dayjs())) {
+                for (let i = 0; i < 3 && refMoment.isAfter(result.start.dayjs()); i++) {
+                    result.start.imply("year", result.start.get("year") + 1);
+                    context.debug(() => {
+                        console.log(`Forward yearly adjusted for ${result} (${result.start})`);
+                    });
+
+                    if (result.end && !result.end.isCertain("year")) {
+                        result.end.imply("year", result.end.get("year") + 1);
+                        context.debug(() => {
+                            console.log(`Forward yearly adjusted for ${result} (${result.end})`);
+                        });
+                    }
+                }
+            }
         });
 
         return results;

package/src/configurations.ts

@@ -12,10 +12,12 @@ export function includeCommonConfiguration(configuration: Configuration, strictM
     configuration.parsers.unshift(new ISOFormatParser());
 
     configuration.refiners.unshift(new MergeWeekdayComponentRefiner());
-    configuration.refiners.unshift(new ExtractTimezoneAbbrRefiner());
     configuration.refiners.unshift(new ExtractTimezoneOffsetRefiner());
     configuration.refiners.unshift(new OverlapRemovalRefiner());
 
+    // Unlike ExtractTimezoneOffsetRefiner, this refiner relies on knowing both date and time in cases where the tz
+    // is ambiguous (in terms of DST/non-DST). It therefore needs to be applied as late as possible in the parsing.
+    configuration.refiners.push(new ExtractTimezoneAbbrRefiner());
     configuration.refiners.push(new OverlapRemovalRefiner());
     configuration.refiners.push(new ForwardDateRefiner());
     configuration.refiners.push(new UnlikelyFormatFilter(strictMode));

package/src/index.ts

@@ -1,114 +1,11 @@
 import { DebugHandler, DebugConsume } from "./debugging";
 import * as en from "./locales/en";
 import { Chrono, Parser, Refiner } from "./chrono";
-import type { ParsingResult } from "./results";
+import { ParsingResult } from "./results";
+import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday } from "./types";
 
 export { en, Chrono, Parser, Refiner, ParsingResult };
-
-export interface ParsingOption {
-    /**
-     * To parse only forward dates (the results should be after the reference date).
-     * This effects date/time implication (e.g. weekday or time mentioning)
-     */
-    forwardDate?: boolean;
-
-    /**
-     * Additional timezone keywords for the parsers to recognize
-     */
-    timezones?: { [tzKeyword: string]: number };
-
-    /**
-     * Internal debug event handler.
-     * @internal
-     */
-    debug?: DebugHandler | DebugConsume;
-}
-
-export interface ParsingReference {
-    /**
-     * Reference date. The instant (JavaScript Date object) when the input is written or mention.
-     * This effect date/time implication (e.g. weekday or time mentioning).
-     * (default = now)
-     */
-    instant?: Date;
-
-    /**
-     * Reference timezone. The timezone where the input is written or mention.
-     * Date/time implication will account the difference between input timezone and the current system timezone.
-     * (default = current timezone)
-     */
-    timezone?: string | number;
-}
-
-/**
- * Parsed result or final output.
- * Each result object represents a date/time (or date/time-range) mentioning in the input.
- */
-export interface ParsedResult {
-    readonly refDate: Date;
-    readonly index: number;
-    readonly text: string;
-
-    readonly start: ParsedComponents;
-    readonly end?: ParsedComponents;
-
-    /**
-     * Create a javascript date object (from the result.start).
-     */
-    date(): Date;
-}
-
-/**
- * A collection of parsed date/time components (e.g. day, hour, minute, ..., etc).
- *
- * Each parsed component has three different levels of certainty.
- * - *Certain* (or *Known*): The component is directly mentioned and parsed.
- * - *Implied*: The component is not directly mentioned, but implied by other parsed information.
- * - *Unknown*: Completely no mention of the component.
- */
-export interface ParsedComponents {
-    /**
-     * Check the component certainly if the component is *Certain* (or *Known*)
-     */
-    isCertain(component: Component): boolean;
-
-    /**
-     * Get the component value for either *Certain* or *Implied* value.
-     */
-    get(component: Component): number | null;
-
-    /**
-     * @return a javascript date object.
-     */
-    date(): Date;
-}
-
-export type Component =
-    | "year"
-    | "month"
-    | "day"
-    | "weekday"
-    | "hour"
-    | "minute"
-    | "second"
-    | "millisecond"
-    | "meridiem"
-    | "timezoneOffset";
-
-export enum Meridiem {
-    AM = 0,
-    PM = 1,
-}
-
-export enum Weekday {
-    SUNDAY = 0,
-    MONDAY = 1,
-    TUESDAY = 2,
-    WEDNESDAY = 3,
-    THURSDAY = 4,
-    FRIDAY = 5,
-    SATURDAY = 6,
-}
+export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday };
 
 // Export all locales
 import * as de from "./locales/de";
@@ -119,7 +16,9 @@ import * as nl from "./locales/nl";
 import * as zh from "./locales/zh";
 import * as ru from "./locales/ru";
 import * as es from "./locales/es";
-export { de, fr, ja, pt, nl, zh, ru, es };
+import * as uk from "./locales/uk";
+
+export { de, fr, ja, pt, nl, zh, ru, es, uk };
 
 /**
  * A shortcut for {@link en | chrono.en.strict}

package/src/locales/de/index.ts

@@ -1,6 +1,7 @@
 import { includeCommonConfiguration } from "../../configurations";
-import { ParsedResult, ParsingOption } from "../../index";
-import { Chrono, Configuration } from "../../chrono";
+import { Chrono, Configuration, Parser, Refiner } from "../../chrono";
+import { ParsingResult } from "../../results";
+import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday } from "../../types";
 import SlashDateFormatParser from "../../common/parsers/SlashDateFormatParser";
 import ISOFormatParser from "../../common/parsers/ISOFormatParser";
 import DETimeExpressionParser from "./parsers/DETimeExpressionParser";
@@ -14,6 +15,9 @@ import DEMonthNameLittleEndianParser from "./parsers/DEMonthNameLittleEndianPars
 import DETimeUnitRelativeFormatParser from "./parsers/DETimeUnitRelativeFormatParser";
 import DETimeUnitWithinFormatParser from "./parsers/DETimeUnitWithinFormatParser";
 
+export { Chrono, Parser, Refiner, ParsingResult };
+export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday };
+
 // Shortcuts
 export const casual = new Chrono(createCasualConfiguration());
 export const strict = new Chrono(createConfiguration(true));

package/src/locales/de/parsers/DECasualTimeParser.ts

@@ -1,7 +1,7 @@
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents, ParsingResult } from "../../../results";
 import dayjs from "dayjs";
-import { Meridiem } from "../../../index";
+import { Meridiem } from "../../../types";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { implySimilarTime } from "../../../utils/dayjs";
 import { addImpliedTimeUnits } from "../../../utils/timeunits";

package/src/locales/de/parsers/DESpecificTimeExpressionParser.ts

@@ -1,6 +1,6 @@
 import { Parser, ParsingContext } from "../../../chrono";
 import { ParsingComponents, ParsingResult } from "../../../results";
-import { Meridiem } from "../../../index";
+import { Meridiem } from "../../../types";
 
 /**
  * 8h10m00s