chrono-node 2.9.0 → 2.9.2

package/test/fi/fi_time_units_casual_relative.test.ts

@@ -0,0 +1,117 @@
+import * as chrono from "../../src";
+import { testSingleCase } from "../test_util";
+
+test("Test - Positive time units", () => {
+    testSingleCase(chrono.fi, "seuraavat 2 viikkoa", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(15);
+    });
+
+    testSingleCase(chrono.fi, "seuraavat 2 päivää", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(3);
+        expect(result.start.get("hour")).toBe(12);
+    });
+
+    testSingleCase(chrono.fi, "seuraavat kaksi vuotta", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2018);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
+    });
+
+    testSingleCase(chrono.fi, "seuraavat 2 viikkoa 3 päivää", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(18);
+        expect(result.start.get("hour")).toBe(12);
+    });
+
+    testSingleCase(chrono.fi, "seuraava yksi vuotta", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(1);
+        expect(result.start.get("hour")).toBe(12);
+    });
+});
+
+test("Test - Negative time units", () => {
+    testSingleCase(chrono.fi, "edelliset 2 viikkoa", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(17);
+        expect(result.start.get("hour")).toBe(12);
+    });
+
+    testSingleCase(chrono.fi, "viimeiset 2 päivää", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(29);
+        expect(result.start.get("hour")).toBe(12);
+    });
+
+    testSingleCase(chrono.fi, "kuluneet kaksi viikkoa", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(9);
+        expect(result.start.get("day")).toBe(17);
+        expect(result.start.get("hour")).toBe(12);
+    });
+
+    testSingleCase(chrono.fi, "+2 kuukautta 5 päivää", new Date(2016, 10 - 1, 1, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(12);
+        expect(result.start.get("day")).toBe(6);
+        expect(result.start.get("hour")).toBe(12);
+    });
+});
+
+test("Test - Plus '+' sign", () => {
+    testSingleCase(chrono.fi.casual, "+15 minuuttia", 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(29);
+
+        expect(result.start).toBeDate(new Date(2012, 7 - 1, 10, 12, 29));
+    });
+
+    testSingleCase(chrono.fi.casual, "+15min", 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(29);
+
+        expect(result.start).toBeDate(new Date(2012, 7 - 1, 10, 12, 29));
+    });
+
+    testSingleCase(chrono.fi.casual, "+1 päivä 2 tuntia", new Date(2012, 7 - 1, 10, 12, 14), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("day")).toBe(11);
+        expect(result.start.get("hour")).toBe(14);
+        expect(result.start.get("minute")).toBe(14);
+
+        expect(result.start).toBeDate(new Date(2012, 7 - 1, 11, 14, 14));
+    });
+});
+
+test("Test - Minus '-' sign", () => {
+    testSingleCase(chrono.fi.casual, "-3vuotta", new Date(2015, 7 - 1, 10, 12, 14), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(7);
+        expect(result.start.get("day")).toBe(10);
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(14);
+
+        expect(result.start).toBeDate(new Date(2012, 7 - 1, 10, 12, 14));
+    });
+});

package/test/fi/fi_time_units_within.test.ts

@@ -0,0 +1,74 @@
+import * as chrono from "../../src";
+import { testSingleCase } from "../test_util";
+
+test("Test - 'sisällä' (within) expression", () => {
+    testSingleCase(chrono.fi, "pitää tehdä jotain 5 päivää sisällä", new Date(2012, 7, 10), (result) => {
+        expect(result.text).toBe("5 päivää sisällä");
+
+        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.fi, "5 minuuttia sisällä", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("5 minuuttia sisällä");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 19));
+    });
+
+    testSingleCase(chrono.fi, "1 tuntia sisällä", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("1 tuntia sisällä");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 13, 14));
+    });
+
+    testSingleCase(chrono.fi, "2 viikkoa sisällä", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.text).toBe("2 viikkoa sisällä");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 24, 12, 14));
+    });
+});
+
+test("Test - 'kuluessa' (within/during) expression", () => {
+    testSingleCase(chrono.fi, "5 päivää kuluessa", new Date(2012, 7, 10), (result) => {
+        expect(result.text).toBe("5 päivää kuluessa");
+
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(15);
+    });
+
+    testSingleCase(chrono.fi, "yksi vuotta kuluessa", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.text).toBe("yksi vuotta kuluessa");
+
+        expect(result.start).toBeDate(new Date(2013, 7, 10, 12, 14));
+    });
+});
+
+test("Test - 'päästä' (from now) expression", () => {
+    testSingleCase(chrono.fi, "5 minuuttia päästä", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.text).toBe("5 minuuttia päästä");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12, 19));
+    });
+
+    testSingleCase(chrono.fi, "3 päivää päästä", new Date(2012, 7, 10, 12, 14), (result) => {
+        expect(result.text).toBe("3 päivää päästä");
+
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(13);
+    });
+
+    testSingleCase(chrono.fi, "2 viikkoa päästä", new Date(2016, 10 - 1, 1), (result) => {
+        expect(result.text).toBe("2 viikkoa päästä");
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(10);
+        expect(result.start.get("day")).toBe(15);
+    });
+});

