chrono-node 2.5.0 → 2.5.1

package/src/locales/de/constants.ts

@@ -123,21 +123,21 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } =
 
 export const NUMBER_PATTERN = `(?:${matchAnyPattern(
     INTEGER_WORD_DICTIONARY
-)}|[0-9]+|[0-9]+\\.[0-9]+|half(?:\\s*an?)?|an?\\b(?:\\s*few)?|few|several|a?\\s*couple\\s*(?:of)?)`;
+)}|[0-9]+|[0-9]+\\.[0-9]+|halb?|halbe?|einigen?|wenigen?|mehreren?)`;
 
 export function parseNumberPattern(match: string): number {
     const num = match.toLowerCase();
     if (INTEGER_WORD_DICTIONARY[num] !== undefined) {
         return INTEGER_WORD_DICTIONARY[num];
-    } else if (num === "a" || num === "an") {
+    } else if (num === "ein" || num === "einer" || num === "einem" || num === "einen" || num === "eine") {
         return 1;
-    } else if (num.match(/few/)) {
-        return 3;
-    } else if (num.match(/half/)) {
-        return 0.5;
-    } else if (num.match(/couple/)) {
+    } else if (num.match(/wenigen/)) {
         return 2;
-    } else if (num.match(/several/)) {
+    } else if (num.match(/halb/) || num.match(/halben/)) {
+        return 0.5;
+    } else if (num.match(/einigen/)) {
+        return 3;
+    } else if (num.match(/mehreren/)) {
         return 7;
     }
 

package/src/locales/de/index.ts

@@ -12,6 +12,7 @@ import DECasualDateParser from "./parsers/DECasualDateParser";
 import DECasualTimeParser from "./parsers/DECasualTimeParser";
 import DEMonthNameLittleEndianParser from "./parsers/DEMonthNameLittleEndianParser";
 import DETimeUnitRelativeFormatParser from "./parsers/DETimeUnitRelativeFormatParser";
+import DETimeUnitWithinFormatParser from "./parsers/DETimeUnitWithinFormatParser";
 
 // Shortcuts
 export const casual = new Chrono(createCasualConfiguration());
@@ -43,6 +44,7 @@ export function createConfiguration(strictMode = true, littleEndian = true): Con
                 new DESpecificTimeExpressionParser(),
                 new DEMonthNameLittleEndianParser(),
                 new DEWeekdayParser(),
+                new DETimeUnitWithinFormatParser(),
             ],
             refiners: [new DEMergeDateRangeRefiner(), new DEMergeDateTimeRefiner()],
         },

package/src/locales/de/parsers/DETimeUnitWithinFormatParser.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 DETimeUnitWithinFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return new RegExp(`(?:in|für|während)\\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/en/constants.ts

@@ -156,6 +156,7 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } =
     week: "week",
     weeks: "week",
     mo: "month",
+    mon: "month",
     mos: "month",
     month: "month",
     months: "month",
