chrono-node 2.4.2 → 2.5.1

package/src/locales/es/parsers/ESCasualTimeParser.ts

@@ -0,0 +1,47 @@
+import { ParsingContext } from "../../../chrono";
+import { Meridiem } from "../../../index";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { assignTheNextDay } from "../../../utils/dayjs";
+import dayjs from "dayjs";
+
+export default class ESCasualTimeParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern() {
+        return /(?:esta\s*)?(mañana|tarde|medianoche|mediodia|mediodía|noche)(?=\W|$)/i;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const targetDate = dayjs(context.refDate);
+        const component = context.createParsingComponents();
+        switch (match[1].toLowerCase()) {
+            case "tarde":
+                component.imply("meridiem", Meridiem.PM);
+                component.imply("hour", 15);
+                break;
+
+            case "noche":
+                component.imply("meridiem", Meridiem.PM);
+                component.imply("hour", 22);
+                break;
+
+            case "mañana":
+                component.imply("meridiem", Meridiem.AM);
+                component.imply("hour", 6);
+                break;
+
+            case "medianoche":
+                assignTheNextDay(component, targetDate);
+                component.imply("hour", 0);
+                component.imply("minute", 0);
+                component.imply("second", 0);
+                break;
+
+            case "mediodia":
+            case "mediodía":
+                component.imply("meridiem", Meridiem.AM);
+                component.imply("hour", 12);
+                break;
+        }
+
+        return component;
+    }
+}

package/src/locales/es/parsers/ESMonthNameLittleEndianParser.ts

@@ -0,0 +1,60 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingResult } from "../../../results";
+import { findYearClosestToRef } from "../../../calculation/years";
+import { MONTH_DICTIONARY } from "../constants";
+import { YEAR_PATTERN, parseYear } from "../constants";
+import { matchAnyPattern } from "../../../utils/pattern";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const PATTERN = new RegExp(
+    `([0-9]{1,2})(?:º|ª|°)?` +
+        "(?:\\s*(?:desde|de|\\-|\\–|ao?|\\s)\\s*([0-9]{1,2})(?:º|ª|°)?)?\\s*(?:de)?\\s*" +
+        `(?:-|/|\\s*(?:de|,)?\\s*)` +
+        `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+        `(?:\\s*(?:de|,)?\\s*(${YEAR_PATTERN}))?` +
+        `(?=\\W|$)`,
+    "i"
+);
+
+const DATE_GROUP = 1;
+const DATE_TO_GROUP = 2;
+const MONTH_NAME_GROUP = 3;
+const YEAR_GROUP = 4;
+
+export default class ESMonthNameLittleEndianParser extends AbstractParserWithWordBoundaryChecking {
+    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 = parseInt(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 = parseYear(match[YEAR_GROUP]);
+            result.start.assign("year", yearNumber);
+        } else {
+            const year = findYearClosestToRef(context.refDate, day, month);
+            result.start.imply("year", year);
+        }
+
+        if (match[DATE_TO_GROUP]) {
+            const endDate = parseInt(match[DATE_TO_GROUP]);
+
+            result.end = result.start.clone();
+            result.end.assign("day", endDate);
+        }
+
+        return result;
+    }
+}

package/src/locales/es/parsers/ESTimeExpressionParser.ts

@@ -0,0 +1,20 @@
+import { AbstractTimeExpressionParser } from "../../../common/parsers/AbstractTimeExpressionParser";
+
+export default class ESTimeExpressionParser extends AbstractTimeExpressionParser {
+    primaryPrefix(): string {
+        return "(?:(?:aslas|deslas|las?|al?|de|del)\\s*)?";
+    }
+
+    followingPhase(): string {
+        return "\\s*(?:\\-|\\–|\\~|\\〜|a(?:l)?|\\?)\\s*";
+    }
+
+    // extractPrimaryTimeComponents(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | null {
+    //     // This looks more like a year e.g. 2020
+    //     // if (match[0].match(/^\s*\d{4}\s*$/)) {
+    //     //     return null;
+    //     // }
+    //
+    //     return super.extractPrimaryTimeComponents(context, match);
+    // }
+}

package/src/locales/es/parsers/ESTimeUnitWithinFormatParser.ts

@@ -0,0 +1,15 @@
+import { TIME_UNITS_PATTERN, parseTimeUnits } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+export default class ESTimeUnitWithinFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return new RegExp(`(?:en|por|durante|de|dentro de)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const timeUnits = parseTimeUnits(match[1]);
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}

