chrono-node 2.3.9 → 2.4.2

package/src/locales/ru/constants.ts

@@ -47,9 +47,9 @@ export const FULL_MONTH_NAME_DICTIONARY: { [word: string]: number } = {
     январь: 1,
     января: 1,
     январе: 1,
-    февряль: 2,
-    февряля: 2,
-    февряле: 2,
+    февраль: 2,
+    февраля: 2,
+    феврале: 2,
     март: 3,
     марта: 3,
     марте: 3,
@@ -125,7 +125,7 @@ export const INTEGER_WORD_DICTIONARY: { [word: string]: number } = {
     семь: 7,
     семи: 7,
     восемь: 8,
-    восемьми: 8,
+    восьми: 8,
     девять: 9,
     девяти: 9,
     десять: 10,
@@ -288,8 +288,6 @@ export function parseOrdinalNumberPattern(match: string): number {
     if (ORDINAL_WORD_DICTIONARY[num] !== undefined) {
         return ORDINAL_WORD_DICTIONARY[num];
     }
-
-    num = num.replace(/(?:st|nd|rd|th)$/i, "");
     return parseInt(num);
 }
 

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

@@ -3,7 +3,7 @@ import { ParsingComponents } from "../../../results";
 import { REGEX_PARTS, WEEKDAY_DICTIONARY } from "../constants";
 import { matchAnyPattern } from "../../../utils/pattern";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
-import { toDayJSWeekday } from "../../../calculation/weeks";
+import { createParsingComponentsAtWeekday } from "../../../common/calculation/weekdays";
 
 const PATTERN = new RegExp(
     `(?:(?:,|\\(|（)\\s*)?` +
@@ -31,7 +31,7 @@ export default class RUWeekdayParser extends AbstractParserWithWordBoundaryCheck
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
         const dayOfWeek = match[WEEKDAY_GROUP].toLowerCase();
-        const offset = WEEKDAY_DICTIONARY[dayOfWeek];
+        const weekday = WEEKDAY_DICTIONARY[dayOfWeek];
         const prefix = match[PREFIX_GROUP];
         const postfix = match[POSTFIX_GROUP];
         let modifierWord = prefix || postfix;
@@ -52,12 +52,6 @@ export default class RUWeekdayParser extends AbstractParserWithWordBoundaryCheck
             modifier = "this";
         }
 
-        const date = toDayJSWeekday(context.refDate, offset, modifier);
-        return context
-            .createParsingComponents()
-            .assign("weekday", offset)
-            .imply("day", date.date())
-            .imply("month", date.month() + 1)
-            .imply("year", date.year());
+        return createParsingComponentsAtWeekday(context.reference, weekday, modifier);
     }
 }

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

@@ -6,7 +6,7 @@ import AbstractMergeDateRangeRefiner from "../../../common/refiners/AbstractMerg
  * - c 06.09.1989 [до|по] 11.12.1996
  * - c пятницы и до среды
  */