@@ -172,13 +173,13 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } =
 
 export const NUMBER_PATTERN = `(?:${matchAnyPattern(
     INTEGER_WORD_DICTIONARY
-)}|[0-9]+|[0-9]+\\.[0-9]+|half(?:\\s{0,2}an?)?|an?\\b(?:\\s{0,2}few)?|few|several|a?\\s{0,2}couple\\s{0,2}(?:of)?)`;
+)}|[0-9]+|[0-9]+\\.[0-9]+|half(?:\\s{0,2}an?)?|an?\\b(?:\\s{0,2}few)?|few|several|the|a?\\s{0,2}couple\\s{0,2}(?:of)?)`;
 
 export function parseNumberPattern(match: string): number {
     const num = match.toLowerCase();
     if (INTEGER_WORD_DICTIONARY[num] !== undefined) {
         return INTEGER_WORD_DICTIONARY[num];
-    } else if (num === "a" || num === "an") {
+    } else if (num === "a" || num === "an" || num == "the") {
         return 1;
     } else if (num.match(/few/)) {
         return 3;

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

@@ -5,7 +5,8 @@ import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/
 import { assignSimilarDate } from "../../../utils/dayjs";
 import * as references from "../../../common/casualReferences";
 
-const PATTERN = /(now|today|tonight|tomorrow|tmr|tmrw|yesterday|last\s*night)(?=\W|$)/i;
+const PATTERN =
+    /(now|today|tonight|tomorrow|tmr|tmrw|yesterday|last\s*night|(?<!\d\s*)day\s*after\s*tomorrow|(?<!\d\s*)day\s*before\s*yesterday)(?=\W|$)/i;
 
 export default class ENCasualDateParser extends AbstractParserWithWordBoundaryChecking {
     innerPattern(context: ParsingContext): RegExp {
@@ -45,6 +46,14 @@ export default class ENCasualDateParser extends AbstractParserWithWordBoundaryCh
                     component.imply("hour", 0);
                 }
 
+                if (lowerText.match(/after\s*tomorrow/)) {
+                    return references.theDayAfter(context.reference, 2);
+                }
+
+                if (lowerText.match(/before\s*yesterday/)) {
+                    return references.theDayBefore(context.reference, 2);
+                }
+
                 break;
         }
 

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

@@ -9,7 +9,7 @@ export default class ENTimeExpressionParser extends AbstractTimeExpressionParser
     }
 
     followingPhase(): string {
-        return "\\s*(?:\\-|\\–|\\~|\\〜|to|\\?)\\s*";
+        return "\\s*(?:\\-|\\–|\\~|\\〜|to|until|through|till|\\?)\\s*";
     }
 
     primaryPrefix(): string {

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

@@ -12,6 +12,6 @@ import AbstractMergeDateRangeRefiner from "../../../common/refiners/AbstractMerg
  */
 export default class ENMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner {
     patternBetween(): RegExp {
-        return /^\s*(to|-)\s*$/i;
+        return /^\s*(to|-|–|until|through|till)\s*$/i;
     }
 }

package/src/locales/es/constants.ts

@@ -1,3 +1,6 @@
+import { OpUnitType, QUnitType } from "dayjs";
+import { matchAnyPattern, repeatedTimeunitPattern } from "../../utils/pattern";
+
 export const WEEKDAY_DICTIONARY: { [word: string]: number } = {
     "domingo": 0,
     "dom": 0,
@@ -59,6 +62,69 @@ export const MONTH_DICTIONARY: { [word: string]: number } = {
     "dic.": 12,
 };
 
+export const INTEGER_WORD_DICTIONARY: { [word: string]: number } = {
+    "uno": 1,
+    "dos": 2,
+    "tres": 3,
+    "cuatro": 4,
+    "cinco": 5,
+    "seis": 6,
+    "siete": 7,
+    "ocho": 8,
+    "nueve": 9,
+    "diez": 10,
+    "once": 11,
+    "doce": 12,
+    "trece": 13,
+};
+
+export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } = {
+    "sec": "second",
+    "segundo": "second",
+    "segundos": "second",
+    "min": "minute",
+    "mins": "minute",
+    "minuto": "minute",
+    "minutos": "minute",
+    "h": "hour",
+    "hr": "hour",
+    "hrs": "hour",
+    "hora": "hour",
+    "horas": "hour",
+    "día": "d",
+    "días": "d",
+    "semana": "week",
+    "semanas": "week",
+    "mes": "month",
+    "meses": "month",
+    "cuarto": "quarter",
+    "cuartos": "quarter",
+    "año": "year",
+    "años": "year",
+};
+
+//-----------------------------
+
+export const NUMBER_PATTERN = `(?:${matchAnyPattern(
+    INTEGER_WORD_DICTIONARY
+)}|[0-9]+|[0-9]+\\.[0-9]+|un?|uno?|una?|algunos?|unos?|demi-?)`;
+
+export function parseNumberPattern(match: string): number {
+    const num = match.toLowerCase();
+    if (INTEGER_WORD_DICTIONARY[num] !== undefined) {
+        return INTEGER_WORD_DICTIONARY[num];
+    } else if (num === "un" || num === "una" || num === "uno") {
+        return 1;
+    } else if (num.match(/algunos?/)) {
+        return 3;
+    } else if (num.match(/unos?/)) {
+        return 3;
+    } else if (num.match(/media?/)) {
+        return 0.5;
+    }
+
+    return parseFloat(num);
+}
 //-----------------------------
 // 88 p. Chr. n.
 // 234 AC
@@ -83,3 +149,26 @@ export function parseYear(match: string): number {
 
     return parseInt(match);
 }
+
+const SINGLE_TIME_UNIT_PATTERN = `(${NUMBER_PATTERN})\\s{0,5}(${matchAnyPattern(TIME_UNIT_DICTIONARY)})\\s{0,5}`;
+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): { [c in OpUnitType | QUnitType]?: number } {
+    const fragments = {};
+    let remainingText = timeunitText;
+    let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
+    while (match) {
+        collectDateTimeFragment(fragments, match);
+        remainingText = remainingText.substring(match[0].length);
+        match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
+    }
+    return fragments as { [c in OpUnitType | QUnitType]?: number };
+}
+
+function collectDateTimeFragment(fragments, match) {
+    const num = parseNumberPattern(match[1]);
+    const unit = TIME_UNIT_DICTIONARY[match[2].toLowerCase()];
+    fragments[unit] = num;
+}

package/src/locales/es/index.ts

@@ -1,5 +1,5 @@
 /**
- * Chrono components for Portuguese support (*parsers*, *refiners*, and *configuration*)
+ * Chrono components for Spanish support (*parsers*, *refiners*, and *configuration*)
  *
  * @module
  */
@@ -15,6 +15,7 @@ import ESMergeDateRangeRefiner from "./refiners/ESMergeDateRangeRefiner";
 import ESMonthNameLittleEndianParser from "./parsers/ESMonthNameLittleEndianParser";
 import ESCasualDateParser from "./parsers/ESCasualDateParser";
 import ESCasualTimeParser from "./parsers/ESCasualTimeParser";
+import ESTimeUnitWithinFormatParser from "./parsers/ESTimeUnitWithinFormatParser";
 
 // Shortcuts
 export const casual = new Chrono(createCasualConfiguration());
@@ -49,6 +50,7 @@ export function createConfiguration(strictMode = true, littleEndian = true): Con
                 new ESWeekdayParser(),
                 new ESTimeExpressionParser(),
                 new ESMonthNameLittleEndianParser(),
+                new ESTimeUnitWithinFormatParser(),
             ],
             refiners: [new ESMergeDateTimeRefiner(), new ESMergeDateRangeRefiner()],
         },

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/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/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_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 () {
@@ -264,6 +274,32 @@ test("Test - Nested time ago", function () {
     });
 });
 
+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 () {
     testUnexpectedResult(chrono, "15 hours 29 min");
     testUnexpectedResult(chrono, "a few hour");

package/test/en/en_time_units_casual_relative.test.ts

@@ -1,5 +1,5 @@
 import * as chrono from "../../src";
-import { testSingleCase } from "../test_util";
+import { testSingleCase, testUnexpectedResult } from "../test_util";
 
 test("Test - Positive time units", () => {
     testSingleCase(chrono, "next 2 weeks", new Date(2016, 10 - 1, 1, 12), (result, text) => {
@@ -109,6 +109,14 @@ test("Test - Plus '+' sign", () => {
 
         expect(result.start).toBeDate(new Date(2012, 7 - 1, 11, 14, 14));
     });
+
+    testSingleCase(chrono.casual, "+1m", new Date(2012, 7 - 1, 10, 12, 14), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(15);
+
+        expect(result.start).toBeDate(new Date(2012, 7 - 1, 10, 12, 15));
+    });
 });
 
 test("Test - Minus '-' sign", () => {
@@ -132,3 +140,10 @@ test("Test - Minus '-' sign", () => {
         expect(result.start.get("minute")).toBe(55);
     });
 });
+
+test("Test - Negative cases", () => {
+    testUnexpectedResult(chrono.casual, "3y", new Date(2015, 7 - 1, 10, 12, 14));
+    testUnexpectedResult(chrono.casual, "1 m", new Date(2015, 7 - 1, 10, 12, 14));
+    testUnexpectedResult(chrono.casual, "the day", new Date(2015, 7 - 1, 10, 12, 14));
+    testUnexpectedResult(chrono.casual, "a day", new Date(2015, 7 - 1, 10, 12, 14));
+});