package/test/fi/fi_weekday.test.ts

@@ -0,0 +1,90 @@
+import * as chrono from "../../src/locales/fi";
+import { testSingleCase } from "../test_util";
+
+test("Test - Single Expression", function () {
+    testSingleCase(chrono, "maanantai", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("maanantai");
+
+        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(6);
+        expect(result.start.get("weekday")).toBe(1);
+    });
+
+    testSingleCase(chrono, "maanantaina", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("maanantaina");
+
+        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(6);
+        expect(result.start.get("weekday")).toBe(1);
+    });
+});
+
+test("Test - Next/Last Week Expression", function () {
+    testSingleCase(chrono, "ensi maanantai", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("ensi maanantai");
+
+        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(13);
+        expect(result.start.get("weekday")).toBe(1);
+    });
+
+    testSingleCase(chrono, "viime maanantai", new Date(2012, 7, 9), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("viime maanantai");
+
+        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(6);
+        expect(result.start.get("weekday")).toBe(1);
+    });
+});
+
+test("Test - Weekday variations", function () {
+    testSingleCase(chrono, "sunnuntai", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(0);
+    });
+
+    testSingleCase(chrono, "tiistai", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(2);
+    });
+
+    testSingleCase(chrono, "keskiviikko", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(3);
+    });
+
+    testSingleCase(chrono, "torstai", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(4);
+    });
+
+    testSingleCase(chrono, "perjantai", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(5);
+    });
+
+    testSingleCase(chrono, "lauantai", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(6);
+    });
+});
+
+test("Test - Weekday abbreviations", function () {
+    testSingleCase(chrono, "ma", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(1);
+    });
+
+    testSingleCase(chrono, "pe", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(5);
+    });
+
+    testSingleCase(chrono, "su", new Date(2012, 7, 9), (result) => {
+        expect(result.start.get("weekday")).toBe(0);
+    });
+});

package/test/fr/fr_casual.test.ts

@@ -298,3 +298,17 @@ test("Test - Combined Expression", function () {
 //     expect(results.length).toBe(0);
 //
 // });
+
+test("Test - Casual time keeps its meridiem when merged with an explicit time", () => {
+    testSingleCase(chrono.fr, "après-midi à 5", new Date(2016, 7, 10, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(17);
+        expect(result.start.get("meridiem")).toBe(1);
+    });
+
+    testSingleCase(chrono.fr, "soir à 8", new Date(2016, 7, 10, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(20);
+        expect(result.start.get("meridiem")).toBe(1);
+    });
+});

package/test/fr/fr_time_units_casual_relative.test.ts

@@ -106,3 +106,9 @@ test("Test - fr - relative date", function () {
         expect(result.start.isCertain("second")).toBeFalsy();
     });
 });
+
+test("Test - fr - false positive prevention for single-letter time units", function () {
+    // Test that "la derniere h" in "la derniere homme" doesn't match as "la derniere h" (last hour)
+    // The word boundary check should prevent "h" from matching the time unit "h"
+    testUnexpectedResult(chrono.fr, "la derniere homme");
+});

package/test/it/it_casual.test.ts

@@ -42,3 +42,40 @@ test("Test - Single Expression", () => {
         expect(result.start).toBeDate(new Date(2012, 7, 11, 17, 10));
     });
 });
