chrono-node 2.6.5 → 2.7.0

package/package.json

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

package/src/calculation/mergingCalculation.ts

@@ -77,5 +77,7 @@ export function mergeDateTimeComponent(
         }
     }
 
+    dateTimeComponent.addTags(dateComponent.tags());
+    dateTimeComponent.addTags(timeComponent.tags());
     return dateTimeComponent;
 }

package/src/common/casualReferences.ts

@@ -17,6 +17,7 @@ export function now(reference: ReferenceWithTimezone): ParsingComponents {
     if (reference.timezoneOffset !== null) {
         component.assign("timezoneOffset", targetDate.utcOffset());
     }
+    component.addTag("casualReference/now");
     return component;
 }
 
@@ -25,6 +26,7 @@ export function today(reference: ReferenceWithTimezone): ParsingComponents {
     const component = new ParsingComponents(reference, {});
     assignSimilarDate(component, targetDate);
     implySimilarTime(component, targetDate);
+    component.addTag("casualReference/today");
     return component;
 }
 
@@ -32,7 +34,7 @@ export function today(reference: ReferenceWithTimezone): ParsingComponents {
  * The previous day. Imply the same time.
  */
 export function yesterday(reference: ReferenceWithTimezone): ParsingComponents {
-    return theDayBefore(reference, 1);
+    return theDayBefore(reference, 1).addTag("casualReference/yesterday");
 }
 
 export function theDayBefore(reference: ReferenceWithTimezone, numDay: number): ParsingComponents {
@@ -43,7 +45,7 @@ export function theDayBefore(reference: ReferenceWithTimezone, numDay: number):
  * The following day with dayjs.assignTheNextDay()
  */
 export function tomorrow(reference: ReferenceWithTimezone): ParsingComponents {
-    return theDayAfter(reference, 1);
+    return theDayAfter(reference, 1).addTag("casualReference/tomorrow");
 }
 
 export function theDayAfter(reference: ReferenceWithTimezone, nDays: number): ParsingComponents {
@@ -58,9 +60,10 @@ export function theDayAfter(reference: ReferenceWithTimezone, nDays: number): Pa
 export function tonight(reference: ReferenceWithTimezone, implyHour = 22): ParsingComponents {
     const targetDate = dayjs(reference.instant);
     const component = new ParsingComponents(reference, {});
+    assignSimilarDate(component, targetDate);
     component.imply("hour", implyHour);
     component.imply("meridiem", Meridiem.PM);
-    assignSimilarDate(component, targetDate);
+    component.addTag("casualReference/tonight");
     return component;
 }
 
@@ -79,6 +82,7 @@ export function evening(reference: ReferenceWithTimezone, implyHour = 20): Parsi
     const component = new ParsingComponents(reference, {});
     component.imply("meridiem", Meridiem.PM);
     component.imply("hour", implyHour);
+    component.addTag("casualReference/evening");
     return component;
 }
 
@@ -89,6 +93,8 @@ export function yesterdayEvening(reference: ReferenceWithTimezone, implyHour = 2
     assignSimilarDate(component, targetDate);
     component.imply("hour", implyHour);
     component.imply("meridiem", Meridiem.PM);
+    component.addTag("casualReference/yesterday");
+    component.addTag("casualReference/evening");
     return component;
 }
 
@@ -104,6 +110,7 @@ export function midnight(reference: ReferenceWithTimezone): ParsingComponents {
     component.imply("minute", 0);
     component.imply("second", 0);
     component.imply("millisecond", 0);
+    component.addTag("casualReference/midnight");
     return component;
 }
 
@@ -114,6 +121,7 @@ export function morning(reference: ReferenceWithTimezone, implyHour = 6): Parsin
     component.imply("minute", 0);
     component.imply("second", 0);
     component.imply("millisecond", 0);
+    component.addTag("casualReference/morning");
     return component;
 }
 
@@ -124,6 +132,7 @@ export function afternoon(reference: ReferenceWithTimezone, implyHour = 15): Par
     component.imply("minute", 0);
     component.imply("second", 0);
     component.imply("millisecond", 0);
+    component.addTag("casualReference/afternoon");
     return component;
 }
 
