chrono-node 2.6.6 → 2.7.1

package/src/locales/ru/parsers/AbstractParserWithWordBoundaryChecking.ts

@@ -0,0 +1,25 @@
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { REGEX_PARTS } from "../constants";
+import { ParsingContext } from "../../../chrono";
+
+export abstract class AbstractParserWithLeftBoundaryChecking extends AbstractParserWithWordBoundaryChecking {
+    abstract innerPatternString(context: ParsingContext): string;
+
+    patternLeftBoundary(): string {
+        return REGEX_PARTS.leftBoundary;
+    }
+
+    innerPattern(context: ParsingContext): RegExp {
+        return new RegExp(this.innerPatternString(context), REGEX_PARTS.flags);
+    }
+
+    innerPatternHasChange(context: ParsingContext, currentInnerPattern: RegExp): boolean {
+        return false;
+    }
+}
+
+export abstract class AbstractParserWithLeftRightBoundaryChecking extends AbstractParserWithLeftBoundaryChecking {
+    innerPattern(context: ParsingContext): RegExp {
+        return new RegExp(`${this.innerPatternString(context)}${REGEX_PARTS.rightBoundary}`, REGEX_PARTS.flags);
+    }
+}

package/src/locales/ru/parsers/RUCasualDateParser.ts