+
+test("Test - Casual time keeps its meridiem when merged with an explicit time", () => {
+    testSingleCase(chrono.it, "pomeriggio alle 5", new Date(2016, 7, 10, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(17);
+        expect(result.start.get("meridiem")).toBe(1);
+    });
+
+    testSingleCase(chrono.it, "sera alle 8", new Date(2016, 7, 10, 12), (result, text) => {
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(20);
+        expect(result.start.get("meridiem")).toBe(1);
+    });
+});
+
+test("Test - Casual time midnight and noon", () => {
+    testSingleCase(chrono.it.casual, "La scadenza è mezzanotte", new Date(2012, 7, 10, 12), (result) => {
+        expect(result.index).toBe(13);
+        expect(result.text).toBe(" mezzanotte");
+        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);
+    });
+
+    testSingleCase(chrono.it.casual, "La scadenza è mezzogiorno", new Date(2012, 7, 10, 12), (result) => {
+        expect(result.index).toBe(13);
+        expect(result.text).toBe(" mezzogiorno");
+        expect(result.start.get("year")).toBe(2012);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(10);
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("meridiem")).toBe(0);
+    });
+});

package/test/it/it_month_name_middle_endian.test.ts

@@ -0,0 +1,39 @@
+import * as chrono from "../../src";
+import { testSingleCase } from "../test_util";
+
+test("Test - Single Expression", () => {
+    testSingleCase(chrono.it, "Ci vediamo ad Agosto 2017.", (result) => {
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2017);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(1);
+
+        expect(result.index).toBe(14);
+        expect(result.text).toBe("Agosto 2017");
+
+        expect(result.start).toBeDate(new Date(2017, 8 - 1, 1, 12));
+    });
+
+    testSingleCase(chrono.it, "Agosto 10, 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(8);
+        expect(result.start.get("day")).toBe(10);
+
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Agosto 10, 2012");
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 12));
+    });
+
+    testSingleCase(chrono.it, "La scadenza è Agosto 10", new Date(2012, 7, 10), (result) => {
+        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(10);
+
+        expect(result.text).toBe("Agosto 10");
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 12));
+    });
+});

package/test/it/it_time_exp.test.ts

@@ -0,0 +1,84 @@
+import * as chrono from "../../src";
+import { testSingleCase } from "../test_util";
+
+test("Test - Single Expression", function () {
+    testSingleCase(chrono.it, "Alle 18:10", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Alle 18:10");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("hour")).toBe(18);
+        expect(result.start.get("minute")).toBe(10);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 18, 10));
+    });
+
+    testSingleCase(chrono.it, "Alle 6:10", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Alle 6:10");
+
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("hour")).toBe(6);
+        expect(result.start.get("minute")).toBe(10);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 6, 10));
+    });
+});
+
+test("Test - Time Expression with Meridiem", function () {
+    testSingleCase(chrono.it, "6 del pomeriggio", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("6 del pomeriggio");
+
+        expect(result.start.get("hour")).toBe(18);
+        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("meridiem")).toBe(1);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 18, 0));
+    });
+
+    testSingleCase(chrono.it, "ore 6 in punto", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(4);
+        expect(result.text).toBe("6 in punto");
+
+        expect(result.start.get("hour")).toBe(6);
+        expect(result.start.get("minute")).toBe(0);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 6, 0));
+    });
+
+    testSingleCase(chrono.it, "6 della mattina", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("6 della mattina");
+
+        expect(result.start.get("hour")).toBe(6);
+        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("meridiem")).toBe(0);
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 6, 0));
+    });
+
+    testSingleCase(chrono.it, "Alle 20 sera", new Date(2012, 7, 10), (result) => {
+        expect(result.text).toBe("Alle 20 sera");
+        expect(result.start.get("hour")).toBe(20);
+        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("meridiem")).toBe(1);
+    });
+});
+
+test("Test - Casual Time Expression", function () {
+    testSingleCase(chrono.it, "Stasera", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("Stasera");
+        expect(result.start.get("hour")).toBe(22); // Implied "evening" hours?
+    });
+
+    // Check if this parser handles range
+    testSingleCase(chrono.it, "10:00 - 12:00", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("10:00 - 12:00");
+
+        expect(result.start.get("hour")).toBe(10);
+        expect(result.end.get("hour")).toBe(12);
+    });
+});

package/test/it/it_year_month_day.test.ts

