chrono-node 2.3.7 → 2.3.8

package/dist/common/refiners/ExtractTimezoneAbbrRefiner.js

@@ -214,7 +214,7 @@ class ExtractTimezoneAbbrRefiner {
                 return;
             }
             context.debug(() => {
-                console.log(`Extracting timezone: '${timezoneAbbr}' into : ${extractedTimezoneOffset}`);
+                console.log(`Extracting timezone: '${timezoneAbbr}' into: ${extractedTimezoneOffset} for: ${result.start}`);
             });
             const currentTimezoneOffset = result.start.get("timezoneOffset");
             if (currentTimezoneOffset !== null && extractedTimezoneOffset != currentTimezoneOffset) {

package/dist/locales/de/constants.d.ts

@@ -1,4 +1,4 @@
-import { OpUnitType } from "dayjs";
+import { OpUnitType, QUnitType } from "dayjs";
 import { TimeUnits } from "../../utils/timeunits";
 export declare const WEEKDAY_DICTIONARY: {
     [word: string]: number;
@@ -10,11 +10,11 @@ export declare const INTEGER_WORD_DICTIONARY: {
     [word: string]: number;
 };
 export declare const TIME_UNIT_DICTIONARY: {
-    [word: string]: OpUnitType;
+    [word: string]: OpUnitType | QUnitType;
 };
 export declare const NUMBER_PATTERN: string;
 export declare function parseNumberPattern(match: string): number;
-export declare const YEAR_PATTERN = "(?:[0-9]{1,4}(?:\\s*[vn]\\.?\\s*C(?:hr)?\\.?)?)";
+export declare const YEAR_PATTERN = "(?:[0-9]{1,4}(?:\\s*[vn]\\.?\\s*(?:C(?:hr)?|(?:u\\.?|d\\.?(?:\\s*g\\.?)?)?\\s*Z)\\.?|\\s*(?:u\\.?|d\\.?(?:\\s*g\\.)?)\\s*Z\\.?)?)";
 export declare function parseYear(match: string): number;
 export declare const TIME_UNITS_PATTERN: string;
 export declare function parseTimeUnits(timeunitText: any): TimeUnits;

package/dist/locales/de/constants.js

@@ -21,9 +21,12 @@ exports.WEEKDAY_DICTIONARY = {
 };
 exports.MONTH_DICTIONARY = {
     "januar": 1,
+    "jänner": 1,
+    "janner": 1,
     "jan": 1,
     "jan.": 1,
     "februar": 2,
+    "feber": 2,
     "feb": 2,
     "feb.": 2,
     "märz": 3,
@@ -62,6 +65,10 @@ exports.MONTH_DICTIONARY = {
 };
 exports.INTEGER_WORD_DICTIONARY = {
     "eins": 1,
+    "eine": 1,
+    "einem": 1,
+    "einen": 1,
+    "einer": 1,
     "zwei": 2,
     "drei": 3,
     "vier": 4,
@@ -77,28 +84,36 @@ exports.INTEGER_WORD_DICTIONARY = {
     "zwoelf": 12,
 };
 exports.TIME_UNIT_DICTIONARY = {
-    sec: "second",
-    second: "second",
-    seconds: "second",
+    sek: "second",
+    sekunde: "second",
+    sekunden: "second",
     min: "minute",
-    mins: "minute",
     minute: "minute",
-    minutes: "minute",
+    minuten: "minute",
     h: "hour",
-    hr: "hour",
-    hrs: "hour",
-    hour: "hour",
-    hours: "hour",
-    day: "d",
-    days: "d",
-    week: "week",
-    weeks: "week",
-    month: "month",
-    months: "month",
-    y: "year",
-    yr: "year",
-    year: "year",
-    years: "year",
+    std: "hour",
+    stunde: "hour",
+    stunden: "hour",
+    tag: "d",
+    tage: "d",
+    tagen: "d",
+    woche: "week",
+    wochen: "week",
+    monat: "month",
+    monate: "month",
+    monaten: "month",
+    monats: "month",
+    quartal: "quarter",
+    quartals: "quarter",
+    quartale: "quarter",
+    quartalen: "quarter",
+    a: "year",
+    j: "year",
+    jr: "year",
+    jahr: "year",
+    jahre: "year",
+    jahren: "year",
+    jahres: "year",
 };
 exports.NUMBER_PATTERN = `(?:${pattern_1.matchAnyPattern(exports.INTEGER_WORD_DICTIONARY)}|[0-9]+|[0-9]+\\.[0-9]+|half(?:\\s*an?)?|an?\\b(?:\\s*few)?|few|several|a?\\s*couple\\s*(?:of)?)`;
 function parseNumberPattern(match) {
@@ -124,7 +139,7 @@ function parseNumberPattern(match) {
     return parseFloat(num);
 }
 exports.parseNumberPattern = parseNumberPattern;
-exports.YEAR_PATTERN = `(?:[0-9]{1,4}(?:\\s*[vn]\\.?\\s*C(?:hr)?\\.?)?)`;
+exports.YEAR_PATTERN = `(?:[0-9]{1,4}(?:\\s*[vn]\\.?\\s*(?:C(?:hr)?|(?:u\\.?|d\\.?(?:\\s*g\\.?)?)?\\s*Z)\\.?|\\s*(?:u\\.?|d\\.?(?:\\s*g\\.)?)\\s*Z\\.?)?)`;
 function parseYear(match) {
     if (/v/i.test(match)) {
         return -parseInt(match.replace(/[^0-9]+/gi, ""));
@@ -132,6 +147,9 @@ function parseYear(match) {
     if (/n/i.test(match)) {
         return parseInt(match.replace(/[^0-9]+/gi, ""));
     }
+    if (/z/i.test(match)) {
+        return parseInt(match.replace(/[^0-9]+/gi, ""));
+    }
     const rawYearNumber = parseInt(match);
     return years_1.findMostLikelyADYear(rawYearNumber);
 }

package/dist/locales/de/index.js

@@ -10,11 +10,13 @@ const SlashDateFormatParser_1 = __importDefault(require("../../common/parsers/Sl
 const ISOFormatParser_1 = __importDefault(require("../../common/parsers/ISOFormatParser"));
 const DETimeExpressionParser_1 = __importDefault(require("./parsers/DETimeExpressionParser"));
 const DEWeekdayParser_1 = __importDefault(require("./parsers/DEWeekdayParser"));
+const DESpecificTimeExpressionParser_1 = __importDefault(require("./parsers/DESpecificTimeExpressionParser"));
 const DEMergeDateRangeRefiner_1 = __importDefault(require("./refiners/DEMergeDateRangeRefiner"));
 const DEMergeDateTimeRefiner_1 = __importDefault(require("./refiners/DEMergeDateTimeRefiner"));
 const DECasualDateParser_1 = __importDefault(require("./parsers/DECasualDateParser"));
 const DECasualTimeParser_1 = __importDefault(require("./parsers/DECasualTimeParser"));
 const DEMonthNameLittleEndianParser_1 = __importDefault(require("./parsers/DEMonthNameLittleEndianParser"));
+const DETimeUnitRelativeFormatParser_1 = __importDefault(require("./parsers/DETimeUnitRelativeFormatParser"));
 exports.casual = new chrono_1.Chrono(createCasualConfiguration());
 exports.strict = new chrono_1.Chrono(createConfiguration(true));
 function parse(text, ref, option) {
@@ -29,6 +31,7 @@ function createCasualConfiguration(littleEndian = true) {
     const option = createConfiguration(false, littleEndian);
     option.parsers.unshift(new DECasualTimeParser_1.default());
     option.parsers.unshift(new DECasualDateParser_1.default());
+    option.parsers.unshift(new DETimeUnitRelativeFormatParser_1.default());
     return option;
 }
 exports.createCasualConfiguration = createCasualConfiguration;
@@ -38,6 +41,7 @@ function createConfiguration(strictMode = true, littleEndian = true) {
             new ISOFormatParser_1.default(),
             new SlashDateFormatParser_1.default(littleEndian),
             new DETimeExpressionParser_1.default(),
+            new DESpecificTimeExpressionParser_1.default(),
             new DEMonthNameLittleEndianParser_1.default(),
             new DEWeekdayParser_1.default(),
         ],

package/dist/locales/de/parsers/DESpecificTimeExpressionParser.d.ts

@@ -0,0 +1,7 @@
+import { Parser, ParsingContext } from "../../../chrono";
+import { ParsingResult } from "../../../results";
+export default class DESpecificTimeExpressionParser implements Parser {
+    pattern(context: any): RegExp;
+    extract(context: ParsingContext, match: RegExpMatchArray): ParsingResult | null;
+    private static extractTimeComponent;
+}

package/dist/locales/de/parsers/DESpecificTimeExpressionParser.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../../index");
+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;
+class DESpecificTimeExpressionParser {
+    pattern(context) {
+        return FIRST_REG_PATTERN;
+    }
+    extract(context, match) {
+        const result = context.createParsingResult(match.index + match[1].length, match[0].substring(match[1].length));
+        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;
+    }
+    static extractTimeComponent(extractingComponents, match) {
+        let hour = 0;
+        let minute = 0;
+        let meridiem = null;
+        hour = parseInt(match[HOUR_GROUP]);
+        if (match[MINUTE_GROUP] != null) {
+            minute = parseInt(match[MINUTE_GROUP]);
+        }
+        if (minute >= 60 || hour > 24) {
+            return null;
+        }
+        if (hour >= 12) {
+            meridiem = index_1.Meridiem.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 = index_1.Meridiem.AM;
+                if (hour == 12) {
+                    hour = 0;
+                }
+            }
+            if (ampm.match(/nachmittag|abend/)) {
+                meridiem = index_1.Meridiem.PM;
+                if (hour != 12) {
+                    hour += 12;
+                }
+            }
+            if (ampm.match(/nacht/)) {
+                if (hour == 12) {
+                    meridiem = index_1.Meridiem.AM;
+                    hour = 0;
+                }
+                else if (hour < 6) {
+                    meridiem = index_1.Meridiem.AM;
+                }
+                else {
+                    meridiem = index_1.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", index_1.Meridiem.AM);
+            }
+            else {
+                extractingComponents.imply("meridiem", index_1.Meridiem.PM);
+            }
+        }
+        if (match[SECOND_GROUP] != null) {
+            const second = parseInt(match[SECOND_GROUP]);
+            if (second >= 60)
+                return null;
+            extractingComponents.assign("second", second);
+        }
+        return extractingComponents;
+    }
+}
+exports.default = DESpecificTimeExpressionParser;

package/dist/locales/de/parsers/DETimeExpressionParser.d.ts

@@ -4,6 +4,5 @@ import { ParsingContext } from "../../../chrono";
 export default class DETimeExpressionParser extends AbstractTimeExpressionParser {
     primaryPrefix(): string;
     followingPhase(): string;
-    primarySuffix(): string;
     extractPrimaryTimeComponents(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | null;
 }

package/dist/locales/de/parsers/DETimeExpressionParser.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const AbstractTimeExpressionParser_1 = require("../../../common/parsers/AbstractTimeExpressionParser");
-const index_1 = require("../../../index");
 class DETimeExpressionParser extends AbstractTimeExpressionParser_1.AbstractTimeExpressionParser {
     primaryPrefix() {
         return "(?:(?:um|von)\\s*)?";
@@ -9,28 +8,11 @@ class DETimeExpressionParser extends AbstractTimeExpressionParser_1.AbstractTime
     followingPhase() {
         return "\\s*(?:\\-|\\–|\\~|\\〜|bis)\\s*";
     }
-    primarySuffix() {
-        return "(?:\\s*uhr)?(?:\\s*(?:morgens|vormittags|nachmittags|abends|nachts))?(?=\\W|$)";
-    }
     extractPrimaryTimeComponents(context, match) {
-        const components = super.extractPrimaryTimeComponents(context, match);
-        if (components) {
-            if (match[0].endsWith("morgens") || match[0].endsWith("vormittags")) {
-                components.assign("meridiem", index_1.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", index_1.Meridiem.PM);
-                const hour = components.get("hour");
-                if (hour < 12) {
-                    components.assign("hour", components.get("hour") + 12);
-                }
-            }
+        if (match[0].match(/^\s*\d{4}\s*$/)) {
+            return null;
         }
-        return components;
+        return super.extractPrimaryTimeComponents(context, match);
     }
 }
 exports.default = DETimeExpressionParser;

package/dist/locales/de/parsers/DETimeUnitRelativeFormatParser.d.ts

@@ -0,0 +1,8 @@
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+export default class DETimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor();
+    innerPattern(): RegExp;
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents;
+}

package/dist/locales/de/parsers/DETimeUnitRelativeFormatParser.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const results_1 = require("../../../results");
+const AbstractParserWithWordBoundary_1 = require("../../../common/parsers/AbstractParserWithWordBoundary");
+const timeunits_1 = require("../../../utils/timeunits");
+const pattern_1 = require("../../../utils/pattern");
+class DETimeUnitAgoFormatParser extends AbstractParserWithWordBoundary_1.AbstractParserWithWordBoundaryChecking {
+    constructor() {
+        super();
+    }
+    innerPattern() {
+        return new RegExp(`(?:\\s*((?:nächste|kommende|folgende|letzte|vergangene|vorige|vor(?:her|an)gegangene)(?:s|n|m|r)?|vor|in)\\s*)?` +
+            `(${constants_1.NUMBER_PATTERN})?` +
+            `(?:\\s*(nächste|kommende|folgende|letzte|vergangene|vorige|vor(?:her|an)gegangene)(?:s|n|m|r)?)?` +
+            `\\s*(${pattern_1.matchAnyPattern(constants_1.TIME_UNIT_DICTIONARY)})`, "i");
+    }
+    innerExtract(context, match) {
+        const num = match[2] ? constants_1.parseNumberPattern(match[2]) : 1;
+        const unit = constants_1.TIME_UNIT_DICTIONARY[match[4].toLowerCase()];
+        let timeUnits = {};
+        timeUnits[unit] = num;
+        let modifier = match[1] || match[3] || "";
+        modifier = modifier.toLowerCase();
+        if (!modifier) {
+            return;
+        }
+        if (/vor/.test(modifier) || /letzte/.test(modifier) || /vergangen/.test(modifier)) {
+            timeUnits = timeunits_1.reverseTimeUnits(timeUnits);
+        }
+        return results_1.ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}
+exports.default = DETimeUnitAgoFormatParser;

package/dist/locales/en/constants.d.ts

@@ -1,4 +1,4 @@
-import { OpUnitType } from "dayjs";
+import { OpUnitType, QUnitType } from "dayjs";
 import { TimeUnits } from "../../utils/timeunits";
 export declare const WEEKDAY_DICTIONARY: {
     [word: string]: number;
@@ -16,7 +16,7 @@ export declare const ORDINAL_WORD_DICTIONARY: {
     [word: string]: number;
 };
 export declare const TIME_UNIT_DICTIONARY: {
-    [word: string]: OpUnitType;
+    [word: string]: OpUnitType | QUnitType;
 };
 export declare const NUMBER_PATTERN: string;
 export declare function parseNumberPattern(match: string): number;

package/dist/locales/en/constants.js

@@ -121,6 +121,9 @@ exports.TIME_UNIT_DICTIONARY = {
     weeks: "week",
     month: "month",
     months: "month",
+    qtr: "quarter",
+    quarter: "quarter",
+    quarters: "quarter",
     y: "year",
     yr: "year",
     year: "year",

package/dist/results.d.ts

@@ -2,7 +2,7 @@ import { Component, ParsedComponents, ParsedResult, ParsingReference } from "./i
 import dayjs, { OpUnitType, QUnitType } from "dayjs";
 export declare class ReferenceWithTimezone {
     readonly instant: Date;
-    readonly timezoneOffset?: number;
+    readonly timezoneOffset?: number | null;
     constructor(input?: ParsingReference | Date);
 }
 export declare class ParsingComponents implements ParsedComponents {

package/dist/results.js

@@ -15,7 +15,6 @@ class ReferenceWithTimezone {
         input = input !== null && input !== void 0 ? input : new Date();
         if (input instanceof Date) {
             this.instant = input;
-            this.timezoneOffset = -input.getTimezoneOffset();
         }
         else {
             this.instant = (_a = input.instant) !== null && _a !== void 0 ? _a : new Date();
@@ -113,7 +112,7 @@ class ParsingComponents {
         return true;
     }
     toString() {
-        return `[ParsingComponents {knownValues: ${JSON.stringify(this.knownValues)}, impliedValues: ${JSON.stringify(this.impliedValues)}}]`;
+        return `[ParsingComponents {knownValues: ${JSON.stringify(this.knownValues)}, impliedValues: ${JSON.stringify(this.impliedValues)}}, reference: ${JSON.stringify(this.reference)}]`;
     }
     dayjs() {
         return dayjs_1.default(this.date());

package/dist/timezone.d.ts

@@ -191,4 +191,4 @@ export declare const TIMEZONE_ABBR_MAP: {
     YEKST: number;
     YEKT: number;
 };
-export declare function toTimezoneOffset(timezoneInput: string | number): number | null;
+export declare function toTimezoneOffset(timezoneInput?: string | number): number | null;

package/dist/timezone.js

@@ -196,12 +196,12 @@ exports.TIMEZONE_ABBR_MAP = {
 };
 function toTimezoneOffset(timezoneInput) {
     var _a;
-    if (timezoneInput === null) {
+    if (timezoneInput === null || timezoneInput === undefined) {
         return null;
     }
     if (typeof timezoneInput === "number") {
         return timezoneInput;
     }
-    return (_a = exports.TIMEZONE_ABBR_MAP[timezoneInput]) !== null && _a !== void 0 ? _a : 0;
+    return (_a = exports.TIMEZONE_ABBR_MAP[timezoneInput]) !== null && _a !== void 0 ? _a : null;
 }
 exports.toTimezoneOffset = toTimezoneOffset;

package/package.json

@@ -15,7 +15,7 @@
     "preset": "ts-jest"
   },
   "license": "MIT",
-  "version": "2.3.7",
+  "version": "2.3.8",
   "directories": {
     "source": "./src",
     "test": "./test"

package/src/common/refiners/ExtractTimezoneAbbrRefiner.ts

@@ -221,7 +221,9 @@ export default class ExtractTimezoneAbbrRefiner implements Refiner {
             }
 
             context.debug(() => {
-                console.log(`Extracting timezone: '${timezoneAbbr}' into : ${extractedTimezoneOffset}`);
+                console.log(
+                    `Extracting timezone: '${timezoneAbbr}' into: ${extractedTimezoneOffset} for: ${result.start}`
+                );
             });
 
             const currentTimezoneOffset = result.start.get("timezoneOffset");

package/src/locales/de/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";
@@ -22,9 +22,12 @@ export const WEEKDAY_DICTIONARY: { [word: string]: number } = {
 
 export const MONTH_DICTIONARY: { [word: string]: number } = {
     "januar": 1,
+    "jänner": 1,
+    "janner": 1,
     "jan": 1,
     "jan.": 1,
     "februar": 2,
+    "feber": 2,
     "feb": 2,
     "feb.": 2,
     "märz": 3,
@@ -64,6 +67,10 @@ export const MONTH_DICTIONARY: { [word: string]: number } = {
 
 export const INTEGER_WORD_DICTIONARY: { [word: string]: number } = {
     "eins": 1,
+    "eine": 1,
+    "einem": 1,
+    "einen": 1,
+    "einer": 1,
     "zwei": 2,
     "drei": 3,
     "vier": 4,
@@ -79,29 +86,37 @@ export const INTEGER_WORD_DICTIONARY: { [word: string]: number } = {
     "zwoelf": 12,
 };
 
-export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType } = {
-    sec: "second",
-    second: "second",
-    seconds: "second",
+export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } = {
+    sek: "second",
+    sekunde: "second",
+    sekunden: "second",
     min: "minute",
-    mins: "minute",
     minute: "minute",
-    minutes: "minute",
+    minuten: "minute",
     h: "hour",
-    hr: "hour",
-    hrs: "hour",
-    hour: "hour",
-    hours: "hour",
-    day: "d",
-    days: "d",
-    week: "week",
-    weeks: "week",
-    month: "month",
-    months: "month",
-    y: "year",
-    yr: "year",
-    year: "year",
-    years: "year",
+    std: "hour",
+    stunde: "hour",
+    stunden: "hour",
+    tag: "d",
+    tage: "d",
+    tagen: "d",
+    woche: "week",
+    wochen: "week",
+    monat: "month",
+    monate: "month",
+    monaten: "month",
+    monats: "month",
+    quartal: "quarter",
+    quartals: "quarter",
+    quartale: "quarter",
+    quartalen: "quarter",
+    a: "year",
+    j: "year",
+    jr: "year",
+    jahr: "year",
+    jahre: "year",
+    jahren: "year",
+    jahres: "year",
 };
 
 //-----------------------------
@@ -131,7 +146,7 @@ export function parseNumberPattern(match: string): number {
 
 //-----------------------------
 
-export const YEAR_PATTERN = `(?:[0-9]{1,4}(?:\\s*[vn]\\.?\\s*C(?:hr)?\\.?)?)`;
+export const YEAR_PATTERN = `(?:[0-9]{1,4}(?:\\s*[vn]\\.?\\s*(?:C(?:hr)?|(?:u\\.?|d\\.?(?:\\s*g\\.?)?)?\\s*Z)\\.?|\\s*(?:u\\.?|d\\.?(?:\\s*g\\.)?)\\s*Z\\.?)?)`;
 export function parseYear(match: string): number {
     if (/v/i.test(match)) {
         // v.Chr.
@@ -143,6 +158,11 @@ export function parseYear(match: string): number {
         return parseInt(match.replace(/[^0-9]+/gi, ""));
     }
 
+    if (/z/i.test(match)) {
+        // n.Chr. as "uZ" or "dgZ"
+        return parseInt(match.replace(/[^0-9]+/gi, ""));
+    }
+
     const rawYearNumber = parseInt(match);
     return findMostLikelyADYear(rawYearNumber);
 }

package/src/locales/de/index.ts

@@ -5,11 +5,13 @@ import SlashDateFormatParser from "../../common/parsers/SlashDateFormatParser";
 import ISOFormatParser from "../../common/parsers/ISOFormatParser";
 import DETimeExpressionParser from "./parsers/DETimeExpressionParser";
 import DEWeekdayParser from "./parsers/DEWeekdayParser";
+import DESpecificTimeExpressionParser from "./parsers/DESpecificTimeExpressionParser";
 import DEMergeDateRangeRefiner from "./refiners/DEMergeDateRangeRefiner";
 import DEMergeDateTimeRefiner from "./refiners/DEMergeDateTimeRefiner";
 import DECasualDateParser from "./parsers/DECasualDateParser";
 import DECasualTimeParser from "./parsers/DECasualTimeParser";
 import DEMonthNameLittleEndianParser from "./parsers/DEMonthNameLittleEndianParser";
+import DETimeUnitRelativeFormatParser from "./parsers/DETimeUnitRelativeFormatParser";
 
 // Shortcuts
 export const casual = new Chrono(createCasualConfiguration());
@@ -27,6 +29,7 @@ export function createCasualConfiguration(littleEndian = true): Configuration {
     const option = createConfiguration(false, littleEndian);
     option.parsers.unshift(new DECasualTimeParser());
     option.parsers.unshift(new DECasualDateParser());
+    option.parsers.unshift(new DETimeUnitRelativeFormatParser());
     return option;
 }
 
@@ -37,6 +40,7 @@ export function createConfiguration(strictMode = true, littleEndian = true): Con
                 new ISOFormatParser(),
                 new SlashDateFormatParser(littleEndian),
                 new DETimeExpressionParser(),
+                new DESpecificTimeExpressionParser(),
                 new DEMonthNameLittleEndianParser(),
                 new DEWeekdayParser(),
             ],