@@ -134,5 +143,6 @@ export function noon(reference: ReferenceWithTimezone): ParsingComponents {
     component.imply("minute", 0);
     component.imply("second", 0);
     component.imply("millisecond", 0);
+    component.addTag("casualReference/noon");
     return component;
 }

package/src/common/parsers/AbstractTimeExpressionParser.ts

@@ -66,11 +66,11 @@ export abstract class AbstractTimeExpressionParser implements Parser {
     }
 
     primarySuffix(): string {
-        return `(?=\\W|$)`;
+        return `(?!/)(?=\\W|$)`;
     }
 
     followingSuffix(): string {
-        return `(?=\\W|$)`;
+        return `(?!/)(?=\\W|$)`;
     }
 
     pattern(context: ParsingContext): RegExp {

package/src/index.ts

@@ -1,10 +1,10 @@
 import * as en from "./locales/en";
 import { Chrono, Parser, Refiner } from "./chrono";
 import { ParsingResult, ParsingComponents, ReferenceWithTimezone } from "./results";
-import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday } from "./types";
+import { Component, ParsedComponents, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday } from "./types";
 
 export { en, Chrono, Parser, Refiner, ParsingResult, ParsingComponents, ReferenceWithTimezone };
-export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday };
+export { Component, ParsedComponents, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday };
 
 // Export all locales
 import * as de from "./locales/de";

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

@@ -15,25 +15,30 @@ export default class ENCasualDateParser extends AbstractParserWithWordBoundaryCh
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult {
         let targetDate = dayjs(context.refDate);
         const lowerText = match[0].toLowerCase();
-        const component = context.createParsingComponents();
+        let component = context.createParsingComponents();
 
         switch (lowerText) {
             case "now":
-                return references.now(context.reference);
+                component = references.now(context.reference);
+                break;
 
             case "today":
-                return references.today(context.reference);
+                component = references.today(context.reference);
+                break;
 
             case "yesterday":
-                return references.yesterday(context.reference);
+                component = references.yesterday(context.reference);
+                break;
 
             case "tomorrow":
             case "tmr":
             case "tmrw":
-                return references.tomorrow(context.reference);
+                component = references.tomorrow(context.reference);
+                break;
 
             case "tonight":
-                return references.tonight(context.reference);
+                component = references.tonight(context.reference);
+                break;
 
             default:
                 if (lowerText.match(/last\s*night/)) {
@@ -46,7 +51,7 @@ export default class ENCasualDateParser extends AbstractParserWithWordBoundaryCh
                 }
                 break;
         }
-
+        component.addTag("parser/ENCasualDateParser");
         return component;
     }
 }

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

@@ -9,20 +9,29 @@ export default class ENCasualTimeParser extends AbstractParserWithWordBoundaryCh
         return PATTERN;
     }
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        let component = null;
         switch (match[1].toLowerCase()) {
             case "afternoon":
-                return casualReferences.afternoon(context.reference);
+                component = casualReferences.afternoon(context.reference);
+                break;
             case "evening":
             case "night":
-                return casualReferences.evening(context.reference);
+                component = casualReferences.evening(context.reference);
+                break;
             case "midnight":
-                return casualReferences.midnight(context.reference);
+                component = casualReferences.midnight(context.reference);
+                break;
             case "morning":
-                return casualReferences.morning(context.reference);
+                component = casualReferences.morning(context.reference);
+                break;
             case "noon":
             case "midday":
-                return casualReferences.noon(context.reference);
+                component = casualReferences.noon(context.reference);
+                break;
         }
-        return null;
+        if (component) {
+            component.addTag("parser/ENCasualTimeParser");
+        }
+        return component;
     }
 }

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