@@ -0,0 +1,41 @@
+import { testSingleCase, testUnexpectedResult } from "../test_util";
+import * as chrono from "../../src";
+
+test("Test - Single Expression (YYYY.MM.DD)", function () {
+    testSingleCase(chrono.it, "2012.08.10", new Date(2012, 7, 10), (result) => {
+        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(10);
+
+        expect(result.index).toBe(0);
+        expect(result.text).toBe("2012.08.10");
+
+        expect(result.start).toBeDate(new Date(2012, 8 - 1, 10, 12));
+    });
+
+    testSingleCase(chrono.it, "La scadenza è 2012.08.10", new Date(2012, 7, 10), (result) => {
+        expect(result.index).toBe(14);
+        expect(result.text).toBe("2012.08.10");
+
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 12));
+    });
+
+    testSingleCase(chrono.it.strict, "2014.02.28", (result) => {
+        expect(result.text).toBe("2014.02.28");
+    });
+
+    testSingleCase(chrono.it.strict, "2014.12.28", (result) => {
+        expect(result.text).toBe("2014.12.28");
+        expect(result).toBeDate(new Date(2014, 12 - 1, 28, 12));
+    });
+});
+
+test("Test - Not parse unlikely YYYY.MM.DD pattern", function () {
+    testUnexpectedResult(chrono.it, "2012.80.10", new Date(2012, 7, 10));
+});
+
+test("Test - Not parse impossible dates", function () {
+    testUnexpectedResult(chrono.it, "2014.08.32");
+    testUnexpectedResult(chrono.it, "2014.02.30");
+});

package/test/result.test.ts