package/src/locales/es/parsers/ESWeekdayParser.ts

@@ -0,0 +1,50 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { 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*)?" +
+        "(?:(este|esta|pasado|pr[oó]ximo)\\s*)?" +
+        `(${matchAnyPattern(WEEKDAY_DICTIONARY)})` +
+        "(?:\\s*(?:\\,|\\)|\\）))?" +
+        "(?:\\s*(este|esta|pasado|pr[óo]ximo)\\s*semana)?" +
+        "(?=\\W|\\d|$)",
+    "i"
+);
+
+const PREFIX_GROUP = 1;
+const WEEKDAY_GROUP = 2;
+const POSTFIX_GROUP = 3;
+
+export default class ESWeekdayParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const dayOfWeek = match[WEEKDAY_GROUP].toLowerCase();
+        const weekday = WEEKDAY_DICTIONARY[dayOfWeek];
+        if (weekday === undefined) {
+            return null;
+        }
+
+        const prefix = match[PREFIX_GROUP];
+        const postfix = match[POSTFIX_GROUP];
+        let norm = prefix || postfix || "";
+        norm = norm.toLowerCase();
+
+        let modifier = null;
+        if (norm == "pasado") {
+            modifier = "this";
+        } else if (norm == "próximo" || norm == "proximo") {
+            modifier = "next";
+        } else if (norm == "este") {
+            modifier = "this";
+        }
+
+        return createParsingComponentsAtWeekday(context.reference, weekday, modifier);
+    }
+}

package/src/locales/es/refiners/ESMergeDateRangeRefiner.ts

@@ -0,0 +1,15 @@
+/*
+  
+*/
+
+import AbstractMergeDateRangeRefiner from "../../../common/refiners/AbstractMergeDateRangeRefiner";
+
+/**
+ * Merging before and after results (see. AbstractMergeDateRangeRefiner)
+ *
+ */
+export default class ESMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner {
+    patternBetween(): RegExp {
+        return /^\s*(?:-)\s*$/i;
+    }
+}

package/src/locales/es/refiners/ESMergeDateTimeRefiner.ts

@@ -0,0 +1,10 @@
+import AbstractMergeDateTimeRefiner from "../../../common/refiners/AbstractMergeDateTimeRefiner";
+
+/**
+ * Merging date-only result and time-only result (see. AbstractMergeDateTimeRefiner).
+ */
+export default class ESMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner {
+    patternBetween(): RegExp {
+        return new RegExp("^\\s*(?:,|de|aslas|a)?\\s*$");
+    }
+}

package/src/locales/nl/constants.ts

