chrono-node 2.3.7 → 2.4.1

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

@@ -204,6 +204,18 @@ test("Test - Range expression", function () {
 
         expect(result.end).toBeDate(new Date(2013, 10 - 1, 12, 12));
     });
+
+    testSingleCase(chrono.de, "10. jänner 2012", new Date(2012, 7, 10), (result) => {
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(1);
+        expect(result.start.get("day")).toBe(10);
+
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("10. jänner 2012");
+
+        expect(result.start).toBeDate(new Date(2012, 1 - 1, 10, 12));
+    });
 });
 
 test("Test - Combined expression", function () {

package/test/de/de_time_exp.test.ts

@@ -27,6 +27,11 @@ test("Test - Simple Expression", function () {
         expect(result.start.get("minute")).toBe(0);
     });
 
+    testSingleCase(chrono.de, "um 16h", new Date(2012, 7, 10), (result) => {
+        expect(result.start.get("hour")).toBe(16);
+        expect(result.start.get("minute")).toBe(0);
+    });
+
     testSingleCase(chrono.de, "um 7 morgens", new Date(2012, 7, 10), (result) => {
         expect(result.start.get("hour")).toBe(7);
         expect(result.start.get("minute")).toBe(0);
@@ -64,6 +69,22 @@ test("Test - Simple Expression", function () {
         expect(result.start.get("meridiem")).toBe(Meridiem.PM);
         expect(result.start.isCertain("meridiem")).toBeTruthy();
     });
+
+    testSingleCase(chrono.de, "um 8 Uhr in der Nacht", new Date(2012, 7, 10), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(20);
+        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("meridiem")).toBe(Meridiem.PM);
+        expect(result.start.isCertain("meridiem")).toBeTruthy();
+    });
+
+    testSingleCase(chrono.de, "um 5 Uhr in der Nacht", new Date(2012, 7, 10), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(5);
+        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("meridiem")).toBe(Meridiem.AM);
+        expect(result.start.isCertain("meridiem")).toBeTruthy();
+    });
 });
 
 test("Test - Range Expression", function () {
@@ -118,6 +139,44 @@ test("Test - Range Expression", function () {
 
         expect(result.end).toBeDate(new Date(2012, 7, 10, 23, 0));
     });
+
+    testSingleCase(chrono.de, " von 6h30 bis 23h00 ", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(1);
+        expect(result.text).toBe("von 6h30 bis 23h00");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("hour")).toBe(6);
+        expect(result.start.get("minute")).toBe(30);
+        expect(result.start.get("meridiem")).toBe(0);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 6, 30));
+
+        expect(result.end).not.toBeNull();
+        expect(result.end.get("hour")).toBe(23);
+        expect(result.end.get("minute")).toBe(0);
+        expect(result.end.get("meridiem")).toBe(1);
+
+        expect(result.end).toBeDate(new Date(2012, 7, 10, 23, 0));
+    });
+
+    testSingleCase(chrono.de, " von 6h30 morgens bis 11 am Abend", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(1);
+        expect(result.text).toBe("von 6h30 morgens bis 11 am Abend");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("hour")).toBe(6);
+        expect(result.start.get("minute")).toBe(30);
+        expect(result.start.get("meridiem")).toBe(0);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 6, 30));
+
+        expect(result.end).not.toBeNull();
+        expect(result.end.get("hour")).toBe(23);
+        expect(result.end.get("minute")).toBe(0);
+        expect(result.end.get("meridiem")).toBe(1);
+
+        expect(result.end).toBeDate(new Date(2012, 7, 10, 23, 0));
+    });
 });
 
 test("Test - Timezone extraction", function () {

package/test/de/de_time_units_casual_relative.test.ts

@@ -0,0 +1,108 @@
+import * as chrono from "../../src";
+import { testSingleCase, testUnexpectedResult } from "../test_util";
+
+// test("Test - fr - modifier mandatory just after", function () {
+//     testUnexpectedResult(chrono.de, "le mois d'avril");
+//
+//     testUnexpectedResult(chrono.de, "le mois d'avril prochain");
+// });
+
+test("Test - de - relative date", function () {
+    testSingleCase(chrono.de, "kommende Woche", new Date(2017, 5 - 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(5);
+        expect(result.start.get("day")).toBe(19);
+    });
+
+    testSingleCase(chrono.de, "in 2 Wochen", new Date(2017, 5 - 1, 12, 18, 11), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(5);
+        expect(result.start.get("day")).toBe(26);
+        expect(result.start.get("hour")).toBe(18);
+        expect(result.start.get("minute")).toBe(11);
+    });
+
+    testSingleCase(chrono.de, "in drei Wochen", new Date(2017, 5 - 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(6);
+        expect(result.start.get("day")).toBe(2);
+    });
+
+    testSingleCase(chrono.de, "letzten Monat", new Date(2017, 5 - 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(4);
+        expect(result.start.get("day")).toBe(12);
+    });
+
+    testSingleCase(chrono.de, "in den 30 vorangegangenen Tagen", new Date(2017, 5 - 1, 12), (result, text) => {
+        expect(result.text).toBe("30 vorangegangenen Tagen");
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(4);
+        expect(result.start.get("day")).toBe(12);
+    });
+
+    testSingleCase(chrono.de, "die vergangenen 24 Stunden", new Date(2017, 5 - 1, 12, 11, 27), (result, text) => {
+        expect(result.text).toBe("vergangenen 24 Stunden");
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(5);
+        expect(result.start.get("day")).toBe(11);
+        expect(result.start.get("hour")).toBe(11);
+        expect(result.start.get("minute")).toBe(27);
+    });
+
+    testSingleCase(chrono.de, "in den folgenden 90 sekunden", new Date(2017, 5 - 1, 12, 11, 27, 3), (result, text) => {
+        expect(result.text).toBe("folgenden 90 sekunden");
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(5);
+        expect(result.start.get("day")).toBe(12);
+        expect(result.start.get("hour")).toBe(11);
+        expect(result.start.get("minute")).toBe(28);
+        expect(result.start.get("second")).toBe(33);
+    });
+
+    testSingleCase(chrono.de, "die letzten acht Minuten", new Date(2017, 5 - 1, 12, 11, 27), (result, text) => {
+        expect(result.text).toBe("letzten acht Minuten");
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(5);
+        expect(result.start.get("day")).toBe(12);
+        expect(result.start.get("hour")).toBe(11);
+        expect(result.start.get("minute")).toBe(19);
+        expect(result.start.get("second")).toBe(0);
+    });
+
+    testSingleCase(chrono.de, "letztes Quartal", new Date(2017, 5 - 1, 12, 11, 27), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(2);
+        expect(result.start.get("day")).toBe(12);
+        expect(result.start.get("hour")).toBe(11);
+        expect(result.start.get("minute")).toBe(27);
+        expect(result.start.get("second")).toBe(0);
+
+        expect(result.start.isCertain("month")).toBeFalsy();
+        expect(result.start.isCertain("day")).toBeFalsy();
+        expect(result.start.isCertain("hour")).toBeFalsy();
+        expect(result.start.isCertain("minute")).toBeFalsy();
+        expect(result.start.isCertain("second")).toBeFalsy();
+    });
+
+    testSingleCase(chrono.de, "kommendes Jahr", new Date(2017, 5 - 1, 12, 11, 27), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2018);
+        expect(result.start.get("month")).toBe(5);
+        expect(result.start.get("day")).toBe(12);
+        expect(result.start.get("hour")).toBe(11);
+        expect(result.start.get("minute")).toBe(27);
+        expect(result.start.get("second")).toBe(0);
+
+        expect(result.start.isCertain("month")).toBeFalsy();
+        expect(result.start.isCertain("day")).toBeFalsy();
+        expect(result.start.isCertain("hour")).toBeFalsy();
+        expect(result.start.isCertain("minute")).toBeFalsy();
+        expect(result.start.isCertain("second")).toBeFalsy();
+    });
+});