@@ -87,6 +87,14 @@ test("Test - Create & manipulate parsing results", () => {
     expect(result.toString()).toContain(text);
     expect(result.toString()).toContain("custom/testing_start_component_tag");
     expect(result.toString()).toContain("custom/testing_end_component_tag");
+
+    // The result's addTag() and addTags() should add the tags to both start/end components
+    result.addTag("custom/testing_result_tag1");
+    result.addTags(["custom/testing_result_tag2"]);
+    expect(startComponents.tags()).toContain("custom/testing_result_tag1");
+    expect(startComponents.tags()).toContain("custom/testing_result_tag2");
+    expect(endComponents.tags()).toContain("custom/testing_result_tag1");
+    expect(endComponents.tags()).toContain("custom/testing_result_tag2");
 });
 
 test("Test - Calendar checking with implied components", () => {

package/test/system.test.ts

@@ -228,9 +228,10 @@ test("Test - Compare with native js", () => {
 
     testByCompareWithNative("22 Feb 2015 04:12:00 -0000");
 
-    testByCompareWithNative("1900-01-01T00:00:00-01:00");
-
-    testByCompareWithNative("1900-01-01T00:00:00-00:00");
+    // Chrono's timezone calculation uses `Date.prototype.getTimezoneOffset()` which returns precision in minutes.
+    // Historical Local Mean Time (LMT) often includes seconds (e.g., Shanghai 1900 is +08:05:43).
+    // testByCompareWithNative("1900-01-01T00:00:00-01:00");
+    // testByCompareWithNative("1900-01-01T00:00:00-00:00");
 
     testByCompareWithNative("9999-12-31T23:59:00-00:00");
 

package/test/system_timezone.test.ts

@@ -183,3 +183,102 @@ test("Test - Precise date/time mentioned", function () {
         expect(result).toBeDate(new Date(text));
     });
 });
+
+test("Test - Minimize diff because of local timezone (pre-1900)", () => {
+    // Because of Local mean time (LMT), the local/system timezone my work differently before 1900
+    // For example:
+    //  - Shanghai LMT in 1900 was +08:05:43
+    // We expect Chrono to parse this within a few hours precision
+
+    testSingleCase(chrono, "1900-01-01T00:00:00-00:00", (result) => {
+        const expectedDate = new Date("1900-01-01T00:00:00-00:00");
+        const differenceMinutes = Math.abs(result.date().getTime() - expectedDate.getTime()) / (1000 * 60);
+        expect(differenceMinutes).toBeLessThanOrEqual(60);
+    });
+
+    testSingleCase(chrono, "1900-01-01T00:00:00-01:00", (result) => {
+        const expectedDate = new Date("1900-01-01T00:00:00-01:00");
+        const differenceMinutes = Math.abs(result.date().getTime() - expectedDate.getTime()) / (1000 * 60);
+        expect(differenceMinutes).toBeLessThanOrEqual(60 * 2);
+    });
+
+    testSingleCase(chrono, "1900-01-01T00:00:00+08:00", (result) => {
+        const expectedDate = new Date("1900-01-01T00:00:00+08:00");
+        const differenceMinutes = Math.abs(result.date().getTime() - expectedDate.getTime()) / (1000 * 60);
+        expect(differenceMinutes).toBeLessThanOrEqual(60 * 2);
+    });
+
+    testSingleCase(chrono, "1900-01-01T00:00", { timezone: "JST" }, (result) => {
+        const expectedDate = new Date("1900-01-01T00:00:00+08:00");
+        const differenceMinutes = Math.abs(result.date().getTime() - expectedDate.getTime()) / (1000 * 60);
+        expect(differenceMinutes).toBeLessThanOrEqual(60 * 2);
+    });
+});
+
+test("Test - Timezone DST transitions", function () {
+    // CT (Central Time) transitions:
+    // - DST starts: 2nd Sunday of March at 2am
+    // - DST ends: 1st Sunday of November at 2am
+    testSingleCase(chrono, "2022-03-12 23:00 CT", (result, text) => {
+        // Before DST transition, expected: -360
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-6 * 60);
+    });
+    testSingleCase(chrono, "2022-03-13 23:00 CT", (result, text) => {
+        // Within DST, expect -300 minutes
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-5 * 60);
+    });
+    testSingleCase(chrono, "2022-11-06 23:00 CT", (result, text) => {
+        // After DST transition, expected: -360
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-6 * 60);
+    });
+
+    // MT (Mountain Time) transitions:
+    // - DST starts: 2nd Sunday of March at 2am
+    // - DST ends: 1st Sunday of November at 2am
+    testSingleCase(chrono, "2022-03-12 23:00 MT", (result, text) => {
+        // Before DST transition, expected: -420
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-7 * 60);
+    });
+    testSingleCase(chrono, "2022-03-13 23:00 MT", (result, text) => {
+        // Within DST, expected: -360
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-6 * 60);
+    });
+    testSingleCase(chrono, "2022-11-06 23:00 MT", (result, text) => {
+        // After DST transition, expected: -420
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-7 * 60);
+    });
+
+    // PT (Pacific Time) transitions:
+    // - DST starts: 2nd Sunday of March at 2am
+    // - DST ends: 1st Sunday of November at 2am
+    testSingleCase(chrono, "2022-03-12 23:00 PT", (result, text) => {
+        // Before DST transition, expected: -480
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-8 * 60);
+    });
+    testSingleCase(chrono, "2022-03-13 23:00 PT", (result, text) => {
+        // Within DST, expected: -420
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-7 * 60);
+    });
+    testSingleCase(chrono, "2022-11-06 23:00 PT", (result, text) => {
+        // After DST transition, expected: -480
+        expect(result.text).toBe(text);
+        expect(result.start.get("hour")).toBe(23);
+        expect(result.start.get("timezoneOffset")).toBe(-8 * 60);
+    });
+});

package/test/uk/uk_time_units_within.test.ts

@@ -1,5 +1,5 @@
 import * as chrono from "../../src";
-import { testSingleCase } from "../test_util";
+import { testSingleCase, testUnexpectedResult } from "../test_util";
 
 test("Test - The normal within expression", () => {
     testSingleCase(chrono.uk, "буде зроблено протягом хвилини", new Date(2012, 7, 10), (result) => {
@@ -14,3 +14,10 @@ test("Test - The normal within expression", () => {
         expect(result.start).toBeDate(new Date(2012, 7, 10, 2));
     });
 });
+
+test("Test - Within expression respects the word boundary", () => {
+    // The forwardDate branch builds a bare time-unit pattern whose right boundary uses the
+    // \p{L}\p{N} escapes, so a unit glued to a following letter must not match. "годин" (hours)
+    // is a prefix of "годинників" (watches), so this sentence must not parse as "5 hours".
+    testUnexpectedResult(chrono.uk, "купив 5 годинників", new Date(2012, 7, 10), { forwardDate: true });
+});