chrono-node 2.8.3 → 2.8.5

package/src/common/refiners/AbstractMergeDateRangeRefiner.ts

@@ -4,6 +4,7 @@
 
 import { ParsingResult } from "../../results";
 import { MergingRefiner } from "../abstractRefiners";
+import { addDuration } from "../../calculation/duration";
 
 export default abstract class AbstractMergeDateRangeRefiner extends MergingRefiner {
     abstract patternBetween(): RegExp;
@@ -26,31 +27,30 @@ export default abstract class AbstractMergeDateRangeRefiner extends MergingRefin
                 }
             });
         }
+        if (fromResult.start.date() > toResult.start.date()) {
+            let fromDate = fromResult.start.date();
+            let toDate = toResult.start.date();
 
-        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());
+            if (toResult.start.isOnlyWeekdayComponent() && addDuration(toDate, { day: 7 }) > fromDate) {
+                toDate = addDuration(toDate, { day: 7 });
+                toResult.start.imply("day", toDate.getDate());
+                toResult.start.imply("month", toDate.getMonth() + 1);
+                toResult.start.imply("year", toDate.getFullYear());
+            } else if (fromResult.start.isOnlyWeekdayComponent() && addDuration(fromDate, { day: -7 }) < toDate) {
+                fromDate = addDuration(fromDate, { day: -7 });
+                fromResult.start.imply("day", fromDate.getDate());
+                fromResult.start.imply("month", fromDate.getMonth() + 1);
+                fromResult.start.imply("year", fromDate.getFullYear());
+            } else if (toResult.start.isDateWithUnknownYear() && addDuration(toDate, { year: 1 }) > fromDate) {
+                toDate = addDuration(toDate, { year: 1 });
+                toResult.start.imply("year", toDate.getFullYear());
+            } else if (fromResult.start.isDateWithUnknownYear() && addDuration(fromDate, { year: -1 }) < toDate) {
+                fromDate = addDuration(fromDate, { year: -1 });
+                fromResult.start.imply("year", fromDate.getFullYear());
             } else {
                 [toResult, fromResult] = [fromResult, toResult];
             }
         }
-
         const result = fromResult.clone();
         result.start = fromResult.start;
         result.end = toResult.start;
@@ -60,7 +60,6 @@ export default abstract class AbstractMergeDateRangeRefiner extends MergingRefin
         } else {
             result.text = toResult.text + textBetween + fromResult.text;
         }
-
         return result;
     }
 }

package/src/common/refiners/ForwardDateRefiner.ts

@@ -6,8 +6,9 @@
 
 import { ParsingContext, Refiner } from "../../chrono";
 import { ParsingResult } from "../../results";
-import dayjs from "dayjs";
 import * as dates from "../../utils/dates";
