chrono-node 2.4.1 → 2.5.0

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/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/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/src/locales/zh/hans/parsers/ZHHansTimeExpressionParser.ts

@@ -76,7 +76,7 @@ export default class ZHHansTimeExpressionParser extends AbstractParserWithWordBo
 
         const refMoment = dayjs(context.refDate);
         const result = context.createParsingResult(match.index, match[0]);
-        const startMoment = refMoment.clone();
+        let startMoment = refMoment.clone();
 
         // ----- Day
         if (match[DAY_GROUP_1]) {
@@ -84,18 +84,18 @@ export default class ZHHansTimeExpressionParser extends AbstractParserWithWordBo
             if (day1 == "明") {
                 // Check not "Tomorrow" on late night
                 if (refMoment.hour() > 1) {
-                    startMoment.add(1, "day");
+                    startMoment = startMoment.add(1, "day");
                 }
             } else if (day1 == "昨") {
-                startMoment.add(-1, "day");
+                startMoment = startMoment.add(-1, "day");
             } else if (day1 == "前") {
-                startMoment.add(-2, "day");
+                startMoment = startMoment.add(-2, "day");
             } else if (day1 == "大前") {
-                startMoment.add(-3, "day");
+                startMoment = startMoment.add(-3, "day");
             } else if (day1 == "后") {
-                startMoment.add(2, "day");
+                startMoment = startMoment.add(2, "day");
             } else if (day1 == "大后") {
-                startMoment.add(3, "day");
+                startMoment = startMoment.add(3, "day");
             }
             result.start.assign("day", startMoment.date());
             result.start.assign("month", startMoment.month() + 1);
@@ -103,17 +103,17 @@ export default class ZHHansTimeExpressionParser extends AbstractParserWithWordBo
         } else if (match[DAY_GROUP_3]) {
             const day3 = match[DAY_GROUP_3];
             if (day3 == "明") {
-                startMoment.add(1, "day");
+                startMoment = startMoment.add(1, "day");
             } else if (day3 == "昨") {
-                startMoment.add(-1, "day");
+                startMoment = startMoment.add(-1, "day");
             } else if (day3 == "前") {
-                startMoment.add(-2, "day");
+                startMoment = startMoment.add(-2, "day");
             } else if (day3 == "大前") {
-                startMoment.add(-3, "day");
+                startMoment = startMoment.add(-3, "day");
             } else if (day3 == "后") {
-                startMoment.add(2, "day");
+                startMoment = startMoment.add(2, "day");
             } else if (day3 == "大后") {
-                startMoment.add(3, "day");
+                startMoment = startMoment.add(3, "day");
             }
             result.start.assign("day", startMoment.date());
             result.start.assign("month", startMoment.month() + 1);
@@ -242,7 +242,7 @@ export default class ZHHansTimeExpressionParser extends AbstractParserWithWordBo
             return result;
         }
 
-        const endMoment = startMoment.clone();
+        let endMoment = startMoment.clone();
         result.end = context.createParsingComponents();
 
         // ----- Day
@@ -251,18 +251,18 @@ export default class ZHHansTimeExpressionParser extends AbstractParserWithWordBo
             if (day1 == "明") {
                 // Check not "Tomorrow" on late night
                 if (refMoment.hour() > 1) {
-                    endMoment.add(1, "day");
+                    endMoment = endMoment.add(1, "day");
                 }
             } else if (day1 == "昨") {
-                endMoment.add(-1, "day");
+                endMoment = endMoment.add(-1, "day");
             } else if (day1 == "前") {
-                endMoment.add(-2, "day");
+                endMoment = endMoment.add(-2, "day");
             } else if (day1 == "大前") {
-                endMoment.add(-3, "day");
+                endMoment = endMoment.add(-3, "day");
             } else if (day1 == "后") {
-                endMoment.add(2, "day");
+                endMoment = endMoment.add(2, "day");
             } else if (day1 == "大后") {
-                endMoment.add(3, "day");
+                endMoment = endMoment.add(3, "day");
             }
             result.end.assign("day", endMoment.date());
             result.end.assign("month", endMoment.month() + 1);
