chrono-node 2.7.5 → 2.7.7

package/src/common/parsers/SlashDateFormatParser.ts

@@ -41,18 +41,22 @@ export default class SlashDateFormatParser implements Parser {
     extract(context: ParsingContext, match: RegExpMatchArray): ParsingResult {
         // Because of how pattern is executed on remaining text in `chrono.ts`, the character before the match could
         // still be a number (e.g. X[X/YY/ZZ] or XX[/YY/ZZ] or [XX/YY/]ZZ). We want to check and skip them.
-        if (match[OPENING_GROUP].length == 0 && match.index > 0 && match.index < context.text.length) {
-            const previousChar = context.text[match.index - 1];
-            if (previousChar >= "0" && previousChar <= "9") {
+        const index = match.index + match[OPENING_GROUP].length;
+        const indexEnd = match.index + match[0].length - match[ENDING_GROUP].length;
+        if (index > 0) {
+            const textBefore = context.text.substring(0, index);
+            if (textBefore.match("\\d/?$")) {
+                return;
+            }
+        }
+        if (indexEnd < context.text.length) {
+            const textAfter = context.text.substring(indexEnd);
+            if (textAfter.match("^/?\\d")) {
                 return;
             }
         }
 
-        const index = match.index + match[OPENING_GROUP].length;
-        const text = match[0].substr(
-            match[OPENING_GROUP].length,
-            match[0].length - match[OPENING_GROUP].length - match[ENDING_GROUP].length
-        );
+        const text = context.text.substring(index, indexEnd);
 
         // '1.12', '1.12.12' is more like a version numbers
         if (text.match(/^\d\.\d$/) || text.match(/^\d\.\d{1,2}\.\d{1,2}\s*$/)) {
@@ -61,14 +65,13 @@ export default class SlashDateFormatParser implements Parser {
 
         // MM/dd -> OK
         // MM.dd -> NG
-        if (!match[YEAR_GROUP] && match[0].indexOf("/") < 0) {
+        if (!match[YEAR_GROUP] && text.indexOf("/") < 0) {
             return;
         }
 
         const result = context.createParsingResult(index, text);
         let month = parseInt(match[this.groupNumberMonth]);
         let day = parseInt(match[this.groupNumberDay]);
-
         if (month < 1 || month > 12) {
             if (month > 12) {
                 if (day >= 1 && day <= 12 && month <= 31) {

package/src/common/refiners/ForwardDateRefiner.ts

@@ -15,7 +15,7 @@ export default class ForwardDateRefiner implements Refiner {
             return results;
         }
 
-        results.forEach(function (result) {
+        results.forEach((result) => {
             let refMoment = dayjs(context.refDate);
 
             if (result.start.isOnlyTime() && refMoment.isAfter(result.start.dayjs())) {
@@ -28,6 +28,9 @@ export default class ForwardDateRefiner implements Refiner {
                         implySimilarDate(result.end, refMoment);
                     }
                 }
+                context.debug(() => {
+                    console.log(`${this.constructor.name} adjusted ${result} time result (${result.start})`);
+                });
             }
 
             if (result.start.isOnlyWeekdayComponent() && refMoment.isAfter(result.start.dayjs())) {
@@ -41,7 +44,7 @@ export default class ForwardDateRefiner implements Refiner {
                 result.start.imply("month", refMoment.month() + 1);
                 result.start.imply("year", refMoment.year());
                 context.debug(() => {
-                    console.log(`Forward weekly adjusted for ${result} (${result.start})`);
+                    console.log(`${this.constructor.name} adjusted ${result} weekday (${result.start})`);
                 });
 
                 if (result.end && result.end.isOnlyWeekdayComponent()) {
@@ -56,7 +59,7 @@ export default class ForwardDateRefiner implements Refiner {
                     result.end.imply("month", refMoment.month() + 1);
                     result.end.imply("year", refMoment.year());
                     context.debug(() => {
-                        console.log(`Forward weekly adjusted for ${result} (${result.end})`);
+                        console.log(`${this.constructor.name} adjusted ${result} weekday (${result.end})`);
                     });
                 }
             }
@@ -67,13 +70,13 @@ export default class ForwardDateRefiner implements Refiner {
                 for (let i = 0; i < 3 && refMoment.isAfter(result.start.dayjs()); i++) {
                     result.start.imply("year", result.start.get("year") + 1);
                     context.debug(() => {
-                        console.log(`Forward yearly adjusted for ${result} (${result.start})`);
+                        console.log(`${this.constructor.name} adjusted ${result} year (${result.start})`);
                     });
 
                     if (result.end && !result.end.isCertain("year")) {
                         result.end.imply("year", result.end.get("year") + 1);
                         context.debug(() => {
-                            console.log(`Forward yearly adjusted for ${result} (${result.end})`);
+                            console.log(`${this.constructor.name} adjusted ${result} month (${result.start})`);
                         });
                     }
                 }

package/src/locales/en/configuration.ts

@@ -4,7 +4,7 @@ import ENTimeUnitWithinFormatParser from "./parsers/ENTimeUnitWithinFormatParser
 import ENMonthNameLittleEndianParser from "./parsers/ENMonthNameLittleEndianParser";
 import ENMonthNameMiddleEndianParser from "./parsers/ENMonthNameMiddleEndianParser";
 import ENMonthNameParser from "./parsers/ENMonthNameParser";
-import ENCasualYearMonthDayParser from "./parsers/ENCasualYearMonthDayParser";
+import ENYearMonthDayParser from "./parsers/ENYearMonthDayParser";
 import ENSlashMonthFormatParser from "./parsers/ENSlashMonthFormatParser";
 import ENTimeExpressionParser from "./parsers/ENTimeExpressionParser";
 import ENTimeUnitAgoFormatParser from "./parsers/ENTimeUnitAgoFormatParser";
@@ -23,6 +23,7 @@ import ENTimeUnitCasualRelativeFormatParser from "./parsers/ENTimeUnitCasualRela
 import ENMergeRelativeAfterDateRefiner from "./refiners/ENMergeRelativeAfterDateRefiner";
 import ENMergeRelativeFollowByDateRefiner from "./refiners/ENMergeRelativeFollowByDateRefiner";
 import OverlapRemovalRefiner from "../../common/refiners/OverlapRemovalRefiner";
+import ENExtractYearSuffixRefiner from "./refiners/ENExtractYearSuffixRefiner";
 
 export default class ENDefaultConfiguration {
     /**
@@ -54,7 +55,6 @@ export default class ENDefaultConfiguration {
                     new ENMonthNameLittleEndianParser(),
                     new ENMonthNameMiddleEndianParser(/*shouldSkipYearLikeDate=*/ littleEndian),
                     new ENWeekdayParser(),
-                    new ENCasualYearMonthDayParser(),
                     new ENSlashMonthFormatParser(),
                     new ENTimeExpressionParser(strictMode),
                     new ENTimeUnitAgoFormatParser(strictMode),
@@ -64,6 +64,8 @@ export default class ENDefaultConfiguration {
             },
             strictMode
         );
+        options.parsers.unshift(new ENYearMonthDayParser(/*strictMonthDateOrder=*/ strictMode));
+
         // These relative-dates consideration should be done before other common refiners.
         options.refiners.unshift(new ENMergeRelativeFollowByDateRefiner());
         options.refiners.unshift(new ENMergeRelativeAfterDateRefiner());
@@ -71,6 +73,10 @@ export default class ENDefaultConfiguration {
 
         // Re-apply the date time refiner again after the timezone refinement and exclusion in common refiners.
         options.refiners.push(new ENMergeDateTimeRefiner());
+
+        // Extract year after merging date and time
+        options.refiners.push(new ENExtractYearSuffixRefiner());
+
         // Keep the date range refiner at the end (after all other refinements).
         options.refiners.push(new ENMergeDateRangeRefiner());
         return options;

package/src/locales/en/constants.ts

@@ -277,7 +277,7 @@ export const TIME_UNITS_NO_ABBR_PATTERN = repeatedTimeunitPattern(
     TIME_UNIT_CONNECTOR_PATTERN
 );
 
-export function parseTimeUnits(timeunitText): TimeUnits {
+export function parseTimeUnits(timeunitText): null | TimeUnits {
     const fragments = {};
     let remainingText = timeunitText;
     let match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
@@ -286,10 +286,16 @@ export function parseTimeUnits(timeunitText): TimeUnits {
         remainingText = remainingText.substring(match[0].length).trim();
         match = SINGLE_TIME_UNIT_REGEX.exec(remainingText);
     }
+    if (Object.keys(fragments).length == 0) {
+        return null;
+    }
     return fragments;
 }
 
 function collectDateTimeFragment(fragments, match) {
+    if (match[0].match(/^[a-zA-Z]+$/)) {
+        return;
+    }
     const num = parseNumberPattern(match[1]);
     const unit = TIME_UNIT_DICTIONARY[match[2].toLowerCase()];
     fragments[unit] = num;

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

@@ -19,7 +19,7 @@ const PATTERN = new RegExp(
         `(${matchAnyPattern(MONTH_DICTIONARY)})` +
         "(?:" +
             `(?:-|/|,?\\s{0,3})` +
-            `(${YEAR_PATTERN}(?![^\\s]\\d))` +
+            `(${YEAR_PATTERN}(?!\\w))` +
         ")?" +
         "(?=\\W|$)",
     "i"

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

@@ -18,8 +18,10 @@ export default class ENTimeUnitAgoFormatParser extends AbstractParserWithWordBou
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
         const timeUnits = parseTimeUnits(match[1]);
+        if (!timeUnits) {
+            return null;
+        }
         const outputTimeUnits = reverseTimeUnits(timeUnits);
-
         return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
     }
 }

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

@@ -19,9 +19,12 @@ export default class ENTimeUnitCasualRelativeFormatParser extends AbstractParser
         return this.allowAbbreviations ? PATTERN : PATTERN_NO_ABBR;
     }
 
-    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
         const prefix = match[1].toLowerCase();
         let timeUnits = parseTimeUnits(match[2]);
+        if (!timeUnits) {
+            return null;
+        }
         switch (prefix) {
             case "last":
             case "past":
@@ -29,7 +32,6 @@ export default class ENTimeUnitCasualRelativeFormatParser extends AbstractParser
                 timeUnits = reverseTimeUnits(timeUnits);
                 break;
         }
-
         return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

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

@@ -21,7 +21,10 @@ export default class ENTimeUnitLaterFormatParser extends AbstractParserWithWordB
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        const fragments = parseTimeUnits(match[GROUP_NUM_TIMEUNITS]);
-        return ParsingComponents.createRelativeFromReference(context.reference, fragments);
+        const timeUnits = parseTimeUnits(match[GROUP_NUM_TIMEUNITS]);
+        if (!timeUnits) {
+            return null;
+        }
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

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

@@ -33,13 +33,15 @@ export default class ENTimeUnitWithinFormatParser extends AbstractParserWithWord
         return context.option.forwardDate ? PATTERN_WITH_OPTIONAL_PREFIX : PATTERN_WITH_PREFIX;
     }
 
-    innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
         // Exclude "for the unit" phases, e.g. "for the year"
         if (match[0].match(/^for\s*the\s*\w+/)) {
             return null;
         }
-
         const timeUnits = parseTimeUnits(match[1]);
+        if (!timeUnits) {
+            return null;
+        }
         return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
     }
 }

package/src/locales/en/parsers/{ENCasualYearMonthDayParser.ts → ENYearMonthDayParser.ts}

@@ -11,8 +11,8 @@ import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/
     - YYYY.MM.DD
 */
 const PATTERN = new RegExp(
-    `([0-9]{4})[\\.\\/\\s]` +
-        `(?:(${matchAnyPattern(MONTH_DICTIONARY)})|([0-9]{1,2}))[\\.\\/\\s]` +
+    `([0-9]{4})[-\\.\\/\\s]` +
+        `(?:(${matchAnyPattern(MONTH_DICTIONARY)})|([0-9]{1,2}))[-\\.\\/\\s]` +
         `([0-9]{1,2})` +
         "(?=\\W|$)",
     "i"
@@ -23,23 +23,34 @@ const MONTH_NAME_GROUP = 2;
 const MONTH_NUMBER_GROUP = 3;
 const DATE_NUMBER_GROUP = 4;
 
-export default class ENCasualYearMonthDayParser extends AbstractParserWithWordBoundaryChecking {
+export default class ENYearMonthDayParser extends AbstractParserWithWordBoundaryChecking {
+    constructor(private strictMonthDateOrder: boolean) {
+        super();
+    }
+
     innerPattern(): RegExp {
         return PATTERN;
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
-        const month = match[MONTH_NUMBER_GROUP]
+        const year = parseInt(match[YEAR_NUMBER_GROUP]);
+        let day = parseInt(match[DATE_NUMBER_GROUP]);
+        let month = match[MONTH_NUMBER_GROUP]
             ? parseInt(match[MONTH_NUMBER_GROUP])
             : MONTH_DICTIONARY[match[MONTH_NAME_GROUP].toLowerCase()];
 
         if (month < 1 || month > 12) {
+            if (this.strictMonthDateOrder) {
+                return null;
+            }
+            if (day >= 1 && day <= 12) {
+                [month, day] = [day, month];
+            }
+        }
+        if (day < 1 || day > 31) {
             return null;
         }
 
-        const year = parseInt(match[YEAR_NUMBER_GROUP]);
-        const day = parseInt(match[DATE_NUMBER_GROUP]);
-
         return {
             day: day,
             month: month,

package/src/locales/en/refiners/ENExtractYearSuffixRefiner.ts

@@ -0,0 +1,34 @@
+import { ParsingContext, Refiner } from "../../../chrono";
+import { ParsingResult } from "../../../results";
+import { YEAR_PATTERN, parseYear } from "../constants";
+
+const YEAR_SUFFIX_PATTERN = new RegExp(`^\\s*(${YEAR_PATTERN})`, "i");
+const YEAR_GROUP = 1;
+export default class ENExtractYearSuffixRefiner implements Refiner {
+    refine(context: ParsingContext, results: ParsingResult[]): ParsingResult[] {
+        results.forEach(function (result) {
+            if (!result.start.isDateWithUnknownYear()) {
+                return;
+            }
+
+            const suffix = context.text.substring(result.index + result.text.length);
+            const match = YEAR_SUFFIX_PATTERN.exec(suffix);
+            if (!match) {
+                return;
+            }
+
+            context.debug(() => {
+                console.log(`Extracting year: '${match[0]}' into : ${result}`);
+            });
+
+            const year = parseYear(match[YEAR_GROUP]);
+            if (result.end != null) {
+                result.end.assign("year", year);
+            }
+            result.start.assign("year", year);
+            result.text += match[0];
+        });
+
+        return results;
+    }
+}

package/src/locales/en/refiners/ENMergeDateTimeRefiner.ts

@@ -8,6 +8,6 @@ import AbstractMergeDateTimeRefiner from "../../../common/refiners/AbstractMerge
  */
 export default class ENMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner {
     patternBetween(): RegExp {
-        return new RegExp("^\\s*(T|at|after|before|on|of|,|-)?\\s*$");
+        return new RegExp("^\\s*(T|at|after|before|on|of|,|-|\\.|∙|:)?\\s*$");
     }
 }

package/src/locales/zh/index.ts

@@ -1,2 +1,74 @@
-export * from "./hant";
+import { includeCommonConfiguration } from "../../configurations";
+import { Chrono, Configuration, Parser, Refiner } from "../../chrono";
+import { ParsingResult, ParsingComponents, ReferenceWithTimezone } from "../../results";
+import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday } from "../../types";
+import ExtractTimezoneOffsetRefiner from "../../common/refiners/ExtractTimezoneOffsetRefiner";
+
+import ZHHansCasualDateParser from "./hans/parsers/ZHHansCasualDateParser";
+import ZHHansDateParser from "./hans/parsers/ZHHansDateParser";
+import ZHHansDeadlineFormatParser from "./hans/parsers/ZHHansDeadlineFormatParser";
+import ZHHansRelationWeekdayParser from "./hans/parsers/ZHHansRelationWeekdayParser";
+import ZHHansTimeExpressionParser from "./hans/parsers/ZHHansTimeExpressionParser";
+import ZHHansWeekdayParser from "./hans/parsers/ZHHansWeekdayParser";
+
+import ZHHantCasualDateParser from "./hant/parsers/ZHHantCasualDateParser";
+import ZHHantDateParser from "./hant/parsers/ZHHantDateParser";
+import ZHHantDeadlineFormatParser from "./hant/parsers/ZHHantDeadlineFormatParser";
+import ZHHantRelationWeekdayParser from "./hant/parsers/ZHHantRelationWeekdayParser";
+import ZHHantTimeExpressionParser from "./hant/parsers/ZHHantTimeExpressionParser";
+import ZHHantWeekdayParser from "./hant/parsers/ZHHantWeekdayParser";
+import ZHHantMergeDateRangeRefiner from "./hant/refiners/ZHHantMergeDateRangeRefiner";
+import ZHHantMergeDateTimeRefiner from "./hant/refiners/ZHHantMergeDateTimeRefiner";
+
+export * as hant from "./hant";
 export * as hans from "./hans";
+export { Chrono, Parser, Refiner, ParsingResult, ParsingComponents, ReferenceWithTimezone };
+export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday };
+
+export const casual = new Chrono(createCasualConfiguration());
+export const strict = new Chrono(createConfiguration());
+
+export function parse(text: string, ref?: ParsingReference | Date, option?: ParsingOption): ParsedResult[] {
+    return casual.parse(text, ref, option);
+}
+
+export function parseDate(text: string, ref?: ParsingReference | Date, option?: ParsingOption): Date {
+    return casual.parseDate(text, ref, option);
+}
+
+/**
+ * @ignore (to be documented later)
+ */
+export function createCasualConfiguration(): Configuration {
+    const option = createConfiguration();
+    option.parsers.unshift(new ZHHantCasualDateParser());
+    return option;
+}
+
+/**
+ * @ignore (to be documented later)
+ */
+export function createConfiguration(): Configuration {
+    const configuration = includeCommonConfiguration({
+        parsers: [
+            new ZHHantDateParser(),
+            new ZHHansDateParser(),
+            new ZHHantRelationWeekdayParser(),
+            new ZHHansRelationWeekdayParser(),
+            new ZHHantWeekdayParser(),
+            new ZHHansWeekdayParser(),
+            new ZHHantTimeExpressionParser(),
+            new ZHHansTimeExpressionParser(),
+            new ZHHantDeadlineFormatParser(),
+            new ZHHansDeadlineFormatParser(),
+        ],
+        refiners: [new ZHHantMergeDateRangeRefiner(), new ZHHantMergeDateTimeRefiner()],
+    });
+
+    // REMOVE ExtractTimezoneOffsetRefiner
+    configuration.refiners = configuration.refiners.filter(
+        (refiner) => !(refiner instanceof ExtractTimezoneOffsetRefiner)
+    );
+
+    return configuration;
+}

package/src/results.ts

@@ -132,7 +132,9 @@ export class ParsingComponents implements ParsedComponents {
     }
 
     isOnlyTime(): boolean {
-        return !this.isCertain("weekday") && !this.isCertain("day") && !this.isCertain("month");
+        return (
+            !this.isCertain("weekday") && !this.isCertain("day") && !this.isCertain("month") && !this.isCertain("year")
+        );
     }
 
     isOnlyWeekdayComponent(): boolean {
@@ -230,11 +232,12 @@ export class ParsingComponents implements ParsedComponents {
                 components.assign("day", date.date());
                 components.assign("month", date.month() + 1);
                 components.assign("year", date.year());
+            } else if (fragments["week"]) {
+                components.assign("day", date.date());
+                components.assign("month", date.month() + 1);
+                components.assign("year", date.year());
+                components.imply("weekday", date.day());
             } else {
-                if (fragments["week"]) {
-                    components.imply("weekday", date.day());
-                }
-
                 components.imply("day", date.date());
                 if (fragments["month"]) {
                     components.assign("month", date.month() + 1);

package/test/en/en_casual.test.ts

@@ -409,4 +409,10 @@ test("Test - Random negative text", () => {
     testUnexpectedResult(chrono, "mar");
 
     testUnexpectedResult(chrono, "jan");
+
+    testUnexpectedResult(chrono, "do I have the money");
+
+    testUnexpectedResult(chrono.casual, "do I have the money");
+
+    testUnexpectedResult(chrono.en.GB, "do I have the money");
 });

package/test/en/en_inter_std.test.ts

@@ -27,34 +27,6 @@ test("Test - Single Expression", function () {
         expect(result.start).toBeDate(new Date(784043130000));
     });
 
-    testSingleCase(chrono, "1994-11-05T13:15:30", new Date(2012, 7, 8), (result) => {
-        expect(result.start).not.toBeNull();
-        expect(result.start.get("year")).toBe(1994);
-        expect(result.start.get("month")).toBe(11);
-        expect(result.start.get("day")).toBe(5);
-        expect(result.start.get("hour")).toBe(13);
-        expect(result.start.get("minute")).toBe(15);
-        expect(result.start.get("second")).toBe(30);
-        expect(result.start.get("timezoneOffset")).toBe(0);
-        expect(result.text).toBe("1994-11-05T13:15:30");
-
-        expect(result.start).toBeDate(new Date(784041330000));
-    });
-
-    testSingleCase(chrono, "2015-07-31T12:00:00", new Date(2012, 7, 8), (result) => {
-        expect(result.start).not.toBeNull();
-        expect(result.start.get("year")).toBe(2015);
-        expect(result.start.get("month")).toBe(7);
-        expect(result.start.get("day")).toBe(31);
-        expect(result.start.get("hour")).toBe(12);
-        expect(result.start.get("minute")).toBe(0);
-        expect(result.start.get("second")).toBe(0);
-        expect(result.start.get("timezoneOffset")).toBe(0);
-        expect(result.text).toBe("2015-07-31T12:00:00");
-
-        expect(result.start).toBeDate(new Date(1438344000000));
-    });
-
     testSingleCase(chrono, "1994-11-05T13:15:30Z", new Date(2012, 7, 8), (result) => {
         expect(result.start).not.toBeNull();
         expect(result.start.get("year")).toBe(1994);
@@ -114,3 +86,33 @@ test("Test - Single Expression", function () {
         expect(result.start).toBeDate(new Date(1462661100487));
     });
 });
+
+test("Test - Single Expression with local timezeon", function () {
+    testSingleCase(chrono, "1994-11-05T13:15:30", new Date(2012, 7, 8), (result) => {
+        expect(result.text).toBe("1994-11-05T13:15:30");
+        expect(result.start.get("year")).toBe(1994);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(5);
+        expect(result.start.get("hour")).toBe(13);
+        expect(result.start.get("minute")).toBe(15);
+        expect(result.start.get("second")).toBe(30);
+        expect(result.start.get("millisecond")).toBe(0);
+
+        expect(result.start.isCertain("timezoneOffset")).toBe(false);
+        expect(result.start).toBeDate(new Date("1994-11-05T13:15:30"));
+    });
+
+    testSingleCase(chrono, "2015-07-31T12:00:00", new Date(2012, 7, 8), (result) => {
+        expect(result.text).toBe("2015-07-31T12:00:00");
+        expect(result.start.get("year")).toBe(2015);
+        expect(result.start.get("month")).toBe(7);
+        expect(result.start.get("day")).toBe(31);
+        expect(result.start.get("hour")).toBe(12);
+        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("second")).toBe(0);
+        expect(result.start.get("millisecond")).toBe(0);
+
+        expect(result.start.isCertain("timezoneOffset")).toBe(false);
+        expect(result.start).toBeDate(new Date("2015-07-31T12:00:00"));
+    });
+});

package/test/en/en_merging_relative_dates.test.ts

@@ -11,10 +11,9 @@ test("Test - Single Expression", function () {
         expect(result.start.get("day")).toBe(15);
         expect(result.start.get("weekday")).toBe(2);
 
-        expect(result.start.isCertain("day")).toBe(false);
-        expect(result.start.isCertain("month")).toBe(false);
-        expect(result.start.isCertain("year")).toBe(false);
-        expect(result.start.isCertain("weekday")).toBe(false);
+        expect(result.start.isCertain("day")).toBe(true);
+        expect(result.start.isCertain("month")).toBe(true);
+        expect(result.start.isCertain("year")).toBe(true);
 
         expect(result.start).toBeDate(new Date(2022, 2 - 1, 15, 0));
     });