@@ -22,34 +22,36 @@ export default class ENTimeExpressionParser extends AbstractTimeExpressionParser
 
     extractPrimaryTimeComponents(context: ParsingContext, match: RegExpMatchArray): null | ParsingComponents {
         const components = super.extractPrimaryTimeComponents(context, match);
-        if (components) {
-            if (match[0].endsWith("night")) {
-                const hour = components.get("hour");
-                if (hour >= 6 && hour < 12) {
-                    components.assign("hour", components.get("hour") + 12);
-                    components.assign("meridiem", Meridiem.PM);
-                } else if (hour < 6) {
-                    components.assign("meridiem", Meridiem.AM);
-                }
-            }
+        if (!components) {
+            return components;
+        }
 
-            if (match[0].endsWith("afternoon")) {
+        if (match[0].endsWith("night")) {
+            const hour = components.get("hour");
+            if (hour >= 6 && hour < 12) {
+                components.assign("hour", components.get("hour") + 12);
                 components.assign("meridiem", Meridiem.PM);
-                const hour = components.get("hour");
-                if (hour >= 0 && hour <= 6) {
-                    components.assign("hour", components.get("hour") + 12);
-                }
+            } else if (hour < 6) {
+                components.assign("meridiem", Meridiem.AM);
+            }
+        }
+
+        if (match[0].endsWith("afternoon")) {
+            components.assign("meridiem", Meridiem.PM);
+            const hour = components.get("hour");
+            if (hour >= 0 && hour <= 6) {
+                components.assign("hour", components.get("hour") + 12);
             }
+        }
 
-            if (match[0].endsWith("morning")) {
-                components.assign("meridiem", Meridiem.AM);
-                const hour = components.get("hour");
-                if (hour < 12) {
-                    components.assign("hour", components.get("hour"));
-                }
+        if (match[0].endsWith("morning")) {
+            components.assign("meridiem", Meridiem.AM);
+            const hour = components.get("hour");
+            if (hour < 12) {
+                components.assign("hour", components.get("hour"));
             }
         }
 
-        return components;
+        return components.addTag("parser/ENTimeExpressionParser");
     }
 }

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

@@ -3,8 +3,9 @@ import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 
-const PATTERN_WITHOUT_PREFIX = new RegExp(
-    `(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})(?=\\W|$)`,
+const PATTERN_WITH_OPTIONAL_PREFIX = new RegExp(
+    `(?:(?:within|in|for)\\s*)?` +
+        `(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})(?=\\W|$)`,
     "i"
 );
 
@@ -29,7 +30,7 @@ export default class ENTimeUnitWithinFormatParser extends AbstractParserWithWord
         if (this.strictMode) {
             return PATTERN_WITH_PREFIX_STRICT;
         }
-        return context.option.forwardDate ? PATTERN_WITHOUT_PREFIX : PATTERN_WITH_PREFIX;
+        return context.option.forwardDate ? PATTERN_WITH_OPTIONAL_PREFIX : PATTERN_WITH_PREFIX;
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {

package/src/locales/fr/refiners/FRMergeDateRangeRefiner.ts

@@ -10,6 +10,6 @@ import AbstractMergeDateRangeRefiner from "../../../common/refiners/AbstractMerg
  */
 export default class FRMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner {
     patternBetween(): RegExp {
-        return /^\s*(à|a|-)\s*$/i;
+        return /^\s*(à|a|au|-)\s*$/i;
     }
 }

package/src/locales/fr/refiners/FRMergeDateTimeRefiner.ts

@@ -5,6 +5,6 @@ import AbstractMergeDateTimeRefiner from "../../../common/refiners/AbstractMerge
  */
 export default class FRMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner {
     patternBetween(): RegExp {
-        return new RegExp("^\\s*(T|à|a|vers|de|,|-)?\\s*$");
+        return new RegExp("^\\s*(T|à|a|au|vers|de|,|-)?\\s*$");
     }
 }

package/src/results.ts

@@ -50,6 +50,7 @@ export class ParsingComponents implements ParsedComponents {
     private knownValues: { [c in Component]?: number };
     private impliedValues: { [c in Component]?: number };
     private reference: ReferenceWithTimezone;
+    private _tags = new Set<string>();
 
     constructor(reference: ReferenceWithTimezone, knownComponents?: { [c in Component]?: number }) {
         this.reference = reference;
@@ -155,9 +156,11 @@ export class ParsingComponents implements ParsedComponents {
     }
 
     toString() {
-        return `[ParsingComponents {knownValues: ${JSON.stringify(this.knownValues)}, impliedValues: ${JSON.stringify(
-            this.impliedValues
-        )}}, reference: ${JSON.stringify(this.reference)}]`;
+        return `[ParsingComponents {
+            tags: ${JSON.stringify(Array.from(this._tags).sort())}, 
+            knownValues: ${JSON.stringify(this.knownValues)}, 
+            impliedValues: ${JSON.stringify(this.impliedValues)}}, 
+            reference: ${JSON.stringify(this.reference)}]`;
     }
 
     dayjs() {
@@ -170,6 +173,22 @@ export class ParsingComponents implements ParsedComponents {
         return new Date(date.getTime() + timezoneAdjustment * 60000);
     }
 
+    addTag(tag: string): ParsingComponents {
+        this._tags.add(tag);
+        return this;
+    }
+
+    addTags(tags: string[] | Set<string>): ParsingComponents {
+        for (const tag of tags) {
+            this._tags.add(tag);
+        }
+        return this;
+    }
+
+    tags(): Set<string> {
+        return new Set(this._tags);
+    }
+
     private dateWithoutTimezoneAdjustment() {
         const date = new Date(
             this.get("year"),
@@ -271,7 +290,18 @@ export class ParsingResult implements ParsedResult {
         return this.start.date();
     }
 
+    tags(): Set<string> {
+        const combinedTags: Set<string> = new Set(this.start.tags());
+        if (this.end) {
+            for (const tag of this.end.tags()) {
+                combinedTags.add(tag);
+            }
+        }
+        return combinedTags;
+    }
+
     toString() {
-        return `[ParsingResult {index: ${this.index}, text: '${this.text}', ...}]`;
+        const tags = Array.from(this.tags()).sort();
+        return `[ParsingResult {index: ${this.index}, text: '${this.text}', tags: ${JSON.stringify(tags)} ...}]`;
     }
 }

package/src/types.ts

@@ -77,9 +77,14 @@ export interface ParsedResult {
     readonly end?: ParsedComponents;
 
     /**
-     * Create a javascript date object (from the result.start).
+     * @return a javascript date object created from the `result.start`.
      */
     date(): Date;
+
+    /**
+     * @return debugging tags combined of the `result.start` and `result.end`.
+     */
+    tags(): Set<string>;
 }
 
 /**
@@ -105,6 +110,11 @@ export interface ParsedComponents {
      * @return a javascript date object.
      */
     date(): Date;
+
+    /**
+     * @return debugging tags of the parsed component.
+     */
+    tags(): Set<string>;
 }
 
 export type Component =

package/test/en/en_slash.test.ts

@@ -159,6 +159,40 @@ test("Test - Range Expression", function () {
     });
 });
 
+test("Test - Range Expressions with Time", function () {
+    testSingleCase(chrono.en, "from 01/21/2021 10:00 to 01/01/2023 07:00", new Date(2012, 7, 10), (result) => {
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2021);
+        expect(result.start.get("month")).toBe(1);
+        expect(result.start.get("day")).toBe(21);
+        expect(result.start.get("hour")).toBe(10);
+        expect(result.start.get("minute")).toBe(0);
+
+        expect(result.end).not.toBeNull();
+        expect(result.end.get("year")).toBe(2023);
+        expect(result.end.get("month")).toBe(1);
+        expect(result.end.get("day")).toBe(1);
+        expect(result.end.get("hour")).toBe(7);
+        expect(result.end.get("minute")).toBe(0);
+    });
+
+    testSingleCase(chrono.en, "08/08/2023, 09:15 AM to 08/29/2023, 09:15 AM", new Date(2012, 7, 10), (result) => {
+        expect(result.start).not.toBeNull();
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(8);
+        expect(result.start.get("hour")).toBe(9);
+        expect(result.start.get("minute")).toBe(15);
+
+        expect(result.end).not.toBeNull();
+        expect(result.end.get("year")).toBe(2023);
+        expect(result.end.get("month")).toBe(8);
+        expect(result.end.get("day")).toBe(29);
+        expect(result.end.get("hour")).toBe(9);
+        expect(result.end.get("minute")).toBe(15);
+    });
+});
+
 test("Test - Splitter variances patterns", function () {
     const expectDate = new Date(2015, 5 - 1, 25, 12, 0);
 

package/test/en/en_time_exp.test.ts

@@ -82,6 +82,17 @@ test("Test - Time range expression", function () {
     });
 });
 
+test("Test - Time non-range expression", function () {
+    testSingleCase(chrono, "10:00:00 - 15/15", new Date(2016, 10 - 1, 1, 8), (result, text) => {
+        expect(result.text).toBe("10:00:00");
+
+        expect(result.start.get("hour")).toBe(10);
+        expect(result.start.get("minute")).toBe(0);
+        expect(result.start.get("second")).toBe(0);
+        expect(result.start.get("meridiem")).toBe(Meridiem.AM);
+    });
+});
+
 test("Test - Casual time number expression", function () {
     testSingleCase(chrono, "11 at night", new Date(2016, 10 - 1, 1, 8), (result, text) => {
         expect(result.text).toBe(text);

package/test/en/en_time_units_within.test.ts

@@ -336,7 +336,7 @@ test("Test - Time units' certainty", () => {
     });
 });
 
-test("Test - Strict mode", function () {
+test("Test - Strict mode", () => {
     testSingleCase(chrono, "in 2hour", new Date(2016, 10 - 1, 1, 14, 52), (result, text) => {
         expect(result.start.get("hour")).toBe(16);
         expect(result.start.get("minute")).toBe(52);
@@ -345,3 +345,24 @@ test("Test - Strict mode", function () {
     testUnexpectedResult(chrono.strict, "in 15m");
     testUnexpectedResult(chrono.strict, "within 5hr");
 });
+
+test("Test - Forward date option", () => {
+    testSingleCase(chrono, "1 hour", new Date(2012, 7, 10, 12, 14), { forwardDate: true }, (result) => {
+        expect(result.text).toBe("1 hour");
+        expect(result.start).toBeDate(new Date(2012, 7, 10, 13, 14));
+    });
+
+    testSingleCase(chrono, "1 month", new Date(2016, 10 - 1, 1, 14, 52), { forwardDate: true }, (result, text) => {
+        expect(result.text).toBe("1 month");
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(1);
+    });
+
+    testSingleCase(chrono, "in 1 month", new Date(2016, 10 - 1, 1, 14, 52), { forwardDate: true }, (result, text) => {
+        expect(result.text).toBe("in 1 month");
+        expect(result.start.get("year")).toBe(2016);
+        expect(result.start.get("month")).toBe(11);
+        expect(result.start.get("day")).toBe(1);
+    });
+});

package/test/fr/fr_casual.test.ts

@@ -132,6 +132,16 @@ test("Test - Single Expression", function () {
         expect(result.text).toBe(text);
         expect(result.start.get("hour")).toBe(0);
     });
+
+    testSingleCase(chrono.fr, "Du 24 août 2023 au 26 août 2023", (result) => {
+        expect(result.text).toBe("24 août 2023 au 26 août 2023");
+        expect(result.start.get("year")).toBe(2023);
+        expect(result.start.get("month")).toBe(8);
+        expect(result.start.get("day")).toBe(24);
+        expect(result.end.get("year")).toBe(2023);
+        expect(result.end.get("month")).toBe(8);
+        expect(result.end.get("day")).toBe(26);
+    });
 });
 
 test("Test - Combined Expression", function () {

package/test/result.test.ts

@@ -1,6 +1,6 @@
-import { ParsingComponents, ReferenceWithTimezone } from "../src/results";
+import { ParsingComponents, ParsingResult, ReferenceWithTimezone } from "../src/results";
 
-test("Test - Create & manipulate date results", () => {
+test("Test - Create & manipulate parsing components", () => {
     const reference = new ReferenceWithTimezone(new Date());
     const components = new ParsingComponents(reference, { year: 2014, month: 11, day: 24 });
 
@@ -8,6 +8,7 @@ test("Test - Create & manipulate date results", () => {
     expect(components.get("month")).toBe(11);
     expect(components.get("day")).toBe(24);
     expect(components.date()).toBeDefined();
+    expect(components.tags().size).toBe(0);
 
     // null
     expect(components.get("weekday")).toBeNull();
@@ -23,13 +24,45 @@ test("Test - Create & manipulate date results", () => {
     expect(components.get("weekday")).toBe(2);
     expect(components.isCertain("weekday")).toBe(true);
 
-    // "imply" doesn't overrides "assign"
+    // "imply" doesn't override "assign"
     components.imply("year", 2013);
     expect(components.get("year")).toBe(2014);
 
     // "assign" overrides "assign"
     components.assign("year", 2013);
     expect(components.get("year")).toBe(2013);
+
+    components.addTag("custom/testing_component_tag");
+    expect(components.tags().size).toBe(1);
+    expect(components.tags()).toContain("custom/testing_component_tag");
+    expect(components.toString()).toContain("custom/testing_component_tag");
+});
+
+test("Test - Create & manipulate parsing results", () => {
+    const reference = new ReferenceWithTimezone(new Date());
+    const text = "1 - 2 hour later";
+
+    const startComponents = ParsingComponents.createRelativeFromReference(reference, { "hour": 1 }).addTag(
+        "custom/testing_start_component_tag"
+    );
+
+    const endComponents = ParsingComponents.createRelativeFromReference(reference, { "hour": 2 }).addTag(
+        "custom/testing_end_component_tag"
+    );
+
+    const result = new ParsingResult(reference, 0, text, startComponents, endComponents);
+
+    // The result's date() should be the same as the start components' date()
+    expect(result.date()).toStrictEqual(startComponents.date());
+
+    // The result's tags should include both the start and end components' tags
+    expect(result.tags()).toContain("custom/testing_start_component_tag");
+    expect(result.tags()).toContain("custom/testing_end_component_tag");
+
+    // The result's toString() should include the text and tags
+    expect(result.toString()).toContain(text);
+    expect(result.toString()).toContain("custom/testing_start_component_tag");
+    expect(result.toString()).toContain("custom/testing_end_component_tag");
 });
 
 test("Test - Calendar checking with implied components", () => {

package/test/system.test.ts

@@ -5,6 +5,7 @@ import UnlikelyFormatFilter from "../src/common/refiners/UnlikelyFormatFilter";
 import SlashDateFormatParser from "../src/common/parsers/SlashDateFormatParser";
 import ENWeekdayParser from "../src/locales/en/parsers/ENWeekdayParser";
 import ENTimeUnitCasualRelativeFormatParser from "../src/locales/en/parsers/ENTimeUnitCasualRelativeFormatParser";
+import { ParsingComponents } from "../src/";
 
 //-------------------------------------
 
@@ -124,6 +125,42 @@ test("Test - Add custom refiner example", () => {
     });
 });
 
+test("Test - Add custom parser with tags example", () => {
+    const custom = chrono.casual.clone();
+    custom.parsers.push({
+        pattern: () => {
+            return /\bChristmas\b/i;
+        },
+        extract: (context) => {
+            return context
+                .createParsingComponents({
+                    day: 25,
+                    month: 12,
+                })
+                .addTag("parser/ChristmasDayParser");
+        },
+    });
+
+    testSingleCase(custom, "Doing something tomorrow", (result) => {
+        expect(result.text).toBe("tomorrow");
+        expect(result.tags()).toContain("parser/ENCasualDateParser");
+    });
+
+    testSingleCase(custom, "I'll arrive at 2.30AM on Christmas", (result) => {
+        expect(result.text).toBe("at 2.30AM on Christmas");
+        expect(result.tags()).toContain("parser/ChristmasDayParser");
+        expect(result.tags()).toContain("parser/ENTimeExpressionParser");
+    });
+
+    testSingleCase(custom, "I'll arrive at Christmas night", (result) => {
+        expect(result.text).toBe("Christmas night");
+        expect(result.tags()).toContain("parser/ChristmasDayParser");
+        expect(result.tags()).toContain("parser/ENCasualTimeParser");
+    });
+
+    // TODO: Check if the merge date range combine tags correctly
+});
+
 test("Test - Remove a parser example", () => {
     const custom = chrono.en.strict.clone();
     custom.parsers = custom.parsers.filter((r) => !(r instanceof SlashDateFormatParser));