@@ -56,6 +56,8 @@ export const MONTH_DICTIONARY: { [word: string]: number } = {
     maart: 3,
     mar: 3,
     "mar.": 3,
+    mrt: 3,
+    "mrt.": 3,
     april: 4,
     apr: 4,
     "apr.": 4,

package/src/locales/nl/refiners/NLMergeDateRangeRefiner.ts

@@ -1,12 +1,12 @@
 /*
-  
+
 */
 
 import AbstractMergeDateRangeRefiner from "../../../common/refiners/AbstractMergeDateRangeRefiner";
 
 /**
  * Merging before and after results (see. AbstractMergeDateRangeRefiner)
- * This implementation should provide English connecting phases
+ * This implementation should provide Dutch connecting phases
  * - 2020-02-13 [tot] 2020-02-13
  * - Wednesday [-] Friday
  */

package/src/locales/nl/refiners/NLMergeDateTimeRefiner.ts

@@ -2,7 +2,7 @@ import AbstractMergeDateTimeRefiner from "../../../common/refiners/AbstractMerge
 
 /**
  * Merging date-only result and time-only result (see. AbstractMergeDateTimeRefiner).
- * This implementation should provide English connecting phases
+ * This implementation should provide Dutch connecting phases
  * - 2020-02-13 [at] 6pm
  * - Tomorrow [after] 7am
  */

package/src/locales/ru/parsers/RUCasualDateParser.ts

@@ -5,7 +5,7 @@ import * as references from "../../../common/casualReferences";
 import { REGEX_PARTS } from "../constants";
 
 const PATTERN = new RegExp(
-    `(?:с|со)?\\s*(сегодня|вчера|завтра|послезавтра|позавчера)${REGEX_PARTS.rightBoundary}`,
+    `(?:с|со)?\\s*(сегодня|вчера|завтра|послезавтра|послепослезавтра|позапозавчера|позавчера)${REGEX_PARTS.rightBoundary}`,
     REGEX_PARTS.flags
 );
 
@@ -35,8 +35,14 @@ export default class RUCasualDateParser extends AbstractParserWithWordBoundaryCh
             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/ru/parsers/RUTimeUnitCasualRelativeFormatParser.ts

@@ -5,7 +5,7 @@ import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/
 import { reverseTimeUnits } from "../../../utils/timeunits";
 
 const PATTERN = new RegExp(
-    `(эти|последние|прошлые|следующие|после|через|\\+|-)\\s*(${TIME_UNITS_PATTERN})${REGEX_PARTS.rightBoundary}`,
+    `(эти|последние|прошлые|следующие|после|спустя|через|\\+|-)\\s*(${TIME_UNITS_PATTERN})${REGEX_PARTS.rightBoundary}`,
     REGEX_PARTS.flags
 );
 

package/src/locales/ru/refiners/RUMergeDateTimeRefiner.ts

@@ -2,7 +2,7 @@ import AbstractMergeDateTimeRefiner from "../../../common/refiners/AbstractMerge
 
 /**
  * Merging date-only result and time-only result (see. AbstractMergeDateTimeRefiner).
- * This implementation should provide English connecting phases
+ * This implementation should provide Russian connecting phases
  * - 2020-02-13 [в] 6:00
  * - Завтра [,] 7:00
  */

package/test/de/de_time_units_within.test.ts

@@ -0,0 +1,119 @@
+import * as chrono from "../../src";
+import { testSingleCase } from "../test_util";
+
+test("Test - Single Expression", function () {
+    testSingleCase(chrono.de, "Wir müssen etwas in 5 Tagen erledigen.", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(17);
+        expect(result.text).toBe("in 5 Tagen");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(15);
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 15));
+    });
+
+    testSingleCase(chrono.de, "Wir müssen etwas in fünf Tagen erledigen.", new Date(2012, 7, 10, 11, 12), (result) => {
+        expect(result.index).toBe(17);
+        expect(result.text).toBe("in fünf Tagen");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(15);
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 15, 11, 12));
+    });
+
+    testSingleCase(chrono.de, "in 5 Minuten", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("in 5 Minuten");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 19));
+    });
+
+    testSingleCase(chrono.de, "für 5 minuten", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("für 5 minuten");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 19));
+    });
+
+    testSingleCase(chrono.de, "in einer Stunde", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("in einer Stunde");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 13, 14));
+    });
+
+    testSingleCase(chrono.de, "starte einen Timer für 5 Minuten", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(19);
+        expect(result.text).toBe("für 5 Minuten");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 19));
+    });
+
+    testSingleCase(chrono.de, "In 5 Minuten gehe ich nach Hause", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("In 5 Minuten");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 19));
+    });
+
+    testSingleCase(chrono.de, "In 5 Sekunden wird ein Auto fahren", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("In 5 Sekunden");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 14, 5));
+    });
+
+    testSingleCase(chrono.de, "in zwei Wochen", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("in zwei Wochen");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 24, 12, 14));
+    });
+
+    testSingleCase(chrono.de, "in einem Monat", new Date(2012, 7, 10, 7, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("in einem Monat");
+
+        expect(result.start).toBeDate(new Date(2012, 8, 10, 7, 14));
+    });
+
+    testSingleCase(chrono.de, "in einigen Monaten", new Date(2012, 6, 10, 22, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("in einigen Monaten");
+
+        expect(result.start).toBeDate(new Date(2012, 9, 10, 22, 14));
+    });
+
+    testSingleCase(chrono.de, "in einem Jahr", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("in einem Jahr");
+
+        expect(result.start).toBeDate(new Date(2013, 7, 10, 12, 14));
+    });
+
+    testSingleCase(chrono.de, "in 20 Jahren", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("in 20 Jahren");
+
+        expect(result.start).toBeDate(new Date(2032, 7, 10, 12, 14));
+    });
+
+    testSingleCase(chrono.de, "In 5 Minuten wird ein Auto fahren", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("In 5 Minuten");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 19));
+    });
+
+    testSingleCase(chrono.de, "In 5 Min wird ein Auto fahren", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("In 5 Min");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 19));
+    });
+});

package/test/en/en.test.ts

