chrono-node 2.3.7 → 2.3.8

package/src/locales/de/parsers/DESpecificTimeExpressionParser.ts

@@ -0,0 +1,150 @@
+import { Parser, ParsingContext } from "../../../chrono";
+import { ParsingComponents, ParsingResult } from "../../../results";
+import { Meridiem } from "../../../index";
+
+/**
+ * 8h10m00s
+ * 8h10m00
+ * 8h10
+ * 8 Uhr
+ * 8h10m00s Uhr
+ * 8:10 Uhr
+ */
+const FIRST_REG_PATTERN = new RegExp(
+    "(^|\\s|T)" +
+        "(?:(?:um|von)\\s*)?" +
+        "(\\d{1,2})(?:h|:)?" +
+        "(?:(\\d{1,2})(?:m|:)?)?" +
+        "(?:(\\d{1,2})(?:s)?)?" +
+        "(?:\\s*Uhr)?" +
+        "(?:\\s*(morgens|vormittags|nachmittags|abends|nachts|am\\s+(?:Morgen|Vormittag|Nachmittag|Abend)|in\\s+der\\s+Nacht))?" +
+        "(?=\\W|$)",
+    "i"
+);
+
+const SECOND_REG_PATTERN = new RegExp(
+    "^\\s*(\\-|\\–|\\~|\\〜|bis(?:\\s+um)?|\\?)\\s*" +
+        "(\\d{1,2})(?:h|:)?" +
+        "(?:(\\d{1,2})(?:m|:)?)?" +
+        "(?:(\\d{1,2})(?:s)?)?" +
+        "(?:\\s*Uhr)?" +
+        "(?:\\s*(morgens|vormittags|nachmittags|abends|nachts|am\\s+(?:Morgen|Vormittag|Nachmittag|Abend)|in\\s+der\\s+Nacht))?" +
+        "(?=\\W|$)",
+    "i"
+);
+
+const HOUR_GROUP = 2;
+const MINUTE_GROUP = 3;
+const SECOND_GROUP = 4;
+const AM_PM_HOUR_GROUP = 5;
+
+export default class DESpecificTimeExpressionParser implements Parser {
+    pattern(context): RegExp {
+        return FIRST_REG_PATTERN;
+    }
+
+    extract(context: ParsingContext, match: RegExpMatchArray): ParsingResult | null {
+        const result = context.createParsingResult(match.index + match[1].length, match[0].substring(match[1].length));
+
+        // This looks more like a year e.g. 2020
+        if (result.text.match(/^\d{4}$/)) {
+            match.index += match[0].length;
+            return null;
+        }
+
+        result.start = DESpecificTimeExpressionParser.extractTimeComponent(result.start.clone(), match);
+        if (!result.start) {
+            match.index += match[0].length;
+            return null;
+        }
+
+        const remainingText = context.text.substring(match.index + match[0].length);
+        const secondMatch = SECOND_REG_PATTERN.exec(remainingText);
+        if (secondMatch) {
+            result.end = DESpecificTimeExpressionParser.extractTimeComponent(result.start.clone(), secondMatch);
+            if (result.end) {
+                result.text += secondMatch[0];
+            }
+        }
+
+        return result;
+    }
+
+    private static extractTimeComponent(
+        extractingComponents: ParsingComponents,
+        match: RegExpMatchArray
+    ): ParsingComponents | null {
+        let hour = 0;
+        let minute = 0;
+        let meridiem = null;
+
+        // ----- Hours
+        hour = parseInt(match[HOUR_GROUP]);
+
+        // ----- Minutes
+        if (match[MINUTE_GROUP] != null) {
+            minute = parseInt(match[MINUTE_GROUP]);
+        }
+
+        if (minute >= 60 || hour > 24) {
+            return null;
+        }
+
+        if (hour >= 12) {
+            meridiem = Meridiem.PM;
+        }
+
+        // ----- AM & PM
+        if (match[AM_PM_HOUR_GROUP] != null) {
+            if (hour > 12) return null;
+            const ampm = match[AM_PM_HOUR_GROUP].toLowerCase();
+            if (ampm.match(/morgen|vormittag/)) {
+                meridiem = Meridiem.AM;
+                if (hour == 12) {
+                    hour = 0;
+                }
+            }
+
+            if (ampm.match(/nachmittag|abend/)) {
+                meridiem = Meridiem.PM;
+                if (hour != 12) {
+                    hour += 12;
+                }
+            }
+
+            if (ampm.match(/nacht/)) {
+                if (hour == 12) {
+                    meridiem = Meridiem.AM;
+                    hour = 0;
+                } else if (hour < 6) {
+                    meridiem = Meridiem.AM;
+                } else {
+                    meridiem = Meridiem.PM;
+                    hour += 12;
+                }
+            }
+        }
+
+        extractingComponents.assign("hour", hour);
+        extractingComponents.assign("minute", minute);
+        if (meridiem !== null) {
+            extractingComponents.assign("meridiem", meridiem);
+        } else {
+            if (hour < 12) {
+                extractingComponents.imply("meridiem", Meridiem.AM);
+            } else {
+                extractingComponents.imply("meridiem", Meridiem.PM);
+            }
+        }
+
+        // ----- Second
+        if (match[SECOND_GROUP] != null) {
+            const second = parseInt(match[SECOND_GROUP]);
+            if (second >= 60) return null;
+
+            extractingComponents.assign("second", second);
+        }
+
+        return extractingComponents;
+    }
+}