+import { implySimilarDate } from "../../utils/dates";
+import { addDuration } from "../../calculation/duration";
 
 export default class ForwardDateRefiner implements Refiner {
     refine(context: ParsingContext, results: ParsingResult[]): ParsingResult[] {
@@ -16,7 +17,7 @@ export default class ForwardDateRefiner implements Refiner {
         }
 
         results.forEach((result) => {
-            let refMoment = dayjs(context.reference.getDateWithAdjustedTimezone());
+            let refDate = context.reference.getDateWithAdjustedTimezone();
 
             if (result.start.isOnlyTime() && context.reference.instant > result.start.date()) {
                 const refDate = context.reference.getDateWithAdjustedTimezone();
@@ -38,31 +39,25 @@ export default class ForwardDateRefiner implements Refiner {
                 }
             }
 
-            if (result.start.isOnlyWeekdayComponent() && refMoment.isAfter(result.start.dayjs())) {
-                if (refMoment.day() >= result.start.get("weekday")) {
-                    refMoment = refMoment.day(result.start.get("weekday") + 7);
-                } else {
-                    refMoment = refMoment.day(<number>result.start.get("weekday"));
+            if (result.start.isOnlyWeekdayComponent() && refDate > result.start.date()) {
+                let daysToAdd = result.start.get("weekday") - refDate.getDay();
+                if (daysToAdd <= 0) {
+                    daysToAdd += 7;
                 }
-
-                result.start.imply("day", refMoment.date());
-                result.start.imply("month", refMoment.month() + 1);
-                result.start.imply("year", refMoment.year());
+                refDate = addDuration(refDate, { day: daysToAdd });
+                implySimilarDate(result.start, refDate);
                 context.debug(() => {
                     console.log(`${this.constructor.name} adjusted ${result} weekday (${result.start})`);
                 });
 
                 if (result.end && result.end.isOnlyWeekdayComponent()) {
                     // Adjust date to the coming week
-                    if (refMoment.day() > result.end.get("weekday")) {
-                        refMoment = refMoment.day(result.end.get("weekday") + 7);
-                    } else {
-                        refMoment = refMoment.day(<number>result.end.get("weekday"));
+                    let daysToAdd = result.end.get("weekday") - refDate.getDay();
+                    if (daysToAdd <= 0) {
+                        daysToAdd += 7;
                     }
-
-                    result.end.imply("day", refMoment.date());
-                    result.end.imply("month", refMoment.month() + 1);
-                    result.end.imply("year", refMoment.year());
+                    refDate = addDuration(refDate, { day: daysToAdd });
+                    implySimilarDate(result.end, refDate);
                     context.debug(() => {
                         console.log(`${this.constructor.name} adjusted ${result} weekday (${result.end})`);
                     });
@@ -70,9 +65,9 @@ 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++) {
+            // try move to another year (up-to 3 times)
+            if (result.start.isDateWithUnknownYear() && refDate > result.start.date()) {
+                for (let i = 0; i < 3 && refDate > result.start.date(); i++) {
                     result.start.imply("year", result.start.get("year") + 1);
                     context.debug(() => {
                         console.log(`${this.constructor.name} adjusted ${result} year (${result.start})`);

package/src/index.ts

@@ -16,8 +16,10 @@ import * as zh from "./locales/zh";
 import * as ru from "./locales/ru";
 import * as es from "./locales/es";
 import * as uk from "./locales/uk";
+import * as it from "./locales/it";
+import * as sv from "./locales/sv";
 
-export { de, fr, ja, pt, nl, zh, ru, es, uk };
+export { de, fr, ja, pt, nl, zh, ru, es, uk, it, sv };
 
 /**
  * A shortcut for {@link en | chrono.en.strict}

package/src/locales/de/constants.ts

@@ -1,7 +1,7 @@
-import { OpUnitType, QUnitType } from "dayjs";
 import { matchAnyPattern, repeatedTimeunitPattern } from "../../utils/pattern";
 import { findMostLikelyADYear } from "../../calculation/years";
-import { TimeUnits } from "../../utils/timeunits";
+import { Duration } from "../../calculation/duration";
+import { Timeunit } from "../../types";
 
 export const WEEKDAY_DICTIONARY: { [word: string]: number } = {
     "sonntag": 0,
@@ -86,7 +86,7 @@ export const INTEGER_WORD_DICTIONARY: { [word: string]: number } = {
     "zwoelf": 12,
 };
 
-export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } = {
+export const TIME_UNIT_DICTIONARY: { [word: string]: Timeunit } = {
     sek: "second",
     sekunde: "second",
     sekunden: "second",
@@ -97,9 +97,9 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } =
     std: "hour",
     stunde: "hour",
     stunden: "hour",
-    tag: "d",
-    tage: "d",
-    tagen: "d",
+    tag: "day",
+    tage: "day",
+    tagen: "day",
     woche: "week",
     wochen: "week",
     monat: "month",
@@ -174,7 +174,7 @@ const SINGLE_TIME_UNIT_REGEX = new RegExp(SINGLE_TIME_UNIT_PATTERN, "i");
 
 export const TIME_UNITS_PATTERN = repeatedTimeunitPattern("", SINGLE_TIME_UNIT_PATTERN);
 
-export function parseTimeUnits(timeunitText): TimeUnits {
+export function parseDuration(timeunitText): Duration {
     const fragments = {};
     let remainingText = timeunitText;
     let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
@@ -183,7 +183,7 @@ export function parseTimeUnits(timeunitText): TimeUnits {
         remainingText = remainingText.substring(match[0].length);
         match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
     }
-    return fragments;
+    return fragments as Duration;
 }
 
 function collectDateTimeFragment(fragments, match) {

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

@@ -1,10 +1,10 @@
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents, ParsingResult } from "../../../results";
-import dayjs from "dayjs";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
-import { assignSimilarDate, assignTheNextDay, implySimilarTime } from "../../../utils/dayjs";
+import { assignSimilarDate, implySimilarTime } from "../../../utils/dates";
 import DECasualTimeParser from "./DECasualTimeParser";
 import * as references from "../../../common/casualReferences";
+import { addDuration } from "../../../calculation/duration";
 
 const PATTERN = new RegExp(
     `(jetzt|heute|morgen|übermorgen|uebermorgen|gestern|vorgestern|letzte\\s*nacht)` +
@@ -22,7 +22,7 @@ export default class DECasualDateParser extends AbstractParserWithWordBoundaryCh
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult {
-        let targetDate = dayjs(context.refDate);
+        let targetDate = context.reference.getDateWithAdjustedTimezone();
         const dateKeyword = (match[DATE_GROUP] || "").toLowerCase();
         const timeKeyword = (match[TIME_GROUP] || "").toLowerCase();
 
@@ -37,31 +37,34 @@ export default class DECasualDateParser extends AbstractParserWithWordBoundaryCh
                 break;
 
             case "morgen":
-                assignTheNextDay(component, targetDate);
+                targetDate = addDuration(targetDate, { day: 1 });
+                assignSimilarDate(component, targetDate);
+                implySimilarTime(component, targetDate);
                 break;
 
             case "übermorgen":
             case "uebermorgen":
-                targetDate = targetDate.add(1, "day");
-                assignTheNextDay(component, targetDate);
+                targetDate = addDuration(targetDate, { day: 2 });
+                assignSimilarDate(component, targetDate);
+                implySimilarTime(component, targetDate);
                 break;
 
             case "gestern":
-                targetDate = targetDate.add(-1, "day");
+                targetDate = addDuration(targetDate, { day: -1 });
                 assignSimilarDate(component, targetDate);
                 implySimilarTime(component, targetDate);
                 break;
 
             case "vorgestern":
-                targetDate = targetDate.add(-2, "day");
+                targetDate = addDuration(targetDate, { day: -2 });
                 assignSimilarDate(component, targetDate);
                 implySimilarTime(component, targetDate);
                 break;
 
             default:
                 if (dateKeyword.match(/letzte\s*nacht/)) {
-                    if (targetDate.hour() > 6) {
-                        targetDate = targetDate.add(-1, "day");
+                    if (targetDate.getHours() > 6) {
+                        targetDate = addDuration(targetDate, { day: -1 });
                     }
 
                     assignSimilarDate(component, targetDate);

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

@@ -1,10 +1,8 @@
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents, ParsingResult } from "../../../results";
-import dayjs from "dayjs";
 import { Meridiem } from "../../../types";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
-import { implySimilarTime } from "../../../utils/dayjs";
-import { addImpliedTimeUnits } from "../../../utils/timeunits";
+import { implySimilarTime } from "../../../utils/dates";
 
 export default class DECasualTimeParser extends AbstractParserWithWordBoundaryChecking {
     innerPattern(context: ParsingContext): RegExp {
@@ -12,7 +10,7 @@ export default class DECasualTimeParser extends AbstractParserWithWordBoundaryCh
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult {
-        const targetDate = dayjs(context.refDate);
+        const targetDate = context.refDate;
         const timeKeywordPattern = match[2].toLowerCase();
         const component = context.createParsingComponents();
         implySimilarTime(component, targetDate);
@@ -66,7 +64,7 @@ export default class DECasualTimeParser extends AbstractParserWithWordBoundaryCh
 
             case "mitternacht":
                 if (component.get("hour") > 1) {
-                    component = addImpliedTimeUnits(component, { "day": 1 });
+                    component.addDurationAsImplied({ "day": 1 });
                 }
 
                 component.imply("hour", 0);

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

@@ -2,8 +2,8 @@ import { ParsingContext } from "../../../chrono";
 import { NUMBER_PATTERN, parseNumberPattern, TIME_UNIT_DICTIONARY } from "../constants";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
-import { reverseTimeUnits } from "../../../utils/timeunits";
 import { matchAnyPattern } from "../../../utils/pattern";
+import { reverseDuration } from "../../../calculation/duration";
 
 export default class DETimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
     constructor() {
@@ -34,7 +34,7 @@ export default class DETimeUnitAgoFormatParser extends AbstractParserWithWordBou
         }
 
         if (/vor/.test(modifier) || /letzte/.test(modifier) || /vergangen/.test(modifier)) {
-            timeUnits = reverseTimeUnits(timeUnits);
+            timeUnits = reverseDuration(timeUnits);
         }
 
         return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);

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

@@ -1,4 +1,4 @@
-import { TIME_UNITS_PATTERN, parseTimeUnits } from "../constants";
+import { TIME_UNITS_PATTERN, parseDuration } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
@@ -9,7 +9,7 @@ export default class DETimeUnitWithinFormatParser extends AbstractParserWithWord
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
-        const timeUnits = parseTimeUnits(match[1]);
+        const timeUnits = parseDuration(match[1]);
         return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

package/src/locales/en/constants.ts

@@ -1,8 +1,7 @@
-import { OpUnitType, QUnitType } from "dayjs";
 import { matchAnyPattern, repeatedTimeunitPattern } from "../../utils/pattern";
 import { findMostLikelyADYear } from "../../calculation/years";
-import { TimeUnits } from "../../utils/timeunits";
-import { Weekday } from "../../types";
+import { Duration } from "../../calculation/duration";
+import { Timeunit, Weekday } from "../../types";
 
 export const WEEKDAY_DICTIONARY: { [word: string]: Weekday } = {
     sunday: 0,
@@ -134,15 +133,15 @@ export const ORDINAL_WORD_DICTIONARY: { [word: string]: number } = {
     "thirty-first": 31,
 };
 
-export const TIME_UNIT_DICTIONARY_NO_ABBR: { [word: string]: OpUnitType | QUnitType } = {
+export const TIME_UNIT_DICTIONARY_NO_ABBR: { [word: string]: Timeunit } = {
     second: "second",
     seconds: "second",
     minute: "minute",
     minutes: "minute",
     hour: "hour",
     hours: "hour",
-    day: "d",
-    days: "d",
+    day: "day",
+    days: "day",
     week: "week",
     weeks: "week",
     month: "month",
@@ -153,7 +152,7 @@ export const TIME_UNIT_DICTIONARY_NO_ABBR: { [word: string]: OpUnitType | QUnitT
     years: "year",
 };
 
-export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } = {
+export const TIME_UNIT_DICTIONARY: { [word: string]: Timeunit } = {
     s: "second",
     sec: "second",
     second: "second",
@@ -168,10 +167,10 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } =
     hrs: "hour",
     hour: "hour",
     hours: "hour",
-    d: "d",
-    day: "d",
-    days: "d",
-    w: "w",
+    d: "day",
+    day: "day",
+    days: "day",
+    w: "week",
     week: "week",
     weeks: "week",
     mo: "month",
@@ -277,7 +276,7 @@ export const TIME_UNITS_NO_ABBR_PATTERN = repeatedTimeunitPattern(
     TIME_UNIT_CONNECTOR_PATTERN
 );
 
-export function parseTimeUnits(timeunitText): null | TimeUnits {
+export function parseDuration(timeunitText): null | Duration {
     const fragments = {};
     let remainingText = timeunitText;
     let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
@@ -289,7 +288,7 @@ export function parseTimeUnits(timeunitText): null | TimeUnits {
     if (Object.keys(fragments).length == 0) {
         return null;
     }
-    return fragments;
+    return fragments as Duration;
 }
 
 function collectDateTimeFragment(fragments, match) {

package/src/locales/en/parsers/ENCasualDateParser.ts

@@ -1,8 +1,7 @@
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents, ParsingResult } from "../../../results";
-import dayjs from "dayjs";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
-import { assignSimilarDate } from "../../../utils/dayjs";
+import { assignSimilarDate } from "../../../utils/dates";
 import * as references from "../../../common/casualReferences";
 
 const PATTERN = /(now|today|tonight|tomorrow|overmorrow|tmr|tmrw|yesterday|last\s*night)(?=\W|$)/i;
@@ -13,7 +12,7 @@ export default class ENCasualDateParser extends AbstractParserWithWordBoundaryCh
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult {
-        let targetDate = dayjs(context.refDate);
+        let targetDate = context.refDate;
         const lowerText = match[0].toLowerCase();
         let component = context.createParsingComponents();
 
@@ -46,8 +45,10 @@ export default class ENCasualDateParser extends AbstractParserWithWordBoundaryCh
 
             default:
                 if (lowerText.match(/last\s*night/)) {
-                    if (targetDate.hour() > 6) {
-                        targetDate = targetDate.add(-1, "day");
+                    if (targetDate.getHours() > 6) {
+                        const previousDay = new Date(targetDate.getTime());
+                        previousDay.setDate(previousDay.getDate() - 1);
+                        targetDate = previousDay;
                     }
 
                     assignSimilarDate(component, targetDate);

package/src/locales/en/parsers/ENRelativeDateFormatParser.ts

@@ -1,7 +1,6 @@
 import { 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";
 
@@ -36,32 +35,31 @@ export default class ENRelativeDateFormatParser extends AbstractParserWithWordBo
         }
 
         const components = context.createParsingComponents();
-        let date = dayjs(context.reference.instant);
+        let date = new Date(context.reference.instant.getTime());
 
         // This week
         if (unitWord.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());
+            date.setDate(date.getDate() - date.getDay());
+            components.imply("day", date.getDate());
+            components.imply("month", date.getMonth() + 1);
+            components.imply("year", date.getFullYear());
         }
 
         // This month
         else if (unitWord.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);
+            date.setDate(1);
+            components.imply("day", date.getDate());
+            components.assign("year", date.getFullYear());
+            components.assign("month", date.getMonth() + 1);
         }
 
         // This year
         else if (unitWord.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());
+            date.setDate(1);
+            date.setMonth(0);
+            components.imply("day", date.getDate());
+            components.imply("month", date.getMonth() + 1);
+            components.assign("year", date.getFullYear());
         }
 
         return components;

package/src/locales/en/parsers/ENTimeUnitAgoFormatParser.ts

@@ -1,5 +1,5 @@
 import { ParsingContext } from "../../../chrono";
-import { parseTimeUnits, TIME_UNITS_NO_ABBR_PATTERN, TIME_UNITS_PATTERN } from "../constants";
+import { parseDuration, TIME_UNITS_NO_ABBR_PATTERN, TIME_UNITS_PATTERN } from "../constants";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { reverseDuration } from "../../../calculation/duration";
@@ -17,7 +17,7 @@ export default class ENTimeUnitAgoFormatParser extends AbstractParserWithWordBou
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        const duration = parseTimeUnits(match[1]);
+        const duration = parseDuration(match[1]);
         if (!duration) {
             return null;
         }

package/src/locales/en/parsers/ENTimeUnitCasualRelativeFormatParser.ts

@@ -1,4 +1,4 @@
-import { TIME_UNITS_PATTERN, parseTimeUnits, TIME_UNITS_NO_ABBR_PATTERN } from "../constants";
+import { TIME_UNITS_PATTERN, parseDuration, TIME_UNITS_NO_ABBR_PATTERN } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
@@ -21,7 +21,7 @@ export default class ENTimeUnitCasualRelativeFormatParser extends AbstractParser
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
         const prefix = match[1].toLowerCase();
-        let duration = parseTimeUnits(match[2]);
+        let duration = parseDuration(match[2]);
         if (!duration) {
             return null;
         }

package/src/locales/en/parsers/ENTimeUnitLaterFormatParser.ts

@@ -1,5 +1,5 @@
 import { ParsingContext } from "../../../chrono";
-import { parseTimeUnits, TIME_UNITS_NO_ABBR_PATTERN, TIME_UNITS_PATTERN } from "../constants";
+import { parseDuration, TIME_UNITS_NO_ABBR_PATTERN, TIME_UNITS_PATTERN } from "../constants";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 
@@ -21,7 +21,7 @@ export default class ENTimeUnitLaterFormatParser extends AbstractParserWithWordB
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        const timeUnits = parseTimeUnits(match[GROUP_NUM_TIMEUNITS]);
+        const timeUnits = parseDuration(match[GROUP_NUM_TIMEUNITS]);
         if (!timeUnits) {
             return null;
         }

package/src/locales/en/parsers/ENTimeUnitWithinFormatParser.ts

@@ -1,4 +1,4 @@
-import { TIME_UNITS_PATTERN, parseTimeUnits, TIME_UNITS_NO_ABBR_PATTERN } from "../constants";
+import { TIME_UNITS_PATTERN, parseDuration, TIME_UNITS_NO_ABBR_PATTERN } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
@@ -38,15 +38,10 @@ export default class ENTimeUnitWithinFormatParser extends AbstractParserWithWord
         if (match[0].match(/^for\s*the\s*\w+/)) {
             return null;
         }
-        const timeUnits = parseTimeUnits(match[1]);
+        const timeUnits = parseDuration(match[1]);
         if (!timeUnits) {
             return null;
         }
-        context.debug(() => {
-            console.log(timeUnits);
-            console.log(ParsingComponents.createRelativeFromReference(context.reference, timeUnits));
-        });
-
         return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

package/src/locales/en/refiners/ENMergeRelativeAfterDateRefiner.ts

@@ -1,7 +1,7 @@
 import { MergingRefiner } from "../../../common/abstractRefiners";
 import { ParsingComponents, ParsingResult, ReferenceWithTimezone } from "../../../results";
-import { parseTimeUnits } from "../constants";
-import { reverseTimeUnits } from "../../../utils/timeunits";
+import { parseDuration } from "../constants";
+import { reverseDuration } from "../../../calculation/duration";
 
 function IsPositiveFollowingReference(result: ParsingResult): boolean {
     return result.text.match(/^[+-]/i) != null;
@@ -26,13 +26,13 @@ export default class ENMergeRelativeAfterDateRefiner extends MergingRefiner {
     }
 
     mergeResults(textBetween: string, currentResult: ParsingResult, nextResult: ParsingResult, context): ParsingResult {
-        let timeUnits = parseTimeUnits(nextResult.text);
+        let timeUnits = parseDuration(nextResult.text);
         if (IsNegativeFollowingReference(nextResult)) {
-            timeUnits = reverseTimeUnits(timeUnits);
+            timeUnits = reverseDuration(timeUnits);
         }
 
         const components = ParsingComponents.createRelativeFromReference(
-            new ReferenceWithTimezone(currentResult.start.date()),
+            ReferenceWithTimezone.fromDate(currentResult.start.date()),
             timeUnits
         );
 

package/src/locales/en/refiners/ENMergeRelativeFollowByDateRefiner.ts

@@ -1,6 +1,6 @@
 import { MergingRefiner } from "../../../common/abstractRefiners";
 import { ParsingComponents, ParsingResult, ReferenceWithTimezone } from "../../../results";
-import { parseTimeUnits } from "../constants";
+import { parseDuration } from "../constants";
 import { reverseDuration } from "../../../calculation/duration";
 
 function hasImpliedEarlierReferenceDate(result: ParsingResult): boolean {
@@ -38,13 +38,13 @@ export default class ENMergeRelativeFollowByDateRefiner extends MergingRefiner {
     }
 
     mergeResults(textBetween: string, currentResult: ParsingResult, nextResult: ParsingResult): ParsingResult {
-        let duration = parseTimeUnits(currentResult.text);
+        let duration = parseDuration(currentResult.text);
         if (hasImpliedEarlierReferenceDate(currentResult)) {
             duration = reverseDuration(duration);
         }
 
         const components = ParsingComponents.createRelativeFromReference(
-            new ReferenceWithTimezone(nextResult.start.date()),
+            ReferenceWithTimezone.fromDate(nextResult.start.date()),
             duration
         );