package/test/de/de_year.test.ts

@@ -0,0 +1,147 @@
+import * as chrono from "../../src";
+import { testSingleCase } from "../test_util";
+//import DETimeExpressionParser from "../../src/locales/de/parsers/DETimeExpressionParser";
+
+test("Test - Year numbers with v/nuZ Era label", () => {
+    testSingleCase(chrono.de, "10. August 234 v.u.Z.", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("10. August 234 v.u.Z."); // fails since text is `10 August 234`
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(-234);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+
+        //expect(result.start).toBeDate(new Date(-234, 8 - 1, 10, 12));
+    });
+
+    testSingleCase(chrono.de, "10. August 88 nuZ", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("10. August 88 nuZ");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(88);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+
+        //const resultDate = result.start.date();
+        const expectDate = new Date(88, 8 - 1, 10, 12);
+        expectDate.setFullYear(88);
+        //expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+    });
+
+    testSingleCase(chrono.de, "10. August 88 uZ", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("10. August 88 uZ");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(88);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+
+        //const resultDate = result.start.date();
+        const expectDate = new Date(88, 8 - 1, 10, 12);
+        expectDate.setFullYear(88);
+        //expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+    });
+
+    testSingleCase(chrono.de, "10. August 88 d.g.Z.", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("10. August 88 d.g.Z.");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(88);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+
+        //const resultDate = result.start.date();
+        const expectDate = new Date(88, 8 - 1, 10, 12);
+        expectDate.setFullYear(88);
+        //expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+    });
+});
+
+test("Test - Year numbers with v/nChr Era label", () => {
+    testSingleCase(chrono.de, "10. August 234 v.Chr.", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("10. August 234 v.Chr.");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(-234);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+
+        //expect(result.start).toBeDate(new Date(-234, 8 - 1, 10, 12));
+    });
+
+    testSingleCase(chrono.de, "10. August 88 nC", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("10. August 88 nC");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(88);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+
+        //const resultDate = result.start.date();
+        const expectDate = new Date(88, 8 - 1, 10, 12);
+        expectDate.setFullYear(88);
+        //expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+    });
+});
+
+test("Test - Year numbers with v/ndgZ Era label", () => {
+    testSingleCase(chrono.de, "10. August 234 v.d.Z.", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("10. August 234 v.d.Z.");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(-234);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+
+        //expect(result.start).toBeDate(new Date(-234, 8 - 1, 10, 12));
+    });
+
+    testSingleCase(chrono.de, "10. August 88 ndZ", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("10. August 88 ndZ");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(88);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+
+        //const resultDate = result.start.date();
+        const expectDate = new Date(88, 8 - 1, 10, 12);
+        expectDate.setFullYear(88);
+        //expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+    });
+
+    testSingleCase(chrono.de, "10. August 234 v.d.g.Z.", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("10. August 234 v.d.g.Z.");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(-234);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+
+        //expect(result.start).toBeDate(new Date(-234, 8 - 1, 10, 12));
+    });
+
+    testSingleCase(chrono.de, "10. August 88 ndgZ", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("10. August 88 ndgZ");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(88);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+
+        //const resultDate = result.start.date();
+        const expectDate = new Date(88, 8 - 1, 10, 12);
+        expectDate.setFullYear(88);
+        //expect(expectDate.getTime()).toBeCloseTo(resultDate.getTime());
+    });
+});

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_relative.test.ts