-export default class xf extends AbstractMergeDateRangeRefiner {
+export default class RUMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner {
     patternBetween(): RegExp {
         return /^\s*(и до|и по|до|по|-)\s*$/i;
     }

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/results.ts

@@ -19,6 +19,31 @@ export class ReferenceWithTimezone {
             this.timezoneOffset = toTimezoneOffset(input.timezone);
         }
     }
+
+    /**
+     * Returns a JS date (system timezone) with the { year, month, day, hour, minute, second } equal to the reference.
+     * The output's instant is NOT the reference's instant when the reference's and system's timezone are different.
+     */
+    getDateWithAdjustedTimezone() {
+        return new Date(this.instant.getTime() + this.getSystemTimezoneAdjustmentMinute(this.instant) * 60000);
+    }
+
+    /**
+     * Returns the number minutes difference between the JS date's timezone and the reference timezone.
+     * @param date
+     * @param overrideTimezoneOffset
+     */
+    getSystemTimezoneAdjustmentMinute(date?: Date, overrideTimezoneOffset?: number): number {
+        if (!date || date.getTime() < 0) {
+            // Javascript date timezone calculation got effect when the time epoch < 0
+            // e.g. new Date('Tue Feb 02 1300 00:00:00 GMT+0900 (JST)') => Tue Feb 02 1300 00:18:59 GMT+0918 (JST)
+            date = new Date();
+        }
+
+        const currentTimezoneOffset = -date.getTimezoneOffset();
+        const targetTimezoneOffset = overrideTimezoneOffset ?? this.timezoneOffset ?? currentTimezoneOffset;
+        return currentTimezoneOffset - targetTimezoneOffset;
+    }
 }
 
 export class ParsingComponents implements ParsedComponents {
@@ -141,7 +166,8 @@ export class ParsingComponents implements ParsedComponents {
 
     date(): Date {
         const date = this.dateWithoutTimezoneAdjustment();
-        return new Date(date.getTime() + this.getSystemTimezoneAdjustmentMinute(date) * 60000);
+        const timezoneAdjustment = this.reference.getSystemTimezoneAdjustmentMinute(date, this.get("timezoneOffset"));
+        return new Date(date.getTime() + timezoneAdjustment * 60000);
     }
 
     private dateWithoutTimezoneAdjustment() {
@@ -159,20 +185,6 @@ export class ParsingComponents implements ParsedComponents {
         return date;
     }
 
-    private getSystemTimezoneAdjustmentMinute(date?: Date) {
-        if (!date || date.getTime() < 0) {
-            // Javascript date timezone calculation got effect when the time epoch < 0
-            // e.g. new Date('Tue Feb 02 1300 00:00:00 GMT+0900 (JST)') => Tue Feb 02 1300 00:18:59 GMT+0918 (JST)
-            date = new Date();
-        }
-
-        const currentTimezoneOffset = -date.getTimezoneOffset();
-        const targetTimezoneOffset =
-            this.get("timezoneOffset") ?? this.reference.timezoneOffset ?? currentTimezoneOffset;
-
-        return currentTimezoneOffset - targetTimezoneOffset;
-    }
-
     static createRelativeFromReference(
         reference: ReferenceWithTimezone,
         fragments: { [c in QUnitType]?: number }

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/calculation.test.ts

@@ -0,0 +1,116 @@
+import { createParsingComponentsAtWeekday, getDaysToWeekday } from "../src/common/calculation/weekdays";
+import { Weekday } from "../src";
+import { ReferenceWithTimezone } from "../src/results";
+
+test("Test - This Weekday Calculation", () => {
+    {
+        const reference = new ReferenceWithTimezone(new Date("Sat, 20 Aug 2022 12:00:00"));
+        const output = createParsingComponentsAtWeekday(reference, Weekday.MONDAY, "this");
+        expect(output.date()).toStrictEqual(new Date("Mon, Aug 22 2022 12:00:00"));
+    }
+    {
+        const reference = new ReferenceWithTimezone(new Date("Sun, 21 Aug 2022 12:00:00"));
+        const output = createParsingComponentsAtWeekday(reference, Weekday.FRIDAY, "this");
+        expect(output.date()).toStrictEqual(new Date("Fri, Aug 26 2022 12:00:00"));
+    }
+    {
+        const reference = new ReferenceWithTimezone(new Date("Tue, Aug 2 2022 12:00:00"));
+        const output = createParsingComponentsAtWeekday(reference, Weekday.SUNDAY, "this");
+        expect(output.date()).toStrictEqual(new Date("Sun, Aug 7 2022 12:00:00"));
+    }
+});
+
+test("Test - Last Weekday Calculation", () => {
+    {
+        const reference = new ReferenceWithTimezone(new Date("Sat, 20 Aug 2022 12:00:00"));
+        const output = createParsingComponentsAtWeekday(reference, Weekday.FRIDAY, "last");
+        expect(output.date()).toStrictEqual(new Date("Fri, Aug 19 2022 12:00:00"));
+    }
+    {
+        const reference = new ReferenceWithTimezone(new Date("Sat, 20 Aug 2022 12:00:00"));
+        const output = createParsingComponentsAtWeekday(reference, Weekday.MONDAY, "last");
+        expect(output.date()).toStrictEqual(new Date("Mon, Aug 15 2022 12:00:00"));
+    }
+    {
+        const reference = new ReferenceWithTimezone(new Date("Sat, 20 Aug 2022 12:00:00"));
+        const output = createParsingComponentsAtWeekday(reference, Weekday.SUNDAY, "last");
+        expect(output.date()).toStrictEqual(new Date("Sun, Aug 14 2022 12:00:00"));
+    }
+    {
+        const reference = new ReferenceWithTimezone(new Date("Sat, 20 Aug 2022 12:00:00"));
+        const output = createParsingComponentsAtWeekday(reference, Weekday.SATURDAY, "last");
+        expect(output.date()).toStrictEqual(new Date("Sat, Aug 13 2022 12:00:00"));
+    }
+});
+
+test("Test - Next Weekday Calculation", () => {
+    {
+        const reference = new ReferenceWithTimezone(new Date("Sun, Aug 21 2022 12:00:00"));
+        const output = createParsingComponentsAtWeekday(reference, Weekday.MONDAY, "next");
+        expect(output.date()).toStrictEqual(new Date("Mon, Aug 22 2022 12:00:00"));
+    }
+    {
+        const reference = new ReferenceWithTimezone(new Date("Sun, Aug 21 2022 12:00:00"));
+        const output = createParsingComponentsAtWeekday(reference, Weekday.SATURDAY, "next");
+        expect(output.date()).toStrictEqual(new Date("Sat, Aug 27 2022 12:00:00"));
+    }
+    {
+        const reference = new ReferenceWithTimezone(new Date("Sun, Aug 21 2022 12:00:00"));
+        const output = createParsingComponentsAtWeekday(reference, Weekday.SUNDAY, "next");
+        expect(output.date()).toStrictEqual(new Date("Sun, Aug 28 2022 12:00:00"));
+    }
+    {
+        const reference = new ReferenceWithTimezone(new Date("Sat, Aug 20 2022 12:00:00"));
+        const output = createParsingComponentsAtWeekday(reference, Weekday.FRIDAY, "next");
+        expect(output.date()).toStrictEqual(new Date("Fri, Aug 26 2022 12:00:00"));
+    }
+    {
+        const reference = new ReferenceWithTimezone(new Date("Sat, Aug 20 2022 12:00:00"));
+        const output = createParsingComponentsAtWeekday(reference, Weekday.SATURDAY, "next");
+        expect(output.date()).toStrictEqual(new Date("Sat, Aug 27 2022 12:00:00"));
+    }
+    {
+        const reference = new ReferenceWithTimezone(new Date("Sat, Aug 20 2022 12:00:00"));
+        const output = createParsingComponentsAtWeekday(reference, Weekday.SUNDAY, "next");
+        expect(output.date()).toStrictEqual(new Date("Sun, Aug 28 2022 12:00:00"));
+    }
+    {
+        const reference = new ReferenceWithTimezone(new Date("Tue, Aug 2 2022 12:00:00"));
+        const output = createParsingComponentsAtWeekday(reference, Weekday.MONDAY, "next");
+        expect(output.date()).toStrictEqual(new Date("Mon, Aug 8 2022 12:00:00"));
+    }
+    {
+        const reference = new ReferenceWithTimezone(new Date("Tue, Aug 2 2022 12:00:00"));
+        const output = createParsingComponentsAtWeekday(reference, Weekday.FRIDAY, "next");
+        expect(output.date()).toStrictEqual(new Date("Fri, Aug 12 2022 12:00:00"));
+    }
+
+    {
+        const reference = new ReferenceWithTimezone(new Date("Tue, Aug 2 2022 12:00:00"));
+        const output = createParsingComponentsAtWeekday(reference, Weekday.SUNDAY, "next");
+        expect(output.date()).toStrictEqual(new Date("Sun, Aug 14 2022 12:00:00"));
+    }
+});
+
+test("Test - Closest Weekday Calculation", () => {
+    {
+        const refDate = new Date("Sat, 20 Aug 2022 12:00:00");
+        expect(getDaysToWeekday(refDate, Weekday.MONDAY)).toBe(2);
+    }
+    {
+        const refDate = new Date("Sat, 20 Aug 2022 12:00:00");
+        expect(getDaysToWeekday(refDate, Weekday.TUESDAY)).toBe(3);
+    }
+    {
+        const refDate = new Date("Sat, 20 Aug 2022 12:00:00");
+        expect(getDaysToWeekday(refDate, Weekday.FRIDAY)).toBe(-1);
+    }
+    {
+        const refDate = new Date("Sat, 20 Aug 2022 12:00:00");
+        expect(getDaysToWeekday(refDate, Weekday.THURSDAY)).toBe(-2);
+    }
+    {
+        const refDate = new Date("Sat, 20 Aug 2022 12:00:00");
+        expect(getDaysToWeekday(refDate, Weekday.WEDNESDAY)).toBe(-3);
+    }
+});

package/test/en/en.test.ts

@@ -1,6 +1,7 @@
 import * as chrono from "../../src";
 import { testSingleCase, testUnexpectedResult } from "../test_util";
 import ENTimeExpressionParser from "../../src/locales/en/parsers/ENTimeExpressionParser";
+import { Meridiem } from "../../src";
 
 test("Test - Date + Time Expression", function () {
     testSingleCase(chrono, "Something happen on 2014-04-18 13:00 - 16:00 as", (result) => {
@@ -95,6 +96,15 @@ test("Test - Random text", function () {
         expect(result.start.get("day")).toBe(3);
         expect(result.start.get("month")).toBe(7);
     });
+
+    testSingleCase(chrono, "03-27-2022, 02:00 AM", new Date(2017, 7 - 1, 7), (result) => {
+        expect(result.text).toBe("03-27-2022, 02:00 AM");
+        expect(result.start.get("day")).toBe(27);
+        expect(result.start.get("month")).toBe(3);
+        expect(result.start.get("year")).toBe(2022);
+        expect(result.start.get("hour")).toBe(2);
+        expect(result.start.get("meridiem")).toBe(Meridiem.AM);
+    });
 });
 
 test("Test - Wikipedia Texts", function () {

package/test/en/en_casual.test.ts

@@ -337,6 +337,13 @@ 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);
+    });
 });
 
 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);
+    });
+});