@@ -1,21 +1,11 @@
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents, ParsingResult } from "../../../results";
-import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import * as references from "../../../common/casualReferences";
-import { REGEX_PARTS } from "../constants";
+import { AbstractParserWithLeftRightBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
-const PATTERN = new RegExp(
-    `(?:с|со)?\\s*(сегодня|вчера|завтра|послезавтра|послепослезавтра|позапозавчера|позавчера)${REGEX_PARTS.rightBoundary}`,
-    REGEX_PARTS.flags
-);
-
-export default class RUCasualDateParser extends AbstractParserWithWordBoundaryChecking {
-    patternLeftBoundary(): string {
-        return REGEX_PARTS.leftBoundary;
-    }
-
-    innerPattern(context: ParsingContext): RegExp {
-        return PATTERN;
+export default class RUCasualDateParser extends AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context: ParsingContext): string {
+        return `(?:с|со)?\\s*(сегодня|вчера|завтра|послезавтра|послепослезавтра|позапозавчера|позавчера)`;
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents | ParsingResult {

package/src/locales/ru/parsers/RUCasualTimeParser.ts

@@ -1,22 +1,12 @@
 import { ParsingContext } from "../../../chrono";
-import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import * as references from "../../../common/casualReferences";
 import { assignSimilarDate } from "../../../utils/dayjs";
 import dayjs from "dayjs";
-import { REGEX_PARTS } from "../constants";
+import { AbstractParserWithLeftRightBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
-const PATTERN = new RegExp(
-    `(сейчас|прошлым\\s*вечером|прошлой\\s*ночью|следующей\\s*ночью|сегодня\\s*ночью|этой\\s*ночью|ночью|этим утром|утром|утра|в\\s*полдень|вечером|вечера|в\\s*полночь)` +
-        `${REGEX_PARTS.rightBoundary}`,
-    REGEX_PARTS.flags
-);
-export default class RUCasualTimeParser extends AbstractParserWithWordBoundaryChecking {
-    patternLeftBoundary(): string {
-        return REGEX_PARTS.leftBoundary;
-    }
-
-    innerPattern() {
-        return PATTERN;
+export default class RUCasualTimeParser extends AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context: ParsingContext): string {
+        return `(сейчас|прошлым\\s*вечером|прошлой\\s*ночью|следующей\\s*ночью|сегодня\\s*ночью|этой\\s*ночью|ночью|этим утром|утром|утра|в\\s*полдень|вечером|вечера|в\\s*полночь)`;
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {

package/src/locales/ru/parsers/RUMonthNameLittleEndianParser.ts

@@ -1,41 +1,31 @@
 import { ParsingContext } from "../../../chrono";
 import { ParsingResult } from "../../../results";
 import { findYearClosestToRef } from "../../../calculation/years";
-import { MONTH_DICTIONARY, REGEX_PARTS } from "../constants";
+import { MONTH_DICTIONARY } from "../constants";
 import { YEAR_PATTERN, parseYear } from "../constants";
 import { ORDINAL_NUMBER_PATTERN, parseOrdinalNumberPattern } from "../constants";
 import { matchAnyPattern } from "../../../utils/pattern";
-import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
-
-// prettier-ignore
-const PATTERN = new RegExp(
-    `(?:с)?\\s*(${ORDINAL_NUMBER_PATTERN})` +
-        `(?:` +
-            `\\s{0,3}(?:по|-|–|до)?\\s{0,3}` +
-            `(${ORDINAL_NUMBER_PATTERN})` +
-        `)?` +
-        `(?:-|\\/|\\s{0,3}(?:of)?\\s{0,3})` +
-        `(${matchAnyPattern(MONTH_DICTIONARY)})` +
-        `(?:` +
-            `(?:-|\\/|,?\\s{0,3})` +
-            `(${YEAR_PATTERN}(?![^\\s]\\d))` +
-        `)?` +
-    `${REGEX_PARTS.rightBoundary}`,
-    REGEX_PARTS.flags
-);
+import { AbstractParserWithLeftRightBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
 const DATE_GROUP = 1;
 const DATE_TO_GROUP = 2;
 const MONTH_NAME_GROUP = 3;
 const YEAR_GROUP = 4;
 
-export default class RUMonthNameLittleEndianParser extends AbstractParserWithWordBoundaryChecking {
-    patternLeftBoundary(): string {
-        return REGEX_PARTS.leftBoundary;
-    }
-
-    innerPattern(): RegExp {
-        return PATTERN;
+export default class RUMonthNameLittleEndianParser extends AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context: ParsingContext): string {
+        // prettier-ignore
+        return `(?:с)?\\s*(${ORDINAL_NUMBER_PATTERN})` +
+            `(?:` +
+                `\\s{0,3}(?:по|-|–|до)?\\s{0,3}` +
+                `(${ORDINAL_NUMBER_PATTERN})` +
+            `)?` +
+                `(?:-|\\/|\\s{0,3}(?:of)?\\s{0,3})` +
+                `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+            `(?:` +
+                `(?:-|\\/|,?\\s{0,3})` +
+                `(${YEAR_PATTERN}(?![^\\s]\\d))` +
+            `)?`;
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingResult {

package/src/locales/ru/parsers/RUMonthNameParser.ts

@@ -1,20 +1,9 @@
-import { FULL_MONTH_NAME_DICTIONARY, MONTH_DICTIONARY, REGEX_PARTS } from "../constants";
+import { FULL_MONTH_NAME_DICTIONARY, MONTH_DICTIONARY } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { findYearClosestToRef } from "../../../calculation/years";
 import { matchAnyPattern } from "../../../utils/pattern";
 import { YEAR_PATTERN, parseYear } from "../constants";
-import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
-
-const PATTERN = new RegExp(
-    `((?:в)\\s*)?` +
-        `(${matchAnyPattern(MONTH_DICTIONARY)})` +
-        `\\s*` +
-        `(?:` +
-        `[,-]?\\s*(${YEAR_PATTERN})?` +
-        `)?` +
-        `(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)`,
-    REGEX_PARTS.flags
-);
+import { AbstractParserWithLeftBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
 const MONTH_NAME_GROUP = 2;
 const YEAR_GROUP = 3;
@@ -25,13 +14,17 @@ const YEAR_GROUP = 3;
  * - Январь 2012
  * - Январь
  */
-export default class RUMonthNameParser extends AbstractParserWithWordBoundaryChecking {
-    patternLeftBoundary(): string {
-        return REGEX_PARTS.leftBoundary;
-    }
-
-    innerPattern(): RegExp {
-        return PATTERN;
+export default class RUMonthNameParser extends AbstractParserWithLeftBoundaryChecking {
+    innerPatternString(context: ParsingContext): string {
+        return (
+            `((?:в)\\s*)?` +
+            `(${matchAnyPattern(MONTH_DICTIONARY)})` +
+            `\\s*` +
+            `(?:` +
+            `[,-]?\\s*(${YEAR_PATTERN})?` +
+            `)?` +
+            `(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)`
+        );
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {

package/src/locales/ru/parsers/RURelativeDateFormatParser.ts

@@ -4,24 +4,16 @@ import { ParsingComponents } from "../../../results";
 import dayjs from "dayjs";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { matchAnyPattern } from "../../../utils/pattern";
-
-const PATTERN = new RegExp(
-    `(в прошлом|на прошлой|на следующей|в следующем|на этой|в этом)\\s*(${matchAnyPattern(
-        TIME_UNIT_DICTIONARY
-    )})(?=\\s*)${REGEX_PARTS.rightBoundary}`,
-    REGEX_PARTS.flags
-);
+import { AbstractParserWithLeftRightBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
 const MODIFIER_WORD_GROUP = 1;
 const RELATIVE_WORD_GROUP = 2;
 
-export default class RURelativeDateFormatParser extends AbstractParserWithWordBoundaryChecking {
-    patternLeftBoundary(): string {
-        return REGEX_PARTS.leftBoundary;
-    }
-
-    innerPattern(): RegExp {
-        return PATTERN;
+export default class RURelativeDateFormatParser extends AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context: ParsingContext): string {
+        return `(в прошлом|на прошлой|на следующей|в следующем|на этой|в этом)\\s*(${matchAnyPattern(
+            TIME_UNIT_DICTIONARY
+        )})`;
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {

package/src/locales/ru/parsers/RUTimeUnitAgoFormatParser.ts

@@ -1,18 +1,12 @@
 import { ParsingContext } from "../../../chrono";
-import { parseTimeUnits, REGEX_PARTS, TIME_UNITS_PATTERN } from "../constants";
+import { parseTimeUnits, TIME_UNITS_PATTERN } from "../constants";
 import { ParsingComponents } from "../../../results";
-import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { reverseTimeUnits } from "../../../utils/timeunits";
+import { AbstractParserWithLeftBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
-const PATTERN = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}назад(?=(?:\\W|$))`, REGEX_PARTS.flags);
-
-export default class RUTimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
-    patternLeftBoundary(): string {
-        return REGEX_PARTS.leftBoundary;
-    }
-
-    innerPattern(): RegExp {
-        return PATTERN;
+export default class RUTimeUnitAgoFormatParser extends AbstractParserWithLeftBoundaryChecking {
+    innerPatternString(context: ParsingContext): string {
+        return `(${TIME_UNITS_PATTERN})\\s{0,5}назад(?=(?:\\W|$))`;
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray) {

package/src/locales/ru/parsers/RUTimeUnitCasualRelativeFormatParser.ts

@@ -1,21 +1,12 @@
 import { TIME_UNITS_PATTERN, parseTimeUnits, REGEX_PARTS } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
-import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { reverseTimeUnits } from "../../../utils/timeunits";
+import { AbstractParserWithLeftRightBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
-const PATTERN = new RegExp(
-    `(эти|последние|прошлые|следующие|после|спустя|через|\\+|-)\\s*(${TIME_UNITS_PATTERN})${REGEX_PARTS.rightBoundary}`,
-    REGEX_PARTS.flags
-);
-
-export default class RUTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
-    patternLeftBoundary(): string {
-        return REGEX_PARTS.leftBoundary;
-    }
-
-    innerPattern(): RegExp {
-        return PATTERN;
+export default class RUTimeUnitCasualRelativeFormatParser extends AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context: ParsingContext): string {
+        return `(эти|последние|прошлые|следующие|после|спустя|через|\\+|-)\\s*(${TIME_UNITS_PATTERN})`;
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {

package/src/locales/ru/parsers/RUTimeUnitWithinFormatParser.ts

@@ -4,17 +4,23 @@ import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 
 const PATTERN = `(?:(?:около|примерно)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})${REGEX_PARTS.rightBoundary}`;
-const PATTERN_WITH_PREFIX = new RegExp(`(?:в течение|в течении)\\s*${PATTERN}`, REGEX_PARTS.flags);
-
-const PATTERN_WITHOUT_PREFIX = new RegExp(PATTERN, "i");
 
 export default class RUTimeUnitWithinFormatParser extends AbstractParserWithWordBoundaryChecking {
+    private readonly patternWithPrefix: RegExp;
+    private readonly patternWithoutPrefix: RegExp;
+
+    constructor() {
+        super();
+        this.patternWithPrefix = new RegExp(`(?:в течение|в течении)\\s*${PATTERN}`, REGEX_PARTS.flags);
+        this.patternWithoutPrefix = new RegExp(PATTERN, REGEX_PARTS.flags);
+    }
+
     patternLeftBoundary(): string {
         return REGEX_PARTS.leftBoundary;
     }
 
     innerPattern(context: ParsingContext): RegExp {
-        return context.option.forwardDate ? PATTERN_WITHOUT_PREFIX : PATTERN_WITH_PREFIX;
+        return context.option.forwardDate ? this.patternWithoutPrefix : this.patternWithPrefix;
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {

package/src/locales/ru/parsers/RUWeekdayParser.ts

@@ -1,32 +1,24 @@
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
-import { REGEX_PARTS, WEEKDAY_DICTIONARY } from "../constants";
+import { WEEKDAY_DICTIONARY } from "../constants";
 import { matchAnyPattern } from "../../../utils/pattern";
-import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { createParsingComponentsAtWeekday } from "../../../common/calculation/weekdays";
-
-const PATTERN = new RegExp(
-    `(?:(?:,|\\(|（)\\s*)?` +
-        `(?:в\\s*?)?` +
-        `(?:(эту|этот|прошлый|прошлую|следующий|следующую|следующего)\\s*)?` +
-        `(${matchAnyPattern(WEEKDAY_DICTIONARY)})` +
-        `(?:\\s*(?:,|\\)|）))?` +
-        `(?:\\s*на\\s*(этой|прошлой|следующей)\\s*неделе)?` +
-        `${REGEX_PARTS.rightBoundary}`,
-    REGEX_PARTS.flags
-);
+import { AbstractParserWithLeftRightBoundaryChecking } from "./AbstractParserWithWordBoundaryChecking";
 
 const PREFIX_GROUP = 1;
 const WEEKDAY_GROUP = 2;
 const POSTFIX_GROUP = 3;
 
-export default class RUWeekdayParser extends AbstractParserWithWordBoundaryChecking {
-    innerPattern(): RegExp {
-        return PATTERN;
-    }
-
-    patternLeftBoundary(): string {
-        return REGEX_PARTS.leftBoundary;
+export default class RUWeekdayParser extends AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context: ParsingContext): string {
+        return (
+            `(?:(?:,|\\(|（)\\s*)?` +
+            `(?:в\\s*?)?` +
+            `(?:(эту|этот|прошлый|прошлую|следующий|следующую|следующего)\\s*)?` +
+            `(${matchAnyPattern(WEEKDAY_DICTIONARY)})` +
+            `(?:\\s*(?:,|\\)|）))?` +
+            `(?:\\s*на\\s*(этой|прошлой|следующей)\\s*неделе)?`
+        );
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {

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.test.ts

@@ -107,10 +107,10 @@ test("Test - Random text", function () {
         expect(result.end.get("month")).toBe(7);
     });
 
-    testSingleCase(chrono, "03-27-2022, 02:00 AM", new Date(2017, 7 - 1, 7), (result) => {
-        expect(result.text).toBe("03-27-2022, 02:00 AM");
+    testSingleCase(chrono, "07-27-2022, 02:00 AM", new Date(2017, 7 - 1, 7), (result) => {
+        expect(result.text).toBe("07-27-2022, 02:00 AM");
         expect(result.start.get("day")).toBe(27);
-        expect(result.start.get("month")).toBe(3);
+        expect(result.start.get("month")).toBe(7);
         expect(result.start.get("year")).toBe(2022);
         expect(result.start.get("hour")).toBe(2);
         expect(result.start.get("meridiem")).toBe(Meridiem.AM);

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/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", () => {
@@ -113,3 +146,32 @@ test("Test - Calendar Checking", () => {
         expect(components.isValidDate()).toBe(false);
     }
 });
+
+test("Test - Checking non-existing date during DST skip", () => {
+    // Only CET (or CEST) timezones where the DST starts on "Sunday, March 27, 2022" at "02:00 (2 am) local time"
+    const dateDstPre = new Date(2022, 3 - 1, 27, 2);
+    const dateDstPost = new Date(2022, 3 - 1, 27, 3);
+    if (dateDstPre.getTime() == dateDstPost.getTime()) {
+        const reference = new ReferenceWithTimezone(new Date());
+
+        // On "Sunday, March 27, 2022" at "02:00 local time", the clock is moved forward to "03:00 local time".
+        // Thus, the time between "02:00 and 02:59:59" does not exist.
+        expect(
+            new ParsingComponents(reference, { year: 2022, month: 3, day: 27, hour: 2, minute: 0 }).isValidDate()
+        ).toBe(false);
+        expect(
+            new ParsingComponents(reference, { year: 2022, month: 3, day: 27, hour: 2, minute: 1 }).isValidDate()
+        ).toBe(false);
+        expect(
+            new ParsingComponents(reference, { year: 2022, month: 3, day: 27, hour: 2, minute: 59 }).isValidDate()
+        ).toBe(false);
+
+        // Otherwise, it
+        expect(
+            new ParsingComponents(reference, { year: 2022, month: 3, day: 27, hour: 1, minute: 59 }).isValidDate()
+        ).toBe(true);
+        expect(
+            new ParsingComponents(reference, { year: 2022, month: 3, day: 27, hour: 3, minute: 0 }).isValidDate()
+        ).toBe(true);
+    }
+});