@@ -136,6 +136,45 @@ test("Test - Future relative expressions", () => {
         expect(result.start.isCertain("timezoneOffset")).toBe(false);
     });
 
+    testSingleCase(chrono, "next quarter", new Date(2021, 1 - 1, 22, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2021);
+        expect(result.start.get("month")).toBe(4);
+        expect(result.start.get("day")).toBe(22);
+        expect(result.start.get("hour")).toBe(12);
+
+        expect(result.start.isCertain("year")).toBe(false);
+        expect(result.start.isCertain("month")).toBe(false);
+        expect(result.start.isCertain("day")).toBe(false);
+        expect(result.start.isCertain("hour")).toBe(false);
+    });
+
+    testSingleCase(chrono, "next qtr", new Date(2021, 10 - 1, 22, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2022);
+        expect(result.start.get("month")).toBe(1);
+        expect(result.start.get("day")).toBe(22);
+        expect(result.start.get("hour")).toBe(12);
+
+        expect(result.start.isCertain("year")).toBe(false);
+        expect(result.start.isCertain("month")).toBe(false);
+        expect(result.start.isCertain("day")).toBe(false);
+        expect(result.start.isCertain("hour")).toBe(false);
+    });
+
+    testSingleCase(chrono, "next two quarter", new Date(2021, 1 - 1, 22, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2021);
+        expect(result.start.get("month")).toBe(7);
+        expect(result.start.get("day")).toBe(22);
+        expect(result.start.get("hour")).toBe(12);
+
+        expect(result.start.isCertain("year")).toBe(false);
+        expect(result.start.isCertain("month")).toBe(false);
+        expect(result.start.isCertain("day")).toBe(false);
+        expect(result.start.isCertain("hour")).toBe(false);
+    });
+
     testSingleCase(chrono, "after this year", new Date(2020, 11 - 1, 22, 12, 11, 32, 6), (result, text) => {
         expect(result.text).toBe(text);
         expect(result.start.get("year")).toBe(2021);
@@ -155,6 +194,12 @@ test("Test - Future relative expressions", () => {
         expect(result.start.isCertain("millisecond")).toBe(false);
         expect(result.start.isCertain("timezoneOffset")).toBe(false);
     });
+
+    testSingleCase(chrono, "Connect back after this year", new Date(2022, 4 - 1, 16, 12), (result, text) => {
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(4);
+        expect(result.start.get("day")).toBe(16);
+    });
 });
 
 test("Test - Relative date components' certainty", () => {
@@ -176,14 +221,14 @@ test("Test - Relative date components' certainty", () => {
     });
 
     testSingleCase(chrono, "next month", refDate, (result, text) => {
-        const expectedDate = new Date(2016, 11, 7, 12);
+        //const expectedDate = new Date(2016, 11, 7, 12);
 
         expect(result.text).toBe(text);
         expect(result.start.get("year")).toBe(2016);
         expect(result.start.get("month")).toBe(11);
         expect(result.start.get("day")).toBe(7);
         expect(result.start.get("hour")).toBe(12);
-        expect(result.start.get("timezoneOffset")).toBe(-expectedDate.getTimezoneOffset());
+        //expect(result.start.get("timezoneOffset")).toBe(-expectedDate.getTimezoneOffset());
 
         expect(result.start.isCertain("year")).toBe(true);
         expect(result.start.isCertain("month")).toBe(true);

package/test/en/en_time_units_ago.test.ts

@@ -171,16 +171,16 @@ test("Test - Single Expression", function () {
 });
 
 test("Test - Single Expression (Casual)", function () {
-    testSingleCase(chrono, "5 months ago, we did something", new Date(2012, 8 - 1, 10), (result) => {
+    testSingleCase(chrono, "5 months ago, we did something", new Date(2012, 10 - 1, 10), (result) => {
         expect(result.start).not.toBeNull();
         expect(result.start.get("year")).toBe(2012);
-        expect(result.start.get("month")).toBe(3);
+        expect(result.start.get("month")).toBe(5);
         expect(result.start.get("day")).toBe(10);
 
         expect(result.index).toBe(0);
         expect(result.text).toBe("5 months ago");
 
-        expect(result.start).toBeDate(new Date(2012, 3 - 1, 10));
+        expect(result.start).toBeDate(new Date(2012, 5 - 1, 10));
     });
 
     testSingleCase(chrono, "5 years ago, we did something", new Date(2012, 8 - 1, 10), (result) => {

package/test/en/en_time_units_within.test.ts

@@ -101,11 +101,11 @@ test("Test - The normal within expression", () => {
         expect(result.start).toBeDate(new Date(2012, 8, 10, 12, 14));
     });
 
-    testSingleCase(chrono, "within a few months", new Date(2012, 7, 10, 12, 14), (result) => {
+    testSingleCase(chrono, "within a few months", new Date(2012, 6, 10, 12, 14), (result) => {
         expect(result.index).toBe(0);
         expect(result.text).toBe("within a few months");
 
-        expect(result.start).toBeDate(new Date(2012, 10, 10, 12, 14));
+        expect(result.start).toBeDate(new Date(2012, 9, 10, 12, 14));
     });
 
     testSingleCase(chrono, "within one year", new Date(2012, 7, 10, 12, 14), (result) => {