chrono-node 2.3.0 → 2.3.4

package/dist/timezone.js

@@ -196,6 +196,9 @@ exports.TIMEZONE_ABBR_MAP = {
 };
 function toTimezoneOffset(timezoneInput) {
     var _a;
+    if (timezoneInput === null) {
+        return null;
+    }
     if (typeof timezoneInput === "number") {
         return timezoneInput;
     }

package/dist/utils/pattern.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.matchAnyPattern = exports.extractTerms = exports.repeatedTimeunitPattern = void 0;
 function repeatedTimeunitPattern(prefix, singleTimeunitPattern) {
     const singleTimeunitPatternNoCapture = singleTimeunitPattern.replace(/\((?!\?)/g, "(?:");
-    return `${prefix}${singleTimeunitPatternNoCapture}\\s*(?:,?\\s{0,5}${singleTimeunitPatternNoCapture}){0,10}`;
+    return `${prefix}${singleTimeunitPatternNoCapture}\\s{0,5}(?:,?\\s{0,5}${singleTimeunitPatternNoCapture}){0,10}`;
 }
 exports.repeatedTimeunitPattern = repeatedTimeunitPattern;
 function extractTerms(dictionary) {

package/package.json

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

package/src/common/casualReferences.ts

@@ -8,7 +8,9 @@ export function now(reference: ReferenceWithTimezone): ParsingComponents {
     const component = new ParsingComponents(reference, {});
     assignSimilarDate(component, targetDate);
     assignSimilarTime(component, targetDate);
-    component.assign("timezoneOffset", targetDate.utcOffset());
+    if (reference.timezoneOffset !== null) {
+        component.assign("timezoneOffset", targetDate.utcOffset());
+    }
     return component;
 }
 

package/src/common/refiners/ForwardDateRefiner.ts

@@ -34,7 +34,7 @@ export default class ForwardDateRefiner implements Refiner {
             }
 
             if (result.start.isOnlyWeekdayComponent() && refMoment.isAfter(result.start.dayjs())) {
-                if (refMoment.day() > result.start.get("weekday")) {
+                if (refMoment.day() >= result.start.get("weekday")) {
                     refMoment = refMoment.day(result.start.get("weekday") + 7);
                 } else {
                     refMoment = refMoment.day(<number>result.start.get("weekday"));

package/src/locales/de/constants.ts

@@ -108,7 +108,7 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType } = {
 
 export const NUMBER_PATTERN = `(?:${matchAnyPattern(
     INTEGER_WORD_DICTIONARY
-)}|[0-9]+|[0-9]+\\.[0-9]+|half(?:\\s*an?)?|an?(?:\\s*few)?|few|several|a?\\s*couple\\s*(?:of)?)`;
+)}|[0-9]+|[0-9]+\\.[0-9]+|half(?:\\s*an?)?|an?\\b(?:\\s*few)?|few|several|a?\\s*couple\\s*(?:of)?)`;
 
 export function parseNumberPattern(match: string): number {
     const num = match.toLowerCase();

package/src/locales/en/constants.ts

@@ -162,7 +162,7 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType } = {
 
 export const NUMBER_PATTERN = `(?:${matchAnyPattern(
     INTEGER_WORD_DICTIONARY
-)}|[0-9]+|[0-9]+\\.[0-9]+|half(?:\\s*an?)?|an?(?:\\s*few)?|few|several|a?\\s*couple\\s*(?:of)?)`;
+)}|[0-9]+|[0-9]+\\.[0-9]+|half(?:\\s{0,2}an?)?|an?\\b(?:\\s{0,2}few)?|few|several|a?\\s{0,2}couple\\s{0,2}(?:of)?)`;
 
 export function parseNumberPattern(match: string): number {
     const num = match.toLowerCase();
@@ -198,7 +198,7 @@ export function parseOrdinalNumberPattern(match: string): number {
 
 //-----------------------------
 
-export const YEAR_PATTERN = `(?:[1-9][0-9]{0,3}\\s*(?:BE|AD|BC|BCE|CE)|[1-2][0-9]{3}|[5-9][0-9])`;
+export const YEAR_PATTERN = `(?:[1-9][0-9]{0,3}\\s{0,2}(?:BE|AD|BC|BCE|CE)|[1-2][0-9]{3}|[5-9][0-9])`;
 export function parseYear(match: string): number {
     if (/BE/i.test(match)) {
         // Buddhist Era
@@ -224,10 +224,10 @@ export function parseYear(match: string): number {
 
 //-----------------------------
 
-const SINGLE_TIME_UNIT_PATTERN = `(${NUMBER_PATTERN})\\s{0,5}(${matchAnyPattern(TIME_UNIT_DICTIONARY)})\\s{0,5}`;
+const SINGLE_TIME_UNIT_PATTERN = `(${NUMBER_PATTERN})\\s{0,3}(${matchAnyPattern(TIME_UNIT_DICTIONARY)})`;
 const SINGLE_TIME_UNIT_REGEX = new RegExp(SINGLE_TIME_UNIT_PATTERN, "i");
 
-export const TIME_UNITS_PATTERN = repeatedTimeunitPattern(`(?:(?:about|around)\\s*)?`, SINGLE_TIME_UNIT_PATTERN);
+export const TIME_UNITS_PATTERN = repeatedTimeunitPattern(`(?:(?:about|around)\\s{0,3})?`, SINGLE_TIME_UNIT_PATTERN);
 
 export function parseTimeUnits(timeunitText): TimeUnits {
     const fragments = {};
@@ -235,7 +235,7 @@ export function parseTimeUnits(timeunitText): TimeUnits {
     let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
     while (match) {
         collectDateTimeFragment(fragments, match);
-        remainingText = remainingText.substring(match[0].length);
+        remainingText = remainingText.substring(match[0].length).trim();
         match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
     }
     return fragments;

package/src/locales/en/parsers/ENCasualTimeParser.ts

@@ -4,7 +4,7 @@ import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/
 import dayjs from "dayjs";
 import { assignTheNextDay } from "../../../utils/dayjs";
 
-const PATTERN = /(?:this)?\s*(morning|afternoon|evening|night|midnight|noon)(?=\W|$)/i;
+const PATTERN = /(?:this)?\s{0,3}(morning|afternoon|evening|night|midnight|noon)(?=\W|$)/i;
 
 export default class ENCasualTimeParser extends AbstractParserWithWordBoundaryChecking {
     innerPattern() {

package/src/locales/en/parsers/ENMonthNameLittleEndianParser.ts

@@ -7,20 +7,19 @@ import { ORDINAL_NUMBER_PATTERN, parseOrdinalNumberPattern } from "../constants"
 import { matchAnyPattern } from "../../../utils/pattern";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 
+// prettier-ignore
 const PATTERN = new RegExp(
-    "(?:on\\s*?)?" +
-        `(${ORDINAL_NUMBER_PATTERN})` +
-        "(?:\\s*" +
-        "(?:to|\\-|\\–|until|through|till|\\s)\\s*" +
+    `(?:on\\s{0,3})?` +
         `(${ORDINAL_NUMBER_PATTERN})` +
+        `(?:` +
+            `\\s{0,3}(?:to|\\-|\\–|until|through|till)?\\s{0,3}` +
+            `(${ORDINAL_NUMBER_PATTERN})` +
         ")?" +
-        "(?:-|/|\\s*(?:of)?\\s*)" +
-        "(" +
-        matchAnyPattern(MONTH_DICTIONARY) +
-        ")" +
+        `(?:-|/|\\s{0,3}(?:of)?\\s{0,3})` +
+        `(${matchAnyPattern(MONTH_DICTIONARY)})` +
         "(?:" +
-        "(?:-|/|,?\\s*)" +
-        `(${YEAR_PATTERN}(?![^\\s]\\d))` +
+            `(?:-|/|,?\\s{0,3})` +
+            `(${YEAR_PATTERN}(?![^\\s]\\d))` +
         ")?" +
         "(?=\\W|$)",
     "i"

package/src/locales/en/parsers/ENRelativeDateFormatParser.ts

@@ -26,17 +26,17 @@ export default class ENRelativeDateFormatParser extends AbstractParserWithWordBo
         if (modifier == "next") {
             const timeUnits = {};
             timeUnits[timeunit] = 1;
-            return ParsingComponents.createRelativeFromRefInstant(context.refDate, timeUnits);
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
         }
 
         if (modifier == "last" || modifier == "past") {
             const timeUnits = {};
             timeUnits[timeunit] = -1;
-            return ParsingComponents.createRelativeFromRefInstant(context.refDate, timeUnits);
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
         }
 
         const components = context.createParsingComponents();
-        let date = dayjs(context.refDate);
+        let date = dayjs(context.reference.instant);
 
         // This week
         if (unitWord.match(/week/i)) {

package/src/locales/en/parsers/ENTimeUnitAgoFormatParser.ts

@@ -4,9 +4,8 @@ import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { reverseTimeUnits } from "../../../utils/timeunits";
 
-const PATTERN = new RegExp("" + "(" + TIME_UNITS_PATTERN + ")" + "(?:ago|before|earlier)(?=(?:\\W|$))", "i");
-
-const STRICT_PATTERN = new RegExp("" + "(" + TIME_UNITS_PATTERN + ")" + "ago(?=(?:\\W|$))", "i");
+const PATTERN = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}(?:ago|before|earlier)(?=(?:\\W|$))`, "i");
+const STRICT_PATTERN = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}ago(?=(?:\\W|$))`, "i");
 
 export default class ENTimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
     constructor(private strictMode: boolean) {
@@ -21,6 +20,6 @@ export default class ENTimeUnitAgoFormatParser extends AbstractParserWithWordBou
         const timeUnits = parseTimeUnits(match[1]);
         const outputTimeUnits = reverseTimeUnits(timeUnits);
 
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, outputTimeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
     }
 }

package/src/locales/en/parsers/ENTimeUnitCasualRelativeFormatParser.ts

@@ -22,6 +22,6 @@ export default class ENTimeUnitCasualRelativeFormatParser extends AbstractParser
                 break;
         }
 
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, timeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

package/src/locales/en/parsers/ENTimeUnitLaterFormatParser.ts

@@ -4,7 +4,7 @@ import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 
 const PATTERN = new RegExp(
-    "" + "(" + TIME_UNITS_PATTERN + ")" + "(later|after|from now|henceforth|forward|out)" + "(?=(?:\\W|$))",
+    `(${TIME_UNITS_PATTERN})\\s{0,5}(?:later|after|from now|henceforth|forward|out)` + "(?=(?:\\W|$))",
     "i"
 );
 
@@ -22,6 +22,6 @@ export default class ENTimeUnitLaterFormatParser extends AbstractParserWithWordB
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
         const fragments = parseTimeUnits(match[GROUP_NUM_TIMEUNITS]);
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, fragments);
+        return ParsingComponents.createRelativeFromReference(context.reference, fragments);
     }
 }

package/src/locales/en/parsers/ENTimeUnitWithinFormatParser.ts

@@ -21,6 +21,6 @@ export default class ENTimeUnitWithinFormatParser extends AbstractParserWithWord
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
         const timeUnits = parseTimeUnits(match[1]);
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, timeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

package/src/locales/fr/constants.ts

@@ -105,7 +105,7 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } =
 
 export const NUMBER_PATTERN = `(?:${matchAnyPattern(
     INTEGER_WORD_DICTIONARY
-)}|[0-9]+|[0-9]+\\.[0-9]+|une?|quelques?|demi-?)`;
+)}|[0-9]+|[0-9]+\\.[0-9]+|une?\\b|quelques?|demi-?)`;
 
 export function parseNumberPattern(match: string): number {
     const num = match.toLowerCase();

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

@@ -17,6 +17,6 @@ export default class FRTimeUnitAgoFormatParser extends AbstractParserWithWordBou
         const timeUnits = parseTimeUnits(match[1]);
         const outputTimeUnits = reverseTimeUnits(timeUnits);
 
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, outputTimeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
     }
 }

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

@@ -38,6 +38,6 @@ export default class FRTimeUnitAgoFormatParser extends AbstractParserWithWordBou
             timeUnits = reverseTimeUnits(timeUnits);
         }
 
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, timeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

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

@@ -10,6 +10,6 @@ export default class FRTimeUnitWithinFormatParser extends AbstractParserWithWord
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
         const timeUnits = parseTimeUnits(match[1]);
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, timeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

package/src/locales/nl/constants.ts

@@ -141,11 +141,14 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType } = {
     min: "minute",
     mins: "minute",
     minute: "minute",
+    minuut: "minute",
     minuten: "minute",
+    minuutje: "minute",
     h: "hour",
     hr: "hour",
     hrs: "hour",
     uur: "hour",
+    u: "hour",
     uren: "hour",
     dag: "d",
     dagen: "d",
@@ -160,18 +163,21 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType } = {
 
 //-----------------------------
 
-export const NUMBER_PATTERN = `(?:${matchAnyPattern(INTEGER_WORD_DICTIONARY)}|[0-9]+|[0-9]+\\.[0-9]+|een?|halve?)`;
+export const NUMBER_PATTERN = `(?:${matchAnyPattern(
+    INTEGER_WORD_DICTIONARY
+)}|[0-9]+|[0-9]+[\\.,][0-9]+|halve?|half|paar)`;
 
 export function parseNumberPattern(match: string): number {
     const num = match.toLowerCase();
     if (INTEGER_WORD_DICTIONARY[num] !== undefined) {
         return INTEGER_WORD_DICTIONARY[num];
-    } else if (num === "een") {
-        return 1;
-    } else if (num.match(/halve?/)) {
+    } else if (num === "paar") {
+        return 2;
+    } else if (num === "half" || num.match(/halve?/)) {
         return 0.5;
     }
-    return parseFloat(num);
+    // Replace "," with "." to support some European languages
+    return parseFloat(num.replace(",", "."));
 }
 
 //-----------------------------

package/src/locales/nl/index.ts

@@ -20,6 +20,10 @@ import NLSlashMonthFormatParser from "./parsers/NLSlashMonthFormatParser";
 import NLTimeExpressionParser from "./parsers/NLTimeExpressionParser";
 import NLCasualYearMonthDayParser from "./parsers/NLCasualYearMonthDayParser";
 import NLCasualDateTimeParser from "./parsers/NLCasualDateTimeParser";
+import NLTimeUnitCasualRelativeFormatParser from "./parsers/NLTimeUnitCasualRelativeFormatParser";
+import NLRelativeDateFormatParser from "./parsers/NLRelativeDateFormatParser";
+import NLTimeUnitAgoFormatParser from "./parsers/NLTimeUnitAgoFormatParser";
+import NLTimeUnitLaterFormatParser from "./parsers/NLTimeUnitLaterFormatParser";
 
 // Shortcuts
 export const casual = new Chrono(createCasualConfiguration());
@@ -38,6 +42,9 @@ export function createCasualConfiguration(littleEndian = true): Configuration {
     option.parsers.unshift(new NLCasualDateParser());
     option.parsers.unshift(new NLCasualTimeParser());
     option.parsers.unshift(new NLCasualDateTimeParser());
+    option.parsers.unshift(new NLMonthNameParser());
+    option.parsers.unshift(new NLRelativeDateFormatParser());
+    option.parsers.unshift(new NLTimeUnitCasualRelativeFormatParser());
     return option;
 }
 
@@ -49,13 +56,15 @@ export function createConfiguration(strictMode = true, littleEndian = true): Con
         {
             parsers: [
                 new SlashDateFormatParser(littleEndian),
+                new NLTimeUnitWithinFormatParser(),
                 new NLMonthNameMiddleEndianParser(),
                 new NLMonthNameParser(),
-                new NLTimeExpressionParser(),
-                new NLTimeUnitWithinFormatParser(),
-                new NLSlashMonthFormatParser(),
                 new NLWeekdayParser(),
                 new NLCasualYearMonthDayParser(),
+                new NLSlashMonthFormatParser(),
+                new NLTimeExpressionParser(strictMode),
+                new NLTimeUnitAgoFormatParser(strictMode),
+                new NLTimeUnitLaterFormatParser(strictMode),
             ],
             refiners: [new NLMergeDateTimeRefiner(), new NLMergeDateRangeRefiner()],
         },

package/src/locales/nl/parsers/NLRelativeDateFormatParser.ts

@@ -0,0 +1,70 @@
+import { TIME_UNIT_DICTIONARY } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import dayjs from "dayjs";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { matchAnyPattern } from "../../../utils/pattern";
+
+const PATTERN = new RegExp(
+    `(dit|deze|komende|volgend|volgende|afgelopen|vorige)\\s*(${matchAnyPattern(TIME_UNIT_DICTIONARY)})(?=\\s*)` +
+        "(?=\\W|$)",
+    "i"
+);
+
+const MODIFIER_WORD_GROUP = 1;
+const RELATIVE_WORD_GROUP = 2;
+
+export default class NLRelativeDateFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const modifier = match[MODIFIER_WORD_GROUP].toLowerCase();
+        const unitWord = match[RELATIVE_WORD_GROUP].toLowerCase();
+        const timeunit = TIME_UNIT_DICTIONARY[unitWord];
+
+        if (modifier == "volgend" || modifier == "volgende" || modifier == "komende") {
+            const timeUnits = {};
+            timeUnits[timeunit] = 1;
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+        }
+
+        if (modifier == "afgelopen" || modifier == "vorige") {
+            const timeUnits = {};
+            timeUnits[timeunit] = -1;
+            return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+        }
+
+        const components = context.createParsingComponents();
+        let date = dayjs(context.reference.instant);
+
+        // This week
+        if (unitWord.match(/week/i)) {
+            date = date.add(-date.get("d"), "d");
+            components.imply("day", date.date());
+            components.imply("month", date.month() + 1);
+            components.imply("year", date.year());
+        }
+
+        // This month
+        else if (unitWord.match(/maand/i)) {
+            date = date.add(-date.date() + 1, "d");
+            components.imply("day", date.date());
+            components.assign("year", date.year());
+            components.assign("month", date.month() + 1);
+        }
+
+        // This year
+        else if (unitWord.match(/jaar/i)) {
+            date = date.add(-date.date() + 1, "d");
+            date = date.add(-date.month(), "month");
+
+            components.imply("day", date.date());
+            components.imply("month", date.month() + 1);
+            components.assign("year", date.year());
+        }
+
+        return components;
+    }
+}

package/src/locales/nl/parsers/NLTimeExpressionParser.ts

@@ -11,6 +11,10 @@ export default class NLTimeExpressionParser extends AbstractTimeExpressionParser
         return "\\s*(?:\\-|\\–|\\~|\\〜|om|\\?)\\s*";
     }
 
+    primarySuffix(): string {
+        return "(?:\\s*(?:uur))?(?!/)(?=\\W|$)";
+    }
+
     extractPrimaryTimeComponents(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | null {
         // This looks more like a year e.g. 2020
         if (match[0].match(/^\s*\d{4}\s*$/)) {

package/src/locales/nl/parsers/NLTimeUnitAgoFormatParser.ts

@@ -0,0 +1,26 @@
+import { ParsingContext } from "../../../chrono";
+import { parseTimeUnits, TIME_UNITS_PATTERN } from "../constants";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { reverseTimeUnits } from "../../../utils/timeunits";
+
+const PATTERN = new RegExp("" + "(" + TIME_UNITS_PATTERN + ")" + "(?:geleden|voor|eerder)(?=(?:\\W|$))", "i");
+
+const STRICT_PATTERN = new RegExp("" + "(" + TIME_UNITS_PATTERN + ")" + "geleden(?=(?:\\W|$))", "i");
+
+export default class NLTimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor(private strictMode: boolean) {
+        super();
+    }
+
+    innerPattern(): RegExp {
+        return this.strictMode ? STRICT_PATTERN : PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const timeUnits = parseTimeUnits(match[1]);
+        const outputTimeUnits = reverseTimeUnits(timeUnits);
+
+        return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
+    }
+}

package/src/locales/nl/parsers/NLTimeUnitCasualRelativeFormatParser.ts

@@ -0,0 +1,27 @@
+import { TIME_UNITS_PATTERN, parseTimeUnits } from "../constants";
+import { ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { reverseTimeUnits } from "../../../utils/timeunits";
+
+const PATTERN = new RegExp(`(deze|vorige|afgelopen|komende|over|\\+|-)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+
+export default class NLTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const prefix = match[1].toLowerCase();
+        let timeUnits = parseTimeUnits(match[2]);
+        switch (prefix) {
+            case "vorige":
+            case "afgelopen":
+            case "-":
+                timeUnits = reverseTimeUnits(timeUnits);
+                break;
+        }
+
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}

package/src/locales/nl/parsers/NLTimeUnitLaterFormatParser.ts

@@ -0,0 +1,27 @@
+import { ParsingContext } from "../../../chrono";
+import { parseTimeUnits, TIME_UNITS_PATTERN } from "../constants";
+import { ParsingComponents } from "../../../results";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+
+const PATTERN = new RegExp(
+    "" + "(" + TIME_UNITS_PATTERN + ")" + "(later|na|vanaf nu|voortaan|vooruit|uit)" + "(?=(?:\\W|$))",
+    "i"
+);
+
+const STRICT_PATTERN = new RegExp("" + "(" + TIME_UNITS_PATTERN + ")" + "(later|vanaf nu)" + "(?=(?:\\W|$))", "i");
+const GROUP_NUM_TIMEUNITS = 1;
+
+export default class NLTimeUnitLaterFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor(private strictMode: boolean) {
+        super();
+    }
+
+    innerPattern(): RegExp {
+        return this.strictMode ? STRICT_PATTERN : PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        const fragments = parseTimeUnits(match[GROUP_NUM_TIMEUNITS]);
+        return ParsingComponents.createRelativeFromReference(context.reference, fragments);
+    }
+}

package/src/locales/nl/parsers/NLTimeUnitWithinFormatParser.ts

@@ -10,6 +10,6 @@ export default class NLTimeUnitWithinFormatParser extends AbstractParserWithWord
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
         const timeUnits = parseTimeUnits(match[1]);
-        return ParsingComponents.createRelativeFromRefInstant(context.refDate, timeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

package/src/results.ts

@@ -8,7 +8,7 @@ dayjs.extend(quarterOfYear);
 
 export class ReferenceWithTimezone {
     readonly instant: Date;
-    readonly timezoneOffset: number;
+    readonly timezoneOffset?: number;
 
     constructor(input?: ParsingReference | Date) {
         input = input ?? new Date();
@@ -17,7 +17,7 @@ export class ReferenceWithTimezone {
             this.timezoneOffset = -input.getTimezoneOffset();
         } else {
             this.instant = input.instant ?? new Date();
-            this.timezoneOffset = toTimezoneOffset(input.timezone ?? -this.instant.getTimezoneOffset());
+            this.timezoneOffset = toTimezoneOffset(input.timezone);
         }
     }
 }
@@ -142,7 +142,7 @@ export class ParsingComponents implements ParsedComponents {
 
     date(): Date {
         const date = this.dateWithoutTimezoneAdjustment();
-        return new Date(date.getTime() + this.getSystemTimezoneAdjustmentMinute() * 60000);
+        return new Date(date.getTime() + this.getSystemTimezoneAdjustmentMinute(date) * 60000);
     }
 
     private dateWithoutTimezoneAdjustment() {
@@ -160,31 +160,41 @@ export class ParsingComponents implements ParsedComponents {
         return date;
     }
 
-    private getSystemTimezoneAdjustmentMinute() {
-        const currentTimezoneOffset = -new Date().getTimezoneOffset();
-        const targetTimezoneOffset = this.get("timezoneOffset") ?? this.reference.timezoneOffset;
+    private getSystemTimezoneAdjustmentMinute(date?: Date) {
+        if (!date || date.getTime() < 0) {
+            // Javascript date timezone calculation got effect when the time epoch < 0
+            // e.g. new Date('Tue Feb 02 1300 00:00:00 GMT+0900 (JST)') => Tue Feb 02 1300 00:18:59 GMT+0918 (JST)
+            date = new Date();
+        }
+
+        const currentTimezoneOffset = -date.getTimezoneOffset();
+        const targetTimezoneOffset =
+            this.get("timezoneOffset") ?? this.reference.timezoneOffset ?? currentTimezoneOffset;
 
         return currentTimezoneOffset - targetTimezoneOffset;
     }
 
-    static createRelativeFromRefInstant(
-        refInstant: Date,
+    static createRelativeFromReference(
+        reference: ReferenceWithTimezone,
         fragments: { [c in OpUnitType | QUnitType]?: number }
     ): ParsingComponents {
-        let date = dayjs(refInstant);
+        let date = dayjs(reference.instant);
         for (const key in fragments) {
             date = date.add(fragments[key as OpUnitType], key as OpUnitType);
         }
 
-        const reference = new ReferenceWithTimezone(refInstant);
         const components = new ParsingComponents(reference);
         if (fragments["hour"] || fragments["minute"] || fragments["second"]) {
             assignSimilarTime(components, date);
             assignSimilarDate(components, date);
-            components.assign("timezoneOffset", -refInstant.getTimezoneOffset());
+            if (reference.timezoneOffset !== null) {
+                components.assign("timezoneOffset", -reference.instant.getTimezoneOffset());
+            }
         } else {
             implySimilarTime(components, date);
-            components.imply("timezoneOffset", -refInstant.getTimezoneOffset());
+            if (reference.timezoneOffset !== null) {
+                components.imply("timezoneOffset", -reference.instant.getTimezoneOffset());
+            }
 
             if (fragments["d"]) {
                 components.assign("day", date.date());

package/src/timezone.ts

@@ -192,7 +192,11 @@ export const TIMEZONE_ABBR_MAP = {
     YEKT: 360,
 };
 
-export function toTimezoneOffset(timezoneInput: string | number): number {
+export function toTimezoneOffset(timezoneInput: string | number): number | null {
+    if (timezoneInput === null) {
+        return null;
+    }
+
     if (typeof timezoneInput === "number") {
         return timezoneInput;
     }

package/src/utils/pattern.ts

@@ -2,7 +2,7 @@ type DictionaryLike = string[] | { [word: string]: unknown } | Map<string, unkno
 
 export function repeatedTimeunitPattern(prefix: string, singleTimeunitPattern: string): string {
     const singleTimeunitPatternNoCapture = singleTimeunitPattern.replace(/\((?!\?)/g, "(?:");
-    return `${prefix}${singleTimeunitPatternNoCapture}\\s*(?:,?\\s{0,5}${singleTimeunitPatternNoCapture}){0,10}`;
+    return `${prefix}${singleTimeunitPatternNoCapture}\\s{0,5}(?:,?\\s{0,5}${singleTimeunitPatternNoCapture}){0,10}`;
 }
 
 export function extractTerms(dictionary: DictionaryLike): string[] {

package/test/en/en_casual.test.ts

@@ -21,6 +21,17 @@ test("Test - Single Expression", () => {
         expect(result.start).toBeDate(new Date(2012, 7, 10, 8, 9, 10, 11));
     });
 
+    testSingleCase(
+        chrono.casual,
+        "The Deadline is now, without implicit local timezone",
+        { instant: new Date(1637674343000), timezone: null },
+        (result) => {
+            expect(result.text).toBe("now");
+            expect(result.start).toBeDate(new Date(1637674343000));
+            expect(result.start.isCertain("timezoneOffset")).toBe(false);
+        }
+    );
+
     testSingleCase(chrono.casual, "The Deadline is today", new Date(2012, 7, 10, 14, 12), (result) => {
         expect(result.index).toBe(16);
         expect(result.text).toBe("today");