@@ -50,6 +50,14 @@ test("Test - Quoted Expressions", function () {
 test("Test - Strict Mode", function () {
     testUnexpectedResult(chrono.strict, "Tuesday");
 });
+test("Test - Built-in English variants", () => {
+    testSingleCase(chrono.en, "6/10/2018", (result) => {
+        expect(result.start).toBeDate(new Date(2018, 6 - 1, 10, 12));
+    });
+    testSingleCase(chrono.en.GB, "6/10/2018", (result) => {
+        expect(result.start).toBeDate(new Date(2018, 10 - 1, 6, 12));
+    });
+});
 
 test("Test - Random text", function () {
     testSingleCase(chrono, "Adam <Adam@supercalendar.com> написал(а):\nThe date is 02.07.2013", (result) => {
@@ -95,6 +103,8 @@ test("Test - Random text", function () {
         expect(result.text).toBe("Monday afternoon to last night");
         expect(result.start.get("day")).toBe(3);
         expect(result.start.get("month")).toBe(7);
+        expect(result.end.get("day")).toBe(7);
+        expect(result.end.get("month")).toBe(7);
     });
 
     testSingleCase(chrono, "03-27-2022, 02:00 AM", new Date(2017, 7 - 1, 7), (result) => {

package/test/en/en_casual.test.ts

@@ -132,15 +132,35 @@ test("Test - Single Expression", () => {
         expect(result.start.get("hour")).toBe(0);
     });
 
-    // "Midnight" at 0~1AM, assume it's the coming midnight of following day
-    // This is similar to "Tomorrow" at 0~1AM
-    testSingleCase(chrono.casual, "The Deadline was midnight ", new Date(2012, 7, 10, 1), (result) => {
+    // "Midnight" at 0~2AM, assume it's the passed midnight
+    testSingleCase(chrono.casual, "The Deadline was midnight ", new Date(2012, 8 - 1, 10, 1), (result) => {
         expect(result.text).toBe("midnight");
         expect(result.start.get("year")).toBe(2012);
         expect(result.start.get("month")).toBe(8);
-        expect(result.start.get("day")).toBe(11);
+        expect(result.start.get("day")).toBe(10);
         expect(result.start.get("hour")).toBe(0);
+        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("second")).toBe(0);
+        expect(result.start.get("millisecond")).toBe(0);
     });
+
+    // "Midnight" at 0~2AM with forwardDate option, should be the next night
+    testSingleCase(
+        chrono.casual,
+        "The Deadline was midnight ",
+        new Date(2012, 8 - 1, 10, 1),
+        { forwardDate: true },
+        (result) => {
+            expect(result.text).toBe("midnight");
+            expect(result.start.get("year")).toBe(2012);
+            expect(result.start.get("month")).toBe(8);
+            expect(result.start.get("day")).toBe(11);
+            expect(result.start.get("hour")).toBe(0);
+            expect(result.start.get("minute")).toBe(0);
+            expect(result.start.get("second")).toBe(0);
+            expect(result.start.get("millisecond")).toBe(0);
+        }
+    );
 });
 
 test("Test - Combined Expression", () => {
@@ -343,6 +363,9 @@ test("Test - Random text", () => {
         expect(result.start.get("month")).toBe(8);
         expect(result.start.get("day")).toBe(12);
         expect(result.start.get("hour")).toBe(0);
+        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("second")).toBe(0);
+        expect(result.start.get("millisecond")).toBe(0);
     });
 });
 

package/test/en/en_time_exp.test.ts

@@ -38,6 +38,48 @@ test("Test - Time range expression", function () {
         expect(result.end.get("second")).toBe(0);
         expect(result.end.get("meridiem")).toBe(Meridiem.PM);
     });
+
+    testSingleCase(chrono, "10:00:00 until 21:45:00", new Date(2016, 10 - 1, 1, 11), (result, text) => {
+        expect(result.text).toBe(text);
+
+        expect(result.start.get("hour")).toBe(10);
+        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("second")).toBe(0);
+        expect(result.start.get("meridiem")).toBe(Meridiem.AM);
+
+        expect(result.end.get("hour")).toBe(21);
+        expect(result.end.get("minute")).toBe(45);
+        expect(result.end.get("second")).toBe(0);
+        expect(result.end.get("meridiem")).toBe(Meridiem.PM);
+    });
+
+    testSingleCase(chrono, "10:00:00 till 21:45:00", new Date(2016, 10 - 1, 1, 11), (result, text) => {
+        expect(result.text).toBe(text);
+
+        expect(result.start.get("hour")).toBe(10);
+        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("second")).toBe(0);
+        expect(result.start.get("meridiem")).toBe(Meridiem.AM);
+
+        expect(result.end.get("hour")).toBe(21);
+        expect(result.end.get("minute")).toBe(45);
+        expect(result.end.get("second")).toBe(0);
+        expect(result.end.get("meridiem")).toBe(Meridiem.PM);
+    });
+
+    testSingleCase(chrono, "10:00:00 through 21:45:00", new Date(2016, 10 - 1, 1, 11), (result, text) => {
+        expect(result.text).toBe(text);
+
+        expect(result.start.get("hour")).toBe(10);
+        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("second")).toBe(0);
+        expect(result.start.get("meridiem")).toBe(Meridiem.AM);
+
+        expect(result.end.get("hour")).toBe(21);
+        expect(result.end.get("minute")).toBe(45);
+        expect(result.end.get("second")).toBe(0);
+        expect(result.end.get("meridiem")).toBe(Meridiem.PM);
+    });
 });
 
 test("Test - Casual time number expression", function () {
@@ -228,6 +270,24 @@ test("Test - Time range's meridiem handling", function () {
     });
 });
 
+test("Test - Time range to the next day", () => {
+    testSingleCase(chrono, "December 31, 2022 10:00 pm - 1:00 am", new Date(2017, 7 - 1, 7), (result) => {
+        expect(result.start.get("day")).toBe(31);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.start.get("year")).toBe(2022);
+        expect(result.start.get("hour")).toBe(22);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
+    });
+
+    testSingleCase(chrono, "December 31, 2022 10:00 pm - 12:00 am", new Date(2017, 7 - 1, 7), (result) => {
+        expect(result.start.get("day")).toBe(31);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.start.get("year")).toBe(2022);
+        expect(result.start.get("hour")).toBe(22);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
+    });
+});
+
 test("Test - Parsing causal positive cases", function () {
     testSingleCase(chrono.casual, "at 1", (result) => {
         expect(result.text).toBe("at 1");

package/test/en/en_time_units_ago.test.ts

@@ -168,6 +168,16 @@ test("Test - Single Expression", function () {
 
         expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 13));
     });
+
+    testSingleCase(chrono, "the min before", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("the min before");
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(13);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 13));
+    });
 });
 
 test("Test - Single Expression (Casual)", function () {
@@ -237,6 +247,14 @@ test("Test - Nested time ago", function () {
         expect(result.start.get("meridiem")).toBe(Meridiem.AM);
     });
 
+    testSingleCase(chrono, "1d 21 h 25m ago ", new Date(2012, 7, 10, 22, 30), (result) => {
+        expect(result.text).toBe("1d 21 h 25m ago");
+        expect(result.start.get("day")).toBe(9);
+        expect(result.start.get("hour")).toBe(1);
+        expect(result.start.get("minute")).toBe(5);
+        expect(result.start.get("meridiem")).toBe(Meridiem.AM);
+    });
+
     testSingleCase(chrono, "3 min 49 sec ago ", new Date(2012, 7, 10, 22, 30), (result) => {
         expect(result.text).toBe("3 min 49 sec ago");
         expect(result.start.get("day")).toBe(10);
@@ -245,6 +263,41 @@ test("Test - Nested time ago", function () {
         expect(result.start.get("second")).toBe(11);
         expect(result.start.get("meridiem")).toBe(Meridiem.PM);
     });
+
+    testSingleCase(chrono, "3m 49s ago ", new Date(2012, 7, 10, 22, 30), (result) => {
+        expect(result.text).toBe("3m 49s ago");
+        expect(result.start.get("day")).toBe(10);
+        expect(result.start.get("hour")).toBe(22);
+        expect(result.start.get("minute")).toBe(26);
+        expect(result.start.get("second")).toBe(11);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
+    });
+});
+
+test("Test - Before with reference", () => {
+    testSingleCase(chrono, "2 day before today", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(8);
+    });
+
+    testSingleCase(chrono, "the day before yesterday", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(8);
+    });
+
+    testSingleCase(chrono, "2 day before yesterday", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(7);
+    });
+
+    testSingleCase(chrono, "a week before yesterday", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(2);
+    });
 });
 
 test("Test - Negative cases", function () {