@@ -270,17 +270,17 @@ export default class ZHHansTimeExpressionParser extends AbstractParserWithWordBo
         } else if (match[DAY_GROUP_3]) {
             const day3 = match[DAY_GROUP_3];
             if (day3 == "明") {
-                endMoment.add(1, "day");
+                endMoment = endMoment.add(1, "day");
             } else if (day3 == "昨") {
-                endMoment.add(-1, "day");
+                endMoment = endMoment.add(-1, "day");
             } else if (day3 == "前") {
-                endMoment.add(-2, "day");
+                endMoment = endMoment.add(-2, "day");
             } else if (day3 == "大前") {
-                endMoment.add(-3, "day");
+                endMoment = endMoment.add(-3, "day");
             } else if (day3 == "后") {
-                endMoment.add(2, "day");
+                endMoment = endMoment.add(2, "day");
             } else if (day3 == "大后") {
-                endMoment.add(3, "day");
+                endMoment = endMoment.add(3, "day");
             }
             result.end.assign("day", endMoment.date());
             result.end.assign("month", endMoment.month() + 1);

package/src/locales/zh/hant/parsers/ZHHantTimeExpressionParser.ts

@@ -76,7 +76,7 @@ export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBo
 
         const refMoment = dayjs(context.refDate);
         const result = context.createParsingResult(match.index, match[0]);
-        const startMoment = refMoment.clone();
+        let startMoment = refMoment.clone();
 
         // ----- Day
         if (match[DAY_GROUP_1]) {
@@ -84,18 +84,18 @@ export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBo
             if (day1 == "明" || day1 == "聽") {
                 // Check not "Tomorrow" on late night
                 if (refMoment.hour() > 1) {
-                    startMoment.add(1, "day");
+                    startMoment = startMoment.add(1, "day");
                 }
             } else if (day1 == "昨" || day1 == "尋" || day1 == "琴") {
-                startMoment.add(-1, "day");
+                startMoment = startMoment.add(-1, "day");
             } else if (day1 == "前") {
-                startMoment.add(-2, "day");
+                startMoment = startMoment.add(-2, "day");
             } else if (day1 == "大前") {
-                startMoment.add(-3, "day");
+                startMoment = startMoment.add(-3, "day");
             } else if (day1 == "後") {
-                startMoment.add(2, "day");
+                startMoment = startMoment.add(2, "day");
             } else if (day1 == "大後") {
-                startMoment.add(3, "day");
+                startMoment = startMoment.add(3, "day");
             }
             result.start.assign("day", startMoment.date());
             result.start.assign("month", startMoment.month() + 1);
@@ -103,17 +103,17 @@ export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBo
         } else if (match[DAY_GROUP_3]) {
             var day3 = match[DAY_GROUP_3];
             if (day3 == "明" || day3 == "聽") {
-                startMoment.add(1, "day");
+                startMoment = startMoment.add(1, "day");
             } else if (day3 == "昨" || day3 == "尋" || day3 == "琴") {
-                startMoment.add(-1, "day");
+                startMoment = startMoment.add(-1, "day");
             } else if (day3 == "前") {
-                startMoment.add(-2, "day");
+                startMoment = startMoment.add(-2, "day");
             } else if (day3 == "大前") {
-                startMoment.add(-3, "day");
+                startMoment = startMoment.add(-3, "day");
             } else if (day3 == "後") {
-                startMoment.add(2, "day");
+                startMoment = startMoment.add(2, "day");
             } else if (day3 == "大後") {
-                startMoment.add(3, "day");
+                startMoment = startMoment.add(3, "day");
             }
             result.start.assign("day", startMoment.date());
             result.start.assign("month", startMoment.month() + 1);
@@ -242,7 +242,7 @@ export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBo
             return result;
         }
 
-        const endMoment = startMoment.clone();
+        let endMoment = startMoment.clone();
         result.end = context.createParsingComponents();
 
         // ----- Day
@@ -251,18 +251,18 @@ export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBo
             if (day1 == "明" || day1 == "聽") {
                 // Check not "Tomorrow" on late night
                 if (refMoment.hour() > 1) {
-                    endMoment.add(1, "day");
+                    endMoment = endMoment.add(1, "day");
                 }
             } else if (day1 == "昨" || day1 == "尋" || day1 == "琴") {
-                endMoment.add(-1, "day");
+                endMoment = endMoment.add(-1, "day");
             } else if (day1 == "前") {
-                endMoment.add(-2, "day");
+                endMoment = endMoment.add(-2, "day");
             } else if (day1 == "大前") {
-                endMoment.add(-3, "day");
+                endMoment = endMoment.add(-3, "day");
             } else if (day1 == "後") {
-                endMoment.add(2, "day");
+                endMoment = endMoment.add(2, "day");
             } else if (day1 == "大後") {
-                endMoment.add(3, "day");
+                endMoment = endMoment.add(3, "day");
             }
             result.end.assign("day", endMoment.date());
             result.end.assign("month", endMoment.month() + 1);
@@ -270,17 +270,17 @@ export default class ZHHantTimeExpressionParser extends AbstractParserWithWordBo
         } else if (match[DAY_GROUP_3]) {
             var day3 = match[DAY_GROUP_3];
             if (day3 == "明" || day3 == "聽") {
-                endMoment.add(1, "day");
+                endMoment = endMoment.add(1, "day");
             } else if (day3 == "昨" || day3 == "尋" || day3 == "琴") {
-                endMoment.add(-1, "day");
+                endMoment = endMoment.add(-1, "day");
             } else if (day3 == "前") {
-                endMoment.add(-2, "day");
+                endMoment = endMoment.add(-2, "day");
             } else if (day3 == "大前") {
-                endMoment.add(-3, "day");
+                endMoment = endMoment.add(-3, "day");
             } else if (day3 == "後") {
-                endMoment.add(2, "day");
+                endMoment = endMoment.add(2, "day");
             } else if (day3 == "大後") {
-                endMoment.add(3, "day");
+                endMoment = endMoment.add(3, "day");
             }
             result.end.assign("day", endMoment.date());
             result.end.assign("month", endMoment.month() + 1);

package/src/utils/dayjs.ts

@@ -8,6 +8,12 @@ export function assignTheNextDay(component: ParsingComponents, targetDayJs: dayj
     implySimilarTime(component, targetDayJs);
 }
 
+export function implyTheNextDay(component: ParsingComponents, targetDayJs: dayjs.Dayjs) {
+    targetDayJs = targetDayJs.add(1, "day");
+    implySimilarDate(component, targetDayJs);
+    implySimilarTime(component, targetDayJs);
+}
+
 export function assignSimilarDate(component: ParsingComponents, targetDayJs: dayjs.Dayjs) {
     component.assign("day", targetDayJs.date());
     component.assign("month", targetDayJs.month() + 1);
@@ -26,6 +32,12 @@ export function assignSimilarTime(component: ParsingComponents, targetDayJs: day
     }
 }
 
+export function implySimilarDate(component: ParsingComponents, targetDayJs: dayjs.Dayjs) {
+    component.imply("day", targetDayJs.date());
+    component.imply("month", targetDayJs.month() + 1);
+    component.imply("year", targetDayJs.year());
+}
+
 export function implySimilarTime(component: ParsingComponents, targetDayJs: dayjs.Dayjs) {
     component.imply("hour", targetDayJs.hour());
     component.imply("minute", targetDayJs.minute());

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", () => {
@@ -337,6 +357,16 @@ test("Test - Random text", () => {
         expect(result.start.get("day")).toBe(1);
         expect(result.start.get("hour")).toBe(15);
     });
+
+    testSingleCase(chrono.casual, "at midnight on 12th August", new Date(2012, 8 - 1, 10, 15), (result) => {
+        expect(result.start.get("year")).toBe(2012);
+        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);
+    });
 });
 
 test("Test - Casual time with timezone", () => {

package/test/en/en_slash.test.ts

@@ -168,23 +168,24 @@ test("Test - Splitter variances patterns", function () {
     testWithExpectedDate(chrono, "05-25-2015", expectDate);
     testWithExpectedDate(chrono, "05/25/2015", expectDate);
     testWithExpectedDate(chrono, "05.25.2015", expectDate);
+    testWithExpectedDate(chrono, "/05/25/2015", expectDate);
 
     // Also, guessing ambiguous date
     testWithExpectedDate(chrono, "25/05/2015", expectDate);
 });
 
 test("Test - Impossible Dates and Unexpected Results", function () {
-    testUnexpectedResult(chrono, "8/32/2014", new Date(2012, 7, 10));
-
-    testUnexpectedResult(chrono, "8/32", new Date(2012, 7, 10));
-
-    testUnexpectedResult(chrono, "2/29/2014", new Date(2012, 7, 10));
-
-    testUnexpectedResult(chrono, "2014/22/29", new Date(2012, 7, 10));
-
-    testUnexpectedResult(chrono, "2014/13/22", new Date(2012, 7, 10));
-
-    testUnexpectedResult(chrono, "80-32-89-89", new Date(2012, 7, 10));
+    testUnexpectedResult(chrono, "8/32/2014");
+    testUnexpectedResult(chrono, "8/32");
+    testUnexpectedResult(chrono, "2/29/2014");
+    testUnexpectedResult(chrono, "2014/22/29");
+    testUnexpectedResult(chrono, "2014/13/22");
+    testUnexpectedResult(chrono, "80-32-89-89");
+    testUnexpectedResult(chrono, "02/29/2022");
+    testUnexpectedResult(chrono, "06/31/2022");
+    testUnexpectedResult(chrono, "06/-31/2022");
+    testUnexpectedResult(chrono, "18/13/2022");
+    testUnexpectedResult(chrono, "15/28/2022");
 });
 
 test("Test - forward dates only option", function () {

package/test/en/en_time_exp.test.ts

@@ -287,3 +287,56 @@ test("Test - Parsing negative cases : 'at [some numbers] - [some numbers]' (Stri
 
     testUnexpectedResult(chrono.strict, "7-730");
 });
+
+test("Test - forward dates only option", function () {
+    testSingleCase(
+        chrono,
+        "1am",
+        {
+            instant: new Date("Wed May 26 2022 01:57:00 GMT-0500 (CDT)"),
+            timezone: "CDT",
+        },
+        {
+            forwardDate: true,
+        },
+        (result) => {
+            expect(result.start.get("year")).toBe(2022);
+            expect(result.start.get("month")).toBe(5);
+            expect(result.start.get("day")).toBe(27);
+            expect(result.start.get("hour")).toBe(1);
+        }
+    );
+
+    testSingleCase(chrono, "11am", new Date(2016, 10 - 1, 1, 12), { forwardDate: true }, (result) => {
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(2);
+        expect(result.start.get("hour")).toBe(11);
+    });
+
+    testSingleCase(chrono, "  11am to 1am  ", new Date(2016, 10 - 1, 1, 12), { forwardDate: true }, (result) => {
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(2);
+        expect(result.start.get("hour")).toBe(11);
+
+        expect(result.end).not.toBeNull();
+        expect(result.end.get("year")).toBe(2016);
+        expect(result.end.get("month")).toBe(10);
+        expect(result.end.get("day")).toBe(3);
+        expect(result.end.get("hour")).toBe(1);
+    });
+
+    testSingleCase(chrono, "  10am to 12pm  ", new Date(2016, 10 - 1, 1, 11), { forwardDate: true }, (result) => {
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(2);
+        expect(result.start.get("hour")).toBe(10);
+
+        expect(result.end).not.toBeNull();
+        expect(result.end.get("year")).toBe(2016);
+        expect(result.end.get("month")).toBe(10);
+        expect(result.end.get("day")).toBe(2);
+        expect(result.end.get("hour")).toBe(12);
+    });
+});