package/src/locales/de/parsers/DETimeExpressionParser.ts

@@ -1,7 +1,6 @@
 import { AbstractTimeExpressionParser } from "../../../common/parsers/AbstractTimeExpressionParser";
 import { ParsingComponents } from "../../../results";
 import { ParsingContext } from "../../../chrono";
-import { Meridiem } from "../../../index";
 
 export default class DETimeExpressionParser extends AbstractTimeExpressionParser {
     primaryPrefix(): string {
@@ -12,30 +11,12 @@ export default class DETimeExpressionParser extends AbstractTimeExpressionParser
         return "\\s*(?:\\-|\\–|\\~|\\〜|bis)\\s*";
     }
 
-    primarySuffix(): string {
-        return "(?:\\s*uhr)?(?:\\s*(?:morgens|vormittags|nachmittags|abends|nachts))?(?=\\W|$)";
-    }
-
     extractPrimaryTimeComponents(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | null {
-        const components = super.extractPrimaryTimeComponents(context, match);
-        if (components) {
-            if (match[0].endsWith("morgens") || match[0].endsWith("vormittags")) {
-                components.assign("meridiem", Meridiem.AM);
-                const hour = components.get("hour");
-                if (hour < 12) {
-                    components.assign("hour", components.get("hour"));
-                }
-            }
-
-            if (match[0].endsWith("nachmittags") || match[0].endsWith("abends") || match[0].endsWith("nachts")) {
-                components.assign("meridiem", Meridiem.PM);
-                const hour = components.get("hour");
-                if (hour < 12) {
-                    components.assign("hour", components.get("hour") + 12);
-                }
-            }
+        // This looks more like a year e.g. 2020
+        if (match[0].match(/^\s*\d{4}\s*$/)) {
+            return null;
         }
 
-        return components;
+        return super.extractPrimaryTimeComponents(context, match);
     }
 }

package/src/locales/de/parsers/DETimeUnitRelativeFormatParser.ts

@@ -0,0 +1,42 @@
+import { ParsingContext } from "../../../chrono";
+import { NUMBER_PATTERN, parseNumberPattern, TIME_UNIT_DICTIONARY } from "../constants";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { reverseTimeUnits } from "../../../utils/timeunits";
+import { matchAnyPattern } from "../../../utils/pattern";
+
+export default class DETimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor() {
+        super();
+    }
+
+    innerPattern(): RegExp {
+        return new RegExp(
+            `(?:\\s*((?:nächste|kommende|folgende|letzte|vergangene|vorige|vor(?:her|an)gegangene)(?:s|n|m|r)?|vor|in)\\s*)?` +
+                `(${NUMBER_PATTERN})?` +
+                `(?:\\s*(nächste|kommende|folgende|letzte|vergangene|vorige|vor(?:her|an)gegangene)(?:s|n|m|r)?)?` +
+                `\\s*(${matchAnyPattern(TIME_UNIT_DICTIONARY)})`,
+            "i"
+        );
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const num = match[2] ? parseNumberPattern(match[2]) : 1;
+        const unit = TIME_UNIT_DICTIONARY[match[4].toLowerCase()];
+        let timeUnits = {};
+        timeUnits[unit] = num;
+
+        // Modifier
+        let modifier = match[1] || match[3] || "";
+        modifier = modifier.toLowerCase();
+        if (!modifier) {
+            return;
+        }
+
+        if (/vor/.test(modifier) || /letzte/.test(modifier) || /vergangen/.test(modifier)) {
+            timeUnits = reverseTimeUnits(timeUnits);
+        }
+
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}

package/src/locales/en/constants.ts

@@ -1,4 +1,4 @@
-import { OpUnitType } from "dayjs";
+import { OpUnitType, QUnitType } from "dayjs";
 import { matchAnyPattern, repeatedTimeunitPattern } from "../../utils/pattern";
 import { findMostLikelyADYear } from "../../calculation/years";
 import { TimeUnits } from "../../utils/timeunits";
@@ -133,7 +133,7 @@ export const ORDINAL_WORD_DICTIONARY: { [word: string]: number } = {
     "thirty-first": 31,
 };
 
-export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType } = {
+export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } = {
     sec: "second",
     second: "second",
     seconds: "second",
@@ -152,6 +152,9 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType } = {
     weeks: "week",
     month: "month",
     months: "month",
+    qtr: "quarter",
+    quarter: "quarter",
+    quarters: "quarter",
     y: "year",
     yr: "year",
     year: "year",

package/src/results.ts

@@ -8,13 +8,12 @@ dayjs.extend(quarterOfYear);
 
 export class ReferenceWithTimezone {
     readonly instant: Date;
-    readonly timezoneOffset?: number;
+    readonly timezoneOffset?: number | null;
 
     constructor(input?: ParsingReference | Date) {
         input = input ?? new Date();
         if (input instanceof Date) {
             this.instant = input;
-            this.timezoneOffset = -input.getTimezoneOffset();
         } else {
             this.instant = input.instant ?? new Date();
             this.timezoneOffset = toTimezoneOffset(input.timezone);
@@ -133,7 +132,7 @@ export class ParsingComponents implements ParsedComponents {
     toString() {
         return `[ParsingComponents {knownValues: ${JSON.stringify(this.knownValues)}, impliedValues: ${JSON.stringify(
             this.impliedValues
-        )}}]`;
+        )}}, reference: ${JSON.stringify(this.reference)}]`;
     }
 
     dayjs() {

package/src/timezone.ts

@@ -192,8 +192,8 @@ export const TIMEZONE_ABBR_MAP = {
     YEKT: 360,
 };
 
-export function toTimezoneOffset(timezoneInput: string | number): number | null {
-    if (timezoneInput === null) {
+export function toTimezoneOffset(timezoneInput?: string | number): number | null {
+    if (timezoneInput === null || timezoneInput === undefined) {
         return null;
     }
 
@@ -201,5 +201,5 @@ export function toTimezoneOffset(timezoneInput: string | number): number | null
         return timezoneInput;
     }
 
-    return TIMEZONE_ABBR_MAP[timezoneInput] ?? 0;
+    return TIMEZONE_ABBR_MAP[timezoneInput] ?? null;
 }

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());
+    });
+});