chrono-node 2.3.7 → 2.4.1

package/src/common/parsers/AbstractTimeExpressionParser.ts

@@ -3,23 +3,23 @@ import { ParsingComponents, ParsingResult } from "../../results";
 import { Meridiem } from "../../index";
 
 // prettier-ignore
-function primaryTimePattern(primaryPrefix: string, primarySuffix: string) {
+function primaryTimePattern(leftBoundary: string, primaryPrefix: string, primarySuffix: string, flags: string) {
     return new RegExp(
-        "(^|\\s|T|\\b)" +
+            `${leftBoundary}` +
             `${primaryPrefix}` +
-            "(\\d{1,4})" +
-            "(?:" +
-                "(?:\\.|\\:|\\：)" +
-                "(\\d{1,2})" +
-                "(?:" +
-                    "(?:\\:|\\：)" +
-                    "(\\d{2})" +
-                    "(?:\\.(\\d{1,6}))?" +
-                ")?" +
-            ")?" +
-            "(?:\\s*(a\\.m\\.|p\\.m\\.|am?|pm?))?" +
+            `(\\d{1,4})` +
+            `(?:` +
+                `(?:\\.|:|：)` +
+                `(\\d{1,2})` +
+                `(?:` +
+                    `(?::|：)` +
+                    `(\\d{2})` +
+                    `(?:\\.(\\d{1,6}))?` +
+                `)?` +
+            `)?` +
+            `(?:\\s*(a\\.m\\.|p\\.m\\.|am?|pm?))?` +
             `${primarySuffix}`,
-        "i"
+        flags
     );
 }
 
@@ -27,16 +27,16 @@ function primaryTimePattern(primaryPrefix: string, primarySuffix: string) {
 function followingTimePatten(followingPhase: string, followingSuffix: string) {
     return new RegExp(
         `^(${followingPhase})` +
-            "(\\d{1,4})" +
-            "(?:" +
-                "(?:\\.|\\:|\\：)" +
-                "(\\d{1,2})" +
-                "(?:" +
-                    "(?:\\.|\\:|\\：)" +
-                    "(\\d{1,2})(?:\\.(\\d{1,6}))?" +
-                ")?" +
-            ")?" +
-            "(?:\\s*(a\\.m\\.|p\\.m\\.|am?|pm?))?" +
+            `(\\d{1,4})` +
+            `(?:` +
+                `(?:\\.|\\:|\\：)` +
+                `(\\d{1,2})` +
+                `(?:` +
+                    `(?:\\.|\\:|\\：)` +
+                    `(\\d{1,2})(?:\\.(\\d{1,6}))?` +
+                `)?` +
+            `)?` +
+            `(?:\\s*(a\\.m\\.|p\\.m\\.|am?|pm?))?` +
             `${followingSuffix}`,
         "i"
     );
@@ -57,12 +57,20 @@ export abstract class AbstractTimeExpressionParser implements Parser {
         this.strictMode = strictMode;
     }
 
+    patternFlags(): string {
+        return "i";
+    }
+
+    primaryPatternLeftBoundary(): string {
+        return `(^|\\s|T|\\b)`;
+    }
+
     primarySuffix(): string {
-        return "(?=\\W|$)";
+        return `(?=\\W|$)`;
     }
 
     followingSuffix(): string {
-        return "(?=\\W|$)";
+        return `(?=\\W|$)`;
     }
 
     pattern(context: ParsingContext): RegExp {
@@ -84,6 +92,12 @@ export abstract class AbstractTimeExpressionParser implements Parser {
         const remainingText = context.text.substring(match.index);
         const followingPattern = this.getFollowingTimePatternThroughCache();
         const followingMatch = followingPattern.exec(remainingText);
+
+        // Pattern "456-12", "2022-12" should not be time without proper context
+        if (text.match(/^\d{3,4}/) && followingMatch && followingMatch[0].match(/^\s*([+-])\s*\d{2,4}$/)) {
+            return null;
+        }
+
         if (
             !followingMatch ||
             // Pattern "YY.YY -XXXX" is more like timezone offset
@@ -305,11 +319,16 @@ export abstract class AbstractTimeExpressionParser implements Parser {
     }
 
     private checkAndReturnWithoutFollowingPattern(result) {
-        // Single digit (e.g "1") should not be counted as time expression
+        // Single digit (e.g "1") should not be counted as time expression (without proper context)
         if (result.text.match(/^\d$/)) {
             return null;
         }
 
+        // Three or more digit (e.g. "203", "2014") should not be counted as time expression (without proper context)
+        if (result.text.match(/^\d\d\d+$/)) {
+            return null;
+        }
+
         // Instead of "am/pm", it ends with "a" or "p" (e.g "1a", "123p"), this seems unlikely
         if (result.text.match(/\d[apAP]$/)) {
             return null;
@@ -383,7 +402,12 @@ export abstract class AbstractTimeExpressionParser implements Parser {
             return this.cachedPrimaryTimePattern;
         }
 
-        this.cachedPrimaryTimePattern = primaryTimePattern(primaryPrefix, primarySuffix);
+        this.cachedPrimaryTimePattern = primaryTimePattern(
+            this.primaryPatternLeftBoundary(),
+            primaryPrefix,
+            primarySuffix,
+            this.patternFlags()
+        );
         this.cachedPrimaryPrefix = primaryPrefix;
         this.cachedPrimarySuffix = primarySuffix;
         return this.cachedPrimaryTimePattern;

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/common/refiners/ExtractTimezoneOffsetRefiner.ts

@@ -1,7 +1,7 @@
 import { ParsingContext, Refiner } from "../../chrono";
 import { ParsingResult } from "../../results";
 
-const TIMEZONE_OFFSET_PATTERN = new RegExp("^\\s*(?:(?:GMT|UTC)\\s?)?([+-])(\\d{1,2})(?::?(\\d{2}))?", "i");
+const TIMEZONE_OFFSET_PATTERN = new RegExp("^\\s*(?:\\(?(?:GMT|UTC)\\s?)?([+-])(\\d{1,2})(?::?(\\d{2}))?\\)?", "i");
 const TIMEZONE_OFFSET_SIGN_GROUP = 1;
 const TIMEZONE_OFFSET_HOUR_OFFSET_GROUP = 2;
 const TIMEZONE_OFFSET_MINUTE_OFFSET_GROUP = 3;
@@ -26,6 +26,10 @@ export default class ExtractTimezoneOffsetRefiner implements Refiner {
             const hourOffset = parseInt(match[TIMEZONE_OFFSET_HOUR_OFFSET_GROUP]);
             const minuteOffset = parseInt(match[TIMEZONE_OFFSET_MINUTE_OFFSET_GROUP] || "0");
             let timezoneOffset = hourOffset * 60 + minuteOffset;
+            // No timezones have offsets greater than 14 hours, so disregard this match
+            if (timezoneOffset > 14 * 60) {
+                return;
+            }
             if (match[TIMEZONE_OFFSET_SIGN_GROUP] === "-") {
                 timezoneOffset = -timezoneOffset;
             }

package/src/index.ts

@@ -99,6 +99,16 @@ export enum Meridiem {
     PM = 1,
 }
 
+export enum Weekday {
+    SUNDAY = 0,
+    MONDAY = 1,
+    TUESDAY = 2,
+    WEDNESDAY = 3,
+    THURSDAY = 4,
+    FRIDAY = 5,
+    SATURDAY = 6,
+}
+
 // Export all locales
 import * as de from "./locales/de";
 import * as fr from "./locales/fr";
@@ -106,7 +116,8 @@ import * as ja from "./locales/ja";
 import * as pt from "./locales/pt";
 import * as nl from "./locales/nl";
 import * as zh from "./locales/zh";
-export { de, fr, ja, pt, nl, zh };
+import * as ru from "./locales/ru";
+export { de, fr, ja, pt, nl, zh, ru };
 
 /**
  * A shortcut for {@link en | chrono.en.strict}

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(),
             ],

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/de/parsers/DEWeekdayParser.ts

@@ -3,7 +3,7 @@ import { ParsingComponents } from "../../../results";
 import { WEEKDAY_DICTIONARY } from "../constants";
 import { matchAnyPattern } from "../../../utils/pattern";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
-import { toDayJSWeekday } from "../../../calculation/weeks";
+import { createParsingComponentsAtWeekday } from "../../../common/calculation/weekdays";
 
 const PATTERN = new RegExp(
     "(?:(?:\\,|\\(|\\（)\\s*)?" +
@@ -44,12 +44,6 @@ export default class DEWeekdayParser extends AbstractParserWithWordBoundaryCheck
             modifier = "this";
         }
 
-        const date = toDayJSWeekday(context.refDate, offset, modifier);
-        return context
-            .createParsingComponents()
-            .assign("weekday", offset)
-            .imply("day", date.date())
-            .imply("month", date.month() + 1)
-            .imply("year", date.year());
+        return createParsingComponentsAtWeekday(context.reference, offset, modifier);
     }
 }

package/src/locales/en/constants.ts

@@ -1,9 +1,10 @@
-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";
+import { Weekday } from "../../index";
 
-export const WEEKDAY_DICTIONARY: { [word: string]: number } = {
+export const WEEKDAY_DICTIONARY: { [word: string]: Weekday } = {
     sunday: 0,
     sun: 0,
     "sun.": 0,
@@ -133,7 +134,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 +153,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/locales/en/parsers/ENWeekdayParser.ts

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

package/src/locales/fr/parsers/FRTimeUnitWithinFormatParser.ts

@@ -5,7 +5,7 @@ import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/
 
 export default class FRTimeUnitWithinFormatParser extends AbstractParserWithWordBoundaryChecking {
     innerPattern(): RegExp {
-        return new RegExp(`(?:dans|en|pour|pendant)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+        return new RegExp(`(?:dans|en|pour|pendant|de)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {